From 97b56db1d1f40dfae4c605d95f6e34b397688c3a Mon Sep 17 00:00:00 2001 From: brianlball Date: Thu, 27 Aug 2020 15:39:37 -0600 Subject: [PATCH] watercoils --- src/EnergyPlus/Data/CommonIncludes.hh | 1 + src/EnergyPlus/Data/EnergyPlusData.cc | 2 + src/EnergyPlus/Data/EnergyPlusData.hh | 2 + src/EnergyPlus/FanCoilUnits.cc | 33 +- src/EnergyPlus/FaultsManager.cc | 58 +- src/EnergyPlus/MixedAir.cc | 26 +- src/EnergyPlus/ReportSizingManager.cc | 7 +- src/EnergyPlus/StateManagement.cc | 2 - src/EnergyPlus/UnitHeater.cc | 17 +- src/EnergyPlus/UnitVentilator.cc | 29 +- src/EnergyPlus/VentilatedSlab.cc | 29 +- src/EnergyPlus/WaterCoils.cc | 2613 ++++++++--------- src/EnergyPlus/WaterCoils.hh | 226 +- .../unit/AirTerminalSingleDuctMixer.unit.cc | 20 +- .../unit/DesiccantDehumidifiers.unit.cc | 6 +- tst/EnergyPlus/unit/FanCoilUnits.unit.cc | 734 ++--- tst/EnergyPlus/unit/FaultsManager.unit.cc | 32 +- tst/EnergyPlus/unit/HVACControllers.unit.cc | 24 +- .../unit/HVACVariableRefrigerantFlow.unit.cc | 88 +- .../unit/OASystemHWPreheatCoil.unit.cc | 24 +- tst/EnergyPlus/unit/OutdoorAirUnit.unit.cc | 32 +- tst/EnergyPlus/unit/SZVAVModel.unit.cc | 12 +- .../unit/SizeWaterHeatingCoil.unit.cc | 206 +- .../unit/SizingAnalysisObjects.unit.cc | 1 + tst/EnergyPlus/unit/UnitHeater.unit.cc | 28 +- tst/EnergyPlus/unit/UnitarySystem.unit.cc | 486 +-- tst/EnergyPlus/unit/WaterCoils.unit.cc | 634 ++-- 27 files changed, 2615 insertions(+), 2757 deletions(-) diff --git a/src/EnergyPlus/Data/CommonIncludes.hh b/src/EnergyPlus/Data/CommonIncludes.hh index 4fda30bf1e2..c54b48ee5ce 100644 --- a/src/EnergyPlus/Data/CommonIncludes.hh +++ b/src/EnergyPlus/Data/CommonIncludes.hh @@ -57,6 +57,7 @@ #include #include #include +#include #include #include #include diff --git a/src/EnergyPlus/Data/EnergyPlusData.cc b/src/EnergyPlus/Data/EnergyPlusData.cc index 5e6412b26d0..e42f1d7faae 100644 --- a/src/EnergyPlus/Data/EnergyPlusData.cc +++ b/src/EnergyPlus/Data/EnergyPlusData.cc @@ -59,6 +59,7 @@ namespace EnergyPlus { this->dataBaseboardRadiator = std::unique_ptr(new BaseboardRadiatorData); this->dataBaseboardElectric = std::unique_ptr(new BaseboardElectricData); + this->dataWaterCoils = std::unique_ptr(new WaterCoilsData); this->dataWaterManager = std::unique_ptr(new WaterManagerData); this->dataWaterThermalTanks = std::unique_ptr(new WaterThermalTanksData); this->dataWaterToAirHeatPump = std::unique_ptr(new WaterToAirHeatPumpData); @@ -105,6 +106,7 @@ namespace EnergyPlus { pipes.clear_state(); dataPlantChillers.clear_state(); + dataWaterCoils->clear_state(); dataWaterManager->clear_state(); dataWaterThermalTanks->clear_state(); dataWaterToAirHeatPump->clear_state(); diff --git a/src/EnergyPlus/Data/EnergyPlusData.hh b/src/EnergyPlus/Data/EnergyPlusData.hh index 552ab002107..b829c1ecd2b 100644 --- a/src/EnergyPlus/Data/EnergyPlusData.hh +++ b/src/EnergyPlus/Data/EnergyPlusData.hh @@ -91,6 +91,7 @@ namespace EnergyPlus { struct BaseboardRadiatorData; struct BaseboardElectricData; + struct WaterCoilsData; struct WaterManagerData; struct WaterThermalTanksData; struct WaterToAirHeatPumpData; @@ -141,6 +142,7 @@ namespace EnergyPlus { IOFiles files; + std::unique_ptr dataWaterCoils; std::unique_ptr dataWaterManager; std::unique_ptr dataWaterThermalTanks; std::unique_ptr dataWaterToAirHeatPump; diff --git a/src/EnergyPlus/FanCoilUnits.cc b/src/EnergyPlus/FanCoilUnits.cc index 176de0dd9cd..2c3a1f48196 100644 --- a/src/EnergyPlus/FanCoilUnits.cc +++ b/src/EnergyPlus/FanCoilUnits.cc @@ -1388,11 +1388,6 @@ namespace FanCoilUnits { using Psychrometrics::PsyHFnTdbW; using ReportSizingManager::ReportSizingOutput; using ReportSizingManager::RequestSizing; - using WaterCoils::GetCoilWaterInletNode; - using WaterCoils::GetCoilWaterOutletNode; - using WaterCoils::GetWaterCoilIndex; - using WaterCoils::SetCoilDesFlow; - using WaterCoils::WaterCoil; // SUBROUTINE PARAMETER DEFINITIONS: static std::string const RoutineName("SizeFanCoilUnit: "); // include trailing blank space @@ -1755,14 +1750,14 @@ namespace FanCoilUnits { FanCoil(FanCoilNum).MaxHotWaterVolFlow); } } else { - CoilWaterInletNode = GetCoilWaterInletNode(state, "Coil:Heating:Water", FanCoil(FanCoilNum).HCoilName, ErrorsFound); - CoilWaterOutletNode = GetCoilWaterOutletNode(state, "Coil:Heating:Water", FanCoil(FanCoilNum).HCoilName, ErrorsFound); + CoilWaterInletNode = WaterCoils::GetCoilWaterInletNode(state, "Coil:Heating:Water", FanCoil(FanCoilNum).HCoilName, ErrorsFound); + CoilWaterOutletNode = WaterCoils::GetCoilWaterOutletNode(state, "Coil:Heating:Water", FanCoil(FanCoilNum).HCoilName, ErrorsFound); if (IsAutoSize) { PltSizHeatNum = MyPlantSizingIndex( "Coil:Heating:Water", FanCoil(FanCoilNum).HCoilName, CoilWaterInletNode, CoilWaterOutletNode, ErrorsFound); - CoilNum = GetWaterCoilIndex(state, "COIL:HEATING:WATER", FanCoil(FanCoilNum).HCoilName, ErrorsFound); - if (WaterCoil(CoilNum).UseDesignWaterDeltaTemp) { - WaterCoilSizDeltaT = WaterCoil(CoilNum).DesignWaterDeltaTemp; + CoilNum = WaterCoils::GetWaterCoilIndex(state, "COIL:HEATING:WATER", FanCoil(FanCoilNum).HCoilName, ErrorsFound); + if (state.dataWaterCoils->WaterCoil(CoilNum).UseDesignWaterDeltaTemp) { + WaterCoilSizDeltaT = state.dataWaterCoils->WaterCoil(CoilNum).DesignWaterDeltaTemp; DoWaterCoilSizing = true; } else { if (PltSizHeatNum > 0) { @@ -1914,13 +1909,13 @@ namespace FanCoilUnits { CoolingCoilName = FanCoil(FanCoilNum).CCoilName; CoolingCoilType = FanCoil(FanCoilNum).CCoilType; } - CoilWaterInletNode = GetCoilWaterInletNode(state, CoolingCoilType, CoolingCoilName, ErrorsFound); - CoilWaterOutletNode = GetCoilWaterOutletNode(state, CoolingCoilType, CoolingCoilName, ErrorsFound); + CoilWaterInletNode = WaterCoils::GetCoilWaterInletNode(state, CoolingCoilType, CoolingCoilName, ErrorsFound); + CoilWaterOutletNode = WaterCoils::GetCoilWaterOutletNode(state, CoolingCoilType, CoolingCoilName, ErrorsFound); if (IsAutoSize) { PltSizCoolNum = MyPlantSizingIndex(CoolingCoilType, CoolingCoilName, CoilWaterInletNode, CoilWaterOutletNode, ErrorsFound); - CoilNum = GetWaterCoilIndex(state, CoolingCoilType, CoolingCoilName, ErrorsFound); - if (WaterCoil(CoilNum).UseDesignWaterDeltaTemp) { - WaterCoilSizDeltaT = WaterCoil(CoilNum).DesignWaterDeltaTemp; + CoilNum = WaterCoils::GetWaterCoilIndex(state, CoolingCoilType, CoolingCoilName, ErrorsFound); + if (state.dataWaterCoils->WaterCoil(CoilNum).UseDesignWaterDeltaTemp) { + WaterCoilSizDeltaT = state.dataWaterCoils->WaterCoil(CoilNum).DesignWaterDeltaTemp; DoWaterCoilSizing = true; } else { if (PltSizCoolNum > 0) { @@ -2116,11 +2111,11 @@ namespace FanCoilUnits { CoolingCoilType = FanCoil(FanCoilNum).CCoilType; } if (ZoneSizingRunDone) { - SetCoilDesFlow(state, CoolingCoilType, CoolingCoilName, FinalZoneSizing(CurZoneEqNum).DesCoolVolFlow, ErrorsFound); - SetCoilDesFlow(state, FanCoil(FanCoilNum).HCoilType, FanCoil(FanCoilNum).HCoilName, FinalZoneSizing(CurZoneEqNum).DesHeatVolFlow, ErrorsFound); + WaterCoils::SetCoilDesFlow(state, CoolingCoilType, CoolingCoilName, FinalZoneSizing(CurZoneEqNum).DesCoolVolFlow, ErrorsFound); + WaterCoils::SetCoilDesFlow(state, FanCoil(FanCoilNum).HCoilType, FanCoil(FanCoilNum).HCoilName, FinalZoneSizing(CurZoneEqNum).DesHeatVolFlow, ErrorsFound); } else { - SetCoilDesFlow(state, CoolingCoilType, CoolingCoilName, FanCoil(FanCoilNum).MaxAirVolFlow, ErrorsFound); - SetCoilDesFlow(state, FanCoil(FanCoilNum).HCoilType, FanCoil(FanCoilNum).HCoilName, FanCoil(FanCoilNum).MaxAirVolFlow, ErrorsFound); + WaterCoils::SetCoilDesFlow(state, CoolingCoilType, CoolingCoilName, FanCoil(FanCoilNum).MaxAirVolFlow, ErrorsFound); + WaterCoils::SetCoilDesFlow(state, FanCoil(FanCoilNum).HCoilType, FanCoil(FanCoilNum).HCoilName, FanCoil(FanCoilNum).MaxAirVolFlow, ErrorsFound); } if (CurZoneEqNum > 0) { ZoneEqSizing(CurZoneEqNum).MaxHWVolFlow = FanCoil(FanCoilNum).MaxHotWaterVolFlow; diff --git a/src/EnergyPlus/FaultsManager.cc b/src/EnergyPlus/FaultsManager.cc index 3340ee95294..ca614a6aea8 100644 --- a/src/EnergyPlus/FaultsManager.cc +++ b/src/EnergyPlus/FaultsManager.cc @@ -908,12 +908,12 @@ namespace FaultsManager { UtilityRoutines::SameString(SELECT_CASE_VAR, "Coil:Cooling:Water") || UtilityRoutines::SameString(SELECT_CASE_VAR, "Coil:Cooling:Water:Detailedgeometry")) { // Read in coil input if not done yet - if (WaterCoils::GetWaterCoilsInputFlag) { + if (state.dataWaterCoils->GetWaterCoilsInputFlag) { WaterCoils::GetWaterCoilInput(state); - WaterCoils::GetWaterCoilsInputFlag = false; + state.dataWaterCoils->GetWaterCoilsInputFlag = false; } // Check the coil name and coil type - int CoilNum = UtilityRoutines::FindItemInList(FaultsCoilSATSensor(jFault_CoilSAT).CoilName, WaterCoils::WaterCoil); + int CoilNum = UtilityRoutines::FindItemInList(FaultsCoilSATSensor(jFault_CoilSAT).CoilName, state.dataWaterCoils->WaterCoil); if (CoilNum <= 0) { ShowSevereError(cFaultCurrentObject + " = \"" + cAlphaArgs(1) + "\" invalid " + cAlphaFieldNames(5) + " = \"" + cAlphaArgs(5) + "\" not found."); @@ -946,7 +946,7 @@ namespace FaultsManager { HVACControllers::ControllerProps(ControlNum).FaultyCoilSATIndex = jFault_CoilSAT; // Check whether the controller match the coil - if (HVACControllers::ControllerProps(ControlNum).SensedNode != WaterCoils::WaterCoil(CoilNum).AirOutletNodeNum) { + if (HVACControllers::ControllerProps(ControlNum).SensedNode != state.dataWaterCoils->WaterCoil(CoilNum).AirOutletNodeNum) { ShowSevereError(cFaultCurrentObject + " = \"" + cAlphaArgs(1) + "\" invalid " + cAlphaFieldNames(6) + " = \"" + cAlphaArgs(6) + "\" does not match " + cAlphaFieldNames(5) + " = \"" + cAlphaArgs(5)); ErrorsFound = true; @@ -1707,88 +1707,88 @@ namespace FaultsManager { // Coil check and link { // Obtains and Allocates WaterCoil related parameters from input file - if (WaterCoils::GetWaterCoilsInputFlag) { + if (state.dataWaterCoils->GetWaterCoilsInputFlag) { WaterCoils::GetWaterCoilInput(state); - WaterCoils::GetWaterCoilsInputFlag = false; + state.dataWaterCoils->GetWaterCoilsInputFlag = false; } // Check the coil name and type - int CoilNum = UtilityRoutines::FindItemInList(FouledCoils(jFault_FoulingCoil).FouledCoilName, WaterCoils::WaterCoil); + int CoilNum = UtilityRoutines::FindItemInList(FouledCoils(jFault_FoulingCoil).FouledCoilName, state.dataWaterCoils->WaterCoil); if (CoilNum <= 0) { ShowSevereError(cFaultCurrentObject + " = \"" + cAlphaArgs(1) + "\". Referenced Coil named \"" + FouledCoils(jFault_FoulingCoil).FouledCoilName + "\" was not found."); ErrorsFound = true; } else { // Coil is found: check if the right type - if ( (WaterCoils::WaterCoil(CoilNum).WaterCoilType_Num == WaterCoils::WaterCoil_SimpleHeating) || - (WaterCoils::WaterCoil(CoilNum).WaterCoilType_Num == WaterCoils::WaterCoil_Cooling) ) + if ( (state.dataWaterCoils->WaterCoil(CoilNum).WaterCoilType_Num == state.dataWaterCoils->WaterCoil_SimpleHeating) || + (state.dataWaterCoils->WaterCoil(CoilNum).WaterCoilType_Num == state.dataWaterCoils->WaterCoil_Cooling) ) { // Link the Coil with the fault model - WaterCoils::WaterCoil(CoilNum).FaultyCoilFoulingFlag = true; - WaterCoils::WaterCoil(CoilNum).FaultyCoilFoulingIndex = jFault_FoulingCoil; + state.dataWaterCoils->WaterCoil(CoilNum).FaultyCoilFoulingFlag = true; + state.dataWaterCoils->WaterCoil(CoilNum).FaultyCoilFoulingIndex = jFault_FoulingCoil; - FouledCoils(jFault_FoulingCoil).FouledCoiledType = WaterCoils::WaterCoil(CoilNum).WaterCoilType_Num; + FouledCoils(jFault_FoulingCoil).FouledCoiledType = state.dataWaterCoils->WaterCoil(CoilNum).WaterCoilType_Num; FouledCoils(jFault_FoulingCoil).FouledCoilNum = CoilNum; SetupOutputVariable("Coil Fouling Factor", OutputProcessor::Unit::K_W, - WaterCoils::WaterCoil(CoilNum).FaultyCoilFoulingFactor, + state.dataWaterCoils->WaterCoil(CoilNum).FaultyCoilFoulingFactor, "System", "Average", - WaterCoils::WaterCoil(CoilNum).Name); + 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 (WaterCoils::WaterCoil(CoilNum).WaterCoilType_Num == WaterCoils::WaterCoil_Cooling) { + if (state.dataWaterCoils->WaterCoil(CoilNum).WaterCoilType_Num == state.dataWaterCoils->WaterCoil_Cooling) { SetupOutputVariable("Cooling Coil Total U Factor Times Area Value", OutputProcessor::Unit::W_K, - WaterCoils::WaterCoil(CoilNum).UACoilTotal, + state.dataWaterCoils->WaterCoil(CoilNum).UACoilTotal, "System", "Average", - WaterCoils::WaterCoil(CoilNum).Name); + state.dataWaterCoils->WaterCoil(CoilNum).Name); SetupOutputVariable("Cooling Coil External U Factor Times Area Value", OutputProcessor::Unit::W_K, - WaterCoils::WaterCoil(CoilNum).UACoilExternal, + state.dataWaterCoils->WaterCoil(CoilNum).UACoilExternal, "System", "Average", - WaterCoils::WaterCoil(CoilNum).Name); + state.dataWaterCoils->WaterCoil(CoilNum).Name); SetupOutputVariable("Cooling Coil Internal U Factor Times Area Value", OutputProcessor::Unit::W_K, - WaterCoils::WaterCoil(CoilNum).UACoilInternal, + state.dataWaterCoils->WaterCoil(CoilNum).UACoilInternal, "System", "Average", - WaterCoils::WaterCoil(CoilNum).Name); + state.dataWaterCoils->WaterCoil(CoilNum).Name); SetupOutputVariable("Cooling Coil Total U Factor Times Area Value Before Fouling", OutputProcessor::Unit::W_K, - WaterCoils::WaterCoil(CoilNum).OriginalUACoilVariable, + state.dataWaterCoils->WaterCoil(CoilNum).OriginalUACoilVariable, "System", "Average", - WaterCoils::WaterCoil(CoilNum).Name); + state.dataWaterCoils->WaterCoil(CoilNum).Name); SetupOutputVariable("Cooling Coil External U Factor Times Area Value Before Fouling", OutputProcessor::Unit::W_K, - WaterCoils::WaterCoil(CoilNum).OriginalUACoilExternal, + state.dataWaterCoils->WaterCoil(CoilNum).OriginalUACoilExternal, "System", "Average", - WaterCoils::WaterCoil(CoilNum).Name); + state.dataWaterCoils->WaterCoil(CoilNum).Name); SetupOutputVariable("Cooling Coil Internal U Factor Times Area Value Before Fouling", OutputProcessor::Unit::W_K, - WaterCoils::WaterCoil(CoilNum).OriginalUACoilInternal, + state.dataWaterCoils->WaterCoil(CoilNum).OriginalUACoilInternal, "System", "Average", - WaterCoils::WaterCoil(CoilNum).Name); + state.dataWaterCoils->WaterCoil(CoilNum).Name); } else { SetupOutputVariable("Heating Coil U Factor Times Area Value Before Fouling", OutputProcessor::Unit::W_K, - WaterCoils::WaterCoil(CoilNum).OriginalUACoilVariable, + state.dataWaterCoils->WaterCoil(CoilNum).OriginalUACoilVariable, "System", "Average", - WaterCoils::WaterCoil(CoilNum).Name); + state.dataWaterCoils->WaterCoil(CoilNum).Name); } } else { ShowSevereError(cFaultCurrentObject + " = \"" + cAlphaArgs(1) + "\" invalid " diff --git a/src/EnergyPlus/MixedAir.cc b/src/EnergyPlus/MixedAir.cc index 8f758c1aa13..b5cfcd67144 100644 --- a/src/EnergyPlus/MixedAir.cc +++ b/src/EnergyPlus/MixedAir.cc @@ -613,8 +613,6 @@ namespace MixedAir { using SteamCoils::SimulateSteamCoilComponents; using TranspiredCollector::SimTranspiredCollector; using UserDefinedComponents::SimCoilUserDefined; - using WaterCoils::SimulateWaterCoilComponents; - using WaterCoils::WaterCoil; // Locals // SUBROUTINE ARGUMENTS: @@ -667,35 +665,35 @@ namespace MixedAir { } else if (SELECT_CASE_var == WaterCoil_Cooling) { // 'Coil:Cooling:Water' if (Sim) { // get water coil and controller data if not called previously - if (CompIndex == 0) SimulateWaterCoilComponents(state, CompName, FirstHVACIteration, CompIndex); + if (CompIndex == 0) WaterCoils::SimulateWaterCoilComponents(state, CompName, FirstHVACIteration, CompIndex); // iterate on OA sys controller and water coil at the same time SolveWaterCoilController(state, FirstHVACIteration, AirLoopNum, CompName, CompIndex, - WaterCoil(CompIndex).ControllerName, - WaterCoil(CompIndex).ControllerIndex, + state.dataWaterCoils->WaterCoil(CompIndex).ControllerName, + state.dataWaterCoils->WaterCoil(CompIndex).ControllerIndex, false); // set flag to tell HVAC controller it will be simulated only in SolveWaterCoilController() - ControllerProps(WaterCoil(CompIndex).ControllerIndex).BypassControllerCalc = true; + ControllerProps(state.dataWaterCoils->WaterCoil(CompIndex).ControllerIndex).BypassControllerCalc = true; } OACoolingCoil = true; } else if (SELECT_CASE_var == WaterCoil_SimpleHeat) { // 'Coil:Heating:Water') if (Sim) { // get water coil and controller data if not called previously - if (CompIndex == 0) SimulateWaterCoilComponents(state, CompName, FirstHVACIteration, CompIndex); + if (CompIndex == 0) WaterCoils::SimulateWaterCoilComponents(state, CompName, FirstHVACIteration, CompIndex); // iterate on OA sys controller and water coil at the same time SolveWaterCoilController(state, FirstHVACIteration, AirLoopNum, CompName, CompIndex, - WaterCoil(CompIndex).ControllerName, - WaterCoil(CompIndex).ControllerIndex, + state.dataWaterCoils->WaterCoil(CompIndex).ControllerName, + state.dataWaterCoils->WaterCoil(CompIndex).ControllerIndex, false); // set flag to tell HVAC controller it will be simulated only in SolveWaterCoilController() - ControllerProps(WaterCoil(CompIndex).ControllerIndex).BypassControllerCalc = true; + ControllerProps(state.dataWaterCoils->WaterCoil(CompIndex).ControllerIndex).BypassControllerCalc = true; } OAHeatingCoil = true; } else if (SELECT_CASE_var == SteamCoil_AirHeat) { // 'Coil:Heating:Steam' @@ -706,18 +704,18 @@ namespace MixedAir { } else if (SELECT_CASE_var == WaterCoil_DetailedCool) { // 'Coil:Cooling:Water:DetailedGeometry' if (Sim) { // get water coil and controller data if not called previously - if (CompIndex == 0) SimulateWaterCoilComponents(state, CompName, FirstHVACIteration, CompIndex); + if (CompIndex == 0) WaterCoils::SimulateWaterCoilComponents(state, CompName, FirstHVACIteration, CompIndex); // iterate on OA sys controller and water coil at the same time SolveWaterCoilController(state, FirstHVACIteration, AirLoopNum, CompName, CompIndex, - WaterCoil(CompIndex).ControllerName, - WaterCoil(CompIndex).ControllerIndex, + state.dataWaterCoils->WaterCoil(CompIndex).ControllerName, + state.dataWaterCoils->WaterCoil(CompIndex).ControllerIndex, false); // set flag to tell HVAC controller it will be simulated only in SolveWaterCoilController() - ControllerProps(WaterCoil(CompIndex).ControllerIndex).BypassControllerCalc = true; + ControllerProps(state.dataWaterCoils->WaterCoil(CompIndex).ControllerIndex).BypassControllerCalc = true; } OACoolingCoil = true; } else if (SELECT_CASE_var == Coil_ElectricHeat) { // 'Coil:Heating:Electric' diff --git a/src/EnergyPlus/ReportSizingManager.cc b/src/EnergyPlus/ReportSizingManager.cc index 1ec462d8fb8..659989f5b77 100644 --- a/src/EnergyPlus/ReportSizingManager.cc +++ b/src/EnergyPlus/ReportSizingManager.cc @@ -78,6 +78,7 @@ #include #include #include +#include #include #include #include @@ -357,7 +358,6 @@ namespace ReportSizingManager { using FluidProperties::GetDensityGlycol; using FluidProperties::GetSpecificHeatGlycol; using General::RoundSigDigits; - using General::SolveRoot; using General::TrimSigDigits; using Psychrometrics::PsyCpAirFnW; using Psychrometrics::PsyHFnTdbW; @@ -369,7 +369,6 @@ namespace ReportSizingManager { using Psychrometrics::PsyWFnTdbH; using Psychrometrics::PsyWFnTdbRhPb; using Psychrometrics::PsyWFnTdpPb; - using WaterCoils::SimpleHeatingCoilUAResidual; // SUBROUTINE PARAMETER DEFINITIONS: Real64 const Acc(0.0001); // Accuracy of result @@ -2398,7 +2397,7 @@ namespace ReportSizingManager { UA1 = DataCapacityUsedForSizing; // Invert the simple heating coil model: given the design inlet conditions and the design load, // find the design UA. - SolveRoot(Acc, MaxIte, SolFla, AutosizeDes, SimpleHeatingCoilUAResidual, UA0, UA1, Par); + TempSolveRoot::SolveRoot(state, Acc, MaxIte, SolFla, AutosizeDes, WaterCoils::SimpleHeatingCoilUAResidual, UA0, UA1, Par); if (SolFla == -1) { ShowSevereError("Autosizing of heating coil UA failed for Coil:Heating:Water \"" + CompName + "\""); ShowContinueError(" Iteration limit exceeded in calculating coil UA"); @@ -3609,7 +3608,7 @@ namespace ReportSizingManager { UA1 = DataCapacityUsedForSizing; // Invert the simple heating coil model: given the design inlet conditions and the design load, // find the design UA. - SolveRoot(Acc, MaxIte, SolFla, AutosizeDes, SimpleHeatingCoilUAResidual, UA0, UA1, Par); + TempSolveRoot::SolveRoot(state, Acc, MaxIte, SolFla, AutosizeDes, WaterCoils::SimpleHeatingCoilUAResidual, UA0, UA1, Par); if (SolFla == -1) { ShowSevereError("Autosizing of heating coil UA failed for Coil:Heating:Water \"" + CompName + "\""); ShowContinueError(" Iteration limit exceeded in calculating coil UA"); diff --git a/src/EnergyPlus/StateManagement.cc b/src/EnergyPlus/StateManagement.cc index ae888429410..c8e6512d61c 100644 --- a/src/EnergyPlus/StateManagement.cc +++ b/src/EnergyPlus/StateManagement.cc @@ -226,7 +226,6 @@ #include #include #include -#include void EnergyPlus::clearAllStates(EnergyPlusData &state) { @@ -410,7 +409,6 @@ void EnergyPlus::clearAllStates(EnergyPlusData &state) UtilityRoutines::clear_state(); VariableSpeedCoils::clear_state(); VentilatedSlab::clear_state(); - WaterCoils::clear_state(); EIRPlantLoopHeatPumps::EIRPlantLoopHeatPump::clear_state(); ResultsFramework::clear_state(); } diff --git a/src/EnergyPlus/UnitHeater.cc b/src/EnergyPlus/UnitHeater.cc index ab647fc8feb..df07f21e797 100644 --- a/src/EnergyPlus/UnitHeater.cc +++ b/src/EnergyPlus/UnitHeater.cc @@ -979,11 +979,6 @@ namespace UnitHeater { using ReportSizingManager::RequestSizing; using SteamCoils::GetCoilSteamInletNode; using SteamCoils::GetCoilSteamOutletNode; - using WaterCoils::GetCoilWaterInletNode; - using WaterCoils::GetCoilWaterOutletNode; - using WaterCoils::GetWaterCoilIndex; - using WaterCoils::SetCoilDesFlow; - using WaterCoils::WaterCoil; // SUBROUTINE PARAMETER DEFINITIONS: static std::string const RoutineName("SizeUnitHeater"); @@ -1135,14 +1130,14 @@ namespace UnitHeater { } else { CheckZoneSizing("ZoneHVAC:UnitHeater", UnitHeat(UnitHeatNum).Name); - CoilWaterInletNode = GetCoilWaterInletNode(state, "Coil:Heating:Water", UnitHeat(UnitHeatNum).HCoilName, ErrorsFound); - CoilWaterOutletNode = GetCoilWaterOutletNode(state, "Coil:Heating:Water", UnitHeat(UnitHeatNum).HCoilName, ErrorsFound); + CoilWaterInletNode = WaterCoils::GetCoilWaterInletNode(state, "Coil:Heating:Water", UnitHeat(UnitHeatNum).HCoilName, ErrorsFound); + CoilWaterOutletNode = WaterCoils::GetCoilWaterOutletNode(state, "Coil:Heating:Water", UnitHeat(UnitHeatNum).HCoilName, ErrorsFound); if (IsAutoSize) { PltSizHeatNum = MyPlantSizingIndex( "Coil:Heating:Water", UnitHeat(UnitHeatNum).HCoilName, CoilWaterInletNode, CoilWaterOutletNode, ErrorsFound); - CoilNum = GetWaterCoilIndex(state, "COIL:HEATING:WATER", UnitHeat(UnitHeatNum).HCoilName, ErrorsFound); - if (WaterCoil(CoilNum).UseDesignWaterDeltaTemp) { - WaterCoilSizDeltaT = WaterCoil(CoilNum).DesignWaterDeltaTemp; + CoilNum = WaterCoils::GetWaterCoilIndex(state, "COIL:HEATING:WATER", UnitHeat(UnitHeatNum).HCoilName, ErrorsFound); + if (state.dataWaterCoils->WaterCoil(CoilNum).UseDesignWaterDeltaTemp) { + WaterCoilSizDeltaT = state.dataWaterCoils->WaterCoil(CoilNum).DesignWaterDeltaTemp; DoWaterCoilSizing = true; } else { if (PltSizHeatNum > 0) { @@ -1357,7 +1352,7 @@ namespace UnitHeater { // set the design air flow rate for the heating coil - SetCoilDesFlow(state, UnitHeat(UnitHeatNum).HCoilTypeCh, UnitHeat(UnitHeatNum).HCoilName, UnitHeat(UnitHeatNum).MaxAirVolFlow, ErrorsFound); + WaterCoils::SetCoilDesFlow(state, UnitHeat(UnitHeatNum).HCoilTypeCh, UnitHeat(UnitHeatNum).HCoilName, UnitHeat(UnitHeatNum).MaxAirVolFlow, ErrorsFound); if (CurZoneEqNum > 0) { ZoneEqSizing(CurZoneEqNum).MaxHWVolFlow = UnitHeat(UnitHeatNum).MaxVolHotWaterFlow; } diff --git a/src/EnergyPlus/UnitVentilator.cc b/src/EnergyPlus/UnitVentilator.cc index be0281cdf07..c3cbf9e676e 100644 --- a/src/EnergyPlus/UnitVentilator.cc +++ b/src/EnergyPlus/UnitVentilator.cc @@ -1629,11 +1629,6 @@ namespace UnitVentilator { using ReportSizingManager::RequestSizing; using SteamCoils::GetCoilSteamInletNode; using SteamCoils::GetCoilSteamOutletNode; - using WaterCoils::GetCoilWaterInletNode; - using WaterCoils::GetCoilWaterOutletNode; - using WaterCoils::GetWaterCoilIndex; - using WaterCoils::SetCoilDesFlow; - using WaterCoils::WaterCoil; // SUBROUTINE PARAMETER DEFINITIONS: static std::string const RoutineName("SizeUnitVentilator"); @@ -2094,15 +2089,15 @@ namespace UnitVentilator { } else { CheckZoneSizing(cMO_UnitVentilator, UnitVent(UnitVentNum).Name); - CoilWaterInletNode = GetCoilWaterInletNode(state, "Coil:Heating:Water", UnitVent(UnitVentNum).HCoilName, ErrorsFound); - CoilWaterOutletNode = GetCoilWaterOutletNode(state, "Coil:Heating:Water", UnitVent(UnitVentNum).HCoilName, ErrorsFound); + CoilWaterInletNode = WaterCoils::GetCoilWaterInletNode(state, "Coil:Heating:Water", UnitVent(UnitVentNum).HCoilName, ErrorsFound); + CoilWaterOutletNode = WaterCoils::GetCoilWaterOutletNode(state, "Coil:Heating:Water", UnitVent(UnitVentNum).HCoilName, ErrorsFound); if (IsAutoSize) { PltSizHeatNum = MyPlantSizingIndex( "COIL:HEATING:WATER", UnitVent(UnitVentNum).HCoilName, CoilWaterInletNode, CoilWaterOutletNode, ErrorsFound); - CoilNum = GetWaterCoilIndex(state, "COIL:HEATING:WATER", UnitVent(UnitVentNum).HCoilName, ErrorsFound); - if (WaterCoil(CoilNum).UseDesignWaterDeltaTemp) { - WaterCoilSizDeltaT = WaterCoil(CoilNum).DesignWaterDeltaTemp; + CoilNum = WaterCoils::GetWaterCoilIndex(state, "COIL:HEATING:WATER", UnitVent(UnitVentNum).HCoilName, ErrorsFound); + if (state.dataWaterCoils->WaterCoil(CoilNum).UseDesignWaterDeltaTemp) { + WaterCoilSizDeltaT = state.dataWaterCoils->WaterCoil(CoilNum).DesignWaterDeltaTemp; DoWaterCoilSizing = true; } else { if (PltSizHeatNum > 0) { @@ -2344,13 +2339,13 @@ namespace UnitVentilator { CoolingCoilName = UnitVent(UnitVentNum).CCoilName; CoolingCoilType = UnitVent(UnitVentNum).CCoilTypeCh; } - CoilWaterInletNode = GetCoilWaterInletNode(state, CoolingCoilType, CoolingCoilName, ErrorsFound); - CoilWaterOutletNode = GetCoilWaterOutletNode(state, CoolingCoilType, CoolingCoilName, ErrorsFound); + CoilWaterInletNode = WaterCoils::GetCoilWaterInletNode(state, CoolingCoilType, CoolingCoilName, ErrorsFound); + CoilWaterOutletNode = WaterCoils::GetCoilWaterOutletNode(state, CoolingCoilType, CoolingCoilName, ErrorsFound); if (IsAutoSize) { PltSizCoolNum = MyPlantSizingIndex(CoolingCoilType, CoolingCoilName, CoilWaterInletNode, CoilWaterOutletNode, ErrorsFound); - CoilNum = GetWaterCoilIndex(state, CoolingCoilType, CoolingCoilName, ErrorsFound); - if (WaterCoil(CoilNum).UseDesignWaterDeltaTemp) { - WaterCoilSizDeltaT = WaterCoil(CoilNum).DesignWaterDeltaTemp; + CoilNum = WaterCoils::GetWaterCoilIndex(state, CoolingCoilType, CoolingCoilName, ErrorsFound); + if (state.dataWaterCoils->WaterCoil(CoilNum).UseDesignWaterDeltaTemp) { + WaterCoilSizDeltaT = state.dataWaterCoils->WaterCoil(CoilNum).DesignWaterDeltaTemp; DoWaterCoilSizing = true; } else { if (PltSizCoolNum > 0) { @@ -2472,8 +2467,8 @@ namespace UnitVentilator { CoolingCoilName = UnitVent(UnitVentNum).CCoilName; CoolingCoilType = UnitVent(UnitVentNum).CCoilTypeCh; } - SetCoilDesFlow(state, CoolingCoilType, CoolingCoilName, UnitVent(UnitVentNum).MaxAirVolFlow, ErrorsFound); - SetCoilDesFlow(state, UnitVent(UnitVentNum).HCoilTypeCh, UnitVent(UnitVentNum).HCoilName, UnitVent(UnitVentNum).MaxAirVolFlow, ErrorsFound); + WaterCoils::SetCoilDesFlow(state, CoolingCoilType, CoolingCoilName, UnitVent(UnitVentNum).MaxAirVolFlow, ErrorsFound); + WaterCoils::SetCoilDesFlow(state, UnitVent(UnitVentNum).HCoilTypeCh, UnitVent(UnitVentNum).HCoilName, UnitVent(UnitVentNum).MaxAirVolFlow, ErrorsFound); if (CurZoneEqNum > 0) { ZoneEqSizing(CurZoneEqNum).MaxHWVolFlow = UnitVent(UnitVentNum).MaxVolHotWaterFlow; diff --git a/src/EnergyPlus/VentilatedSlab.cc b/src/EnergyPlus/VentilatedSlab.cc index d6db0456d47..e84418f84b6 100644 --- a/src/EnergyPlus/VentilatedSlab.cc +++ b/src/EnergyPlus/VentilatedSlab.cc @@ -1751,11 +1751,6 @@ namespace VentilatedSlab { using ReportSizingManager::RequestSizing; using SteamCoils::GetCoilSteamInletNode; using SteamCoils::GetCoilSteamOutletNode; - using WaterCoils::GetCoilWaterInletNode; - using WaterCoils::GetCoilWaterOutletNode; - using WaterCoils::GetWaterCoilIndex; - using WaterCoils::SetCoilDesFlow; - using WaterCoils::WaterCoil; // SUBROUTINE PARAMETER DEFINITIONS: static std::string const RoutineName("SizeVentilatedSlab"); @@ -2059,14 +2054,14 @@ namespace VentilatedSlab { } else { // Autosize or hard-size with sizing run CheckZoneSizing(cMO_VentilatedSlab, VentSlab(Item).Name); - CoilWaterInletNode = GetCoilWaterInletNode(state, "Coil:Heating:Water", VentSlab(Item).HCoilName, ErrorsFound); - CoilWaterOutletNode = GetCoilWaterOutletNode(state, "Coil:Heating:Water", VentSlab(Item).HCoilName, ErrorsFound); + CoilWaterInletNode = WaterCoils::GetCoilWaterInletNode(state, "Coil:Heating:Water", VentSlab(Item).HCoilName, ErrorsFound); + CoilWaterOutletNode = WaterCoils::GetCoilWaterOutletNode(state, "Coil:Heating:Water", VentSlab(Item).HCoilName, ErrorsFound); if (IsAutoSize) { PltSizHeatNum = MyPlantSizingIndex("Coil:Heating:Water", VentSlab(Item).HCoilName, CoilWaterInletNode, CoilWaterOutletNode, ErrorsFound); - CoilNum = GetWaterCoilIndex(state, "COIL:HEATING:WATER", VentSlab(Item).HCoilName, ErrorsFound); - if (WaterCoil(CoilNum).UseDesignWaterDeltaTemp) { - WaterCoilSizDeltaT = WaterCoil(CoilNum).DesignWaterDeltaTemp; + CoilNum = WaterCoils::GetWaterCoilIndex(state, "COIL:HEATING:WATER", VentSlab(Item).HCoilName, ErrorsFound); + if (state.dataWaterCoils->WaterCoil(CoilNum).UseDesignWaterDeltaTemp) { + WaterCoilSizDeltaT = state.dataWaterCoils->WaterCoil(CoilNum).DesignWaterDeltaTemp; DoWaterCoilSizing = true; } else { if (PltSizHeatNum > 0) { @@ -2300,13 +2295,13 @@ namespace VentilatedSlab { CoolingCoilName = VentSlab(Item).CCoilName; CoolingCoilType = VentSlab(Item).CCoilTypeCh; } - CoilWaterInletNode = GetCoilWaterInletNode(state, CoolingCoilType, CoolingCoilName, ErrorsFound); - CoilWaterOutletNode = GetCoilWaterOutletNode(state, CoolingCoilType, CoolingCoilName, ErrorsFound); + CoilWaterInletNode = WaterCoils::GetCoilWaterInletNode(state, CoolingCoilType, CoolingCoilName, ErrorsFound); + CoilWaterOutletNode = WaterCoils::GetCoilWaterOutletNode(state, CoolingCoilType, CoolingCoilName, ErrorsFound); if (IsAutoSize) { PltSizCoolNum = MyPlantSizingIndex(CoolingCoilType, CoolingCoilName, CoilWaterInletNode, CoilWaterOutletNode, ErrorsFound); - CoilNum = GetWaterCoilIndex(state, CoolingCoilType, CoolingCoilName, ErrorsFound); - if (WaterCoil(CoilNum).UseDesignWaterDeltaTemp) { - WaterCoilSizDeltaT = WaterCoil(CoilNum).DesignWaterDeltaTemp; + CoilNum = WaterCoils::GetWaterCoilIndex(state, CoolingCoilType, CoolingCoilName, ErrorsFound); + if (state.dataWaterCoils->WaterCoil(CoilNum).UseDesignWaterDeltaTemp) { + WaterCoilSizDeltaT = state.dataWaterCoils->WaterCoil(CoilNum).DesignWaterDeltaTemp; DoWaterCoilSizing = true; } else { if (PltSizCoolNum > 0) { @@ -2408,8 +2403,8 @@ namespace VentilatedSlab { CoolingCoilName = VentSlab(Item).CCoilName; CoolingCoilType = VentSlab(Item).CCoilTypeCh; } - SetCoilDesFlow(state, CoolingCoilType, CoolingCoilName, VentSlab(Item).MaxAirVolFlow, ErrorsFound); - SetCoilDesFlow(state, VentSlab(Item).HCoilTypeCh, VentSlab(Item).HCoilName, VentSlab(Item).MaxAirVolFlow, ErrorsFound); + WaterCoils::SetCoilDesFlow(state, CoolingCoilType, CoolingCoilName, VentSlab(Item).MaxAirVolFlow, ErrorsFound); + WaterCoils::SetCoilDesFlow(state, VentSlab(Item).HCoilTypeCh, VentSlab(Item).HCoilName, VentSlab(Item).MaxAirVolFlow, ErrorsFound); if (CurZoneEqNum > 0) { ZoneEqSizing(CurZoneEqNum).MaxHWVolFlow = VentSlab(Item).MaxVolHotWaterFlow; diff --git a/src/EnergyPlus/WaterCoils.cc b/src/EnergyPlus/WaterCoils.cc index c16e0493ede..29e9bdc22c5 100644 --- a/src/EnergyPlus/WaterCoils.cc +++ b/src/EnergyPlus/WaterCoils.cc @@ -86,6 +86,7 @@ #include #include #include +#include #include #include #include @@ -147,104 +148,9 @@ namespace WaterCoils { // MODULE PARAMETER DEFINITIONS static std::string const BlankString; - int const MaxPolynomOrder(4); - int const MaxOrderedPairs(60); - - Real64 const PolyConvgTol(1.E-05); - Real64 const MinWaterMassFlowFrac(0.000001); - Real64 const MinAirMassFlow(0.001); - - // coil types in this module - int const WaterCoil_SimpleHeating(TypeOf_CoilWaterSimpleHeating); - int const WaterCoil_DetFlatFinCooling(TypeOf_CoilWaterDetailedFlatCooling); - int const WaterCoil_Cooling(TypeOf_CoilWaterCooling); - - int const CoilType_Cooling(1); - int const CoilType_Heating(2); - - int const CoilModel_Simple(1); - int const CoilModel_Cooling(2); - int const CoilModel_Detailed(3); - - // Parameters for Heat Exchanger Configuration - int const CounterFlow(1); - int const CrossFlow(2); - int const SimpleAnalysis(1); - int const DetailedAnalysis(2); - - // Water Systems - int const CondensateDiscarded(1001); // default mode where water is "lost" - int const CondensateToTank(1002); // collect coil condensate from air and store in water storage tank - - // Parameters for COIL:Water:SimpleHeating Coil Performance Input Method - int const UAandFlow(1); // for Coil Performance Input Method = UA and Design Water Flow Rate - int const NomCap(2); // for Coil Performance Input Method = Nominal Capacity - - // Parameters Subroutine CoolingCoil: design calc or simulation calc. - int const DesignCalc(1); // ignore on/off check in CoolingCoil - int const SimCalc(2); // pay attention to on/off check in CoolingCoil - - // DERIVED TYPE DEFINITIONS - - // MODULE VARIABLE DECLARATIONS: - int NumWaterCoils(0); // The Number of WaterCoils found in the Input - Array1D_bool MySizeFlag; - Array1D_bool MyUAAndFlowCalcFlag; - Array1D_bool MyCoilDesignFlag; - Array1D_bool CoilWarningOnceFlag; - Array1D_int WaterTempCoolCoilErrs; // error counting for detailed coils - Array1D_int PartWetCoolCoilErrs; // error counting for detailed coils - bool GetWaterCoilsInputFlag(true); // Flag set to make sure you get input once - bool WaterCoilControllerCheckOneTimeFlag(true); // flg used to check water coil controller - Array1D_bool CheckEquipName; - namespace { - // These were static variables within different functions. They were pulled out into the namespace - // to facilitate easier unit testing of those functions. - // These are purposefully not in the header file as an extern variable. No one outside of this should - // use these. They are cleared by clear_state() for use by unit tests, but normal simulations should be unaffected. - // This is purposefully in an anonymous namespace so nothing outside this implementation file can use it. - bool InitWaterCoilOneTimeFlag(true); - } // namespace - // Subroutine Specifications for the Module - // Driver/Manager Routines - - // Get Input routines for module - - // Initialization routines for module - - // Algorithms for the module - - // Update routine to check convergence and update nodes - - // Reporting routines for module - - // Other routines - - // Object Data - Array1D WaterCoil; - Array1D WaterCoilNumericFields; - // MODULE SUBROUTINES: //************************************************************************* - // Functions - void clear_state() - { - NumWaterCoils = 0; - InitWaterCoilOneTimeFlag = true; - MySizeFlag.deallocate(); - MyUAAndFlowCalcFlag.deallocate(); - MyCoilDesignFlag.deallocate(); - CoilWarningOnceFlag.deallocate(); - WaterTempCoolCoilErrs.deallocate(); - PartWetCoolCoilErrs.deallocate(); - GetWaterCoilsInputFlag = true; - CheckEquipName.deallocate(); - WaterCoil.deallocate(); - WaterCoilNumericFields.deallocate(); - WaterCoilControllerCheckOneTimeFlag = true; - } - void SimulateWaterCoilComponents(EnergyPlusData &state, std::string const &CompName, bool const FirstHVACIteration, int &CompIndex, @@ -273,30 +179,30 @@ namespace WaterCoils { // FLOW: // Obtains and Allocates WaterCoil related parameters from input file - if (GetWaterCoilsInputFlag) { // First time subroutine has been entered + if (state.dataWaterCoils->GetWaterCoilsInputFlag) { // First time subroutine has been entered GetWaterCoilInput(state); - GetWaterCoilsInputFlag = false; + state.dataWaterCoils->GetWaterCoilsInputFlag = false; } // Find the correct WaterCoilNumber with the Coil Name if (CompIndex == 0) { - CoilNum = UtilityRoutines::FindItemInList(CompName, WaterCoil); + CoilNum = UtilityRoutines::FindItemInList(CompName, state.dataWaterCoils->WaterCoil); if (CoilNum == 0) { ShowFatalError("SimulateWaterCoilComponents: Coil not found=" + CompName); } CompIndex = CoilNum; } else { CoilNum = CompIndex; - if (CoilNum > NumWaterCoils || CoilNum < 1) { + if (CoilNum > state.dataWaterCoils->NumWaterCoils || CoilNum < 1) { ShowFatalError("SimulateWaterCoilComponents: Invalid CompIndex passed=" + TrimSigDigits(CoilNum) + - ", Number of Water Coils=" + TrimSigDigits(NumWaterCoils) + ", Coil name=" + CompName); + ", Number of Water Coils=" + TrimSigDigits(state.dataWaterCoils->NumWaterCoils) + ", Coil name=" + CompName); } - if (CheckEquipName(CoilNum)) { - if (CompName != WaterCoil(CoilNum).Name) { + if (state.dataWaterCoils->CheckEquipName(CoilNum)) { + if (CompName != state.dataWaterCoils->WaterCoil(CoilNum).Name) { ShowFatalError("SimulateWaterCoilComponents: Invalid CompIndex passed=" + TrimSigDigits(CoilNum) + ", Coil name=" + CompName + - ", stored Coil Name for that index=" + WaterCoil(CoilNum).Name); + ", stored Coil Name for that index=" + state.dataWaterCoils->WaterCoil(CoilNum).Name); } - CheckEquipName(CoilNum) = false; + state.dataWaterCoils->CheckEquipName(CoilNum) = false; } } @@ -315,24 +221,24 @@ namespace WaterCoils { } // Calculate the Correct WaterCoil Model with the current CoilNum - if (WaterCoil(CoilNum).WaterCoilType_Num == WaterCoil_DetFlatFinCooling) { - CalcDetailFlatFinCoolingCoil(CoilNum, SimCalc, OpMode, PartLoadFrac); - if (present(QActual)) QActual = WaterCoil(CoilNum).SenWaterCoolingCoilRate; - } else if (WaterCoil(CoilNum).WaterCoilType_Num == WaterCoil_Cooling) { - CoolingCoil(CoilNum, FirstHVACIteration, SimCalc, OpMode, PartLoadFrac); - if (present(QActual)) QActual = WaterCoil(CoilNum).SenWaterCoolingCoilRate; + if (state.dataWaterCoils->WaterCoil(CoilNum).WaterCoilType_Num == state.dataWaterCoils->WaterCoil_DetFlatFinCooling) { + CalcDetailFlatFinCoolingCoil(state, CoilNum, state.dataWaterCoils->SimCalc, OpMode, PartLoadFrac); + if (present(QActual)) QActual = state.dataWaterCoils->WaterCoil(CoilNum).SenWaterCoolingCoilRate; + } else if (state.dataWaterCoils->WaterCoil(CoilNum).WaterCoilType_Num == state.dataWaterCoils->WaterCoil_Cooling) { + CoolingCoil(state, CoilNum, FirstHVACIteration, state.dataWaterCoils->SimCalc, OpMode, PartLoadFrac); + if (present(QActual)) QActual = state.dataWaterCoils->WaterCoil(CoilNum).SenWaterCoolingCoilRate; } - if (WaterCoil(CoilNum).WaterCoilType_Num == WaterCoil_SimpleHeating) { - CalcSimpleHeatingCoil(CoilNum, OpMode, PartLoadFrac, SimCalc); - if (present(QActual)) QActual = WaterCoil(CoilNum).TotWaterHeatingCoilRate; + if (state.dataWaterCoils->WaterCoil(CoilNum).WaterCoilType_Num == state.dataWaterCoils->WaterCoil_SimpleHeating) { + CalcSimpleHeatingCoil(state, CoilNum, OpMode, PartLoadFrac, state.dataWaterCoils->SimCalc); + if (present(QActual)) QActual = state.dataWaterCoils->WaterCoil(CoilNum).TotWaterHeatingCoilRate; } // Update the current WaterCoil to the outlet nodes - UpdateWaterCoil(CoilNum); + UpdateWaterCoil(state, CoilNum); // Report the current WaterCoil - ReportWaterCoil(CoilNum); + ReportWaterCoil(state, CoilNum); } // Get Input Section of the Module @@ -395,14 +301,14 @@ namespace WaterCoils { NumSimpHeat = inputProcessor->getNumObjectsFound("Coil:Heating:Water"); NumFlatFin = inputProcessor->getNumObjectsFound("Coil:Cooling:Water:DetailedGeometry"); NumCooling = inputProcessor->getNumObjectsFound("Coil:Cooling:Water"); - NumWaterCoils = NumSimpHeat + NumFlatFin + NumCooling; - - if (NumWaterCoils > 0) { - WaterCoil.allocate(NumWaterCoils); - WaterCoilNumericFields.allocate(NumWaterCoils); - WaterTempCoolCoilErrs.dimension(NumWaterCoils, 0); - PartWetCoolCoilErrs.dimension(NumWaterCoils, 0); - CheckEquipName.dimension(NumWaterCoils, true); + state.dataWaterCoils->NumWaterCoils = NumSimpHeat + NumFlatFin + NumCooling; + + if (state.dataWaterCoils->NumWaterCoils > 0) { + state.dataWaterCoils->WaterCoil.allocate(state.dataWaterCoils->NumWaterCoils); + state.dataWaterCoils->WaterCoilNumericFields.allocate(state.dataWaterCoils->NumWaterCoils); + state.dataWaterCoils->WaterTempCoolCoilErrs.dimension(state.dataWaterCoils->NumWaterCoils, 0); + state.dataWaterCoils->PartWetCoolCoilErrs.dimension(state.dataWaterCoils->NumWaterCoils, 0); + state.dataWaterCoils->CheckEquipName.dimension(state.dataWaterCoils->NumWaterCoils, true); } inputProcessor->getObjectDefMaxArgs("Coil:Heating:Water", TotalArgs, NumAlphas, NumNums); @@ -440,89 +346,89 @@ namespace WaterCoils { cAlphaFields, cNumericFields); - WaterCoilNumericFields(CoilNum).FieldNames.allocate(MaxNums); - WaterCoilNumericFields(CoilNum).FieldNames = ""; - WaterCoilNumericFields(CoilNum).FieldNames = cNumericFields; + state.dataWaterCoils->WaterCoilNumericFields(CoilNum).FieldNames.allocate(MaxNums); + state.dataWaterCoils->WaterCoilNumericFields(CoilNum).FieldNames = ""; + state.dataWaterCoils->WaterCoilNumericFields(CoilNum).FieldNames = cNumericFields; UtilityRoutines::IsNameEmpty(AlphArray(1), cCurrentModuleObject, ErrorsFound); // ErrorsFound will be set to True if problem was found, left untouched otherwise VerifyUniqueCoilName(CurrentModuleObject, AlphArray(1), ErrorsFound, CurrentModuleObject + " Name"); - WaterCoil(CoilNum).Name = AlphArray(1); - WaterCoil(CoilNum).Schedule = AlphArray(2); + state.dataWaterCoils->WaterCoil(CoilNum).Name = AlphArray(1); + state.dataWaterCoils->WaterCoil(CoilNum).Schedule = AlphArray(2); if (lAlphaBlanks(2)) { - WaterCoil(CoilNum).SchedPtr = ScheduleAlwaysOn; + state.dataWaterCoils->WaterCoil(CoilNum).SchedPtr = ScheduleAlwaysOn; } else { - WaterCoil(CoilNum).SchedPtr = GetScheduleIndex(AlphArray(2)); - if (WaterCoil(CoilNum).SchedPtr == 0) { + state.dataWaterCoils->WaterCoil(CoilNum).SchedPtr = GetScheduleIndex(AlphArray(2)); + if (state.dataWaterCoils->WaterCoil(CoilNum).SchedPtr == 0) { ShowSevereError(CurrentModuleObject + ": invalid " + cAlphaFields(2) + " entered =" + AlphArray(2) + " for " + cAlphaFields(1) + '=' + AlphArray(1)); ErrorsFound = true; } } - WaterCoil(CoilNum).WaterCoilTypeA = "Heating"; - WaterCoil(CoilNum).WaterCoilType = CoilType_Heating; // 'Heating' - WaterCoil(CoilNum).WaterCoilModelA = "SIMPLE"; - WaterCoil(CoilNum).WaterCoilModel = CoilModel_Simple; // 'SIMPLE' - WaterCoil(CoilNum).WaterCoilType_Num = WaterCoil_SimpleHeating; + state.dataWaterCoils->WaterCoil(CoilNum).WaterCoilTypeA = "Heating"; + state.dataWaterCoils->WaterCoil(CoilNum).WaterCoilType = state.dataWaterCoils->CoilType_Heating; // 'Heating' + state.dataWaterCoils->WaterCoil(CoilNum).WaterCoilModelA = "SIMPLE"; + state.dataWaterCoils->WaterCoil(CoilNum).WaterCoilModel = state.dataWaterCoils->CoilModel_Simple; // 'SIMPLE' + state.dataWaterCoils->WaterCoil(CoilNum).WaterCoilType_Num = state.dataWaterCoils->WaterCoil_SimpleHeating; - WaterCoil(CoilNum).UACoil = NumArray(1); - WaterCoil(CoilNum).UACoilVariable = WaterCoil(CoilNum).UACoil; - WaterCoil(CoilNum).MaxWaterVolFlowRate = NumArray(2); - WaterCoil(CoilNum).WaterInletNodeNum = GetOnlySingleNode( + state.dataWaterCoils->WaterCoil(CoilNum).UACoil = NumArray(1); + state.dataWaterCoils->WaterCoil(CoilNum).UACoilVariable = state.dataWaterCoils->WaterCoil(CoilNum).UACoil; + state.dataWaterCoils->WaterCoil(CoilNum).MaxWaterVolFlowRate = NumArray(2); + state.dataWaterCoils->WaterCoil(CoilNum).WaterInletNodeNum = GetOnlySingleNode( AlphArray(3), ErrorsFound, CurrentModuleObject, AlphArray(1), NodeType_Water, NodeConnectionType_Inlet, 2, ObjectIsNotParent); - WaterCoil(CoilNum).WaterOutletNodeNum = GetOnlySingleNode( + state.dataWaterCoils->WaterCoil(CoilNum).WaterOutletNodeNum = GetOnlySingleNode( AlphArray(4), ErrorsFound, CurrentModuleObject, AlphArray(1), NodeType_Water, NodeConnectionType_Outlet, 2, ObjectIsNotParent); - WaterCoil(CoilNum).AirInletNodeNum = GetOnlySingleNode( + state.dataWaterCoils->WaterCoil(CoilNum).AirInletNodeNum = GetOnlySingleNode( AlphArray(5), ErrorsFound, CurrentModuleObject, AlphArray(1), NodeType_Air, NodeConnectionType_Inlet, 1, ObjectIsNotParent); - WaterCoil(CoilNum).AirOutletNodeNum = GetOnlySingleNode( + state.dataWaterCoils->WaterCoil(CoilNum).AirOutletNodeNum = GetOnlySingleNode( AlphArray(6), ErrorsFound, CurrentModuleObject, AlphArray(1), NodeType_Air, NodeConnectionType_Outlet, 1, ObjectIsNotParent); { auto const SELECT_CASE_var(AlphArray(7)); if (SELECT_CASE_var == "UFACTORTIMESAREAANDDESIGNWATERFLOWRATE") { - WaterCoil(CoilNum).CoilPerfInpMeth = UAandFlow; + state.dataWaterCoils->WaterCoil(CoilNum).CoilPerfInpMeth = state.dataWaterCoils->UAandFlow; } else if (SELECT_CASE_var == "NOMINALCAPACITY") { - WaterCoil(CoilNum).CoilPerfInpMeth = NomCap; + state.dataWaterCoils->WaterCoil(CoilNum).CoilPerfInpMeth = state.dataWaterCoils->NomCap; } else { // will be caught by input processor - WaterCoil(CoilNum).CoilPerfInpMeth = UAandFlow; + state.dataWaterCoils->WaterCoil(CoilNum).CoilPerfInpMeth = state.dataWaterCoils->UAandFlow; } } - WaterCoil(CoilNum).DesTotWaterCoilLoad = NumArray(3); + state.dataWaterCoils->WaterCoil(CoilNum).DesTotWaterCoilLoad = NumArray(3); - if (WaterCoil(CoilNum).UACoil == AutoSize && WaterCoil(CoilNum).CoilPerfInpMeth == UAandFlow) - WaterCoil(CoilNum).RequestingAutoSize = true; - if (WaterCoil(CoilNum).MaxWaterVolFlowRate == AutoSize) WaterCoil(CoilNum).RequestingAutoSize = true; - if (WaterCoil(CoilNum).DesTotWaterCoilLoad == AutoSize && WaterCoil(CoilNum).CoilPerfInpMeth == NomCap) - WaterCoil(CoilNum).RequestingAutoSize = true; + if (state.dataWaterCoils->WaterCoil(CoilNum).UACoil == AutoSize && state.dataWaterCoils->WaterCoil(CoilNum).CoilPerfInpMeth == state.dataWaterCoils->UAandFlow) + state.dataWaterCoils->WaterCoil(CoilNum).RequestingAutoSize = true; + if (state.dataWaterCoils->WaterCoil(CoilNum).MaxWaterVolFlowRate == AutoSize) state.dataWaterCoils->WaterCoil(CoilNum).RequestingAutoSize = true; + if (state.dataWaterCoils->WaterCoil(CoilNum).DesTotWaterCoilLoad == AutoSize && state.dataWaterCoils->WaterCoil(CoilNum).CoilPerfInpMeth == state.dataWaterCoils->NomCap) + state.dataWaterCoils->WaterCoil(CoilNum).RequestingAutoSize = true; - WaterCoil(CoilNum).DesInletWaterTemp = NumArray(4); - WaterCoil(CoilNum).DesInletAirTemp = NumArray(5); - WaterCoil(CoilNum).DesOutletWaterTemp = NumArray(6); - WaterCoil(CoilNum).DesOutletAirTemp = NumArray(7); - WaterCoil(CoilNum).RatioAirSideToWaterSideConvect = NumArray(8); + state.dataWaterCoils->WaterCoil(CoilNum).DesInletWaterTemp = NumArray(4); + state.dataWaterCoils->WaterCoil(CoilNum).DesInletAirTemp = NumArray(5); + state.dataWaterCoils->WaterCoil(CoilNum).DesOutletWaterTemp = NumArray(6); + state.dataWaterCoils->WaterCoil(CoilNum).DesOutletAirTemp = NumArray(7); + state.dataWaterCoils->WaterCoil(CoilNum).RatioAirSideToWaterSideConvect = NumArray(8); if (!lNumericBlanks(9)) { - WaterCoil(CoilNum).DesignWaterDeltaTemp = NumArray(9); - WaterCoil(CoilNum).UseDesignWaterDeltaTemp = true; + state.dataWaterCoils->WaterCoil(CoilNum).DesignWaterDeltaTemp = NumArray(9); + state.dataWaterCoils->WaterCoil(CoilNum).UseDesignWaterDeltaTemp = true; } else { - WaterCoil(CoilNum).UseDesignWaterDeltaTemp = false; + state.dataWaterCoils->WaterCoil(CoilNum).UseDesignWaterDeltaTemp = false; } - if (WaterCoil(CoilNum).DesInletWaterTemp <= WaterCoil(CoilNum).DesOutletWaterTemp) { + if (state.dataWaterCoils->WaterCoil(CoilNum).DesInletWaterTemp <= state.dataWaterCoils->WaterCoil(CoilNum).DesOutletWaterTemp) { ShowSevereError("For " + CurrentModuleObject + ", " + AlphArray(1)); ShowContinueError(" the " + cNumericFields(4) + " must be greater than the " + cNumericFields(6) + '.'); ErrorsFound = true; } - if (WaterCoil(CoilNum).DesInletAirTemp >= WaterCoil(CoilNum).DesOutletAirTemp) { + if (state.dataWaterCoils->WaterCoil(CoilNum).DesInletAirTemp >= state.dataWaterCoils->WaterCoil(CoilNum).DesOutletAirTemp) { ShowSevereError("For " + CurrentModuleObject + ", " + AlphArray(1)); ShowContinueError(" the " + cNumericFields(5) + " must be less than the " + cNumericFields(7) + '.'); ErrorsFound = true; } - if (WaterCoil(CoilNum).DesInletAirTemp >= WaterCoil(CoilNum).DesInletWaterTemp) { + if (state.dataWaterCoils->WaterCoil(CoilNum).DesInletAirTemp >= state.dataWaterCoils->WaterCoil(CoilNum).DesInletWaterTemp) { ShowSevereError("For " + CurrentModuleObject + ", " + AlphArray(1)); ShowContinueError(" the " + cNumericFields(5) + " must be less than the " + cNumericFields(4) + '.'); ErrorsFound = true; @@ -535,10 +441,10 @@ namespace WaterCoils { // CurrentModuleObject = "Coil:Heating:Water" SetupOutputVariable("Heating Coil Heating Energy", OutputProcessor::Unit::J, - WaterCoil(CoilNum).TotWaterHeatingCoilEnergy, + state.dataWaterCoils->WaterCoil(CoilNum).TotWaterHeatingCoilEnergy, "System", "Sum", - WaterCoil(CoilNum).Name, + state.dataWaterCoils->WaterCoil(CoilNum).Name, _, "ENERGYTRANSFER", "HEATINGCOILS", @@ -546,10 +452,10 @@ namespace WaterCoils { "System"); SetupOutputVariable("Heating Coil Source Side Heat Transfer Energy", OutputProcessor::Unit::J, - WaterCoil(CoilNum).TotWaterHeatingCoilEnergy, + state.dataWaterCoils->WaterCoil(CoilNum).TotWaterHeatingCoilEnergy, "System", "Sum", - WaterCoil(CoilNum).Name, + state.dataWaterCoils->WaterCoil(CoilNum).Name, _, "PLANTLOOPHEATINGDEMAND", "HEATINGCOILS", @@ -557,16 +463,16 @@ namespace WaterCoils { "System"); SetupOutputVariable("Heating Coil Heating Rate", OutputProcessor::Unit::W, - WaterCoil(CoilNum).TotWaterHeatingCoilRate, + state.dataWaterCoils->WaterCoil(CoilNum).TotWaterHeatingCoilRate, "System", "Average", - WaterCoil(CoilNum).Name); + state.dataWaterCoils->WaterCoil(CoilNum).Name); SetupOutputVariable("Heating Coil U Factor Times Area Value", OutputProcessor::Unit::W_K, - WaterCoil(CoilNum).UACoilVariable, + state.dataWaterCoils->WaterCoil(CoilNum).UACoilVariable, "System", "Average", - WaterCoil(CoilNum).Name); + state.dataWaterCoils->WaterCoil(CoilNum).Name); } CurrentModuleObject = "Coil:Cooling:Water:DetailedGeometry"; @@ -587,99 +493,99 @@ namespace WaterCoils { cAlphaFields, cNumericFields); - WaterCoilNumericFields(CoilNum).FieldNames.allocate(MaxNums); - WaterCoilNumericFields(CoilNum).FieldNames = ""; - WaterCoilNumericFields(CoilNum).FieldNames = cNumericFields; + state.dataWaterCoils->WaterCoilNumericFields(CoilNum).FieldNames.allocate(MaxNums); + state.dataWaterCoils->WaterCoilNumericFields(CoilNum).FieldNames = ""; + state.dataWaterCoils->WaterCoilNumericFields(CoilNum).FieldNames = cNumericFields; UtilityRoutines::IsNameEmpty(AlphArray(1), cCurrentModuleObject, ErrorsFound); // ErrorsFound will be set to True if problem was found, left untouched otherwise VerifyUniqueCoilName(CurrentModuleObject, AlphArray(1), ErrorsFound, CurrentModuleObject + " Name"); - WaterCoil(CoilNum).Name = AlphArray(1); - WaterCoil(CoilNum).Schedule = AlphArray(2); + state.dataWaterCoils->WaterCoil(CoilNum).Name = AlphArray(1); + state.dataWaterCoils->WaterCoil(CoilNum).Schedule = AlphArray(2); if (lAlphaBlanks(2)) { - WaterCoil(CoilNum).SchedPtr = ScheduleAlwaysOn; + state.dataWaterCoils->WaterCoil(CoilNum).SchedPtr = ScheduleAlwaysOn; } else { - WaterCoil(CoilNum).SchedPtr = GetScheduleIndex(AlphArray(2)); - if (WaterCoil(CoilNum).SchedPtr == 0) { + state.dataWaterCoils->WaterCoil(CoilNum).SchedPtr = GetScheduleIndex(AlphArray(2)); + if (state.dataWaterCoils->WaterCoil(CoilNum).SchedPtr == 0) { ShowSevereError(CurrentModuleObject + ": invalid " + cAlphaFields(2) + " entered =" + AlphArray(2) + " for " + cAlphaFields(1) + '=' + AlphArray(1)); ErrorsFound = true; } } - WaterCoil(CoilNum).WaterCoilTypeA = "Cooling"; - WaterCoil(CoilNum).WaterCoilType = CoilType_Cooling; // 'Cooling' - WaterCoil(CoilNum).WaterCoilModelA = "DETAILED FLAT FIN"; - WaterCoil(CoilNum).WaterCoilModel = CoilModel_Detailed; // 'DETAILED FLAT FIN' - WaterCoil(CoilNum).WaterCoilType_Num = WaterCoil_DetFlatFinCooling; - - WaterCoil(CoilNum).MaxWaterVolFlowRate = NumArray(1); - if (WaterCoil(CoilNum).MaxWaterVolFlowRate == AutoSize) WaterCoil(CoilNum).RequestingAutoSize = true; - WaterCoil(CoilNum).TubeOutsideSurfArea = NumArray(2); - if (WaterCoil(CoilNum).TubeOutsideSurfArea == AutoSize) WaterCoil(CoilNum).RequestingAutoSize = true; - WaterCoil(CoilNum).TotTubeInsideArea = NumArray(3); - if (WaterCoil(CoilNum).TotTubeInsideArea == AutoSize) WaterCoil(CoilNum).RequestingAutoSize = true; - WaterCoil(CoilNum).FinSurfArea = NumArray(4); - if (WaterCoil(CoilNum).FinSurfArea == AutoSize) WaterCoil(CoilNum).RequestingAutoSize = true; - WaterCoil(CoilNum).MinAirFlowArea = NumArray(5); - if (WaterCoil(CoilNum).MinAirFlowArea == AutoSize) WaterCoil(CoilNum).RequestingAutoSize = true; - WaterCoil(CoilNum).CoilDepth = NumArray(6); - if (WaterCoil(CoilNum).CoilDepth == AutoSize) WaterCoil(CoilNum).RequestingAutoSize = true; - WaterCoil(CoilNum).FinDiam = NumArray(7); - if (WaterCoil(CoilNum).FinDiam == AutoSize) WaterCoil(CoilNum).RequestingAutoSize = true; - WaterCoil(CoilNum).FinThickness = NumArray(8); - if (WaterCoil(CoilNum).FinThickness <= 0.0) { + state.dataWaterCoils->WaterCoil(CoilNum).WaterCoilTypeA = "Cooling"; + state.dataWaterCoils->WaterCoil(CoilNum).WaterCoilType = state.dataWaterCoils->CoilType_Cooling; // 'Cooling' + state.dataWaterCoils->WaterCoil(CoilNum).WaterCoilModelA = "DETAILED FLAT FIN"; + state.dataWaterCoils->WaterCoil(CoilNum).WaterCoilModel = state.dataWaterCoils->CoilModel_Detailed; // 'DETAILED FLAT FIN' + state.dataWaterCoils->WaterCoil(CoilNum).WaterCoilType_Num = state.dataWaterCoils->WaterCoil_DetFlatFinCooling; + + state.dataWaterCoils->WaterCoil(CoilNum).MaxWaterVolFlowRate = NumArray(1); + if (state.dataWaterCoils->WaterCoil(CoilNum).MaxWaterVolFlowRate == AutoSize) state.dataWaterCoils->WaterCoil(CoilNum).RequestingAutoSize = true; + state.dataWaterCoils->WaterCoil(CoilNum).TubeOutsideSurfArea = NumArray(2); + if (state.dataWaterCoils->WaterCoil(CoilNum).TubeOutsideSurfArea == AutoSize) state.dataWaterCoils->WaterCoil(CoilNum).RequestingAutoSize = true; + state.dataWaterCoils->WaterCoil(CoilNum).TotTubeInsideArea = NumArray(3); + if (state.dataWaterCoils->WaterCoil(CoilNum).TotTubeInsideArea == AutoSize) state.dataWaterCoils->WaterCoil(CoilNum).RequestingAutoSize = true; + state.dataWaterCoils->WaterCoil(CoilNum).FinSurfArea = NumArray(4); + if (state.dataWaterCoils->WaterCoil(CoilNum).FinSurfArea == AutoSize) state.dataWaterCoils->WaterCoil(CoilNum).RequestingAutoSize = true; + state.dataWaterCoils->WaterCoil(CoilNum).MinAirFlowArea = NumArray(5); + if (state.dataWaterCoils->WaterCoil(CoilNum).MinAirFlowArea == AutoSize) state.dataWaterCoils->WaterCoil(CoilNum).RequestingAutoSize = true; + state.dataWaterCoils->WaterCoil(CoilNum).CoilDepth = NumArray(6); + if (state.dataWaterCoils->WaterCoil(CoilNum).CoilDepth == AutoSize) state.dataWaterCoils->WaterCoil(CoilNum).RequestingAutoSize = true; + state.dataWaterCoils->WaterCoil(CoilNum).FinDiam = NumArray(7); + if (state.dataWaterCoils->WaterCoil(CoilNum).FinDiam == AutoSize) state.dataWaterCoils->WaterCoil(CoilNum).RequestingAutoSize = true; + state.dataWaterCoils->WaterCoil(CoilNum).FinThickness = NumArray(8); + if (state.dataWaterCoils->WaterCoil(CoilNum).FinThickness <= 0.0) { ShowSevereError(CurrentModuleObject + ": " + cNumericFields(8) + " must be > 0.0, for " + cAlphaFields(1) + " = " + - WaterCoil(CoilNum).Name); + state.dataWaterCoils->WaterCoil(CoilNum).Name); ErrorsFound = true; } - WaterCoil(CoilNum).TubeInsideDiam = NumArray(9); - WaterCoil(CoilNum).TubeOutsideDiam = NumArray(10); - WaterCoil(CoilNum).TubeThermConductivity = NumArray(11); - if (WaterCoil(CoilNum).TubeThermConductivity <= 0.0) { + state.dataWaterCoils->WaterCoil(CoilNum).TubeInsideDiam = NumArray(9); + state.dataWaterCoils->WaterCoil(CoilNum).TubeOutsideDiam = NumArray(10); + state.dataWaterCoils->WaterCoil(CoilNum).TubeThermConductivity = NumArray(11); + if (state.dataWaterCoils->WaterCoil(CoilNum).TubeThermConductivity <= 0.0) { ShowSevereError(CurrentModuleObject + ": " + cNumericFields(11) + " must be > 0.0, for " + cAlphaFields(1) + " = " + - WaterCoil(CoilNum).Name); + state.dataWaterCoils->WaterCoil(CoilNum).Name); ErrorsFound = true; } - WaterCoil(CoilNum).FinThermConductivity = NumArray(12); - if (WaterCoil(CoilNum).FinThermConductivity <= 0.0) { + state.dataWaterCoils->WaterCoil(CoilNum).FinThermConductivity = NumArray(12); + if (state.dataWaterCoils->WaterCoil(CoilNum).FinThermConductivity <= 0.0) { ShowSevereError(CurrentModuleObject + ": " + cNumericFields(12) + " must be > 0.0, for " + cAlphaFields(1) + " = " + - WaterCoil(CoilNum).Name); + state.dataWaterCoils->WaterCoil(CoilNum).Name); ErrorsFound = true; } - WaterCoil(CoilNum).FinSpacing = NumArray(13); - WaterCoil(CoilNum).TubeDepthSpacing = NumArray(14); - WaterCoil(CoilNum).NumOfTubeRows = NumArray(15); - WaterCoil(CoilNum).NumOfTubesPerRow = NumArray(16); - if (WaterCoil(CoilNum).NumOfTubesPerRow == AutoSize) WaterCoil(CoilNum).RequestingAutoSize = true; + state.dataWaterCoils->WaterCoil(CoilNum).FinSpacing = NumArray(13); + state.dataWaterCoils->WaterCoil(CoilNum).TubeDepthSpacing = NumArray(14); + state.dataWaterCoils->WaterCoil(CoilNum).NumOfTubeRows = NumArray(15); + state.dataWaterCoils->WaterCoil(CoilNum).NumOfTubesPerRow = NumArray(16); + if (state.dataWaterCoils->WaterCoil(CoilNum).NumOfTubesPerRow == AutoSize) state.dataWaterCoils->WaterCoil(CoilNum).RequestingAutoSize = true; if (!lNumericBlanks(17)) { - WaterCoil(CoilNum).DesignWaterDeltaTemp = NumArray(17); - WaterCoil(CoilNum).UseDesignWaterDeltaTemp = true; + state.dataWaterCoils->WaterCoil(CoilNum).DesignWaterDeltaTemp = NumArray(17); + state.dataWaterCoils->WaterCoil(CoilNum).UseDesignWaterDeltaTemp = true; } else { - WaterCoil(CoilNum).UseDesignWaterDeltaTemp = false; + state.dataWaterCoils->WaterCoil(CoilNum).UseDesignWaterDeltaTemp = false; } - WaterCoil(CoilNum).WaterInletNodeNum = GetOnlySingleNode( + state.dataWaterCoils->WaterCoil(CoilNum).WaterInletNodeNum = GetOnlySingleNode( AlphArray(3), ErrorsFound, CurrentModuleObject, AlphArray(1), NodeType_Water, NodeConnectionType_Inlet, 2, ObjectIsNotParent); - WaterCoil(CoilNum).WaterOutletNodeNum = GetOnlySingleNode( + state.dataWaterCoils->WaterCoil(CoilNum).WaterOutletNodeNum = GetOnlySingleNode( AlphArray(4), ErrorsFound, CurrentModuleObject, AlphArray(1), NodeType_Water, NodeConnectionType_Outlet, 2, ObjectIsNotParent); - WaterCoil(CoilNum).AirInletNodeNum = GetOnlySingleNode( + state.dataWaterCoils->WaterCoil(CoilNum).AirInletNodeNum = GetOnlySingleNode( AlphArray(5), ErrorsFound, CurrentModuleObject, AlphArray(1), NodeType_Air, NodeConnectionType_Inlet, 1, ObjectIsNotParent); - WaterCoil(CoilNum).AirOutletNodeNum = GetOnlySingleNode( + state.dataWaterCoils->WaterCoil(CoilNum).AirOutletNodeNum = GetOnlySingleNode( AlphArray(6), ErrorsFound, CurrentModuleObject, AlphArray(1), NodeType_Air, NodeConnectionType_Outlet, 1, ObjectIsNotParent); // A7 ; \field Name of Water Storage Tank for Condensate Collection - WaterCoil(CoilNum).CondensateCollectName = AlphArray(7); + state.dataWaterCoils->WaterCoil(CoilNum).CondensateCollectName = AlphArray(7); if (lAlphaBlanks(7)) { - WaterCoil(CoilNum).CondensateCollectMode = CondensateDiscarded; + state.dataWaterCoils->WaterCoil(CoilNum).CondensateCollectMode = state.dataWaterCoils->CondensateDiscarded; } else { - WaterCoil(CoilNum).CondensateCollectMode = CondensateToTank; - SetupTankSupplyComponent(state, WaterCoil(CoilNum).Name, + state.dataWaterCoils->WaterCoil(CoilNum).CondensateCollectMode = state.dataWaterCoils->CondensateToTank; + SetupTankSupplyComponent(state, state.dataWaterCoils->WaterCoil(CoilNum).Name, CurrentModuleObject, - WaterCoil(CoilNum).CondensateCollectName, + state.dataWaterCoils->WaterCoil(CoilNum).CondensateCollectName, ErrorsFound, - WaterCoil(CoilNum).CondensateTankID, - WaterCoil(CoilNum).CondensateTankSupplyARRID); + state.dataWaterCoils->WaterCoil(CoilNum).CondensateTankID, + state.dataWaterCoils->WaterCoil(CoilNum).CondensateTankSupplyARRID); } TestCompSet(CurrentModuleObject, AlphArray(1), AlphArray(3), AlphArray(4), "Water Nodes"); @@ -689,10 +595,10 @@ namespace WaterCoils { // CurrentModuleObject = "Coil:Cooling:Water:DetailedGeometry" SetupOutputVariable("Cooling Coil Total Cooling Energy", OutputProcessor::Unit::J, - WaterCoil(CoilNum).TotWaterCoolingCoilEnergy, + state.dataWaterCoils->WaterCoil(CoilNum).TotWaterCoolingCoilEnergy, "System", "Sum", - WaterCoil(CoilNum).Name, + state.dataWaterCoils->WaterCoil(CoilNum).Name, _, "ENERGYTRANSFER", "COOLINGCOILS", @@ -700,10 +606,10 @@ namespace WaterCoils { "System"); SetupOutputVariable("Cooling Coil Source Side Heat Transfer Energy", OutputProcessor::Unit::J, - WaterCoil(CoilNum).TotWaterCoolingCoilEnergy, + state.dataWaterCoils->WaterCoil(CoilNum).TotWaterCoolingCoilEnergy, "System", "Sum", - WaterCoil(CoilNum).Name, + state.dataWaterCoils->WaterCoil(CoilNum).Name, _, "PLANTLOOPCOOLINGDEMAND", "COOLINGCOILS", @@ -711,37 +617,37 @@ namespace WaterCoils { "System"); SetupOutputVariable("Cooling Coil Sensible Cooling Energy", OutputProcessor::Unit::J, - WaterCoil(CoilNum).SenWaterCoolingCoilEnergy, + state.dataWaterCoils->WaterCoil(CoilNum).SenWaterCoolingCoilEnergy, "System", "Sum", - WaterCoil(CoilNum).Name); + state.dataWaterCoils->WaterCoil(CoilNum).Name); SetupOutputVariable("Cooling Coil Total Cooling Rate", OutputProcessor::Unit::W, - WaterCoil(CoilNum).TotWaterCoolingCoilRate, + state.dataWaterCoils->WaterCoil(CoilNum).TotWaterCoolingCoilRate, "System", "Average", - WaterCoil(CoilNum).Name); + state.dataWaterCoils->WaterCoil(CoilNum).Name); SetupOutputVariable("Cooling Coil Sensible Cooling Rate", OutputProcessor::Unit::W, - WaterCoil(CoilNum).SenWaterCoolingCoilRate, + state.dataWaterCoils->WaterCoil(CoilNum).SenWaterCoolingCoilRate, "System", "Average", - WaterCoil(CoilNum).Name); + state.dataWaterCoils->WaterCoil(CoilNum).Name); - if (WaterCoil(CoilNum).CondensateCollectMode == CondensateToTank) { + if (state.dataWaterCoils->WaterCoil(CoilNum).CondensateCollectMode == state.dataWaterCoils->CondensateToTank) { SetupOutputVariable("Cooling Coil Condensate Volume Flow Rate", OutputProcessor::Unit::m3_s, - WaterCoil(CoilNum).CondensateVdot, + state.dataWaterCoils->WaterCoil(CoilNum).CondensateVdot, "System", "Average", - WaterCoil(CoilNum).Name); + state.dataWaterCoils->WaterCoil(CoilNum).Name); SetupOutputVariable("Cooling Coil Condensate Volume", OutputProcessor::Unit::m3, - WaterCoil(CoilNum).CondensateVol, + state.dataWaterCoils->WaterCoil(CoilNum).CondensateVol, "System", "Sum", - WaterCoil(CoilNum).Name, + state.dataWaterCoils->WaterCoil(CoilNum).Name, _, "OnSiteWater", "Condensate", @@ -768,74 +674,74 @@ namespace WaterCoils { cAlphaFields, cNumericFields); - WaterCoilNumericFields(CoilNum).FieldNames.allocate(MaxNums); - WaterCoilNumericFields(CoilNum).FieldNames = ""; - WaterCoilNumericFields(CoilNum).FieldNames = cNumericFields; + state.dataWaterCoils->WaterCoilNumericFields(CoilNum).FieldNames.allocate(MaxNums); + state.dataWaterCoils->WaterCoilNumericFields(CoilNum).FieldNames = ""; + state.dataWaterCoils->WaterCoilNumericFields(CoilNum).FieldNames = cNumericFields; UtilityRoutines::IsNameEmpty(AlphArray(1), cCurrentModuleObject, ErrorsFound); // ErrorsFound will be set to True if problem was found, left untouched otherwise VerifyUniqueCoilName(CurrentModuleObject, AlphArray(1), ErrorsFound, CurrentModuleObject + " Name"); - WaterCoil(CoilNum).Name = AlphArray(1); - WaterCoil(CoilNum).Schedule = AlphArray(2); + state.dataWaterCoils->WaterCoil(CoilNum).Name = AlphArray(1); + state.dataWaterCoils->WaterCoil(CoilNum).Schedule = AlphArray(2); if (lAlphaBlanks(2)) { - WaterCoil(CoilNum).SchedPtr = ScheduleAlwaysOn; + state.dataWaterCoils->WaterCoil(CoilNum).SchedPtr = ScheduleAlwaysOn; } else { - WaterCoil(CoilNum).SchedPtr = GetScheduleIndex(AlphArray(2)); - if (WaterCoil(CoilNum).SchedPtr == 0) { + state.dataWaterCoils->WaterCoil(CoilNum).SchedPtr = GetScheduleIndex(AlphArray(2)); + if (state.dataWaterCoils->WaterCoil(CoilNum).SchedPtr == 0) { ShowSevereError(CurrentModuleObject + ": invalid " + cAlphaFields(2) + " entered =" + AlphArray(2) + " for " + cAlphaFields(1) + '=' + AlphArray(1)); ErrorsFound = true; } } - WaterCoil(CoilNum).WaterCoilTypeA = "Cooling"; - WaterCoil(CoilNum).WaterCoilType = CoilType_Cooling; // 'Cooling' - WaterCoil(CoilNum).WaterCoilModelA = "Cooling"; - WaterCoil(CoilNum).WaterCoilModel = CoilModel_Cooling; // 'Cooling' - WaterCoil(CoilNum).WaterCoilType_Num = WaterCoil_Cooling; - - WaterCoil(CoilNum).MaxWaterVolFlowRate = NumArray(1); // Liquid mass flow rate at Design kg/s - if (WaterCoil(CoilNum).MaxWaterVolFlowRate == AutoSize) WaterCoil(CoilNum).RequestingAutoSize = true; - WaterCoil(CoilNum).DesAirVolFlowRate = NumArray(2); // Dry air mass flow rate at Design (kg/s) - if (WaterCoil(CoilNum).DesAirVolFlowRate == AutoSize) WaterCoil(CoilNum).RequestingAutoSize = true; - WaterCoil(CoilNum).DesInletWaterTemp = NumArray(3); // Entering water temperature at Design C - if (WaterCoil(CoilNum).DesInletWaterTemp == AutoSize) WaterCoil(CoilNum).RequestingAutoSize = true; - WaterCoil(CoilNum).DesInletAirTemp = NumArray(4); // Entering air dry bulb temperature at Design(C) - if (WaterCoil(CoilNum).DesInletAirTemp == AutoSize) WaterCoil(CoilNum).RequestingAutoSize = true; - WaterCoil(CoilNum).DesOutletAirTemp = NumArray(5); // Leaving air dry bulb temperature at Design(C) - if (WaterCoil(CoilNum).DesOutletAirTemp == AutoSize) WaterCoil(CoilNum).RequestingAutoSize = true; - WaterCoil(CoilNum).DesInletAirHumRat = NumArray(6); // Entering air humidity ratio at Design - if (WaterCoil(CoilNum).DesInletAirHumRat == AutoSize) WaterCoil(CoilNum).RequestingAutoSize = true; - WaterCoil(CoilNum).DesOutletAirHumRat = NumArray(7); // Leaving air humidity ratio at Design - if (WaterCoil(CoilNum).DesOutletAirHumRat == AutoSize) WaterCoil(CoilNum).RequestingAutoSize = true; + state.dataWaterCoils->WaterCoil(CoilNum).WaterCoilTypeA = "Cooling"; + state.dataWaterCoils->WaterCoil(CoilNum).WaterCoilType = state.dataWaterCoils->CoilType_Cooling; // 'Cooling' + state.dataWaterCoils->WaterCoil(CoilNum).WaterCoilModelA = "Cooling"; + state.dataWaterCoils->WaterCoil(CoilNum).WaterCoilModel = state.dataWaterCoils->CoilModel_Cooling; // 'Cooling' + state.dataWaterCoils->WaterCoil(CoilNum).WaterCoilType_Num = state.dataWaterCoils->WaterCoil_Cooling; + + state.dataWaterCoils->WaterCoil(CoilNum).MaxWaterVolFlowRate = NumArray(1); // Liquid mass flow rate at Design kg/s + if (state.dataWaterCoils->WaterCoil(CoilNum).MaxWaterVolFlowRate == AutoSize) state.dataWaterCoils->WaterCoil(CoilNum).RequestingAutoSize = true; + state.dataWaterCoils->WaterCoil(CoilNum).DesAirVolFlowRate = NumArray(2); // Dry air mass flow rate at Design (kg/s) + if (state.dataWaterCoils->WaterCoil(CoilNum).DesAirVolFlowRate == AutoSize) state.dataWaterCoils->WaterCoil(CoilNum).RequestingAutoSize = true; + state.dataWaterCoils->WaterCoil(CoilNum).DesInletWaterTemp = NumArray(3); // Entering water temperature at Design C + if (state.dataWaterCoils->WaterCoil(CoilNum).DesInletWaterTemp == AutoSize) state.dataWaterCoils->WaterCoil(CoilNum).RequestingAutoSize = true; + state.dataWaterCoils->WaterCoil(CoilNum).DesInletAirTemp = NumArray(4); // Entering air dry bulb temperature at Design(C) + if (state.dataWaterCoils->WaterCoil(CoilNum).DesInletAirTemp == AutoSize) state.dataWaterCoils->WaterCoil(CoilNum).RequestingAutoSize = true; + state.dataWaterCoils->WaterCoil(CoilNum).DesOutletAirTemp = NumArray(5); // Leaving air dry bulb temperature at Design(C) + if (state.dataWaterCoils->WaterCoil(CoilNum).DesOutletAirTemp == AutoSize) state.dataWaterCoils->WaterCoil(CoilNum).RequestingAutoSize = true; + state.dataWaterCoils->WaterCoil(CoilNum).DesInletAirHumRat = NumArray(6); // Entering air humidity ratio at Design + if (state.dataWaterCoils->WaterCoil(CoilNum).DesInletAirHumRat == AutoSize) state.dataWaterCoils->WaterCoil(CoilNum).RequestingAutoSize = true; + state.dataWaterCoils->WaterCoil(CoilNum).DesOutletAirHumRat = NumArray(7); // Leaving air humidity ratio at Design + if (state.dataWaterCoils->WaterCoil(CoilNum).DesOutletAirHumRat == AutoSize) state.dataWaterCoils->WaterCoil(CoilNum).RequestingAutoSize = true; if (!lNumericBlanks(8)) { - WaterCoil(CoilNum).DesignWaterDeltaTemp = NumArray(8); - WaterCoil(CoilNum).UseDesignWaterDeltaTemp = true; + state.dataWaterCoils->WaterCoil(CoilNum).DesignWaterDeltaTemp = NumArray(8); + state.dataWaterCoils->WaterCoil(CoilNum).UseDesignWaterDeltaTemp = true; } else { - WaterCoil(CoilNum).UseDesignWaterDeltaTemp = false; + state.dataWaterCoils->WaterCoil(CoilNum).UseDesignWaterDeltaTemp = false; } - WaterCoil(CoilNum).WaterInletNodeNum = GetOnlySingleNode( + state.dataWaterCoils->WaterCoil(CoilNum).WaterInletNodeNum = GetOnlySingleNode( AlphArray(3), ErrorsFound, CurrentModuleObject, AlphArray(1), NodeType_Water, NodeConnectionType_Inlet, 2, ObjectIsNotParent); - WaterCoil(CoilNum).WaterOutletNodeNum = GetOnlySingleNode( + state.dataWaterCoils->WaterCoil(CoilNum).WaterOutletNodeNum = GetOnlySingleNode( AlphArray(4), ErrorsFound, CurrentModuleObject, AlphArray(1), NodeType_Water, NodeConnectionType_Outlet, 2, ObjectIsNotParent); - WaterCoil(CoilNum).AirInletNodeNum = GetOnlySingleNode( + state.dataWaterCoils->WaterCoil(CoilNum).AirInletNodeNum = GetOnlySingleNode( AlphArray(5), ErrorsFound, CurrentModuleObject, AlphArray(1), NodeType_Air, NodeConnectionType_Inlet, 1, ObjectIsNotParent); - WaterCoil(CoilNum).AirOutletNodeNum = GetOnlySingleNode( + state.dataWaterCoils->WaterCoil(CoilNum).AirOutletNodeNum = GetOnlySingleNode( AlphArray(6), ErrorsFound, CurrentModuleObject, AlphArray(1), NodeType_Air, NodeConnectionType_Outlet, 1, ObjectIsNotParent); { auto const SELECT_CASE_var(AlphArray(7)); // The default is SimpleAnalysis = 2. and DetailedAnalysis =1 if (SELECT_CASE_var == "SIMPLEANALYSIS") { - WaterCoil(CoilNum).CoolingCoilAnalysisMode = SimpleAnalysis; + state.dataWaterCoils->WaterCoil(CoilNum).CoolingCoilAnalysisMode = state.dataWaterCoils->SimpleAnalysis; } else if (SELECT_CASE_var == "DETAILEDANALYSIS") { - WaterCoil(CoilNum).CoolingCoilAnalysisMode = DetailedAnalysis; + state.dataWaterCoils->WaterCoil(CoilNum).CoolingCoilAnalysisMode = state.dataWaterCoils->DetailedAnalysis; } else { - WaterCoil(CoilNum).CoolingCoilAnalysisMode = SimpleAnalysis; + state.dataWaterCoils->WaterCoil(CoilNum).CoolingCoilAnalysisMode = state.dataWaterCoils->SimpleAnalysis; } } @@ -843,28 +749,28 @@ namespace WaterCoils { auto const SELECT_CASE_var(AlphArray(8)); // The default is CrossFlow = 2. and CounterFlow=1 if (SELECT_CASE_var == "CROSSFLOW") { - WaterCoil(CoilNum).HeatExchType = CrossFlow; + state.dataWaterCoils->WaterCoil(CoilNum).HeatExchType = state.dataWaterCoils->CrossFlow; } else if (SELECT_CASE_var == "COUNTERFLOW") { - WaterCoil(CoilNum).HeatExchType = CounterFlow; + state.dataWaterCoils->WaterCoil(CoilNum).HeatExchType = state.dataWaterCoils->CounterFlow; } else { - WaterCoil(CoilNum).HeatExchType = CrossFlow; + state.dataWaterCoils->WaterCoil(CoilNum).HeatExchType = state.dataWaterCoils->CrossFlow; } } // A9; \field Name of Water Storage Tank for Condensate Collection - WaterCoil(CoilNum).CondensateCollectName = AlphArray(9); + state.dataWaterCoils->WaterCoil(CoilNum).CondensateCollectName = AlphArray(9); if (lAlphaBlanks(9)) { - WaterCoil(CoilNum).CondensateCollectMode = CondensateDiscarded; + state.dataWaterCoils->WaterCoil(CoilNum).CondensateCollectMode = state.dataWaterCoils->CondensateDiscarded; } else { - WaterCoil(CoilNum).CondensateCollectMode = CondensateToTank; - SetupTankSupplyComponent(state, WaterCoil(CoilNum).Name, + state.dataWaterCoils->WaterCoil(CoilNum).CondensateCollectMode = state.dataWaterCoils->CondensateToTank; + SetupTankSupplyComponent(state, state.dataWaterCoils->WaterCoil(CoilNum).Name, CurrentModuleObject, - WaterCoil(CoilNum).CondensateCollectName, + state.dataWaterCoils->WaterCoil(CoilNum).CondensateCollectName, ErrorsFound, - WaterCoil(CoilNum).CondensateTankID, - WaterCoil(CoilNum).CondensateTankSupplyARRID); + state.dataWaterCoils->WaterCoil(CoilNum).CondensateTankID, + state.dataWaterCoils->WaterCoil(CoilNum).CondensateTankSupplyARRID); } TestCompSet(CurrentModuleObject, AlphArray(1), AlphArray(3), AlphArray(4), "Water Nodes"); @@ -874,10 +780,10 @@ namespace WaterCoils { // CurrentModuleObject = "Coil:Cooling:Water" SetupOutputVariable("Cooling Coil Total Cooling Energy", OutputProcessor::Unit::J, - WaterCoil(CoilNum).TotWaterCoolingCoilEnergy, + state.dataWaterCoils->WaterCoil(CoilNum).TotWaterCoolingCoilEnergy, "System", "Sum", - WaterCoil(CoilNum).Name, + state.dataWaterCoils->WaterCoil(CoilNum).Name, _, "ENERGYTRANSFER", "COOLINGCOILS", @@ -885,10 +791,10 @@ namespace WaterCoils { "System"); SetupOutputVariable("Cooling Coil Source Side Heat Transfer Energy", OutputProcessor::Unit::J, - WaterCoil(CoilNum).TotWaterCoolingCoilEnergy, + state.dataWaterCoils->WaterCoil(CoilNum).TotWaterCoolingCoilEnergy, "System", "Sum", - WaterCoil(CoilNum).Name, + state.dataWaterCoils->WaterCoil(CoilNum).Name, _, "PLANTLOOPCOOLINGDEMAND", "COOLINGCOILS", @@ -896,43 +802,43 @@ namespace WaterCoils { "System"); SetupOutputVariable("Cooling Coil Sensible Cooling Energy", OutputProcessor::Unit::J, - WaterCoil(CoilNum).SenWaterCoolingCoilEnergy, + state.dataWaterCoils->WaterCoil(CoilNum).SenWaterCoolingCoilEnergy, "System", "Sum", - WaterCoil(CoilNum).Name); + state.dataWaterCoils->WaterCoil(CoilNum).Name); SetupOutputVariable("Cooling Coil Total Cooling Rate", OutputProcessor::Unit::W, - WaterCoil(CoilNum).TotWaterCoolingCoilRate, + state.dataWaterCoils->WaterCoil(CoilNum).TotWaterCoolingCoilRate, "System", "Average", - WaterCoil(CoilNum).Name); + state.dataWaterCoils->WaterCoil(CoilNum).Name); SetupOutputVariable("Cooling Coil Sensible Cooling Rate", OutputProcessor::Unit::W, - WaterCoil(CoilNum).SenWaterCoolingCoilRate, + state.dataWaterCoils->WaterCoil(CoilNum).SenWaterCoolingCoilRate, "System", "Average", - WaterCoil(CoilNum).Name); + state.dataWaterCoils->WaterCoil(CoilNum).Name); SetupOutputVariable("Cooling Coil Wetted Area Fraction", OutputProcessor::Unit::None, - WaterCoil(CoilNum).SurfAreaWetFraction, + state.dataWaterCoils->WaterCoil(CoilNum).SurfAreaWetFraction, "System", "Average", - WaterCoil(CoilNum).Name); + state.dataWaterCoils->WaterCoil(CoilNum).Name); - if (WaterCoil(CoilNum).CondensateCollectMode == CondensateToTank) { + if (state.dataWaterCoils->WaterCoil(CoilNum).CondensateCollectMode == state.dataWaterCoils->CondensateToTank) { SetupOutputVariable("Cooling Coil Condensate Volume Flow Rate", OutputProcessor::Unit::m3_s, - WaterCoil(CoilNum).CondensateVdot, + state.dataWaterCoils->WaterCoil(CoilNum).CondensateVdot, "System", "Average", - WaterCoil(CoilNum).Name); + state.dataWaterCoils->WaterCoil(CoilNum).Name); SetupOutputVariable("Cooling Coil Condensate Volume", OutputProcessor::Unit::m3, - WaterCoil(CoilNum).CondensateVol, + state.dataWaterCoils->WaterCoil(CoilNum).CondensateVol, "System", "Sum", - WaterCoil(CoilNum).Name, + state.dataWaterCoils->WaterCoil(CoilNum).Name, _, "OnSiteWater", "Condensate", @@ -953,12 +859,6 @@ namespace WaterCoils { lNumericBlanks.deallocate(); } - // End of Get Input subroutines for the HB Module - //****************************************************************************** - - // Beginning Initialization Section of the Module - //****************************************************************************** - void InitWaterCoil(EnergyPlusData &state, int const CoilNum, bool const FirstHVACIteration) { @@ -1074,62 +974,62 @@ namespace WaterCoils { // FLOW: - if (InitWaterCoilOneTimeFlag) { + if (state.dataWaterCoils->InitWaterCoilOneTimeFlag) { // initialize the environment and sizing flags - MyEnvrnFlag.allocate(NumWaterCoils); - MySizeFlag.allocate(NumWaterCoils); - CoilWarningOnceFlag.allocate(NumWaterCoils); - DesCpAir.allocate(NumWaterCoils); - MyUAAndFlowCalcFlag.allocate(NumWaterCoils); - MyCoilDesignFlag.allocate(NumWaterCoils); - MyCoilReportFlag.allocate(NumWaterCoils); - DesUARangeCheck.allocate(NumWaterCoils); - PlantLoopScanFlag.allocate(NumWaterCoils); + MyEnvrnFlag.allocate(state.dataWaterCoils->NumWaterCoils); + state.dataWaterCoils->MySizeFlag.allocate(state.dataWaterCoils->NumWaterCoils); + state.dataWaterCoils->CoilWarningOnceFlag.allocate(state.dataWaterCoils->NumWaterCoils); + DesCpAir.allocate(state.dataWaterCoils->NumWaterCoils); + state.dataWaterCoils->MyUAAndFlowCalcFlag.allocate(state.dataWaterCoils->NumWaterCoils); + state.dataWaterCoils->MyCoilDesignFlag.allocate(state.dataWaterCoils->NumWaterCoils); + MyCoilReportFlag.allocate(state.dataWaterCoils->NumWaterCoils); + DesUARangeCheck.allocate(state.dataWaterCoils->NumWaterCoils); + PlantLoopScanFlag.allocate(state.dataWaterCoils->NumWaterCoils); DesCpAir = 0.0; DesUARangeCheck = 0.0; MyEnvrnFlag = true; - MySizeFlag = true; - CoilWarningOnceFlag = true; - MyUAAndFlowCalcFlag = true; - MyCoilDesignFlag = true; + state.dataWaterCoils->MySizeFlag = true; + state.dataWaterCoils->CoilWarningOnceFlag = true; + state.dataWaterCoils->MyUAAndFlowCalcFlag = true; + state.dataWaterCoils->MyCoilDesignFlag = true; MyCoilReportFlag = true; - InitWaterCoilOneTimeFlag = false; + state.dataWaterCoils->InitWaterCoilOneTimeFlag = false; PlantLoopScanFlag = true; - for (tempCoilNum = 1; tempCoilNum <= NumWaterCoils; ++tempCoilNum) { + for (tempCoilNum = 1; tempCoilNum <= state.dataWaterCoils->NumWaterCoils; ++tempCoilNum) { GetControllerNameAndIndex(state, - WaterCoil(tempCoilNum).WaterInletNodeNum, WaterCoil(tempCoilNum).ControllerName, WaterCoil(tempCoilNum).ControllerIndex, errFlag); + state.dataWaterCoils->WaterCoil(tempCoilNum).WaterInletNodeNum, state.dataWaterCoils->WaterCoil(tempCoilNum).ControllerName, state.dataWaterCoils->WaterCoil(tempCoilNum).ControllerIndex, errFlag); } } - if (WaterCoilControllerCheckOneTimeFlag && (DataHVACGlobals::GetAirPathDataDone)) { + if (state.dataWaterCoils->WaterCoilControllerCheckOneTimeFlag && (DataHVACGlobals::GetAirPathDataDone)) { bool ErrorsFound = false; bool WaterCoilOnAirLoop = true; - for (tempCoilNum = 1; tempCoilNum <= NumWaterCoils; ++tempCoilNum) { - if (WaterCoil(tempCoilNum).ControllerIndex > 0) { + for (tempCoilNum = 1; tempCoilNum <= state.dataWaterCoils->NumWaterCoils; ++tempCoilNum) { + if (state.dataWaterCoils->WaterCoil(tempCoilNum).ControllerIndex > 0) { int CoilTypeNum(0); std::string CompType; - std::string CompName = WaterCoil(tempCoilNum).Name; - if (WaterCoil(tempCoilNum).WaterCoilType_Num == WaterCoils::WaterCoil_Cooling) { + std::string CompName = state.dataWaterCoils->WaterCoil(tempCoilNum).Name; + if (state.dataWaterCoils->WaterCoil(tempCoilNum).WaterCoilType_Num == state.dataWaterCoils->WaterCoil_Cooling) { CoilTypeNum = SimAirServingZones::WaterCoil_Cooling; CompType = cAllCoilTypes(DataHVACGlobals::Coil_CoolingWater); - } else if (WaterCoil(tempCoilNum).WaterCoilType_Num == WaterCoils::WaterCoil_DetFlatFinCooling) { + } else if (state.dataWaterCoils->WaterCoil(tempCoilNum).WaterCoilType_Num == state.dataWaterCoils->WaterCoil_DetFlatFinCooling) { CoilTypeNum = SimAirServingZones::WaterCoil_DetailedCool; CompType = cAllCoilTypes(DataHVACGlobals::Coil_CoolingWaterDetailed); - } else if (WaterCoil(tempCoilNum).WaterCoilType_Num == WaterCoils::WaterCoil_SimpleHeating) { + } else if (state.dataWaterCoils->WaterCoil(tempCoilNum).WaterCoilType_Num == state.dataWaterCoils->WaterCoil_SimpleHeating) { CoilTypeNum = SimAirServingZones::WaterCoil_SimpleHeat; CompType = cAllCoilTypes(DataHVACGlobals::Coil_HeatingWater); } WaterCoilOnAirLoop = true; CheckWaterCoilIsOnAirLoop(state, CoilTypeNum, CompType, CompName, WaterCoilOnAirLoop); if (!WaterCoilOnAirLoop) { - ShowContinueError("Controller:WaterCoil = " + WaterCoil(tempCoilNum).ControllerName + ". Invalid water controller entry."); + ShowContinueError("Controller:WaterCoil = " + state.dataWaterCoils->WaterCoil(tempCoilNum).ControllerName + ". Invalid water controller entry."); ErrorsFound = true; } } } - WaterCoilControllerCheckOneTimeFlag = false; + state.dataWaterCoils->WaterCoilControllerCheckOneTimeFlag = false; if (ErrorsFound) { ShowFatalError("Program terminated for previous condition."); } @@ -1138,12 +1038,12 @@ namespace WaterCoils { if (PlantLoopScanFlag(CoilNum) && allocated(PlantLoop)) { errFlag = false; ScanPlantLoopsForObject(state.dataBranchInputManager, - WaterCoil(CoilNum).Name, - WaterCoil(CoilNum).WaterCoilType_Num, - WaterCoil(CoilNum).WaterLoopNum, - WaterCoil(CoilNum).WaterLoopSide, - WaterCoil(CoilNum).WaterLoopBranchNum, - WaterCoil(CoilNum).WaterLoopCompNum, + state.dataWaterCoils->WaterCoil(CoilNum).Name, + state.dataWaterCoils->WaterCoil(CoilNum).WaterCoilType_Num, + state.dataWaterCoils->WaterCoil(CoilNum).WaterLoopNum, + state.dataWaterCoils->WaterCoil(CoilNum).WaterLoopSide, + state.dataWaterCoils->WaterCoil(CoilNum).WaterLoopBranchNum, + state.dataWaterCoils->WaterCoil(CoilNum).WaterLoopCompNum, errFlag, _, _, @@ -1155,41 +1055,41 @@ namespace WaterCoils { } PlantLoopScanFlag(CoilNum) = false; } - if (!SysSizingCalc && MySizeFlag(CoilNum)) { + if (!SysSizingCalc && state.dataWaterCoils->MySizeFlag(CoilNum)) { // for each coil, do the sizing once. SizeWaterCoil(state, CoilNum); - MySizeFlag(CoilNum) = false; + state.dataWaterCoils->MySizeFlag(CoilNum) = false; } // Do the Begin Environment initializations if (BeginEnvrnFlag && MyEnvrnFlag(CoilNum)) { - rho = GetDensityGlycol(PlantLoop(WaterCoil(CoilNum).WaterLoopNum).FluidName, + rho = GetDensityGlycol(PlantLoop(state.dataWaterCoils->WaterCoil(CoilNum).WaterLoopNum).FluidName, InitConvTemp, - PlantLoop(WaterCoil(CoilNum).WaterLoopNum).FluidIndex, + PlantLoop(state.dataWaterCoils->WaterCoil(CoilNum).WaterLoopNum).FluidIndex, RoutineName); // Initialize all report variables to a known state at beginning of simulation - WaterCoil(CoilNum).TotWaterHeatingCoilEnergy = 0.0; - WaterCoil(CoilNum).TotWaterCoolingCoilEnergy = 0.0; - WaterCoil(CoilNum).SenWaterCoolingCoilEnergy = 0.0; - WaterCoil(CoilNum).TotWaterHeatingCoilRate = 0.0; - WaterCoil(CoilNum).TotWaterCoolingCoilRate = 0.0; - WaterCoil(CoilNum).SenWaterCoolingCoilRate = 0.0; + state.dataWaterCoils->WaterCoil(CoilNum).TotWaterHeatingCoilEnergy = 0.0; + state.dataWaterCoils->WaterCoil(CoilNum).TotWaterCoolingCoilEnergy = 0.0; + state.dataWaterCoils->WaterCoil(CoilNum).SenWaterCoolingCoilEnergy = 0.0; + state.dataWaterCoils->WaterCoil(CoilNum).TotWaterHeatingCoilRate = 0.0; + state.dataWaterCoils->WaterCoil(CoilNum).TotWaterCoolingCoilRate = 0.0; + state.dataWaterCoils->WaterCoil(CoilNum).SenWaterCoolingCoilRate = 0.0; // The rest of the one time initializations - AirInletNode = WaterCoil(CoilNum).AirInletNodeNum; - WaterInletNode = WaterCoil(CoilNum).WaterInletNodeNum; - WaterOutletNode = WaterCoil(CoilNum).WaterOutletNodeNum; + AirInletNode = state.dataWaterCoils->WaterCoil(CoilNum).AirInletNodeNum; + WaterInletNode = state.dataWaterCoils->WaterCoil(CoilNum).WaterInletNodeNum; + WaterOutletNode = state.dataWaterCoils->WaterCoil(CoilNum).WaterOutletNodeNum; DesCpAir(CoilNum) = PsyCpAirFnW(0.0); - DesUARangeCheck(CoilNum) = (-1568.6 * WaterCoil(CoilNum).DesInletAirHumRat + 20.157); + DesUARangeCheck(CoilNum) = (-1568.6 * state.dataWaterCoils->WaterCoil(CoilNum).DesInletAirHumRat + 20.157); - if (WaterCoil(CoilNum).WaterCoilType == CoilType_Cooling) { // 'Cooling' + if (state.dataWaterCoils->WaterCoil(CoilNum).WaterCoilType == state.dataWaterCoils->CoilType_Cooling) { // 'Cooling' Node(WaterInletNode).Temp = 5.0; - Cp = GetSpecificHeatGlycol(PlantLoop(WaterCoil(CoilNum).WaterLoopNum).FluidName, + Cp = GetSpecificHeatGlycol(PlantLoop(state.dataWaterCoils->WaterCoil(CoilNum).WaterLoopNum).FluidName, Node(WaterInletNode).Temp, - PlantLoop(WaterCoil(CoilNum).WaterLoopNum).FluidIndex, + PlantLoop(state.dataWaterCoils->WaterCoil(CoilNum).WaterLoopNum).FluidIndex, RoutineName); Node(WaterInletNode).Enthalpy = Cp * Node(WaterInletNode).Temp; @@ -1198,94 +1098,94 @@ namespace WaterCoils { Node(WaterInletNode).HumRat = 0.0; } - if (WaterCoil(CoilNum).WaterCoilType == CoilType_Heating) { // 'Heating' + if (state.dataWaterCoils->WaterCoil(CoilNum).WaterCoilType == state.dataWaterCoils->CoilType_Heating) { // 'Heating' Node(WaterInletNode).Temp = 60.0; - Cp = GetSpecificHeatGlycol(PlantLoop(WaterCoil(CoilNum).WaterLoopNum).FluidName, + Cp = GetSpecificHeatGlycol(PlantLoop(state.dataWaterCoils->WaterCoil(CoilNum).WaterLoopNum).FluidName, Node(WaterInletNode).Temp, - PlantLoop(WaterCoil(CoilNum).WaterLoopNum).FluidIndex, + PlantLoop(state.dataWaterCoils->WaterCoil(CoilNum).WaterLoopNum).FluidIndex, RoutineName); Node(WaterInletNode).Enthalpy = Cp * Node(WaterInletNode).Temp; Node(WaterInletNode).Quality = 0.0; Node(WaterInletNode).Press = 0.0; Node(WaterInletNode).HumRat = 0.0; - MyUAAndFlowCalcFlag(CoilNum) = false; + state.dataWaterCoils->MyUAAndFlowCalcFlag(CoilNum) = false; // fill values for variable UA CpAirStd = PsyCpAirFnW(0.0); - WaterCoil(CoilNum).DesAirMassFlowRate = StdRhoAir * WaterCoil(CoilNum).DesAirVolFlowRate; - WaterCoil(CoilNum).LiquidSideNominalConvect = WaterCoil(CoilNum).UACoil * (WaterCoil(CoilNum).RatioAirSideToWaterSideConvect + 1) / - WaterCoil(CoilNum).RatioAirSideToWaterSideConvect; - WaterCoil(CoilNum).AirSideNominalConvect = - WaterCoil(CoilNum).RatioAirSideToWaterSideConvect * WaterCoil(CoilNum).LiquidSideNominalConvect; + state.dataWaterCoils->WaterCoil(CoilNum).DesAirMassFlowRate = StdRhoAir * state.dataWaterCoils->WaterCoil(CoilNum).DesAirVolFlowRate; + state.dataWaterCoils->WaterCoil(CoilNum).LiquidSideNominalConvect = state.dataWaterCoils->WaterCoil(CoilNum).UACoil * (state.dataWaterCoils->WaterCoil(CoilNum).RatioAirSideToWaterSideConvect + 1) / + state.dataWaterCoils->WaterCoil(CoilNum).RatioAirSideToWaterSideConvect; + state.dataWaterCoils->WaterCoil(CoilNum).AirSideNominalConvect = + state.dataWaterCoils->WaterCoil(CoilNum).RatioAirSideToWaterSideConvect * state.dataWaterCoils->WaterCoil(CoilNum).LiquidSideNominalConvect; } else { - MyUAAndFlowCalcFlag(CoilNum) = false; + state.dataWaterCoils->MyUAAndFlowCalcFlag(CoilNum) = false; } - WaterCoil(CoilNum).MaxWaterMassFlowRate = rho * WaterCoil(CoilNum).MaxWaterVolFlowRate; + state.dataWaterCoils->WaterCoil(CoilNum).MaxWaterMassFlowRate = rho * state.dataWaterCoils->WaterCoil(CoilNum).MaxWaterVolFlowRate; InitComponentNodes(0.0, - WaterCoil(CoilNum).MaxWaterMassFlowRate, - WaterCoil(CoilNum).WaterInletNodeNum, - WaterCoil(CoilNum).WaterOutletNodeNum, - WaterCoil(CoilNum).WaterLoopNum, - WaterCoil(CoilNum).WaterLoopSide, - WaterCoil(CoilNum).WaterLoopBranchNum, - WaterCoil(CoilNum).WaterLoopCompNum); + state.dataWaterCoils->WaterCoil(CoilNum).MaxWaterMassFlowRate, + state.dataWaterCoils->WaterCoil(CoilNum).WaterInletNodeNum, + state.dataWaterCoils->WaterCoil(CoilNum).WaterOutletNodeNum, + state.dataWaterCoils->WaterCoil(CoilNum).WaterLoopNum, + state.dataWaterCoils->WaterCoil(CoilNum).WaterLoopSide, + state.dataWaterCoils->WaterCoil(CoilNum).WaterLoopBranchNum, + state.dataWaterCoils->WaterCoil(CoilNum).WaterLoopCompNum); // effective fin diameter for detailed flat fin coil - if (WaterCoil(CoilNum).WaterCoilModel == CoilModel_Detailed) { // 'DETAILED FLAT FIN' - WaterCoil(CoilNum).EffectiveFinDiam = std::sqrt(4.0 * WaterCoil(CoilNum).FinDiam * WaterCoil(CoilNum).CoilDepth / - (Pi * WaterCoil(CoilNum).NumOfTubeRows * WaterCoil(CoilNum).NumOfTubesPerRow)); + if (state.dataWaterCoils->WaterCoil(CoilNum).WaterCoilModel == state.dataWaterCoils->CoilModel_Detailed) { // 'DETAILED FLAT FIN' + state.dataWaterCoils->WaterCoil(CoilNum).EffectiveFinDiam = std::sqrt(4.0 * state.dataWaterCoils->WaterCoil(CoilNum).FinDiam * state.dataWaterCoils->WaterCoil(CoilNum).CoilDepth / + (Pi * state.dataWaterCoils->WaterCoil(CoilNum).NumOfTubeRows * state.dataWaterCoils->WaterCoil(CoilNum).NumOfTubesPerRow)); // calculate fixed geometric parameters of the coil: // Total Area - WaterCoil(CoilNum).TotCoilOutsideSurfArea = WaterCoil(CoilNum).TubeOutsideSurfArea + WaterCoil(CoilNum).FinSurfArea; + state.dataWaterCoils->WaterCoil(CoilNum).TotCoilOutsideSurfArea = state.dataWaterCoils->WaterCoil(CoilNum).TubeOutsideSurfArea + state.dataWaterCoils->WaterCoil(CoilNum).FinSurfArea; // Effective Tube Inside Diameter - the model assumes that the coil // can be simulated as a tube with an equivalent hydraulic diameter. - WaterCoil(CoilNum).CoilEffectiveInsideDiam = - 4.0 * WaterCoil(CoilNum).MinAirFlowArea * WaterCoil(CoilNum).CoilDepth / WaterCoil(CoilNum).TotCoilOutsideSurfArea; + state.dataWaterCoils->WaterCoil(CoilNum).CoilEffectiveInsideDiam = + 4.0 * state.dataWaterCoils->WaterCoil(CoilNum).MinAirFlowArea * state.dataWaterCoils->WaterCoil(CoilNum).CoilDepth / state.dataWaterCoils->WaterCoil(CoilNum).TotCoilOutsideSurfArea; // Ratio of tube outside diameter to effective fin diameter should always // be less than 1 - TubeToFinDiamRatio = WaterCoil(CoilNum).TubeOutsideDiam / WaterCoil(CoilNum).EffectiveFinDiam; + TubeToFinDiamRatio = state.dataWaterCoils->WaterCoil(CoilNum).TubeOutsideDiam / state.dataWaterCoils->WaterCoil(CoilNum).EffectiveFinDiam; if (TubeToFinDiamRatio > 1.0) { ShowWarningError("InitWaterCoil: Detailed Flat Fin Coil, TubetoFinDiamRatio > 1.0, [" + RoundSigDigits(TubeToFinDiamRatio, 4) + ']'); // reset tube depth spacing and recalc dependent parameters - WaterCoil(CoilNum).TubeDepthSpacing *= (pow_2(TubeToFinDiamRatio) + 0.1); - WaterCoil(CoilNum).CoilDepth = WaterCoil(CoilNum).TubeDepthSpacing * WaterCoil(CoilNum).NumOfTubeRows; - WaterCoil(CoilNum).EffectiveFinDiam = std::sqrt(4.0 * WaterCoil(CoilNum).FinDiam * WaterCoil(CoilNum).CoilDepth / - (Pi * WaterCoil(CoilNum).NumOfTubeRows * WaterCoil(CoilNum).NumOfTubesPerRow)); - WaterCoil(CoilNum).CoilEffectiveInsideDiam = - 4.0 * WaterCoil(CoilNum).MinAirFlowArea * WaterCoil(CoilNum).CoilDepth / WaterCoil(CoilNum).TotCoilOutsideSurfArea; - TubeToFinDiamRatio = WaterCoil(CoilNum).TubeOutsideDiam / WaterCoil(CoilNum).EffectiveFinDiam; - ShowContinueError(" Resetting tube depth spacing to " + RoundSigDigits(WaterCoil(CoilNum).TubeDepthSpacing, 4) + " meters"); - ShowContinueError(" Resetting coil depth to " + RoundSigDigits(WaterCoil(CoilNum).CoilDepth, 4) + " meters"); + state.dataWaterCoils->WaterCoil(CoilNum).TubeDepthSpacing *= (pow_2(TubeToFinDiamRatio) + 0.1); + state.dataWaterCoils->WaterCoil(CoilNum).CoilDepth = state.dataWaterCoils->WaterCoil(CoilNum).TubeDepthSpacing * state.dataWaterCoils->WaterCoil(CoilNum).NumOfTubeRows; + state.dataWaterCoils->WaterCoil(CoilNum).EffectiveFinDiam = std::sqrt(4.0 * state.dataWaterCoils->WaterCoil(CoilNum).FinDiam * state.dataWaterCoils->WaterCoil(CoilNum).CoilDepth / + (Pi * state.dataWaterCoils->WaterCoil(CoilNum).NumOfTubeRows * state.dataWaterCoils->WaterCoil(CoilNum).NumOfTubesPerRow)); + state.dataWaterCoils->WaterCoil(CoilNum).CoilEffectiveInsideDiam = + 4.0 * state.dataWaterCoils->WaterCoil(CoilNum).MinAirFlowArea * state.dataWaterCoils->WaterCoil(CoilNum).CoilDepth / state.dataWaterCoils->WaterCoil(CoilNum).TotCoilOutsideSurfArea; + TubeToFinDiamRatio = state.dataWaterCoils->WaterCoil(CoilNum).TubeOutsideDiam / state.dataWaterCoils->WaterCoil(CoilNum).EffectiveFinDiam; + ShowContinueError(" Resetting tube depth spacing to " + RoundSigDigits(state.dataWaterCoils->WaterCoil(CoilNum).TubeDepthSpacing, 4) + " meters"); + ShowContinueError(" Resetting coil depth to " + RoundSigDigits(state.dataWaterCoils->WaterCoil(CoilNum).CoilDepth, 4) + " meters"); } - CalcDryFinEffCoef(TubeToFinDiamRatio, CoefSeries); + CalcDryFinEffCoef(state, TubeToFinDiamRatio, CoefSeries); - WaterCoil(CoilNum).DryFinEfficncyCoef = CoefSeries; + state.dataWaterCoils->WaterCoil(CoilNum).DryFinEfficncyCoef = CoefSeries; - FinDiamVar = 0.5 * (WaterCoil(CoilNum).EffectiveFinDiam - WaterCoil(CoilNum).TubeOutsideDiam); + FinDiamVar = 0.5 * (state.dataWaterCoils->WaterCoil(CoilNum).EffectiveFinDiam - state.dataWaterCoils->WaterCoil(CoilNum).TubeOutsideDiam); - WaterCoil(CoilNum).GeometryCoef1 = 0.159 * - std::pow(WaterCoil(CoilNum).FinThickness / WaterCoil(CoilNum).CoilEffectiveInsideDiam, -0.065) * - std::pow(WaterCoil(CoilNum).FinThickness / FinDiamVar, 0.141); - WaterCoil(CoilNum).GeometryCoef2 = -0.323 * std::pow(WaterCoil(CoilNum).FinSpacing / FinDiamVar, 0.049) * - std::pow(WaterCoil(CoilNum).EffectiveFinDiam / WaterCoil(CoilNum).TubeDepthSpacing, 0.549) * - std::pow(WaterCoil(CoilNum).FinThickness / WaterCoil(CoilNum).FinSpacing, -0.028); + state.dataWaterCoils->WaterCoil(CoilNum).GeometryCoef1 = 0.159 * + std::pow(state.dataWaterCoils->WaterCoil(CoilNum).FinThickness / state.dataWaterCoils->WaterCoil(CoilNum).CoilEffectiveInsideDiam, -0.065) * + std::pow(state.dataWaterCoils->WaterCoil(CoilNum).FinThickness / FinDiamVar, 0.141); + state.dataWaterCoils->WaterCoil(CoilNum).GeometryCoef2 = -0.323 * std::pow(state.dataWaterCoils->WaterCoil(CoilNum).FinSpacing / FinDiamVar, 0.049) * + std::pow(state.dataWaterCoils->WaterCoil(CoilNum).EffectiveFinDiam / state.dataWaterCoils->WaterCoil(CoilNum).TubeDepthSpacing, 0.549) * + std::pow(state.dataWaterCoils->WaterCoil(CoilNum).FinThickness / state.dataWaterCoils->WaterCoil(CoilNum).FinSpacing, -0.028); // Set some initial values for simulation - WaterCoil(CoilNum).SatEnthlCurveConstCoef = -10.57; - WaterCoil(CoilNum).SatEnthlCurveSlope = 3.3867; - WaterCoil(CoilNum).EnthVsTempCurveAppxSlope = 3.3867; - WaterCoil(CoilNum).EnthVsTempCurveConst = -10.57; + state.dataWaterCoils->WaterCoil(CoilNum).SatEnthlCurveConstCoef = -10.57; + state.dataWaterCoils->WaterCoil(CoilNum).SatEnthlCurveSlope = 3.3867; + state.dataWaterCoils->WaterCoil(CoilNum).EnthVsTempCurveAppxSlope = 3.3867; + state.dataWaterCoils->WaterCoil(CoilNum).EnthVsTempCurveConst = -10.57; // Set Saved Values to Zero - WaterCoil(CoilNum).SurfAreaWetSaved = 0.0; - WaterCoil(CoilNum).MeanWaterTempSaved = 0.0; - WaterCoil(CoilNum).InWaterTempSaved = 0.0; - WaterCoil(CoilNum).OutWaterTempSaved = 0.0; + state.dataWaterCoils->WaterCoil(CoilNum).SurfAreaWetSaved = 0.0; + state.dataWaterCoils->WaterCoil(CoilNum).MeanWaterTempSaved = 0.0; + state.dataWaterCoils->WaterCoil(CoilNum).InWaterTempSaved = 0.0; + state.dataWaterCoils->WaterCoil(CoilNum).OutWaterTempSaved = 0.0; } // End the Detailed Flat Fin Coil Initialization @@ -1300,44 +1200,44 @@ namespace WaterCoils { //@@@ DESIGN CONDITION BEGIN HERE @@@ // Check for zero design cooling capacity as specified by coil design inputs - if (MyCoilDesignFlag(CoilNum) && (WaterCoil(CoilNum).WaterCoilModel == CoilModel_Cooling) && - (WaterCoil(CoilNum).DesAirVolFlowRate > 0.0) && (WaterCoil(CoilNum).MaxWaterMassFlowRate > 0.0)) { + if (state.dataWaterCoils->MyCoilDesignFlag(CoilNum) && (state.dataWaterCoils->WaterCoil(CoilNum).WaterCoilModel == state.dataWaterCoils->CoilModel_Cooling) && + (state.dataWaterCoils->WaterCoil(CoilNum).DesAirVolFlowRate > 0.0) && (state.dataWaterCoils->WaterCoil(CoilNum).MaxWaterMassFlowRate > 0.0)) { - DesInletAirEnth = PsyHFnTdbW(WaterCoil(CoilNum).DesInletAirTemp, WaterCoil(CoilNum).DesInletAirHumRat); - DesOutletAirEnth = PsyHFnTdbW(WaterCoil(CoilNum).DesOutletAirTemp, WaterCoil(CoilNum).DesOutletAirHumRat); + DesInletAirEnth = PsyHFnTdbW(state.dataWaterCoils->WaterCoil(CoilNum).DesInletAirTemp, state.dataWaterCoils->WaterCoil(CoilNum).DesInletAirHumRat); + DesOutletAirEnth = PsyHFnTdbW(state.dataWaterCoils->WaterCoil(CoilNum).DesOutletAirTemp, state.dataWaterCoils->WaterCoil(CoilNum).DesOutletAirHumRat); DesSatEnthAtWaterInTemp = - PsyHFnTdbW(WaterCoil(CoilNum).DesInletWaterTemp, PsyWFnTdpPb(WaterCoil(CoilNum).DesInletWaterTemp, StdBaroPress)); + PsyHFnTdbW(state.dataWaterCoils->WaterCoil(CoilNum).DesInletWaterTemp, PsyWFnTdpPb(state.dataWaterCoils->WaterCoil(CoilNum).DesInletWaterTemp, StdBaroPress)); // check for dry coil - DesHumRatAtWaterInTemp = PsyWFnTdbH(WaterCoil(CoilNum).DesInletWaterTemp, DesSatEnthAtWaterInTemp, RoutineName); - if (DesHumRatAtWaterInTemp > WaterCoil(CoilNum).DesOutletAirHumRat && - WaterCoil(CoilNum).DesOutletAirTemp > WaterCoil(CoilNum).DesInletWaterTemp) { + DesHumRatAtWaterInTemp = PsyWFnTdbH(state.dataWaterCoils->WaterCoil(CoilNum).DesInletWaterTemp, DesSatEnthAtWaterInTemp, RoutineName); + if (DesHumRatAtWaterInTemp > state.dataWaterCoils->WaterCoil(CoilNum).DesOutletAirHumRat && + state.dataWaterCoils->WaterCoil(CoilNum).DesOutletAirTemp > state.dataWaterCoils->WaterCoil(CoilNum).DesInletWaterTemp) { // if the design outlet air humrat is lower than the saturated air humrat at the design inlet water temp // and the design outlet air temperature is higher than the design inlet water temp (i.e, cooling possible), // move the design outlet air saturated enthalpy down (i.e., to Twaterin, Wair,out) to allow the coil to size. - DesSatEnthAtWaterInTemp = PsyHFnTdbW(WaterCoil(CoilNum).DesInletWaterTemp, WaterCoil(CoilNum).DesOutletAirHumRat) - 0.0001; + DesSatEnthAtWaterInTemp = PsyHFnTdbW(state.dataWaterCoils->WaterCoil(CoilNum).DesInletWaterTemp, state.dataWaterCoils->WaterCoil(CoilNum).DesOutletAirHumRat) - 0.0001; } - if (DesOutletAirEnth >= DesInletAirEnth || WaterCoil(CoilNum).DesInletWaterTemp >= WaterCoil(CoilNum).DesInletAirTemp) { - ShowWarningError("The design cooling capacity is zero for Coil:Cooling:Water " + WaterCoil(CoilNum).Name); + if (DesOutletAirEnth >= DesInletAirEnth || state.dataWaterCoils->WaterCoil(CoilNum).DesInletWaterTemp >= state.dataWaterCoils->WaterCoil(CoilNum).DesInletAirTemp) { + ShowWarningError("The design cooling capacity is zero for Coil:Cooling:Water " + state.dataWaterCoils->WaterCoil(CoilNum).Name); ShowContinueError(" The maximum water flow rate for this coil will be set to zero and the coil will do no cooling."); ShowContinueError(" Check the following coil design inputs for problems: Tair,in = " + - RoundSigDigits(WaterCoil(CoilNum).DesInletAirTemp, 4)); + RoundSigDigits(state.dataWaterCoils->WaterCoil(CoilNum).DesInletAirTemp, 4)); ShowContinueError(" Wair,in = " + - RoundSigDigits(WaterCoil(CoilNum).DesInletAirHumRat, 6)); + RoundSigDigits(state.dataWaterCoils->WaterCoil(CoilNum).DesInletAirHumRat, 6)); ShowContinueError(" Twater,in = " + - RoundSigDigits(WaterCoil(CoilNum).DesInletWaterTemp, 4)); + RoundSigDigits(state.dataWaterCoils->WaterCoil(CoilNum).DesInletWaterTemp, 4)); ShowContinueError(" Tair,out = " + - RoundSigDigits(WaterCoil(CoilNum).DesOutletAirTemp, 4)); + RoundSigDigits(state.dataWaterCoils->WaterCoil(CoilNum).DesOutletAirTemp, 4)); ShowContinueError(" Wair,out = " + - RoundSigDigits(WaterCoil(CoilNum).DesOutletAirHumRat, 6)); - WaterCoil(CoilNum).MaxWaterVolFlowRate = 0.0; - WaterCoil(CoilNum).MaxWaterMassFlowRate = 0.0; + RoundSigDigits(state.dataWaterCoils->WaterCoil(CoilNum).DesOutletAirHumRat, 6)); + state.dataWaterCoils->WaterCoil(CoilNum).MaxWaterVolFlowRate = 0.0; + state.dataWaterCoils->WaterCoil(CoilNum).MaxWaterMassFlowRate = 0.0; } } - if (MyCoilDesignFlag(CoilNum) && (WaterCoil(CoilNum).WaterCoilModel == CoilModel_Cooling) && - (WaterCoil(CoilNum).DesAirVolFlowRate > 0.0) && (WaterCoil(CoilNum).MaxWaterMassFlowRate > 0.0)) { // 'Cooling' + if (state.dataWaterCoils->MyCoilDesignFlag(CoilNum) && (state.dataWaterCoils->WaterCoil(CoilNum).WaterCoilModel == state.dataWaterCoils->CoilModel_Cooling) && + (state.dataWaterCoils->WaterCoil(CoilNum).DesAirVolFlowRate > 0.0) && (state.dataWaterCoils->WaterCoil(CoilNum).MaxWaterMassFlowRate > 0.0)) { // 'Cooling' - MyCoilDesignFlag(CoilNum) = false; + state.dataWaterCoils->MyCoilDesignFlag(CoilNum) = false; NoSatCurveIntersect = false; BelowInletWaterTemp = false; CBFTooLarge = false; @@ -1347,7 +1247,7 @@ namespace WaterCoils { if (!NoSatCurveIntersect && !BelowInletWaterTemp && !CBFTooLarge) { goto Inlet_Conditions_Loop_exit; // coil UA calcs OK } else { - ShowWarningError("In calculating the design coil UA for Coil:Cooling:Water " + WaterCoil(CoilNum).Name); + ShowWarningError("In calculating the design coil UA for Coil:Cooling:Water " + state.dataWaterCoils->WaterCoil(CoilNum).Name); if (NoSatCurveIntersect) { ShowContinueError("no apparatus dew-point can be found for the initial entering and leaving conditions;"); } @@ -1361,42 +1261,42 @@ namespace WaterCoils { ShowContinueError("the coil outlet design conditions will be changed to correct the problem."); } ShowContinueError("The initial design conditions are: Tair,in = " + - RoundSigDigits(WaterCoil(CoilNum).DesInletAirTemp, 4)); + RoundSigDigits(state.dataWaterCoils->WaterCoil(CoilNum).DesInletAirTemp, 4)); ShowContinueError(" Wair,in = " + - RoundSigDigits(WaterCoil(CoilNum).DesInletAirHumRat, 6)); + RoundSigDigits(state.dataWaterCoils->WaterCoil(CoilNum).DesInletAirHumRat, 6)); ShowContinueError(" Twater,in = " + - RoundSigDigits(WaterCoil(CoilNum).DesInletWaterTemp, 4)); + RoundSigDigits(state.dataWaterCoils->WaterCoil(CoilNum).DesInletWaterTemp, 4)); ShowContinueError(" Tair,out = " + - RoundSigDigits(WaterCoil(CoilNum).DesOutletAirTemp, 4)); + RoundSigDigits(state.dataWaterCoils->WaterCoil(CoilNum).DesOutletAirTemp, 4)); ShowContinueError(" Wair,out = " + - RoundSigDigits(WaterCoil(CoilNum).DesOutletAirHumRat, 6)); + RoundSigDigits(state.dataWaterCoils->WaterCoil(CoilNum).DesOutletAirHumRat, 6)); if (!NoExitCondReset) { ShowContinueError("The revised design conditions are: Tair,out = " + RoundSigDigits(TOutNew, 4)); ShowContinueError(" Wair,out = " + RoundSigDigits(WOutNew, 6)); - WaterCoil(CoilNum).DesOutletAirHumRat = WOutNew; - WaterCoil(CoilNum).DesOutletAirTemp = TOutNew; + state.dataWaterCoils->WaterCoil(CoilNum).DesOutletAirHumRat = WOutNew; + state.dataWaterCoils->WaterCoil(CoilNum).DesOutletAirTemp = TOutNew; // update outlet air conditions used for sizing std::string CompType; - if (WaterCoil(CoilNum).WaterCoilModel == CoilModel_Detailed) { + if (state.dataWaterCoils->WaterCoil(CoilNum).WaterCoilModel == state.dataWaterCoils->CoilModel_Detailed) { CompType = cAllCoilTypes(Coil_CoolingWaterDetailed); } else { CompType = cAllCoilTypes(Coil_CoolingWater); } - coilSelectionReportObj->setCoilLvgAirTemp(WaterCoil(CoilNum).Name, CompType, TOutNew); - coilSelectionReportObj->setCoilLvgAirHumRat(WaterCoil(CoilNum).Name, CompType, WOutNew); + coilSelectionReportObj->setCoilLvgAirTemp(state.dataWaterCoils->WaterCoil(CoilNum).Name, CompType, TOutNew); + coilSelectionReportObj->setCoilLvgAirHumRat(state.dataWaterCoils->WaterCoil(CoilNum).Name, CompType, WOutNew); // end update outlet air conditions used for sizing } } } // Volume flow rate being converted to mass flow rate for water - WaterCoil(CoilNum).DesAirMassFlowRate = StdRhoAir * WaterCoil(CoilNum).DesAirVolFlowRate; + state.dataWaterCoils->WaterCoil(CoilNum).DesAirMassFlowRate = StdRhoAir * state.dataWaterCoils->WaterCoil(CoilNum).DesAirVolFlowRate; // Enthalpy of Air at Inlet design conditions - DesInletAirEnth = PsyHFnTdbW(WaterCoil(CoilNum).DesInletAirTemp, WaterCoil(CoilNum).DesInletAirHumRat); + DesInletAirEnth = PsyHFnTdbW(state.dataWaterCoils->WaterCoil(CoilNum).DesInletAirTemp, state.dataWaterCoils->WaterCoil(CoilNum).DesInletAirHumRat); // Enthalpy of Air at outlet at design conditions - DesOutletAirEnth = PsyHFnTdbW(WaterCoil(CoilNum).DesOutletAirTemp, WaterCoil(CoilNum).DesOutletAirHumRat); + DesOutletAirEnth = PsyHFnTdbW(state.dataWaterCoils->WaterCoil(CoilNum).DesOutletAirTemp, state.dataWaterCoils->WaterCoil(CoilNum).DesOutletAirHumRat); // already calculated above and possibly reset if dry coil // ! Enthalpy of Water at Inlet design conditions @@ -1404,32 +1304,32 @@ namespace WaterCoils { // PsyWFnTdpPb(WaterCoil(CoilNum)%DesInletWaterTemp,StdBaroPress)) // Total Coil Load from Inlet and Outlet Air States (which include fan heat as appropriate). - WaterCoil(CoilNum).DesTotWaterCoilLoad = WaterCoil(CoilNum).DesAirMassFlowRate * (DesInletAirEnth - DesOutletAirEnth); + state.dataWaterCoils->WaterCoil(CoilNum).DesTotWaterCoilLoad = state.dataWaterCoils->WaterCoil(CoilNum).DesAirMassFlowRate * (DesInletAirEnth - DesOutletAirEnth); // Enthalpy of Water at Intlet design conditions - Cp = GetSpecificHeatGlycol(PlantLoop(WaterCoil(CoilNum).WaterLoopNum).FluidName, - WaterCoil(CoilNum).DesInletWaterTemp, - PlantLoop(WaterCoil(CoilNum).WaterLoopNum).FluidIndex, + Cp = GetSpecificHeatGlycol(PlantLoop(state.dataWaterCoils->WaterCoil(CoilNum).WaterLoopNum).FluidName, + state.dataWaterCoils->WaterCoil(CoilNum).DesInletWaterTemp, + PlantLoop(state.dataWaterCoils->WaterCoil(CoilNum).WaterLoopNum).FluidIndex, RoutineName); - DesOutletWaterTemp = WaterCoil(CoilNum).DesInletWaterTemp + - WaterCoil(CoilNum).DesTotWaterCoilLoad / (WaterCoil(CoilNum).MaxWaterMassFlowRate * Cp); + DesOutletWaterTemp = state.dataWaterCoils->WaterCoil(CoilNum).DesInletWaterTemp + + state.dataWaterCoils->WaterCoil(CoilNum).DesTotWaterCoilLoad / (state.dataWaterCoils->WaterCoil(CoilNum).MaxWaterMassFlowRate * Cp); DesSatEnthAtWaterOutTemp = PsyHFnTdbW(DesOutletWaterTemp, PsyWFnTdpPb(DesOutletWaterTemp, StdBaroPress)); - DesEnthAtWaterOutTempAirInHumRat = PsyHFnTdbW(DesOutletWaterTemp, WaterCoil(CoilNum).DesInletAirHumRat); + DesEnthAtWaterOutTempAirInHumRat = PsyHFnTdbW(DesOutletWaterTemp, state.dataWaterCoils->WaterCoil(CoilNum).DesInletAirHumRat); DesEnthWaterOut = min(DesSatEnthAtWaterOutTemp, DesEnthAtWaterOutTempAirInHumRat); // dry coil test - if (WaterCoil(CoilNum).DesOutletAirHumRat < WaterCoil(CoilNum).DesInletAirHumRat && - DesHumRatAtWaterInTemp < WaterCoil(CoilNum).DesInletAirHumRat) { // wet coil + if (state.dataWaterCoils->WaterCoil(CoilNum).DesOutletAirHumRat < state.dataWaterCoils->WaterCoil(CoilNum).DesInletAirHumRat && + DesHumRatAtWaterInTemp < state.dataWaterCoils->WaterCoil(CoilNum).DesInletAirHumRat) { // wet coil // Calculations for BYPASS FACTOR at design conditions // Calculate "slope" of temperature vs. humidity ratio between entering and leaving states - SlopeTempVsHumRatio = (WaterCoil(CoilNum).DesInletAirTemp - WaterCoil(CoilNum).DesOutletAirTemp) / - max((WaterCoil(CoilNum).DesInletAirHumRat - WaterCoil(CoilNum).DesOutletAirHumRat), SmallNo); + SlopeTempVsHumRatio = (state.dataWaterCoils->WaterCoil(CoilNum).DesInletAirTemp - state.dataWaterCoils->WaterCoil(CoilNum).DesOutletAirTemp) / + max((state.dataWaterCoils->WaterCoil(CoilNum).DesInletAirHumRat - state.dataWaterCoils->WaterCoil(CoilNum).DesOutletAirHumRat), SmallNo); // Initialize iteration parameters - DesAirTempApparatusDewPt = PsyTdpFnWPb(WaterCoil(CoilNum).DesOutletAirHumRat, OutBaroPress); + DesAirTempApparatusDewPt = PsyTdpFnWPb(state.dataWaterCoils->WaterCoil(CoilNum).DesOutletAirHumRat, OutBaroPress); // Iterating to calculate Apparatus Dew Point Temperature at Design Conditions for (iter = 1; iter <= itmax; ++iter) { @@ -1439,8 +1339,8 @@ namespace WaterCoils { DesAirHumRatApparatusDewPt = PsyWFnTdpPb(DesAirTempApparatusDewPt, OutBaroPress); // Initial Estimate for apparatus Dew Point Temperature - TempApparatusDewPtEstimate = WaterCoil(CoilNum).DesInletAirTemp - - SlopeTempVsHumRatio * (WaterCoil(CoilNum).DesInletAirHumRat - DesAirHumRatApparatusDewPt); + TempApparatusDewPtEstimate = state.dataWaterCoils->WaterCoil(CoilNum).DesInletAirTemp - + SlopeTempVsHumRatio * (state.dataWaterCoils->WaterCoil(CoilNum).DesInletAirHumRat - DesAirHumRatApparatusDewPt); // Iterating to calculate Apparatus Dew Point Temperature at Design Condition error = DesAirTempApparatusDewPt - TempApparatusDewPtEstimate; @@ -1455,7 +1355,7 @@ namespace WaterCoils { // If not converged due to low Humidity Ratio approximate value at outlet conditions if (iter == itmax) { NoSatCurveIntersect = true; - DesAirTempApparatusDewPt = PsyTdpFnWPb(WaterCoil(CoilNum).DesOutletAirHumRat, OutBaroPress); + DesAirTempApparatusDewPt = PsyTdpFnWPb(state.dataWaterCoils->WaterCoil(CoilNum).DesOutletAirHumRat, OutBaroPress); DesAirHumRatApparatusDewPt = PsyWFnTdpPb(DesAirTempApparatusDewPt, OutBaroPress); goto App_DewPoint_Loop1_exit; } @@ -1477,18 +1377,18 @@ namespace WaterCoils { } if (DesEnthWaterOut > DesInletAirEnth) { - ShowWarningError("In calculating the design coil UA for Coil:Cooling:Water " + WaterCoil(CoilNum).Name); + ShowWarningError("In calculating the design coil UA for Coil:Cooling:Water " + state.dataWaterCoils->WaterCoil(CoilNum).Name); ShowContinueError("the outlet chilled water design enthalpy is greater than the inlet air design enthalpy."); ShowContinueError("To correct this condition the design chilled water flow rate will be increased from " + - RoundSigDigits(WaterCoil(CoilNum).MaxWaterVolFlowRate, 5)); + RoundSigDigits(state.dataWaterCoils->WaterCoil(CoilNum).MaxWaterVolFlowRate, 5)); EnthCorrFrac = (DesEnthWaterOut - DesInletAirEnth) / (DesEnthWaterOut - DesSatEnthAtWaterInTemp); - WaterCoil(CoilNum).MaxWaterVolFlowRate *= (1.0 + 2.0 * EnthCorrFrac); - ShowContinueError("to " + RoundSigDigits(WaterCoil(CoilNum).MaxWaterVolFlowRate, 5) + " m3/s"); - WaterCoil(CoilNum).MaxWaterMassFlowRate = rho * WaterCoil(CoilNum).MaxWaterVolFlowRate; - DesOutletWaterTemp = WaterCoil(CoilNum).DesInletWaterTemp + - WaterCoil(CoilNum).DesTotWaterCoilLoad / (WaterCoil(CoilNum).MaxWaterMassFlowRate * Cp); + state.dataWaterCoils->WaterCoil(CoilNum).MaxWaterVolFlowRate *= (1.0 + 2.0 * EnthCorrFrac); + ShowContinueError("to " + RoundSigDigits(state.dataWaterCoils->WaterCoil(CoilNum).MaxWaterVolFlowRate, 5) + " m3/s"); + state.dataWaterCoils->WaterCoil(CoilNum).MaxWaterMassFlowRate = rho * state.dataWaterCoils->WaterCoil(CoilNum).MaxWaterVolFlowRate; + DesOutletWaterTemp = state.dataWaterCoils->WaterCoil(CoilNum).DesInletWaterTemp + + state.dataWaterCoils->WaterCoil(CoilNum).DesTotWaterCoilLoad / (state.dataWaterCoils->WaterCoil(CoilNum).MaxWaterMassFlowRate * Cp); DesSatEnthAtWaterOutTemp = PsyHFnTdbW(DesOutletWaterTemp, PsyWFnTdpPb(DesOutletWaterTemp, StdBaroPress)); - DesEnthAtWaterOutTempAirInHumRat = PsyHFnTdbW(DesOutletWaterTemp, WaterCoil(CoilNum).DesInletAirHumRat); + DesEnthAtWaterOutTempAirInHumRat = PsyHFnTdbW(DesOutletWaterTemp, state.dataWaterCoils->WaterCoil(CoilNum).DesInletAirHumRat); DesEnthWaterOut = min(DesSatEnthAtWaterOutTemp, DesEnthAtWaterOutTempAirInHumRat); } @@ -1501,52 +1401,52 @@ namespace WaterCoils { } else { LogMeanEnthDiff = 2000.0; // UA will be 1/2 the design coil load } - DesUACoilExternalEnth = WaterCoil(CoilNum).DesTotWaterCoilLoad / LogMeanEnthDiff; - WaterCoil(CoilNum).UACoilExternal = DesUACoilExternalEnth * PsyCpAirFnW(WaterCoil(CoilNum).DesInletAirHumRat); + DesUACoilExternalEnth = state.dataWaterCoils->WaterCoil(CoilNum).DesTotWaterCoilLoad / LogMeanEnthDiff; + state.dataWaterCoils->WaterCoil(CoilNum).UACoilExternal = DesUACoilExternalEnth * PsyCpAirFnW(state.dataWaterCoils->WaterCoil(CoilNum).DesInletAirHumRat); if (Ipass == 1 && (NoSatCurveIntersect || CBFTooLarge || BelowInletWaterTemp)) { // reset outlet conditions to 90% relative humidity at the same outlet enthalpy TOutNew = TdbFnHRhPb(DesOutletAirEnth, 0.9, StdBaroPress); WOutNew = PsyWFnTdbH(TOutNew, DesOutletAirEnth); - if (WOutNew >= WaterCoil(CoilNum).DesInletAirHumRat || TOutNew > WaterCoil(CoilNum).DesOutletAirTemp) { + if (WOutNew >= state.dataWaterCoils->WaterCoil(CoilNum).DesInletAirHumRat || TOutNew > state.dataWaterCoils->WaterCoil(CoilNum).DesOutletAirTemp) { NoExitCondReset = true; } goto Inlet_Conditions_Loop_loop; } - WaterCoil(CoilNum).UACoilInternal = WaterCoil(CoilNum).UACoilExternal * 3.30; + state.dataWaterCoils->WaterCoil(CoilNum).UACoilInternal = state.dataWaterCoils->WaterCoil(CoilNum).UACoilExternal * 3.30; // Overall heat transfer coefficient - WaterCoil(CoilNum).UACoilTotal = 1.0 / (1.0 / WaterCoil(CoilNum).UACoilExternal + 1.0 / WaterCoil(CoilNum).UACoilInternal); + state.dataWaterCoils->WaterCoil(CoilNum).UACoilTotal = 1.0 / (1.0 / state.dataWaterCoils->WaterCoil(CoilNum).UACoilExternal + 1.0 / state.dataWaterCoils->WaterCoil(CoilNum).UACoilInternal); } else { // dry coil - if (DesOutletWaterTemp > WaterCoil(CoilNum).DesInletAirTemp) { - ShowWarningError("In calculating the design coil UA for Coil:Cooling:Water " + WaterCoil(CoilNum).Name); + if (DesOutletWaterTemp > state.dataWaterCoils->WaterCoil(CoilNum).DesInletAirTemp) { + ShowWarningError("In calculating the design coil UA for Coil:Cooling:Water " + state.dataWaterCoils->WaterCoil(CoilNum).Name); ShowContinueError("the outlet chilled water design temperature is greater than the inlet air design temperature."); ShowContinueError("To correct this condition the design chilled water flow rate will be increased from " + - RoundSigDigits(WaterCoil(CoilNum).MaxWaterVolFlowRate, 5)); - TempCorrFrac = (DesOutletWaterTemp - WaterCoil(CoilNum).DesInletAirTemp) / - (DesOutletWaterTemp - WaterCoil(CoilNum).DesInletWaterTemp); - WaterCoil(CoilNum).MaxWaterVolFlowRate *= (1.0 + 2.0 * TempCorrFrac); - ShowContinueError("to " + RoundSigDigits(WaterCoil(CoilNum).MaxWaterVolFlowRate, 5) + " m3/s"); - WaterCoil(CoilNum).MaxWaterMassFlowRate = rho * WaterCoil(CoilNum).MaxWaterVolFlowRate; - DesOutletWaterTemp = WaterCoil(CoilNum).DesInletWaterTemp + - WaterCoil(CoilNum).DesTotWaterCoilLoad / (WaterCoil(CoilNum).MaxWaterMassFlowRate * Cp); + RoundSigDigits(state.dataWaterCoils->WaterCoil(CoilNum).MaxWaterVolFlowRate, 5)); + TempCorrFrac = (DesOutletWaterTemp - state.dataWaterCoils->WaterCoil(CoilNum).DesInletAirTemp) / + (DesOutletWaterTemp - state.dataWaterCoils->WaterCoil(CoilNum).DesInletWaterTemp); + state.dataWaterCoils->WaterCoil(CoilNum).MaxWaterVolFlowRate *= (1.0 + 2.0 * TempCorrFrac); + ShowContinueError("to " + RoundSigDigits(state.dataWaterCoils->WaterCoil(CoilNum).MaxWaterVolFlowRate, 5) + " m3/s"); + state.dataWaterCoils->WaterCoil(CoilNum).MaxWaterMassFlowRate = rho * state.dataWaterCoils->WaterCoil(CoilNum).MaxWaterVolFlowRate; + DesOutletWaterTemp = state.dataWaterCoils->WaterCoil(CoilNum).DesInletWaterTemp + + state.dataWaterCoils->WaterCoil(CoilNum).DesTotWaterCoilLoad / (state.dataWaterCoils->WaterCoil(CoilNum).MaxWaterMassFlowRate * Cp); } - if ((WaterCoil(CoilNum).DesInletAirTemp - DesOutletWaterTemp) > SmallNo && - (WaterCoil(CoilNum).DesOutletAirTemp - WaterCoil(CoilNum).DesInletWaterTemp) > SmallNo) { - LogMeanTempDiff = ((WaterCoil(CoilNum).DesInletAirTemp - DesOutletWaterTemp) - - (WaterCoil(CoilNum).DesOutletAirTemp - WaterCoil(CoilNum).DesInletWaterTemp)) / - std::log((WaterCoil(CoilNum).DesInletAirTemp - DesOutletWaterTemp) / - (WaterCoil(CoilNum).DesOutletAirTemp - WaterCoil(CoilNum).DesInletWaterTemp)); - WaterCoil(CoilNum).UACoilExternal = WaterCoil(CoilNum).DesTotWaterCoilLoad / LogMeanTempDiff; + if ((state.dataWaterCoils->WaterCoil(CoilNum).DesInletAirTemp - DesOutletWaterTemp) > SmallNo && + (state.dataWaterCoils->WaterCoil(CoilNum).DesOutletAirTemp - state.dataWaterCoils->WaterCoil(CoilNum).DesInletWaterTemp) > SmallNo) { + LogMeanTempDiff = ((state.dataWaterCoils->WaterCoil(CoilNum).DesInletAirTemp - DesOutletWaterTemp) - + (state.dataWaterCoils->WaterCoil(CoilNum).DesOutletAirTemp - state.dataWaterCoils->WaterCoil(CoilNum).DesInletWaterTemp)) / + std::log((state.dataWaterCoils->WaterCoil(CoilNum).DesInletAirTemp - DesOutletWaterTemp) / + (state.dataWaterCoils->WaterCoil(CoilNum).DesOutletAirTemp - state.dataWaterCoils->WaterCoil(CoilNum).DesInletWaterTemp)); + state.dataWaterCoils->WaterCoil(CoilNum).UACoilExternal = state.dataWaterCoils->WaterCoil(CoilNum).DesTotWaterCoilLoad / LogMeanTempDiff; } else { - WaterCoil(CoilNum).UACoilExternal = WaterCoil(CoilNum).DesTotWaterCoilLoad / 2.0; // make the UA large + state.dataWaterCoils->WaterCoil(CoilNum).UACoilExternal = state.dataWaterCoils->WaterCoil(CoilNum).DesTotWaterCoilLoad / 2.0; // make the UA large } - WaterCoil(CoilNum).UACoilInternal = WaterCoil(CoilNum).UACoilExternal * 3.30; + state.dataWaterCoils->WaterCoil(CoilNum).UACoilInternal = state.dataWaterCoils->WaterCoil(CoilNum).UACoilExternal * 3.30; // Overall heat transfer coefficient - WaterCoil(CoilNum).UACoilTotal = 1.0 / (1.0 / WaterCoil(CoilNum).UACoilExternal + 1.0 / WaterCoil(CoilNum).UACoilInternal); + state.dataWaterCoils->WaterCoil(CoilNum).UACoilTotal = 1.0 / (1.0 / state.dataWaterCoils->WaterCoil(CoilNum).UACoilExternal + 1.0 / state.dataWaterCoils->WaterCoil(CoilNum).UACoilInternal); goto Inlet_Conditions_Loop_exit; } @@ -1555,115 +1455,115 @@ namespace WaterCoils { Inlet_Conditions_Loop_exit:; // estimate the heat external transfer surface area using typical design over all U value - WaterCoil(CoilNum).TotCoilOutsideSurfArea = EstimateHEXSurfaceArea(CoilNum); + state.dataWaterCoils->WaterCoil(CoilNum).TotCoilOutsideSurfArea = EstimateHEXSurfaceArea(state, CoilNum); // calculate internal and external "UA per external surface area" - WaterCoil(CoilNum).UACoilInternalPerUnitArea = WaterCoil(CoilNum).UACoilInternal / WaterCoil(CoilNum).TotCoilOutsideSurfArea; - WaterCoil(CoilNum).UAWetExtPerUnitArea = WaterCoil(CoilNum).UACoilExternal / WaterCoil(CoilNum).TotCoilOutsideSurfArea; + state.dataWaterCoils->WaterCoil(CoilNum).UACoilInternalPerUnitArea = state.dataWaterCoils->WaterCoil(CoilNum).UACoilInternal / state.dataWaterCoils->WaterCoil(CoilNum).TotCoilOutsideSurfArea; + state.dataWaterCoils->WaterCoil(CoilNum).UAWetExtPerUnitArea = state.dataWaterCoils->WaterCoil(CoilNum).UACoilExternal / state.dataWaterCoils->WaterCoil(CoilNum).TotCoilOutsideSurfArea; // approximate the dry UA as 1.0 times wet UA - WaterCoil(CoilNum).UADryExtPerUnitArea = WaterCoil(CoilNum).UAWetExtPerUnitArea; + state.dataWaterCoils->WaterCoil(CoilNum).UADryExtPerUnitArea = state.dataWaterCoils->WaterCoil(CoilNum).UAWetExtPerUnitArea; // Now use SolveRoot to "invert" the cooling coil model to obtain the UA given the specified design inlet and outlet conditions // Note that the UAs we have obtained so far are rough estimates that are the starting points for the the following iterative // calulation of the actual UAs. - Par(1) = WaterCoil(CoilNum).DesTotWaterCoilLoad; + Par(1) = state.dataWaterCoils->WaterCoil(CoilNum).DesTotWaterCoilLoad; Par(2) = double(CoilNum); Par(3) = double(ContFanCycCoil); // fan operating mode Par(4) = 1.0; // part-load ratio - WaterCoil(CoilNum).InletAirTemp = WaterCoil(CoilNum).DesInletAirTemp; - WaterCoil(CoilNum).InletAirHumRat = WaterCoil(CoilNum).DesInletAirHumRat; - WaterCoil(CoilNum).InletWaterTemp = WaterCoil(CoilNum).DesInletWaterTemp; - WaterCoil(CoilNum).InletWaterMassFlowRate = rho * WaterCoil(CoilNum).MaxWaterVolFlowRate; - WaterCoil(CoilNum).InletAirMassFlowRate = WaterCoil(CoilNum).DesAirMassFlowRate; + state.dataWaterCoils->WaterCoil(CoilNum).InletAirTemp = state.dataWaterCoils->WaterCoil(CoilNum).DesInletAirTemp; + state.dataWaterCoils->WaterCoil(CoilNum).InletAirHumRat = state.dataWaterCoils->WaterCoil(CoilNum).DesInletAirHumRat; + state.dataWaterCoils->WaterCoil(CoilNum).InletWaterTemp = state.dataWaterCoils->WaterCoil(CoilNum).DesInletWaterTemp; + state.dataWaterCoils->WaterCoil(CoilNum).InletWaterMassFlowRate = rho * state.dataWaterCoils->WaterCoil(CoilNum).MaxWaterVolFlowRate; + state.dataWaterCoils->WaterCoil(CoilNum).InletAirMassFlowRate = state.dataWaterCoils->WaterCoil(CoilNum).DesAirMassFlowRate; // set the lower and upper limits on the UA - UA0 = 0.1 * WaterCoil(CoilNum).UACoilExternal; - UA1 = 10.0 * WaterCoil(CoilNum).UACoilExternal; + UA0 = 0.1 * state.dataWaterCoils->WaterCoil(CoilNum).UACoilExternal; + UA1 = 10.0 * state.dataWaterCoils->WaterCoil(CoilNum).UACoilExternal; // Invert the simple cooling coil model: given the design inlet conditions and the design load, find the design UA - SolveRoot(0.001, MaxIte, SolFla, UA, SimpleCoolingCoilUAResidual, UA0, UA1, Par); + TempSolveRoot::SolveRoot(state, 0.001, MaxIte, SolFla, UA, SimpleCoolingCoilUAResidual, UA0, UA1, Par); // if the numerical inversion failed, issue error messages. if (SolFla == -1) { - ShowSevereError("Calculation of cooling coil design UA failed for coil " + WaterCoil(CoilNum).Name); + ShowSevereError("Calculation of cooling coil design UA failed for coil " + state.dataWaterCoils->WaterCoil(CoilNum).Name); ShowContinueError(" Iteration limit exceeded in calculating coil UA"); // CALL ShowFatalError('Preceeding error causes program termination') - WaterCoil(CoilNum).UACoilExternal = UA0 * 10.0; - WaterCoil(CoilNum).UACoilInternal = WaterCoil(CoilNum).UACoilExternal * 3.3; - WaterCoil(CoilNum).UACoilTotal = 1.0 / (1.0 / WaterCoil(CoilNum).UACoilExternal + 1.0 / WaterCoil(CoilNum).UACoilInternal); - WaterCoil(CoilNum).TotCoilOutsideSurfArea = EstimateHEXSurfaceArea(CoilNum); - WaterCoil(CoilNum).UACoilInternalPerUnitArea = WaterCoil(CoilNum).UACoilInternal / WaterCoil(CoilNum).TotCoilOutsideSurfArea; - WaterCoil(CoilNum).UAWetExtPerUnitArea = WaterCoil(CoilNum).UACoilExternal / WaterCoil(CoilNum).TotCoilOutsideSurfArea; - WaterCoil(CoilNum).UADryExtPerUnitArea = WaterCoil(CoilNum).UAWetExtPerUnitArea; - ShowContinueError(" Coil design UA set to " + RoundSigDigits(WaterCoil(CoilNum).UACoilTotal, 6) + " [W/C]"); + state.dataWaterCoils->WaterCoil(CoilNum).UACoilExternal = UA0 * 10.0; + state.dataWaterCoils->WaterCoil(CoilNum).UACoilInternal = state.dataWaterCoils->WaterCoil(CoilNum).UACoilExternal * 3.3; + state.dataWaterCoils->WaterCoil(CoilNum).UACoilTotal = 1.0 / (1.0 / state.dataWaterCoils->WaterCoil(CoilNum).UACoilExternal + 1.0 / state.dataWaterCoils->WaterCoil(CoilNum).UACoilInternal); + state.dataWaterCoils->WaterCoil(CoilNum).TotCoilOutsideSurfArea = EstimateHEXSurfaceArea(state, CoilNum); + state.dataWaterCoils->WaterCoil(CoilNum).UACoilInternalPerUnitArea = state.dataWaterCoils->WaterCoil(CoilNum).UACoilInternal / state.dataWaterCoils->WaterCoil(CoilNum).TotCoilOutsideSurfArea; + state.dataWaterCoils->WaterCoil(CoilNum).UAWetExtPerUnitArea = state.dataWaterCoils->WaterCoil(CoilNum).UACoilExternal / state.dataWaterCoils->WaterCoil(CoilNum).TotCoilOutsideSurfArea; + state.dataWaterCoils->WaterCoil(CoilNum).UADryExtPerUnitArea = state.dataWaterCoils->WaterCoil(CoilNum).UAWetExtPerUnitArea; + ShowContinueError(" Coil design UA set to " + RoundSigDigits(state.dataWaterCoils->WaterCoil(CoilNum).UACoilTotal, 6) + " [W/C]"); } else if (SolFla == -2) { - ShowSevereError("Calculation of cooling coil design UA failed for coil " + WaterCoil(CoilNum).Name); + ShowSevereError("Calculation of cooling coil design UA failed for coil " + state.dataWaterCoils->WaterCoil(CoilNum).Name); ShowContinueError(" Bad starting values for UA"); // CALL ShowFatalError('Preceeding error causes program termination') - WaterCoil(CoilNum).UACoilExternal = UA0 * 10.0; - WaterCoil(CoilNum).UACoilInternal = WaterCoil(CoilNum).UACoilExternal * 3.3; - WaterCoil(CoilNum).UACoilTotal = 1.0 / (1.0 / WaterCoil(CoilNum).UACoilExternal + 1.0 / WaterCoil(CoilNum).UACoilInternal); - WaterCoil(CoilNum).TotCoilOutsideSurfArea = EstimateHEXSurfaceArea(CoilNum); - WaterCoil(CoilNum).UACoilInternalPerUnitArea = WaterCoil(CoilNum).UACoilInternal / WaterCoil(CoilNum).TotCoilOutsideSurfArea; - WaterCoil(CoilNum).UAWetExtPerUnitArea = WaterCoil(CoilNum).UACoilExternal / WaterCoil(CoilNum).TotCoilOutsideSurfArea; - WaterCoil(CoilNum).UADryExtPerUnitArea = WaterCoil(CoilNum).UAWetExtPerUnitArea; - ShowContinueError(" Coil design UA set to " + RoundSigDigits(WaterCoil(CoilNum).UACoilTotal, 6) + " [W/C]"); + state.dataWaterCoils->WaterCoil(CoilNum).UACoilExternal = UA0 * 10.0; + state.dataWaterCoils->WaterCoil(CoilNum).UACoilInternal = state.dataWaterCoils->WaterCoil(CoilNum).UACoilExternal * 3.3; + state.dataWaterCoils->WaterCoil(CoilNum).UACoilTotal = 1.0 / (1.0 / state.dataWaterCoils->WaterCoil(CoilNum).UACoilExternal + 1.0 / state.dataWaterCoils->WaterCoil(CoilNum).UACoilInternal); + state.dataWaterCoils->WaterCoil(CoilNum).TotCoilOutsideSurfArea = EstimateHEXSurfaceArea(state, CoilNum); + state.dataWaterCoils->WaterCoil(CoilNum).UACoilInternalPerUnitArea = state.dataWaterCoils->WaterCoil(CoilNum).UACoilInternal / state.dataWaterCoils->WaterCoil(CoilNum).TotCoilOutsideSurfArea; + state.dataWaterCoils->WaterCoil(CoilNum).UAWetExtPerUnitArea = state.dataWaterCoils->WaterCoil(CoilNum).UACoilExternal / state.dataWaterCoils->WaterCoil(CoilNum).TotCoilOutsideSurfArea; + state.dataWaterCoils->WaterCoil(CoilNum).UADryExtPerUnitArea = state.dataWaterCoils->WaterCoil(CoilNum).UAWetExtPerUnitArea; + ShowContinueError(" Coil design UA set to " + RoundSigDigits(state.dataWaterCoils->WaterCoil(CoilNum).UACoilTotal, 6) + " [W/C]"); } // cooling coil surface area - SurfaceArea = WaterCoil(CoilNum).TotCoilOutsideSurfArea; + SurfaceArea = state.dataWaterCoils->WaterCoil(CoilNum).TotCoilOutsideSurfArea; // cooling coil overall UA value - UATotal = WaterCoil(CoilNum).UACoilTotal; + UATotal = state.dataWaterCoils->WaterCoil(CoilNum).UACoilTotal; // save the design internal and external UAs - WaterCoil(CoilNum).UACoilExternalDes = WaterCoil(CoilNum).UACoilExternal; - WaterCoil(CoilNum).UACoilInternalDes = WaterCoil(CoilNum).UACoilInternal; + state.dataWaterCoils->WaterCoil(CoilNum).UACoilExternalDes = state.dataWaterCoils->WaterCoil(CoilNum).UACoilExternal; + state.dataWaterCoils->WaterCoil(CoilNum).UACoilInternalDes = state.dataWaterCoils->WaterCoil(CoilNum).UACoilInternal; } //@@@@ DESIGN CONDITION END HERE @@@@ // Calculate rated Total, latent, sensible capacity, SHR, effectiveness - if (WaterCoil(CoilNum).WaterCoilType_Num == WaterCoil_SimpleHeating) { - WaterCoil(CoilNum).InletAirTemp = 16.6; - WaterCoil(CoilNum).InletAirHumRat = PsyWFnTdbRhPb(16.6, 0.5, StdBaroPress, RoutineName); - WaterCoil(CoilNum).InletWaterTemp = 82.2; + if (state.dataWaterCoils->WaterCoil(CoilNum).WaterCoilType_Num == state.dataWaterCoils->WaterCoil_SimpleHeating) { + state.dataWaterCoils->WaterCoil(CoilNum).InletAirTemp = 16.6; + state.dataWaterCoils->WaterCoil(CoilNum).InletAirHumRat = PsyWFnTdbRhPb(16.6, 0.5, StdBaroPress, RoutineName); + state.dataWaterCoils->WaterCoil(CoilNum).InletWaterTemp = 82.2; } else { - WaterCoil(CoilNum).InletAirTemp = 26.67; - WaterCoil(CoilNum).InletAirHumRat = PsyWFnTdbTwbPb(26.67, 19.44, StdBaroPress, RoutineName); - WaterCoil(CoilNum).InletWaterTemp = 6.67; + state.dataWaterCoils->WaterCoil(CoilNum).InletAirTemp = 26.67; + state.dataWaterCoils->WaterCoil(CoilNum).InletAirHumRat = PsyWFnTdbTwbPb(26.67, 19.44, StdBaroPress, RoutineName); + state.dataWaterCoils->WaterCoil(CoilNum).InletWaterTemp = 6.67; } - WaterCoil(CoilNum).InletAirEnthalpy = PsyHFnTdbW(WaterCoil(CoilNum).InletAirTemp, WaterCoil(CoilNum).InletAirHumRat); - WaterCoil(CoilNum).InletWaterMassFlowRate = WaterCoil(CoilNum).MaxWaterMassFlowRate; - WaterCoil(CoilNum).InletAirMassFlowRate = StdRhoAir * WaterCoil(CoilNum).DesAirVolFlowRate; - CapacitanceAir = WaterCoil(CoilNum).InletAirMassFlowRate * PsyCpAirFnW(WaterCoil(CoilNum).InletAirHumRat); - - Cp = GetSpecificHeatGlycol(PlantLoop(WaterCoil(CoilNum).WaterLoopNum).FluidName, - WaterCoil(CoilNum).InletWaterTemp, - PlantLoop(WaterCoil(CoilNum).WaterLoopNum).FluidIndex, + state.dataWaterCoils->WaterCoil(CoilNum).InletAirEnthalpy = PsyHFnTdbW(state.dataWaterCoils->WaterCoil(CoilNum).InletAirTemp, state.dataWaterCoils->WaterCoil(CoilNum).InletAirHumRat); + state.dataWaterCoils->WaterCoil(CoilNum).InletWaterMassFlowRate = state.dataWaterCoils->WaterCoil(CoilNum).MaxWaterMassFlowRate; + state.dataWaterCoils->WaterCoil(CoilNum).InletAirMassFlowRate = StdRhoAir * state.dataWaterCoils->WaterCoil(CoilNum).DesAirVolFlowRate; + CapacitanceAir = state.dataWaterCoils->WaterCoil(CoilNum).InletAirMassFlowRate * PsyCpAirFnW(state.dataWaterCoils->WaterCoil(CoilNum).InletAirHumRat); + + Cp = GetSpecificHeatGlycol(PlantLoop(state.dataWaterCoils->WaterCoil(CoilNum).WaterLoopNum).FluidName, + state.dataWaterCoils->WaterCoil(CoilNum).InletWaterTemp, + PlantLoop(state.dataWaterCoils->WaterCoil(CoilNum).WaterLoopNum).FluidIndex, RoutineName); - CapacitanceWater = WaterCoil(CoilNum).InletWaterMassFlowRate * Cp; + CapacitanceWater = state.dataWaterCoils->WaterCoil(CoilNum).InletWaterMassFlowRate * Cp; CMin = min(CapacitanceAir, CapacitanceWater); if (CMin > 0.0) { - if (WaterCoil(CoilNum).WaterCoilType_Num == WaterCoil_Cooling) { - CoolingCoil(CoilNum, FirstHVACIteration, DesignCalc, ContFanCycCoil, 1.0); - CoilEffectiveness = (WaterCoil(CoilNum).InletAirTemp - WaterCoil(CoilNum).OutletAirTemp) / - (WaterCoil(CoilNum).InletAirTemp - WaterCoil(CoilNum).InletWaterTemp) * (CapacitanceAir / CMin); - RatedLatentCapacity = WaterCoil(CoilNum).TotWaterCoolingCoilRate - WaterCoil(CoilNum).SenWaterCoolingCoilRate; - RatedSHR = WaterCoil(CoilNum).SenWaterCoolingCoilRate / WaterCoil(CoilNum).TotWaterCoolingCoilRate; - } else if (WaterCoil(CoilNum).WaterCoilType_Num == WaterCoil_DetFlatFinCooling) { - CalcDetailFlatFinCoolingCoil(CoilNum, DesignCalc, ContFanCycCoil, 1.0); - CoilEffectiveness = (WaterCoil(CoilNum).InletAirTemp - WaterCoil(CoilNum).OutletAirTemp) / - (WaterCoil(CoilNum).InletAirTemp - WaterCoil(CoilNum).InletWaterTemp) * (CapacitanceAir / CMin); - RatedLatentCapacity = WaterCoil(CoilNum).TotWaterCoolingCoilRate - WaterCoil(CoilNum).SenWaterCoolingCoilRate; - RatedSHR = WaterCoil(CoilNum).SenWaterCoolingCoilRate / WaterCoil(CoilNum).TotWaterCoolingCoilRate; - } else if (WaterCoil(CoilNum).WaterCoilType_Num == WaterCoil_SimpleHeating) { - CalcSimpleHeatingCoil(CoilNum, ContFanCycCoil, 1.0, DesignCalc); - CoilEffectiveness = (WaterCoil(CoilNum).OutletAirTemp - WaterCoil(CoilNum).InletAirTemp) / - (WaterCoil(CoilNum).InletWaterTemp - WaterCoil(CoilNum).InletAirTemp) * (CapacitanceAir / CMin); + if (state.dataWaterCoils->WaterCoil(CoilNum).WaterCoilType_Num == state.dataWaterCoils->WaterCoil_Cooling) { + CoolingCoil(state, CoilNum, FirstHVACIteration, state.dataWaterCoils->DesignCalc, ContFanCycCoil, 1.0); + CoilEffectiveness = (state.dataWaterCoils->WaterCoil(CoilNum).InletAirTemp - state.dataWaterCoils->WaterCoil(CoilNum).OutletAirTemp) / + (state.dataWaterCoils->WaterCoil(CoilNum).InletAirTemp - state.dataWaterCoils->WaterCoil(CoilNum).InletWaterTemp) * (CapacitanceAir / CMin); + RatedLatentCapacity = state.dataWaterCoils->WaterCoil(CoilNum).TotWaterCoolingCoilRate - state.dataWaterCoils->WaterCoil(CoilNum).SenWaterCoolingCoilRate; + RatedSHR = state.dataWaterCoils->WaterCoil(CoilNum).SenWaterCoolingCoilRate / state.dataWaterCoils->WaterCoil(CoilNum).TotWaterCoolingCoilRate; + } else if (state.dataWaterCoils->WaterCoil(CoilNum).WaterCoilType_Num == state.dataWaterCoils->WaterCoil_DetFlatFinCooling) { + CalcDetailFlatFinCoolingCoil(state, CoilNum, state.dataWaterCoils->DesignCalc, ContFanCycCoil, 1.0); + CoilEffectiveness = (state.dataWaterCoils->WaterCoil(CoilNum).InletAirTemp - state.dataWaterCoils->WaterCoil(CoilNum).OutletAirTemp) / + (state.dataWaterCoils->WaterCoil(CoilNum).InletAirTemp - state.dataWaterCoils->WaterCoil(CoilNum).InletWaterTemp) * (CapacitanceAir / CMin); + RatedLatentCapacity = state.dataWaterCoils->WaterCoil(CoilNum).TotWaterCoolingCoilRate - state.dataWaterCoils->WaterCoil(CoilNum).SenWaterCoolingCoilRate; + RatedSHR = state.dataWaterCoils->WaterCoil(CoilNum).SenWaterCoolingCoilRate / state.dataWaterCoils->WaterCoil(CoilNum).TotWaterCoolingCoilRate; + } else if (state.dataWaterCoils->WaterCoil(CoilNum).WaterCoilType_Num == state.dataWaterCoils->WaterCoil_SimpleHeating) { + CalcSimpleHeatingCoil(state, CoilNum, ContFanCycCoil, 1.0, state.dataWaterCoils->DesignCalc); + CoilEffectiveness = (state.dataWaterCoils->WaterCoil(CoilNum).OutletAirTemp - state.dataWaterCoils->WaterCoil(CoilNum).InletAirTemp) / + (state.dataWaterCoils->WaterCoil(CoilNum).InletWaterTemp - state.dataWaterCoils->WaterCoil(CoilNum).InletAirTemp) * (CapacitanceAir / CMin); } } else { CoilEffectiveness = 0.0; - WaterCoil(CoilNum).TotWaterHeatingCoilRate = 0.0; - WaterCoil(CoilNum).TotWaterCoolingCoilRate = 0.0; - WaterCoil(CoilNum).SenWaterCoolingCoilRate = 0.0; + state.dataWaterCoils->WaterCoil(CoilNum).TotWaterHeatingCoilRate = 0.0; + state.dataWaterCoils->WaterCoil(CoilNum).TotWaterCoolingCoilRate = 0.0; + state.dataWaterCoils->WaterCoil(CoilNum).SenWaterCoolingCoilRate = 0.0; RatedLatentCapacity = 0.0; RatedSHR = 0.0; } @@ -1680,36 +1580,36 @@ namespace WaterCoils { // create predefined report entries MyCoilReportFlag(CoilNum) = false; { - auto const SELECT_CASE_var(WaterCoil(CoilNum).WaterCoilType_Num); - if (SELECT_CASE_var == WaterCoil_SimpleHeating) { + auto const SELECT_CASE_var(state.dataWaterCoils->WaterCoil(CoilNum).WaterCoilType_Num); + if (SELECT_CASE_var == state.dataWaterCoils->WaterCoil_SimpleHeating) { if (RptCoilHeaderFlag(1)) { print(state.files.eio, "{}", "! ,Component Type,Name,Nominal Total Capacity {W}\n"); RptCoilHeaderFlag(1) = false; } - PreDefTableEntry(pdchHeatCoilType, WaterCoil(CoilNum).Name, "Coil:Heating:Water"); - PreDefTableEntry(pdchHeatCoilDesCap, WaterCoil(CoilNum).Name, WaterCoil(CoilNum).DesWaterHeatingCoilRate); - PreDefTableEntry(pdchHeatCoilNomCap, WaterCoil(CoilNum).Name, WaterCoil(CoilNum).TotWaterHeatingCoilRate); - PreDefTableEntry(pdchHeatCoilNomEff, WaterCoil(CoilNum).Name, "-"); + PreDefTableEntry(pdchHeatCoilType, state.dataWaterCoils->WaterCoil(CoilNum).Name, "Coil:Heating:Water"); + PreDefTableEntry(pdchHeatCoilDesCap, state.dataWaterCoils->WaterCoil(CoilNum).Name, state.dataWaterCoils->WaterCoil(CoilNum).DesWaterHeatingCoilRate); + PreDefTableEntry(pdchHeatCoilNomCap, state.dataWaterCoils->WaterCoil(CoilNum).Name, state.dataWaterCoils->WaterCoil(CoilNum).TotWaterHeatingCoilRate); + PreDefTableEntry(pdchHeatCoilNomEff, state.dataWaterCoils->WaterCoil(CoilNum).Name, "-"); addFootNoteSubTable( pdstHeatCoil, "Nominal values are gross at rated conditions, i.e., the supply air fan heat and electric power NOT accounted for."); print(state.files.eio, "{},{},{:.2R}\n", "Water Heating Coil Capacity Information,Coil:Heating:Water", - WaterCoil(CoilNum).Name, - WaterCoil(CoilNum).TotWaterHeatingCoilRate); - coilSelectionReportObj->setCoilAirFlow(WaterCoil(CoilNum).Name, + state.dataWaterCoils->WaterCoil(CoilNum).Name, + state.dataWaterCoils->WaterCoil(CoilNum).TotWaterHeatingCoilRate); + coilSelectionReportObj->setCoilAirFlow(state.dataWaterCoils->WaterCoil(CoilNum).Name, "Coil:Heating:Water", - WaterCoil(CoilNum).DesAirVolFlowRate, - WaterCoil(CoilNum).RequestingAutoSize); - coilSelectionReportObj->setCoilWaterHeaterCapacityNodeNums(WaterCoil(CoilNum).Name, + state.dataWaterCoils->WaterCoil(CoilNum).DesAirVolFlowRate, + state.dataWaterCoils->WaterCoil(CoilNum).RequestingAutoSize); + coilSelectionReportObj->setCoilWaterHeaterCapacityNodeNums(state.dataWaterCoils->WaterCoil(CoilNum).Name, "Coil:Heating:Water", - WaterCoil(CoilNum).DesWaterHeatingCoilRate, - WaterCoil(CoilNum).RequestingAutoSize, - WaterCoil(CoilNum).WaterInletNodeNum, - WaterCoil(CoilNum).WaterOutletNodeNum, - WaterCoil(CoilNum).WaterLoopNum); // coil report - } else if (SELECT_CASE_var == WaterCoil_DetFlatFinCooling) { + state.dataWaterCoils->WaterCoil(CoilNum).DesWaterHeatingCoilRate, + state.dataWaterCoils->WaterCoil(CoilNum).RequestingAutoSize, + state.dataWaterCoils->WaterCoil(CoilNum).WaterInletNodeNum, + state.dataWaterCoils->WaterCoil(CoilNum).WaterOutletNodeNum, + state.dataWaterCoils->WaterCoil(CoilNum).WaterLoopNum); // coil report + } else if (SELECT_CASE_var == state.dataWaterCoils->WaterCoil_DetFlatFinCooling) { if (RptCoilHeaderFlag(2)) { print(state.files.eio, "{}\n", @@ -1718,38 +1618,38 @@ namespace WaterCoils { "Sensible Heat Ratio"); RptCoilHeaderFlag(2) = false; } - RatedLatentCapacity = WaterCoil(CoilNum).TotWaterCoolingCoilRate - WaterCoil(CoilNum).SenWaterCoolingCoilRate; - RatedSHR = SafeDivide(WaterCoil(CoilNum).SenWaterCoolingCoilRate, WaterCoil(CoilNum).TotWaterCoolingCoilRate); - PreDefTableEntry(pdchCoolCoilType, WaterCoil(CoilNum).Name, "Coil:Cooling:Water:DetailedGeometry"); - PreDefTableEntry(pdchCoolCoilDesCap, WaterCoil(CoilNum).Name, WaterCoil(CoilNum).DesWaterCoolingCoilRate); - PreDefTableEntry(pdchCoolCoilTotCap, WaterCoil(CoilNum).Name, WaterCoil(CoilNum).TotWaterCoolingCoilRate); - PreDefTableEntry(pdchCoolCoilSensCap, WaterCoil(CoilNum).Name, WaterCoil(CoilNum).SenWaterCoolingCoilRate); - PreDefTableEntry(pdchCoolCoilLatCap, WaterCoil(CoilNum).Name, RatedLatentCapacity); - PreDefTableEntry(pdchCoolCoilSHR, WaterCoil(CoilNum).Name, RatedSHR); - PreDefTableEntry(pdchCoolCoilNomEff, WaterCoil(CoilNum).Name, "-"); + RatedLatentCapacity = state.dataWaterCoils->WaterCoil(CoilNum).TotWaterCoolingCoilRate - state.dataWaterCoils->WaterCoil(CoilNum).SenWaterCoolingCoilRate; + RatedSHR = SafeDivide(state.dataWaterCoils->WaterCoil(CoilNum).SenWaterCoolingCoilRate, state.dataWaterCoils->WaterCoil(CoilNum).TotWaterCoolingCoilRate); + PreDefTableEntry(pdchCoolCoilType, state.dataWaterCoils->WaterCoil(CoilNum).Name, "Coil:Cooling:Water:DetailedGeometry"); + PreDefTableEntry(pdchCoolCoilDesCap, state.dataWaterCoils->WaterCoil(CoilNum).Name, state.dataWaterCoils->WaterCoil(CoilNum).DesWaterCoolingCoilRate); + PreDefTableEntry(pdchCoolCoilTotCap, state.dataWaterCoils->WaterCoil(CoilNum).Name, state.dataWaterCoils->WaterCoil(CoilNum).TotWaterCoolingCoilRate); + PreDefTableEntry(pdchCoolCoilSensCap, state.dataWaterCoils->WaterCoil(CoilNum).Name, state.dataWaterCoils->WaterCoil(CoilNum).SenWaterCoolingCoilRate); + PreDefTableEntry(pdchCoolCoilLatCap, state.dataWaterCoils->WaterCoil(CoilNum).Name, RatedLatentCapacity); + PreDefTableEntry(pdchCoolCoilSHR, state.dataWaterCoils->WaterCoil(CoilNum).Name, RatedSHR); + PreDefTableEntry(pdchCoolCoilNomEff, state.dataWaterCoils->WaterCoil(CoilNum).Name, "-"); addFootNoteSubTable( pdstCoolCoil, "Nominal values are gross at rated conditions, i.e., the supply air fan heat and electric power NOT accounted for."); print(state.files.eio, "{},{},{:.2R},{:.2R},{:.2R},{:.2R}\n", "Water Cooling Coil Capacity Information,Coil:Cooling:Water:DetailedGeometry", - WaterCoil(CoilNum).Name, - WaterCoil(CoilNum).TotWaterCoolingCoilRate, - WaterCoil(CoilNum).SenWaterCoolingCoilRate, + state.dataWaterCoils->WaterCoil(CoilNum).Name, + state.dataWaterCoils->WaterCoil(CoilNum).TotWaterCoolingCoilRate, + state.dataWaterCoils->WaterCoil(CoilNum).SenWaterCoolingCoilRate, RatedLatentCapacity, RatedSHR); - coilSelectionReportObj->setCoilAirFlow(WaterCoil(CoilNum).Name, + coilSelectionReportObj->setCoilAirFlow(state.dataWaterCoils->WaterCoil(CoilNum).Name, "Coil:Cooling:Water:DetailedGeometry", - WaterCoil(CoilNum).DesAirVolFlowRate, - WaterCoil(CoilNum).RequestingAutoSize); // Coil Report - coilSelectionReportObj->setCoilWaterCoolingCapacity(WaterCoil(CoilNum).Name, + state.dataWaterCoils->WaterCoil(CoilNum).DesAirVolFlowRate, + state.dataWaterCoils->WaterCoil(CoilNum).RequestingAutoSize); // Coil Report + coilSelectionReportObj->setCoilWaterCoolingCapacity(state.dataWaterCoils->WaterCoil(CoilNum).Name, "Coil:Cooling:Water:DetailedGeometry", - WaterCoil(CoilNum).DesWaterCoolingCoilRate, - WaterCoil(CoilNum).RequestingAutoSize, - WaterCoil(CoilNum).WaterInletNodeNum, - WaterCoil(CoilNum).WaterOutletNodeNum, - WaterCoil(CoilNum).WaterLoopNum); // Coil Report - } else if (SELECT_CASE_var == WaterCoil_Cooling) { + state.dataWaterCoils->WaterCoil(CoilNum).DesWaterCoolingCoilRate, + state.dataWaterCoils->WaterCoil(CoilNum).RequestingAutoSize, + state.dataWaterCoils->WaterCoil(CoilNum).WaterInletNodeNum, + state.dataWaterCoils->WaterCoil(CoilNum).WaterOutletNodeNum, + state.dataWaterCoils->WaterCoil(CoilNum).WaterLoopNum); // Coil Report + } else if (SELECT_CASE_var == state.dataWaterCoils->WaterCoil_Cooling) { if (RptCoilHeaderFlag(2)) { print(state.files.eio, "{}\n", @@ -1758,117 +1658,117 @@ namespace WaterCoils { "Sensible Heat Ratio, Nominal Coil UA Value {W/C}, Nominal Coil Surface Area {m2}"); RptCoilHeaderFlag(2) = false; } - RatedLatentCapacity = WaterCoil(CoilNum).TotWaterCoolingCoilRate - WaterCoil(CoilNum).SenWaterCoolingCoilRate; - RatedSHR = SafeDivide(WaterCoil(CoilNum).SenWaterCoolingCoilRate, WaterCoil(CoilNum).TotWaterCoolingCoilRate); - PreDefTableEntry(pdchCoolCoilType, WaterCoil(CoilNum).Name, "Coil:Cooling:Water"); - PreDefTableEntry(pdchCoolCoilDesCap, WaterCoil(CoilNum).Name, WaterCoil(CoilNum).DesWaterCoolingCoilRate); - PreDefTableEntry(pdchCoolCoilTotCap, WaterCoil(CoilNum).Name, WaterCoil(CoilNum).TotWaterCoolingCoilRate); - PreDefTableEntry(pdchCoolCoilSensCap, WaterCoil(CoilNum).Name, WaterCoil(CoilNum).SenWaterCoolingCoilRate); - PreDefTableEntry(pdchCoolCoilLatCap, WaterCoil(CoilNum).Name, RatedLatentCapacity); - PreDefTableEntry(pdchCoolCoilSHR, WaterCoil(CoilNum).Name, RatedSHR); - PreDefTableEntry(pdchCoolCoilNomEff, WaterCoil(CoilNum).Name, "-"); - PreDefTableEntry(pdchCoolCoilUATotal, WaterCoil(CoilNum).Name, WaterCoil(CoilNum).UACoilTotal); - PreDefTableEntry(pdchCoolCoilArea, WaterCoil(CoilNum).Name, WaterCoil(CoilNum).TotCoilOutsideSurfArea); + RatedLatentCapacity = state.dataWaterCoils->WaterCoil(CoilNum).TotWaterCoolingCoilRate - state.dataWaterCoils->WaterCoil(CoilNum).SenWaterCoolingCoilRate; + RatedSHR = SafeDivide(state.dataWaterCoils->WaterCoil(CoilNum).SenWaterCoolingCoilRate, state.dataWaterCoils->WaterCoil(CoilNum).TotWaterCoolingCoilRate); + PreDefTableEntry(pdchCoolCoilType, state.dataWaterCoils->WaterCoil(CoilNum).Name, "Coil:Cooling:Water"); + PreDefTableEntry(pdchCoolCoilDesCap, state.dataWaterCoils->WaterCoil(CoilNum).Name, state.dataWaterCoils->WaterCoil(CoilNum).DesWaterCoolingCoilRate); + PreDefTableEntry(pdchCoolCoilTotCap, state.dataWaterCoils->WaterCoil(CoilNum).Name, state.dataWaterCoils->WaterCoil(CoilNum).TotWaterCoolingCoilRate); + PreDefTableEntry(pdchCoolCoilSensCap, state.dataWaterCoils->WaterCoil(CoilNum).Name, state.dataWaterCoils->WaterCoil(CoilNum).SenWaterCoolingCoilRate); + PreDefTableEntry(pdchCoolCoilLatCap, state.dataWaterCoils->WaterCoil(CoilNum).Name, RatedLatentCapacity); + PreDefTableEntry(pdchCoolCoilSHR, state.dataWaterCoils->WaterCoil(CoilNum).Name, RatedSHR); + PreDefTableEntry(pdchCoolCoilNomEff, state.dataWaterCoils->WaterCoil(CoilNum).Name, "-"); + PreDefTableEntry(pdchCoolCoilUATotal, state.dataWaterCoils->WaterCoil(CoilNum).Name, state.dataWaterCoils->WaterCoil(CoilNum).UACoilTotal); + PreDefTableEntry(pdchCoolCoilArea, state.dataWaterCoils->WaterCoil(CoilNum).Name, state.dataWaterCoils->WaterCoil(CoilNum).TotCoilOutsideSurfArea); addFootNoteSubTable( pdstCoolCoil, "Nominal values are gross at rated conditions, i.e., the supply air fan heat and electric power NOT accounted for."); print(state.files.eio, "{},{},{:.2R},{:.2R},{:.2R},{:.2R},{:.2R},{:.2R}\n", "Water Cooling Coil Capacity Information,Coil:Cooling:Water", - WaterCoil(CoilNum).Name, - WaterCoil(CoilNum).TotWaterCoolingCoilRate, - WaterCoil(CoilNum).SenWaterCoolingCoilRate, + state.dataWaterCoils->WaterCoil(CoilNum).Name, + state.dataWaterCoils->WaterCoil(CoilNum).TotWaterCoolingCoilRate, + state.dataWaterCoils->WaterCoil(CoilNum).SenWaterCoolingCoilRate, RatedLatentCapacity, RatedSHR, UATotal, SurfaceArea); - coilSelectionReportObj->setCoilAirFlow(WaterCoil(CoilNum).Name, + coilSelectionReportObj->setCoilAirFlow(state.dataWaterCoils->WaterCoil(CoilNum).Name, "Coil:Cooling:Water", - WaterCoil(CoilNum).DesAirVolFlowRate, - WaterCoil(CoilNum).RequestingAutoSize); // Coil Report - coilSelectionReportObj->setCoilWaterCoolingCapacity(WaterCoil(CoilNum).Name, + state.dataWaterCoils->WaterCoil(CoilNum).DesAirVolFlowRate, + state.dataWaterCoils->WaterCoil(CoilNum).RequestingAutoSize); // Coil Report + coilSelectionReportObj->setCoilWaterCoolingCapacity(state.dataWaterCoils->WaterCoil(CoilNum).Name, "Coil:Cooling:Water", - WaterCoil(CoilNum).DesWaterCoolingCoilRate, - WaterCoil(CoilNum).RequestingAutoSize, - WaterCoil(CoilNum).WaterInletNodeNum, - WaterCoil(CoilNum).WaterOutletNodeNum, - WaterCoil(CoilNum).WaterLoopNum); // Coil Report + state.dataWaterCoils->WaterCoil(CoilNum).DesWaterCoolingCoilRate, + state.dataWaterCoils->WaterCoil(CoilNum).RequestingAutoSize, + state.dataWaterCoils->WaterCoil(CoilNum).WaterInletNodeNum, + state.dataWaterCoils->WaterCoil(CoilNum).WaterOutletNodeNum, + state.dataWaterCoils->WaterCoil(CoilNum).WaterLoopNum); // Coil Report } } - if (WaterCoil(CoilNum).DesWaterCoolingCoilRate <= 0.0) - WaterCoil(CoilNum).DesWaterCoolingCoilRate = WaterCoil(CoilNum).TotWaterCoolingCoilRate; - if (WaterCoil(CoilNum).DesWaterHeatingCoilRate <= 0.0) - WaterCoil(CoilNum).DesWaterHeatingCoilRate = WaterCoil(CoilNum).TotWaterHeatingCoilRate; + if (state.dataWaterCoils->WaterCoil(CoilNum).DesWaterCoolingCoilRate <= 0.0) + state.dataWaterCoils->WaterCoil(CoilNum).DesWaterCoolingCoilRate = state.dataWaterCoils->WaterCoil(CoilNum).TotWaterCoolingCoilRate; + if (state.dataWaterCoils->WaterCoil(CoilNum).DesWaterHeatingCoilRate <= 0.0) + state.dataWaterCoils->WaterCoil(CoilNum).DesWaterHeatingCoilRate = state.dataWaterCoils->WaterCoil(CoilNum).TotWaterHeatingCoilRate; // call coil model with everthing set at rating point - WaterCoil(CoilNum).InletAirMassFlowRate = WaterCoil(CoilNum).DesAirMassFlowRate; - WaterCoil(CoilNum).InletAirTemp = WaterCoil(CoilNum).DesInletAirTemp; - WaterCoil(CoilNum).InletAirHumRat = WaterCoil(CoilNum).DesInletAirHumRat; // fixed in sizing routine - WaterCoil(CoilNum).InletAirEnthalpy = - Psychrometrics::PsyHFnTdbW(WaterCoil(CoilNum).DesInletAirTemp, WaterCoil(CoilNum).DesInletAirHumRat); + state.dataWaterCoils->WaterCoil(CoilNum).InletAirMassFlowRate = state.dataWaterCoils->WaterCoil(CoilNum).DesAirMassFlowRate; + state.dataWaterCoils->WaterCoil(CoilNum).InletAirTemp = state.dataWaterCoils->WaterCoil(CoilNum).DesInletAirTemp; + state.dataWaterCoils->WaterCoil(CoilNum).InletAirHumRat = state.dataWaterCoils->WaterCoil(CoilNum).DesInletAirHumRat; // fixed in sizing routine + state.dataWaterCoils->WaterCoil(CoilNum).InletAirEnthalpy = + Psychrometrics::PsyHFnTdbW(state.dataWaterCoils->WaterCoil(CoilNum).DesInletAirTemp, state.dataWaterCoils->WaterCoil(CoilNum).DesInletAirHumRat); Real64 DesInletWetBulb = Psychrometrics::PsyTwbFnTdbWPb( - WaterCoil(CoilNum).DesInletAirTemp, WaterCoil(CoilNum).DesInletAirHumRat, DataEnvironment::StdPressureSeaLevel, "InitWaterCoils"); - WaterCoil(CoilNum).InletWaterMassFlowRate = WaterCoil(CoilNum).MaxWaterMassFlowRate; - WaterCoil(CoilNum).InletWaterTemp = WaterCoil(CoilNum).DesInletWaterTemp; - Real64 cp = GetSpecificHeatGlycol(PlantLoop(WaterCoil(CoilNum).WaterLoopNum).FluidName, - WaterCoil(CoilNum).DesInletWaterTemp, - PlantLoop(WaterCoil(CoilNum).WaterLoopNum).FluidIndex, + state.dataWaterCoils->WaterCoil(CoilNum).DesInletAirTemp, state.dataWaterCoils->WaterCoil(CoilNum).DesInletAirHumRat, DataEnvironment::StdPressureSeaLevel, "InitWaterCoils"); + state.dataWaterCoils->WaterCoil(CoilNum).InletWaterMassFlowRate = state.dataWaterCoils->WaterCoil(CoilNum).MaxWaterMassFlowRate; + state.dataWaterCoils->WaterCoil(CoilNum).InletWaterTemp = state.dataWaterCoils->WaterCoil(CoilNum).DesInletWaterTemp; + Real64 cp = GetSpecificHeatGlycol(PlantLoop(state.dataWaterCoils->WaterCoil(CoilNum).WaterLoopNum).FluidName, + state.dataWaterCoils->WaterCoil(CoilNum).DesInletWaterTemp, + PlantLoop(state.dataWaterCoils->WaterCoil(CoilNum).WaterLoopNum).FluidIndex, "InitWaterCoil"); - WaterCoil(CoilNum).InletWaterEnthalpy = cp * WaterCoil(CoilNum).InletWaterTemp; + state.dataWaterCoils->WaterCoil(CoilNum).InletWaterEnthalpy = cp * state.dataWaterCoils->WaterCoil(CoilNum).InletWaterTemp; - WaterCoil(CoilNum).UACoilVariable = WaterCoil(CoilNum).UACoil; - WaterCoil(CoilNum).FaultyCoilFoulingFactor = 0.0; + state.dataWaterCoils->WaterCoil(CoilNum).UACoilVariable = state.dataWaterCoils->WaterCoil(CoilNum).UACoil; + state.dataWaterCoils->WaterCoil(CoilNum).FaultyCoilFoulingFactor = 0.0; Real64 holdOutBaroPress = DataEnvironment::OutBaroPress; DataEnvironment::OutBaroPress = DataEnvironment::StdPressureSeaLevel; // assume rating is for sea level. - CalcAdjustedCoilUA(CoilNum); + CalcAdjustedCoilUA(state, CoilNum); std::string coilTypeName(" "); // calculate coil sim model at rating point, full load, continuous fan - if (WaterCoil(CoilNum).WaterCoilType_Num == WaterCoil_DetFlatFinCooling) { - CalcDetailFlatFinCoolingCoil(CoilNum, SimCalc, ContFanCycCoil, 1.0); + if (state.dataWaterCoils->WaterCoil(CoilNum).WaterCoilType_Num == state.dataWaterCoils->WaterCoil_DetFlatFinCooling) { + CalcDetailFlatFinCoolingCoil(state, CoilNum, state.dataWaterCoils->SimCalc, ContFanCycCoil, 1.0); coilTypeName = "Coil:Cooling:Water:DetailedGeometry"; - } else if (WaterCoil(CoilNum).WaterCoilType_Num == WaterCoil_Cooling) { - CoolingCoil(CoilNum, FirstHVACIteration, SimCalc, ContFanCycCoil, 1.0); + } else if (state.dataWaterCoils->WaterCoil(CoilNum).WaterCoilType_Num == state.dataWaterCoils->WaterCoil_Cooling) { + CoolingCoil(state, CoilNum, FirstHVACIteration, state.dataWaterCoils->SimCalc, ContFanCycCoil, 1.0); coilTypeName = "Coil:Cooling:Water"; - } else if (WaterCoil(CoilNum).WaterCoilType_Num == WaterCoil_SimpleHeating) { - CalcSimpleHeatingCoil(CoilNum, ContFanCycCoil, 1.0, SimCalc); + } else if (state.dataWaterCoils->WaterCoil(CoilNum).WaterCoilType_Num == state.dataWaterCoils->WaterCoil_SimpleHeating) { + CalcSimpleHeatingCoil(state, CoilNum, ContFanCycCoil, 1.0, state.dataWaterCoils->SimCalc); coilTypeName = "Coil:Heating:Water"; } // coil outlets Real64 RatedOutletWetBulb(0.0); RatedOutletWetBulb = Psychrometrics::PsyTwbFnTdbWPb( - WaterCoil(CoilNum).OutletAirTemp, WaterCoil(CoilNum).OutletAirHumRat, DataEnvironment::StdPressureSeaLevel, "InitWaterCoil"); + state.dataWaterCoils->WaterCoil(CoilNum).OutletAirTemp, state.dataWaterCoils->WaterCoil(CoilNum).OutletAirHumRat, DataEnvironment::StdPressureSeaLevel, "InitWaterCoil"); // call set routine in coil report - if (WaterCoil(CoilNum).WaterCoilType_Num == WaterCoil_DetFlatFinCooling || - WaterCoil(CoilNum).WaterCoilType_Num == WaterCoil_Cooling) { - coilSelectionReportObj->setRatedCoilConditions(WaterCoil(CoilNum).Name, + if (state.dataWaterCoils->WaterCoil(CoilNum).WaterCoilType_Num == state.dataWaterCoils->WaterCoil_DetFlatFinCooling || + state.dataWaterCoils->WaterCoil(CoilNum).WaterCoilType_Num == state.dataWaterCoils->WaterCoil_Cooling) { + coilSelectionReportObj->setRatedCoilConditions(state.dataWaterCoils->WaterCoil(CoilNum).Name, coilTypeName, - WaterCoil(CoilNum).TotWaterCoolingCoilRate, // this is the report variable - WaterCoil(CoilNum).SenWaterCoolingCoilRate, // this is the report variable - WaterCoil(CoilNum).InletAirMassFlowRate, - WaterCoil(CoilNum).InletAirTemp, - WaterCoil(CoilNum).InletAirHumRat, + state.dataWaterCoils->WaterCoil(CoilNum).TotWaterCoolingCoilRate, // this is the report variable + state.dataWaterCoils->WaterCoil(CoilNum).SenWaterCoolingCoilRate, // this is the report variable + state.dataWaterCoils->WaterCoil(CoilNum).InletAirMassFlowRate, + state.dataWaterCoils->WaterCoil(CoilNum).InletAirTemp, + state.dataWaterCoils->WaterCoil(CoilNum).InletAirHumRat, DesInletWetBulb, - WaterCoil(CoilNum).OutletAirTemp, - WaterCoil(CoilNum).OutletAirHumRat, + state.dataWaterCoils->WaterCoil(CoilNum).OutletAirTemp, + state.dataWaterCoils->WaterCoil(CoilNum).OutletAirHumRat, RatedOutletWetBulb, -999.0, -999.0, -999.0, -999.0); // coil effectiveness - } else if (WaterCoil(CoilNum).WaterCoilType_Num == WaterCoil_SimpleHeating) { - coilSelectionReportObj->setRatedCoilConditions(WaterCoil(CoilNum).Name, + } else if (state.dataWaterCoils->WaterCoil(CoilNum).WaterCoilType_Num == state.dataWaterCoils->WaterCoil_SimpleHeating) { + coilSelectionReportObj->setRatedCoilConditions(state.dataWaterCoils->WaterCoil(CoilNum).Name, coilTypeName, - WaterCoil(CoilNum).TotWaterHeatingCoilRate, // this is the report variable - WaterCoil(CoilNum).TotWaterHeatingCoilRate, // this is the report variable - WaterCoil(CoilNum).InletAirMassFlowRate, - WaterCoil(CoilNum).InletAirTemp, - WaterCoil(CoilNum).InletAirHumRat, + state.dataWaterCoils->WaterCoil(CoilNum).TotWaterHeatingCoilRate, // this is the report variable + state.dataWaterCoils->WaterCoil(CoilNum).TotWaterHeatingCoilRate, // this is the report variable + state.dataWaterCoils->WaterCoil(CoilNum).InletAirMassFlowRate, + state.dataWaterCoils->WaterCoil(CoilNum).InletAirTemp, + state.dataWaterCoils->WaterCoil(CoilNum).InletAirHumRat, DesInletWetBulb, - WaterCoil(CoilNum).OutletAirTemp, - WaterCoil(CoilNum).OutletAirHumRat, + state.dataWaterCoils->WaterCoil(CoilNum).OutletAirTemp, + state.dataWaterCoils->WaterCoil(CoilNum).OutletAirHumRat, RatedOutletWetBulb, -999.0, -999.0, @@ -1889,28 +1789,28 @@ namespace WaterCoils { // Do the following initializations (every time step): This should be the info from // the previous components outlets or the node data in this section. // First set the conditions for the air into the coil model - AirInletNode = WaterCoil(CoilNum).AirInletNodeNum; - WaterInletNode = WaterCoil(CoilNum).WaterInletNodeNum; - WaterCoil(CoilNum).InletAirMassFlowRate = Node(AirInletNode).MassFlowRate; - WaterCoil(CoilNum).InletAirTemp = Node(AirInletNode).Temp; - WaterCoil(CoilNum).InletAirHumRat = Node(AirInletNode).HumRat; - WaterCoil(CoilNum).InletAirEnthalpy = Node(AirInletNode).Enthalpy; + AirInletNode = state.dataWaterCoils->WaterCoil(CoilNum).AirInletNodeNum; + WaterInletNode = state.dataWaterCoils->WaterCoil(CoilNum).WaterInletNodeNum; + state.dataWaterCoils->WaterCoil(CoilNum).InletAirMassFlowRate = Node(AirInletNode).MassFlowRate; + state.dataWaterCoils->WaterCoil(CoilNum).InletAirTemp = Node(AirInletNode).Temp; + state.dataWaterCoils->WaterCoil(CoilNum).InletAirHumRat = Node(AirInletNode).HumRat; + state.dataWaterCoils->WaterCoil(CoilNum).InletAirEnthalpy = Node(AirInletNode).Enthalpy; - WaterCoil(CoilNum).InletWaterMassFlowRate = Node(WaterInletNode).MassFlowRate; - WaterCoil(CoilNum).InletWaterTemp = Node(WaterInletNode).Temp; - WaterCoil(CoilNum).InletWaterEnthalpy = Node(WaterInletNode).Enthalpy; + state.dataWaterCoils->WaterCoil(CoilNum).InletWaterMassFlowRate = Node(WaterInletNode).MassFlowRate; + state.dataWaterCoils->WaterCoil(CoilNum).InletWaterTemp = Node(WaterInletNode).Temp; + state.dataWaterCoils->WaterCoil(CoilNum).InletWaterEnthalpy = Node(WaterInletNode).Enthalpy; - WaterCoil(CoilNum).UACoilVariable = WaterCoil(CoilNum).UACoil; + state.dataWaterCoils->WaterCoil(CoilNum).UACoilVariable = state.dataWaterCoils->WaterCoil(CoilNum).UACoil; - CalcAdjustedCoilUA(CoilNum); + CalcAdjustedCoilUA(state, CoilNum); - WaterCoil(CoilNum).TotWaterHeatingCoilRate = 0.0; - WaterCoil(CoilNum).TotWaterCoolingCoilRate = 0.0; - WaterCoil(CoilNum).SenWaterCoolingCoilRate = 0.0; + state.dataWaterCoils->WaterCoil(CoilNum).TotWaterHeatingCoilRate = 0.0; + state.dataWaterCoils->WaterCoil(CoilNum).TotWaterCoolingCoilRate = 0.0; + state.dataWaterCoils->WaterCoil(CoilNum).SenWaterCoolingCoilRate = 0.0; } // refactor coilUA adjustment into separate routine, for use with rating calc - void CalcAdjustedCoilUA(int const CoilNum) + void CalcAdjustedCoilUA(EnergyPlusData &state, int const CoilNum) { // Pull these precalc routines out of big init routine // modify the coil UA based on model in Wetter 1999 @@ -1921,108 +1821,108 @@ namespace WaterCoils { Real64 WaterConvSensitivity; // "s" in Wetter 1999, temperature sensitivity in water side convection // Coil:Heating:Water - if ((WaterCoil(CoilNum).WaterCoilType_Num == WaterCoil_SimpleHeating) && - (!(MyUAAndFlowCalcFlag(CoilNum)))) { // update Coil UA based on inlet mass flows and temps - x_a = 1.0 + 4.769E-3 * (WaterCoil(CoilNum).InletAirTemp - WaterCoil(CoilNum).DesInletAirTemp); - if (WaterCoil(CoilNum).DesAirMassFlowRate > 0.0) { - AirConvectTerm = x_a * std::pow(WaterCoil(CoilNum).InletAirMassFlowRate / WaterCoil(CoilNum).DesAirMassFlowRate, 0.8) * - WaterCoil(CoilNum).AirSideNominalConvect; + if ((state.dataWaterCoils->WaterCoil(CoilNum).WaterCoilType_Num == state.dataWaterCoils->WaterCoil_SimpleHeating) && + (!(state.dataWaterCoils->MyUAAndFlowCalcFlag(CoilNum)))) { // update Coil UA based on inlet mass flows and temps + x_a = 1.0 + 4.769E-3 * (state.dataWaterCoils->WaterCoil(CoilNum).InletAirTemp - state.dataWaterCoils->WaterCoil(CoilNum).DesInletAirTemp); + if (state.dataWaterCoils->WaterCoil(CoilNum).DesAirMassFlowRate > 0.0) { + AirConvectTerm = x_a * std::pow(state.dataWaterCoils->WaterCoil(CoilNum).InletAirMassFlowRate / state.dataWaterCoils->WaterCoil(CoilNum).DesAirMassFlowRate, 0.8) * + state.dataWaterCoils->WaterCoil(CoilNum).AirSideNominalConvect; } else { AirConvectTerm = 0.0; } - WaterConvSensitivity = 0.014 / (1.0 + 0.014 * WaterCoil(CoilNum).DesInletWaterTemp); - x_w = 1.0 + WaterConvSensitivity * (WaterCoil(CoilNum).InletWaterTemp - WaterCoil(CoilNum).DesInletWaterTemp); - if (WaterCoil(CoilNum).MaxWaterMassFlowRate > 0.0) { - WaterConvectTerm = x_w * std::pow(WaterCoil(CoilNum).InletWaterMassFlowRate / WaterCoil(CoilNum).MaxWaterMassFlowRate, 0.85) * - WaterCoil(CoilNum).LiquidSideNominalConvect; + WaterConvSensitivity = 0.014 / (1.0 + 0.014 * state.dataWaterCoils->WaterCoil(CoilNum).DesInletWaterTemp); + x_w = 1.0 + WaterConvSensitivity * (state.dataWaterCoils->WaterCoil(CoilNum).InletWaterTemp - state.dataWaterCoils->WaterCoil(CoilNum).DesInletWaterTemp); + if (state.dataWaterCoils->WaterCoil(CoilNum).MaxWaterMassFlowRate > 0.0) { + WaterConvectTerm = x_w * std::pow(state.dataWaterCoils->WaterCoil(CoilNum).InletWaterMassFlowRate / state.dataWaterCoils->WaterCoil(CoilNum).MaxWaterMassFlowRate, 0.85) * + state.dataWaterCoils->WaterCoil(CoilNum).LiquidSideNominalConvect; } else { WaterConvectTerm = 0.0; } if ((AirConvectTerm > 0.0) && (WaterConvectTerm > 0.0)) { - WaterCoil(CoilNum).UACoilVariable = 1.0 / ((1.0 / WaterConvectTerm) + (1.0 / AirConvectTerm)); + state.dataWaterCoils->WaterCoil(CoilNum).UACoilVariable = 1.0 / ((1.0 / WaterConvectTerm) + (1.0 / AirConvectTerm)); } else { // use nominal UA since variable UA cannot be calculated - WaterCoil(CoilNum).UACoilVariable = WaterCoil(CoilNum).UACoil; + state.dataWaterCoils->WaterCoil(CoilNum).UACoilVariable = state.dataWaterCoils->WaterCoil(CoilNum).UACoil; } // calculate the Faulty Coil Fouling (thermal insulance) Factor using fault information - if (WaterCoil(CoilNum).FaultyCoilFoulingFlag && + if (state.dataWaterCoils->WaterCoil(CoilNum).FaultyCoilFoulingFlag && // The fault shouldn't apply during sizing. (!DataGlobals::WarmupFlag) && (!DataGlobals::DoingSizing) && (!DataGlobals::KickOffSimulation) && // This was preexisting - !(MyUAAndFlowCalcFlag(CoilNum))) + !(state.dataWaterCoils->MyUAAndFlowCalcFlag(CoilNum))) { // Store original value - WaterCoil(CoilNum).OriginalUACoilVariable = WaterCoil(CoilNum).UACoilVariable; + state.dataWaterCoils->WaterCoil(CoilNum).OriginalUACoilVariable = state.dataWaterCoils->WaterCoil(CoilNum).UACoilVariable; - int FaultIndex = WaterCoil(CoilNum).FaultyCoilFoulingIndex; + int FaultIndex = state.dataWaterCoils->WaterCoil(CoilNum).FaultyCoilFoulingIndex; FaultsManager::FaultPropertiesFoulingCoil &fouling = FaultsManager::FouledCoils(FaultIndex); Real64 FaultFrac = fouling.FaultFraction(); if (fouling.FoulingInputMethod == FaultsManager::iFouledCoil_UARated) { // 1/UA' = Frac * (1/UAFouled) + (1-Frac) / UA - WaterCoil(CoilNum).UACoilVariable = 1 / (FaultFrac / (fouling.UAFouled) + (1 - FaultFrac) / WaterCoil(CoilNum).UACoilVariable); + state.dataWaterCoils->WaterCoil(CoilNum).UACoilVariable = 1 / (FaultFrac / (fouling.UAFouled) + (1 - FaultFrac) / state.dataWaterCoils->WaterCoil(CoilNum).UACoilVariable); } else { // R' = R + Rfoul // Rfoul = r_air/A_air + r_water/A_water (FoulingFactor = thermal insulance [K/W, A] = Area [m2], r=fouling factor [m2.K/W] Real64 FoulingFactor = FaultFrac * (fouling.Rfw / (fouling.Aratio * fouling.Aout) + fouling.Rfa / fouling.Aout); - WaterCoil(CoilNum).UACoilVariable = 1.0 / ( (1.0 / WaterCoil(CoilNum).UACoilVariable) + FoulingFactor); + state.dataWaterCoils->WaterCoil(CoilNum).UACoilVariable = 1.0 / ( (1.0 / state.dataWaterCoils->WaterCoil(CoilNum).UACoilVariable) + FoulingFactor); } // Do not allow improving coil performance - WaterCoil(CoilNum).UACoilVariable = min(WaterCoil(CoilNum).UACoilVariable, WaterCoil(CoilNum).OriginalUACoilVariable); + state.dataWaterCoils->WaterCoil(CoilNum).UACoilVariable = min(state.dataWaterCoils->WaterCoil(CoilNum).UACoilVariable, state.dataWaterCoils->WaterCoil(CoilNum).OriginalUACoilVariable); // Only for reporting purposes - WaterCoil(CoilNum).FaultyCoilFoulingFactor = (1.0 / WaterCoil(CoilNum).UACoilVariable) - - (1.0 / WaterCoil(CoilNum).OriginalUACoilVariable); + state.dataWaterCoils->WaterCoil(CoilNum).FaultyCoilFoulingFactor = (1.0 / state.dataWaterCoils->WaterCoil(CoilNum).UACoilVariable) - + (1.0 / state.dataWaterCoils->WaterCoil(CoilNum).OriginalUACoilVariable); } else { - WaterCoil(CoilNum).FaultyCoilFoulingFactor = 0; + state.dataWaterCoils->WaterCoil(CoilNum).FaultyCoilFoulingFactor = 0; } } // Coil:Cooling:Water // update Coil UA based on inlet mass flows and temps - if (WaterCoil(CoilNum).WaterCoilType_Num == WaterCoil_Cooling && (!MyCoilDesignFlag(CoilNum))) { - if (WaterCoil(CoilNum).DesAirMassFlowRate > 0.0) { - x_a = 1.0 + 4.769E-3 * (WaterCoil(CoilNum).InletAirTemp - WaterCoil(CoilNum).DesInletAirTemp); - WaterCoil(CoilNum).UACoilExternal = x_a * - std::pow(WaterCoil(CoilNum).InletAirMassFlowRate / WaterCoil(CoilNum).DesAirMassFlowRate, 0.8) * - WaterCoil(CoilNum).UACoilExternalDes; + if (state.dataWaterCoils->WaterCoil(CoilNum).WaterCoilType_Num == state.dataWaterCoils->WaterCoil_Cooling && (!state.dataWaterCoils->MyCoilDesignFlag(CoilNum))) { + if (state.dataWaterCoils->WaterCoil(CoilNum).DesAirMassFlowRate > 0.0) { + x_a = 1.0 + 4.769E-3 * (state.dataWaterCoils->WaterCoil(CoilNum).InletAirTemp - state.dataWaterCoils->WaterCoil(CoilNum).DesInletAirTemp); + state.dataWaterCoils->WaterCoil(CoilNum).UACoilExternal = x_a * + std::pow(state.dataWaterCoils->WaterCoil(CoilNum).InletAirMassFlowRate / state.dataWaterCoils->WaterCoil(CoilNum).DesAirMassFlowRate, 0.8) * + state.dataWaterCoils->WaterCoil(CoilNum).UACoilExternalDes; } else { - WaterCoil(CoilNum).UACoilExternal = WaterCoil(CoilNum).UACoilExternalDes; + state.dataWaterCoils->WaterCoil(CoilNum).UACoilExternal = state.dataWaterCoils->WaterCoil(CoilNum).UACoilExternalDes; } - if (WaterCoil(CoilNum).MaxWaterMassFlowRate > 0.0) { - WaterConvSensitivity = 0.014 / (1.0 + 0.014 * WaterCoil(CoilNum).DesInletWaterTemp); - x_w = 1.0 + WaterConvSensitivity * (WaterCoil(CoilNum).InletWaterTemp - WaterCoil(CoilNum).DesInletWaterTemp); - WaterCoil(CoilNum).UACoilInternal = - x_w * std::pow(WaterCoil(CoilNum).InletWaterMassFlowRate / WaterCoil(CoilNum).MaxWaterMassFlowRate, 0.85) * - WaterCoil(CoilNum).UACoilInternalDes; + if (state.dataWaterCoils->WaterCoil(CoilNum).MaxWaterMassFlowRate > 0.0) { + WaterConvSensitivity = 0.014 / (1.0 + 0.014 * state.dataWaterCoils->WaterCoil(CoilNum).DesInletWaterTemp); + x_w = 1.0 + WaterConvSensitivity * (state.dataWaterCoils->WaterCoil(CoilNum).InletWaterTemp - state.dataWaterCoils->WaterCoil(CoilNum).DesInletWaterTemp); + state.dataWaterCoils->WaterCoil(CoilNum).UACoilInternal = + x_w * std::pow(state.dataWaterCoils->WaterCoil(CoilNum).InletWaterMassFlowRate / state.dataWaterCoils->WaterCoil(CoilNum).MaxWaterMassFlowRate, 0.85) * + state.dataWaterCoils->WaterCoil(CoilNum).UACoilInternalDes; } else { - WaterCoil(CoilNum).UACoilInternal = WaterCoil(CoilNum).UACoilInternalDes; + state.dataWaterCoils->WaterCoil(CoilNum).UACoilInternal = state.dataWaterCoils->WaterCoil(CoilNum).UACoilInternalDes; } - if (!(WaterCoil(CoilNum).UACoilInternal > 0.0 && WaterCoil(CoilNum).UACoilExternal > 0.0)) { - WaterCoil(CoilNum).UACoilInternal = WaterCoil(CoilNum).UACoilInternalDes; - WaterCoil(CoilNum).UACoilExternal = WaterCoil(CoilNum).UACoilExternalDes; + if (!(state.dataWaterCoils->WaterCoil(CoilNum).UACoilInternal > 0.0 && state.dataWaterCoils->WaterCoil(CoilNum).UACoilExternal > 0.0)) { + state.dataWaterCoils->WaterCoil(CoilNum).UACoilInternal = state.dataWaterCoils->WaterCoil(CoilNum).UACoilInternalDes; + state.dataWaterCoils->WaterCoil(CoilNum).UACoilExternal = state.dataWaterCoils->WaterCoil(CoilNum).UACoilExternalDes; } // If Fouling - if (WaterCoil(CoilNum).FaultyCoilFoulingFlag && + if (state.dataWaterCoils->WaterCoil(CoilNum).FaultyCoilFoulingFlag && // The fault shouldn't apply during sizing. (!DataGlobals::WarmupFlag) && (!DataGlobals::DoingSizing) && (!DataGlobals::KickOffSimulation) && // This was preexisting - !(MyUAAndFlowCalcFlag(CoilNum))) + !(state.dataWaterCoils->MyUAAndFlowCalcFlag(CoilNum))) { // Store original value // This is really UACoilTotal technically, but I don't see the point of declaring another Real on the struct just for that - WaterCoil(CoilNum).OriginalUACoilVariable = 1.0 / - (1.0 / WaterCoil(CoilNum).UACoilExternal + 1.0 / WaterCoil(CoilNum).UACoilInternal); + state.dataWaterCoils->WaterCoil(CoilNum).OriginalUACoilVariable = 1.0 / + (1.0 / state.dataWaterCoils->WaterCoil(CoilNum).UACoilExternal + 1.0 / state.dataWaterCoils->WaterCoil(CoilNum).UACoilInternal); - WaterCoil(CoilNum).OriginalUACoilExternal = WaterCoil(CoilNum).UACoilExternal; - WaterCoil(CoilNum).OriginalUACoilInternal = WaterCoil(CoilNum).UACoilInternal; + state.dataWaterCoils->WaterCoil(CoilNum).OriginalUACoilExternal = state.dataWaterCoils->WaterCoil(CoilNum).UACoilExternal; + state.dataWaterCoils->WaterCoil(CoilNum).OriginalUACoilInternal = state.dataWaterCoils->WaterCoil(CoilNum).UACoilInternal; - int FaultIndex = WaterCoil(CoilNum).FaultyCoilFoulingIndex; + int FaultIndex = state.dataWaterCoils->WaterCoil(CoilNum).FaultyCoilFoulingIndex; FaultsManager::FaultPropertiesFoulingCoil &fouling = FaultsManager::FouledCoils(FaultIndex); Real64 FaultFrac = fouling.FaultFraction(); @@ -2032,8 +1932,8 @@ namespace WaterCoils { Real64 Rfoul_air = FaultFrac * (fouling.Rfa / fouling.Aout); Real64 Rfoul_water = FaultFrac * (fouling.Rfw / (fouling.Aratio * fouling.Aout)); - WaterCoil(CoilNum).UACoilInternal = 1.0 / (1.0 / WaterCoil(CoilNum).UACoilInternal + Rfoul_water); - WaterCoil(CoilNum).UACoilExternal = 1.0 / (1.0 / WaterCoil(CoilNum).UACoilExternal + Rfoul_air); + state.dataWaterCoils->WaterCoil(CoilNum).UACoilInternal = 1.0 / (1.0 / state.dataWaterCoils->WaterCoil(CoilNum).UACoilInternal + Rfoul_water); + state.dataWaterCoils->WaterCoil(CoilNum).UACoilExternal = 1.0 / (1.0 / state.dataWaterCoils->WaterCoil(CoilNum).UACoilExternal + Rfoul_air); // } else { // iFouledCoil_UARated // FouledUARated is supposed to be the overall UA. So we need to split between Internal and External UAs @@ -2053,39 +1953,39 @@ namespace WaterCoils { // UACoilExternal = FaultFrac * [UAFouled * (1+splitRatio) / splitRatio] + (1-FaultFrac) * UACoilExternal // UACoilInternal = FaultFrac * [UAFouled * splitRatio] + (1-FaultFrac) * UACoilInternal - Real64 splitRatio = WaterCoil(CoilNum).UACoilInternal / WaterCoil(CoilNum).UACoilExternal; + Real64 splitRatio = state.dataWaterCoils->WaterCoil(CoilNum).UACoilInternal / state.dataWaterCoils->WaterCoil(CoilNum).UACoilExternal; - WaterCoil(CoilNum).UACoilExternal = 1.0 / + state.dataWaterCoils->WaterCoil(CoilNum).UACoilExternal = 1.0 / ( (FaultFrac * splitRatio) / ((1 + splitRatio) * fouling.UAFouled) + - (1-FaultFrac) / WaterCoil(CoilNum).UACoilExternal); + (1-FaultFrac) / state.dataWaterCoils->WaterCoil(CoilNum).UACoilExternal); //WaterCoil(CoilNum).UACoilInternal = 1.0 / //( FaultFrac / ((1 + splitRatio) * fouling.UAFouled) + //(1-FaultFrac) / WaterCoil(CoilNum).UACoilInternal); - WaterCoil(CoilNum).UACoilInternal = splitRatio * WaterCoil(CoilNum).UACoilExternal; + state.dataWaterCoils->WaterCoil(CoilNum).UACoilInternal = splitRatio * state.dataWaterCoils->WaterCoil(CoilNum).UACoilExternal; } // Do not allow improving coil performance - WaterCoil(CoilNum).UACoilExternal = min(WaterCoil(CoilNum).UACoilExternal, WaterCoil(CoilNum).OriginalUACoilExternal); - WaterCoil(CoilNum).UACoilInternal = min(WaterCoil(CoilNum).UACoilInternal, WaterCoil(CoilNum).OriginalUACoilInternal); + state.dataWaterCoils->WaterCoil(CoilNum).UACoilExternal = min(state.dataWaterCoils->WaterCoil(CoilNum).UACoilExternal, state.dataWaterCoils->WaterCoil(CoilNum).OriginalUACoilExternal); + state.dataWaterCoils->WaterCoil(CoilNum).UACoilInternal = min(state.dataWaterCoils->WaterCoil(CoilNum).UACoilInternal, state.dataWaterCoils->WaterCoil(CoilNum).OriginalUACoilInternal); // Only for reporting purposes - WaterCoil(CoilNum).FaultyCoilFoulingFactor = (1.0 / WaterCoil(CoilNum).UACoilExternal) - - (1.0 / WaterCoil(CoilNum).OriginalUACoilExternal) + - (1.0 / WaterCoil(CoilNum).UACoilInternal) - - (1.0 / WaterCoil(CoilNum).OriginalUACoilInternal); + state.dataWaterCoils->WaterCoil(CoilNum).FaultyCoilFoulingFactor = (1.0 / state.dataWaterCoils->WaterCoil(CoilNum).UACoilExternal) - + (1.0 / state.dataWaterCoils->WaterCoil(CoilNum).OriginalUACoilExternal) + + (1.0 / state.dataWaterCoils->WaterCoil(CoilNum).UACoilInternal) - + (1.0 / state.dataWaterCoils->WaterCoil(CoilNum).OriginalUACoilInternal); } else { - WaterCoil(CoilNum).FaultyCoilFoulingFactor = 0; + state.dataWaterCoils->WaterCoil(CoilNum).FaultyCoilFoulingFactor = 0; } - WaterCoil(CoilNum).UACoilTotal = 1.0 / - (1.0 / WaterCoil(CoilNum).UACoilExternal + 1.0 / WaterCoil(CoilNum).UACoilInternal); + state.dataWaterCoils->WaterCoil(CoilNum).UACoilTotal = 1.0 / + (1.0 / state.dataWaterCoils->WaterCoil(CoilNum).UACoilExternal + 1.0 / state.dataWaterCoils->WaterCoil(CoilNum).UACoilInternal); - WaterCoil(CoilNum).UACoilInternalPerUnitArea = WaterCoil(CoilNum).UACoilInternal / WaterCoil(CoilNum).TotCoilOutsideSurfArea; - WaterCoil(CoilNum).UAWetExtPerUnitArea = WaterCoil(CoilNum).UACoilExternal / WaterCoil(CoilNum).TotCoilOutsideSurfArea; - WaterCoil(CoilNum).UADryExtPerUnitArea = WaterCoil(CoilNum).UAWetExtPerUnitArea; + state.dataWaterCoils->WaterCoil(CoilNum).UACoilInternalPerUnitArea = state.dataWaterCoils->WaterCoil(CoilNum).UACoilInternal / state.dataWaterCoils->WaterCoil(CoilNum).TotCoilOutsideSurfArea; + state.dataWaterCoils->WaterCoil(CoilNum).UAWetExtPerUnitArea = state.dataWaterCoils->WaterCoil(CoilNum).UACoilExternal / state.dataWaterCoils->WaterCoil(CoilNum).TotCoilOutsideSurfArea; + state.dataWaterCoils->WaterCoil(CoilNum).UADryExtPerUnitArea = state.dataWaterCoils->WaterCoil(CoilNum).UAWetExtPerUnitArea; } } @@ -2113,7 +2013,6 @@ namespace WaterCoils { using namespace DataSizing; using DataEnvironment::StdBaroPress; using General::RoundSigDigits; - using General::SolveRoot; using General::TrimSigDigits; using PlantUtilities::RegisterPlantCompDesignFlow; using ReportSizingManager::GetCoilDesFlowT; @@ -2165,19 +2064,19 @@ namespace WaterCoils { CpAirStd = PsyCpAirFnW(0.0); // cooling coils - if (WaterCoil(CoilNum).WaterCoilType == CoilType_Cooling && WaterCoil(CoilNum).RequestingAutoSize) { + if (state.dataWaterCoils->WaterCoil(CoilNum).WaterCoilType == state.dataWaterCoils->CoilType_Cooling && state.dataWaterCoils->WaterCoil(CoilNum).RequestingAutoSize) { // find the appropriate Plant Sizing object PltSizCoolNum = PlantUtilities::MyPlantSizingIndex("chilled water coil", - WaterCoil(CoilNum).Name, - WaterCoil(CoilNum).WaterInletNodeNum, - WaterCoil(CoilNum).WaterOutletNodeNum, + state.dataWaterCoils->WaterCoil(CoilNum).Name, + state.dataWaterCoils->WaterCoil(CoilNum).WaterInletNodeNum, + state.dataWaterCoils->WaterCoil(CoilNum).WaterOutletNodeNum, LoopErrorsFound); } - if (WaterCoil(CoilNum).WaterCoilType == CoilType_Cooling) { // 'Cooling' + if (state.dataWaterCoils->WaterCoil(CoilNum).WaterCoilType == state.dataWaterCoils->CoilType_Cooling) { // 'Cooling' - if (WaterCoil(CoilNum).UseDesignWaterDeltaTemp) { - DataWaterCoilSizCoolDeltaT = WaterCoil(CoilNum).DesignWaterDeltaTemp; + if (state.dataWaterCoils->WaterCoil(CoilNum).UseDesignWaterDeltaTemp) { + DataWaterCoilSizCoolDeltaT = state.dataWaterCoils->WaterCoil(CoilNum).DesignWaterDeltaTemp; } else { if (PltSizCoolNum > 0) { DataWaterCoilSizCoolDeltaT = PlantSizData(PltSizCoolNum).DeltaT; @@ -2187,9 +2086,9 @@ namespace WaterCoils { if (PltSizCoolNum > 0) { DataPltSizCoolNum = PltSizCoolNum; - DataWaterLoopNum = WaterCoil(CoilNum).WaterLoopNum; + DataWaterLoopNum = state.dataWaterCoils->WaterCoil(CoilNum).WaterLoopNum; - if (WaterCoil(CoilNum).WaterCoilModel == CoilModel_Detailed) { // 'DETAILED FLAT FIN' + if (state.dataWaterCoils->WaterCoil(CoilNum).WaterCoilModel == state.dataWaterCoils->CoilModel_Detailed) { // 'DETAILED FLAT FIN' CompType = cAllCoilTypes(Coil_CoolingWaterDetailed); // Coil:Cooling:Water:DetailedGeometry } else { CompType = cAllCoilTypes(Coil_CoolingWater); // Coil:Cooling:Water @@ -2198,9 +2097,9 @@ namespace WaterCoils { // should print this!) TempSize = AutoSize; // get the autosized air volume flow rate for use in other calculations SizingString.clear(); // doesn't matter - CompName = WaterCoil(CoilNum).Name; + CompName = state.dataWaterCoils->WaterCoil(CoilNum).Name; RequestSizing(state, CompType, CompName, CoolingAirflowSizing, SizingString, TempSize, bPRINT, RoutineName); - WaterCoil(CoilNum).InletAirMassFlowRate = StdRhoAir * TempSize; // inlet air mass flow rate is the autosized value + state.dataWaterCoils->WaterCoil(CoilNum).InletAirMassFlowRate = StdRhoAir * TempSize; // inlet air mass flow rate is the autosized value DataAirFlowUsedForSizing = TempSize; // many autosized inputs use the design (autosized) air volume flow rate, save this value DataFlowUsedForSizing = TempSize; @@ -2215,22 +2114,22 @@ namespace WaterCoils { // 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(CoilNum).WaterCoilModel == CoilModel_Detailed) { // 'DETAILED FLAT FIN' + if (state.dataWaterCoils->WaterCoil(CoilNum).WaterCoilModel == state.dataWaterCoils->CoilModel_Detailed) { // 'DETAILED FLAT FIN' TempSize = AutoSize; // coil report } else { - TempSize = WaterCoil(CoilNum).DesInletAirHumRat; // preserve input if entered + TempSize = state.dataWaterCoils->WaterCoil(CoilNum).DesInletAirHumRat; // preserve input if entered } RequestSizing(state, CompType, CompName, CoolingWaterDesAirInletHumRatSizing, SizingString, TempSize, bPRINT, RoutineName); DataDesInletAirHumRat = TempSize; TempSize = AutoSize; RequestSizing(state, CompType, CompName, CoolingCapacitySizing, SizingString, TempSize, bPRINT, RoutineName); DataCapacityUsedForSizing = TempSize; - TempSize = WaterCoil(CoilNum).MaxWaterVolFlowRate; + TempSize = state.dataWaterCoils->WaterCoil(CoilNum).MaxWaterVolFlowRate; RequestSizing(state, CompType, CompName, CoolingWaterflowSizing, SizingString, TempSize, bPRINT, RoutineName); DataWaterFlowUsedForSizing = TempSize; // end pre-sizing data calculations - if (WaterCoil(CoilNum).WaterCoilModel == CoilModel_Detailed) { // 'DETAILED FLAT FIN' + if (state.dataWaterCoils->WaterCoil(CoilNum).WaterCoilModel == state.dataWaterCoils->CoilModel_Detailed) { // '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 = AutoSize; // not an input for this model @@ -2238,212 +2137,212 @@ namespace WaterCoils { } else { FieldNum = 4; // N4 , \field Design Inlet Air Temperature bPRINT = true; - TempSize = WaterCoil(CoilNum).DesInletAirTemp; // preserve input if entered - SizingString = WaterCoilNumericFields(CoilNum).FieldNames(FieldNum) + " [C]"; + TempSize = state.dataWaterCoils->WaterCoil(CoilNum).DesInletAirTemp; // preserve input if entered + SizingString = state.dataWaterCoils->WaterCoilNumericFields(CoilNum).FieldNames(FieldNum) + " [C]"; } RequestSizing(state, CompType, CompName, CoolingWaterDesAirInletTempSizing, SizingString, TempSize, bPRINT, RoutineName); - WaterCoil(CoilNum).DesInletAirTemp = TempSize; + state.dataWaterCoils->WaterCoil(CoilNum).DesInletAirTemp = TempSize; DataDesInletAirTemp = TempSize; - if (WaterCoil(CoilNum).WaterCoilModel == CoilModel_Detailed) { // 'DETAILED FLAT FIN' + if (state.dataWaterCoils->WaterCoil(CoilNum).WaterCoilModel == state.dataWaterCoils->CoilModel_Detailed) { // 'DETAILED FLAT FIN' bPRINT = false; // no field for detailed water coil, should print to eio anyway TempSize = AutoSize; // coil report SizingString.clear(); // doesn't matter } else { FieldNum = 3; // N3 , \field Design Inlet Water Temperature bPRINT = true; - TempSize = WaterCoil(CoilNum).DesInletWaterTemp; // preserve input if entered - SizingString = WaterCoilNumericFields(CoilNum).FieldNames(FieldNum) + " [C]"; + TempSize = state.dataWaterCoils->WaterCoil(CoilNum).DesInletWaterTemp; // preserve input if entered + SizingString = state.dataWaterCoils->WaterCoilNumericFields(CoilNum).FieldNames(FieldNum) + " [C]"; } RequestSizing(state, CompType, CompName, CoolingWaterDesWaterInletTempSizing, SizingString, TempSize, bPRINT, RoutineName); - WaterCoil(CoilNum).DesInletWaterTemp = TempSize; + state.dataWaterCoils->WaterCoil(CoilNum).DesInletWaterTemp = TempSize; if (CurZoneEqNum > 0) { // zone equipment use air inlet humrat to calculate design outlet air temperature - if (WaterCoil(CoilNum).WaterCoilModel == CoilModel_Detailed) { // 'DETAILED FLAT FIN' + if (state.dataWaterCoils->WaterCoil(CoilNum).WaterCoilModel == state.dataWaterCoils->CoilModel_Detailed) { // 'DETAILED FLAT FIN' bPRINT = false; // no field for detailed water coil, should print to eio anyway TempSize = AutoSize; // coil report SizingString.clear(); // doesn't matter } else { FieldNum = 6; // N6 , \field Design Inlet Air Humidity Ratio bPRINT = true; - TempSize = WaterCoil(CoilNum).DesInletAirHumRat; // preserve input if entered - SizingString = WaterCoilNumericFields(CoilNum).FieldNames(FieldNum) + " [kgWater/kgDryAir]"; + TempSize = state.dataWaterCoils->WaterCoil(CoilNum).DesInletAirHumRat; // preserve input if entered + SizingString = state.dataWaterCoils->WaterCoilNumericFields(CoilNum).FieldNames(FieldNum) + " [kgWater/kgDryAir]"; } RequestSizing(state, CompType, CompName, CoolingWaterDesAirInletHumRatSizing, SizingString, TempSize, bPRINT, RoutineName); - WaterCoil(CoilNum).DesInletAirHumRat = TempSize; + state.dataWaterCoils->WaterCoil(CoilNum).DesInletAirHumRat = TempSize; } - if (WaterCoil(CoilNum).WaterCoilModel == CoilModel_Detailed) { // 'DETAILED FLAT FIN' + if (state.dataWaterCoils->WaterCoil(CoilNum).WaterCoilModel == state.dataWaterCoils->CoilModel_Detailed) { // 'DETAILED FLAT FIN' bPRINT = false; // no field for detailed water coil, should print to eio anyway TempSize = AutoSize; // coil report SizingString.clear(); // doesn't matter } else { FieldNum = 5; // N5 , \field Design Outlet Air Temperature bPRINT = true; - TempSize = WaterCoil(CoilNum).DesOutletAirTemp; // preserve input if entered - SizingString = WaterCoilNumericFields(CoilNum).FieldNames(FieldNum) + " [C]"; + TempSize = state.dataWaterCoils->WaterCoil(CoilNum).DesOutletAirTemp; // preserve input if entered + SizingString = state.dataWaterCoils->WaterCoilNumericFields(CoilNum).FieldNames(FieldNum) + " [C]"; } - DataDesInletWaterTemp = WaterCoil(CoilNum).DesInletWaterTemp; // used for warning messages + DataDesInletWaterTemp = state.dataWaterCoils->WaterCoil(CoilNum).DesInletWaterTemp; // used for warning messages RequestSizing(state, CompType, CompName, CoolingWaterDesAirOutletTempSizing, SizingString, TempSize, bPRINT, RoutineName); - WaterCoil(CoilNum).DesOutletAirTemp = TempSize; + state.dataWaterCoils->WaterCoil(CoilNum).DesOutletAirTemp = TempSize; DataDesOutletAirTemp = TempSize; if (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(CoilNum).WaterCoilModel == CoilModel_Detailed) { // 'DETAILED FLAT FIN' + if (state.dataWaterCoils->WaterCoil(CoilNum).WaterCoilModel == state.dataWaterCoils->CoilModel_Detailed) { // 'DETAILED FLAT FIN' bPRINT = false; // no field for detailed water coil, should print this to eio anyway TempSize = AutoSize; // coil report SizingString.clear(); // doesn't matter } else { FieldNum = 6; // N6 , \field Design Inlet Air Humidity Ratio bPRINT = true; - TempSize = WaterCoil(CoilNum).DesInletAirHumRat; - SizingString = WaterCoilNumericFields(CoilNum).FieldNames(FieldNum) + " [kgWater/kgDryAir]"; + TempSize = state.dataWaterCoils->WaterCoil(CoilNum).DesInletAirHumRat; + SizingString = state.dataWaterCoils->WaterCoilNumericFields(CoilNum).FieldNames(FieldNum) + " [kgWater/kgDryAir]"; } RequestSizing(state, CompType, CompName, CoolingWaterDesAirInletHumRatSizing, SizingString, TempSize, bPRINT, RoutineName); - WaterCoil(CoilNum).DesInletAirHumRat = TempSize; + state.dataWaterCoils->WaterCoil(CoilNum).DesInletAirHumRat = TempSize; } - if (WaterCoil(CoilNum).WaterCoilModel == CoilModel_Detailed) { // 'DETAILED FLAT FIN' + if (state.dataWaterCoils->WaterCoil(CoilNum).WaterCoilModel == state.dataWaterCoils->CoilModel_Detailed) { // 'DETAILED FLAT FIN' bPRINT = false; // no field for detailed water coil, should print this to eio anyway TempSize = AutoSize; // coil report SizingString.clear(); // doesn't matter } else { FieldNum = 7; // N7 , \field Design Outlet Air Humidity Ratio bPRINT = true; - TempSize = WaterCoil(CoilNum).DesOutletAirHumRat; // preserve input if entered - SizingString = WaterCoilNumericFields(CoilNum).FieldNames(FieldNum) + " [kgWater/kgDryAir]"; + TempSize = state.dataWaterCoils->WaterCoil(CoilNum).DesOutletAirHumRat; // preserve input if entered + SizingString = state.dataWaterCoils->WaterCoilNumericFields(CoilNum).FieldNames(FieldNum) + " [kgWater/kgDryAir]"; } RequestSizing(state, CompType, CompName, CoolingWaterDesAirOutletHumRatSizing, SizingString, TempSize, bPRINT, RoutineName); - WaterCoil(CoilNum).DesOutletAirHumRat = TempSize; + state.dataWaterCoils->WaterCoil(CoilNum).DesOutletAirHumRat = TempSize; DataDesOutletAirHumRat = TempSize; TempSize = AutoSize; bPRINT = true; - if (WaterCoil(CoilNum).MaxWaterVolFlowRate != AutoSize) bPRINT = false; + if (state.dataWaterCoils->WaterCoil(CoilNum).MaxWaterVolFlowRate != AutoSize) bPRINT = false; if (CurSysNum == 0) bPRINT = false; SizingString = "Design Coil Load [W]"; // there is no input field for this value and this is not the rated capacity (we should // always print this!) // air inlet/outlet conditions should be known. Don't include fan heat in capacity calculation. DataDesAccountForFanHeat = false; RequestSizing(state, CompType, CompName, CoolingCapacitySizing, SizingString, TempSize, bPRINT, RoutineName); - WaterCoil(CoilNum).DesWaterCoolingCoilRate = TempSize; - WaterCoil(CoilNum).InletAirMassFlowRate = StdRhoAir * DataFlowUsedForSizing; // inlet air mass flow rate is the autosized value - DataCapacityUsedForSizing = WaterCoil(CoilNum).DesWaterCoolingCoilRate; + state.dataWaterCoils->WaterCoil(CoilNum).DesWaterCoolingCoilRate = TempSize; + state.dataWaterCoils->WaterCoil(CoilNum).InletAirMassFlowRate = StdRhoAir * DataFlowUsedForSizing; // inlet air mass flow rate is the autosized value + DataCapacityUsedForSizing = state.dataWaterCoils->WaterCoil(CoilNum).DesWaterCoolingCoilRate; // Why isn't the water volume flow rate based on the user inputs for inlet/outlet air/water temps? Water volume flow rate is // always based on autosized inputs. bPRINT = true; FieldNum = 1; // CoilModel_Detailed: N1 , \field Maximum Water Flow Rate, else: N1 , \field Design Water Flow Rate - SizingString = WaterCoilNumericFields(CoilNum).FieldNames(FieldNum) + " [m3/s]"; - TempSize = WaterCoil(CoilNum).MaxWaterVolFlowRate; + SizingString = state.dataWaterCoils->WaterCoilNumericFields(CoilNum).FieldNames(FieldNum) + " [m3/s]"; + TempSize = state.dataWaterCoils->WaterCoil(CoilNum).MaxWaterVolFlowRate; RequestSizing(state, CompType, CompName, CoolingWaterflowSizing, SizingString, TempSize, bPRINT, RoutineName); - WaterCoil(CoilNum).MaxWaterVolFlowRate = TempSize; + state.dataWaterCoils->WaterCoil(CoilNum).MaxWaterVolFlowRate = TempSize; DataWaterFlowUsedForSizing = TempSize; - if (WaterCoil(CoilNum).WaterCoilModel == CoilModel_Detailed) { // 'DETAILED FLAT FIN' + if (state.dataWaterCoils->WaterCoil(CoilNum).WaterCoilModel == state.dataWaterCoils->CoilModel_Detailed) { // '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!) SizingString.clear(); // doesn't matter } else { FieldNum = 2; // N2 , \field Design Air Flow Rate bPRINT = true; - SizingString = WaterCoilNumericFields(CoilNum).FieldNames(FieldNum) + " [m3/s]"; + SizingString = state.dataWaterCoils->WaterCoilNumericFields(CoilNum).FieldNames(FieldNum) + " [m3/s]"; } - TempSize = WaterCoil(CoilNum).DesAirVolFlowRate; + TempSize = state.dataWaterCoils->WaterCoil(CoilNum).DesAirVolFlowRate; RequestSizing(state, CompType, CompName, CoolingAirflowSizing, SizingString, TempSize, bPRINT, RoutineName); - WaterCoil(CoilNum).DesAirVolFlowRate = TempSize; - WaterCoil(CoilNum).DesAirMassFlowRate = WaterCoil(CoilNum).DesAirVolFlowRate * StdRhoAir; + state.dataWaterCoils->WaterCoil(CoilNum).DesAirVolFlowRate = TempSize; + state.dataWaterCoils->WaterCoil(CoilNum).DesAirMassFlowRate = state.dataWaterCoils->WaterCoil(CoilNum).DesAirVolFlowRate * StdRhoAir; - if (WaterCoil(CoilNum).DesAirVolFlowRate <= 0.0) { - WaterCoil(CoilNum).DesAirVolFlowRate = 0.0; - ShowWarningError("The design air flow rate is zero for Coil:Cooling:Water " + WaterCoil(CoilNum).Name); + if (state.dataWaterCoils->WaterCoil(CoilNum).DesAirVolFlowRate <= 0.0) { + state.dataWaterCoils->WaterCoil(CoilNum).DesAirVolFlowRate = 0.0; + ShowWarningError("The design air flow rate is zero for Coil:Cooling:Water " + state.dataWaterCoils->WaterCoil(CoilNum).Name); ShowContinueError("The autosize value for max air volume flow rate is zero"); } - if (WaterCoil(CoilNum).WaterCoilModel == CoilModel_Detailed) { + if (state.dataWaterCoils->WaterCoil(CoilNum).WaterCoilModel == state.dataWaterCoils->CoilModel_Detailed) { FieldNum = 16; // N16, \field Number of Tubes per Row bPRINT = true; - SizingString = WaterCoilNumericFields(CoilNum).FieldNames(FieldNum); + SizingString = state.dataWaterCoils->WaterCoilNumericFields(CoilNum).FieldNames(FieldNum); // Auto size detailed cooling coil number of tubes per row = int( 13750.0 * WaterCoil( CoilNum ).MaxWaterVolFlowRate ) + 1 - DataFlowUsedForSizing = WaterCoil(CoilNum).MaxWaterVolFlowRate; - TempSize = float(WaterCoil(CoilNum).NumOfTubesPerRow); + DataFlowUsedForSizing = state.dataWaterCoils->WaterCoil(CoilNum).MaxWaterVolFlowRate; + TempSize = float(state.dataWaterCoils->WaterCoil(CoilNum).NumOfTubesPerRow); RequestSizing(state, CompType, CompName, CoolingWaterNumofTubesPerRowSizing, SizingString, TempSize, bPRINT, RoutineName); - WaterCoil(CoilNum).NumOfTubesPerRow = int(TempSize); + state.dataWaterCoils->WaterCoil(CoilNum).NumOfTubesPerRow = int(TempSize); FieldNum = 7; // N7 , \field Fin Diameter - SizingString = WaterCoilNumericFields(CoilNum).FieldNames(FieldNum) + " [m]"; + SizingString = state.dataWaterCoils->WaterCoilNumericFields(CoilNum).FieldNames(FieldNum) + " [m]"; // Auto size water coil fin diameter = 0.335 * WaterCoil( CoilNum ).InletAirMassFlowRate - DataConstantUsedForSizing = WaterCoil(CoilNum).InletAirMassFlowRate; + DataConstantUsedForSizing = state.dataWaterCoils->WaterCoil(CoilNum).InletAirMassFlowRate; DataFractionUsedForSizing = 0.335; - TempSize = WaterCoil(CoilNum).FinDiam; + TempSize = state.dataWaterCoils->WaterCoil(CoilNum).FinDiam; RequestSizing(state, CompType, CompName, AutoCalculateSizing, SizingString, TempSize, bPRINT, RoutineName); - WaterCoil(CoilNum).FinDiam = TempSize; + state.dataWaterCoils->WaterCoil(CoilNum).FinDiam = TempSize; FieldNum = 5; // N5 , \field Minimum Airflow Area - SizingString = WaterCoilNumericFields(CoilNum).FieldNames(FieldNum) + " [m2]"; + SizingString = state.dataWaterCoils->WaterCoilNumericFields(CoilNum).FieldNames(FieldNum) + " [m2]"; // Auto size water coil minimum airflow area = 0.44 * WaterCoil( CoilNum ).InletAirMassFlowRate - DataConstantUsedForSizing = WaterCoil(CoilNum).InletAirMassFlowRate; + DataConstantUsedForSizing = state.dataWaterCoils->WaterCoil(CoilNum).InletAirMassFlowRate; DataFractionUsedForSizing = 0.44; - TempSize = WaterCoil(CoilNum).MinAirFlowArea; + TempSize = state.dataWaterCoils->WaterCoil(CoilNum).MinAirFlowArea; RequestSizing(state, CompType, CompName, AutoCalculateSizing, SizingString, TempSize, bPRINT, RoutineName); - WaterCoil(CoilNum).MinAirFlowArea = TempSize; - if (WaterCoil(CoilNum).MinAirFlowArea <= 0.0) { - ShowSevereError("Coil:Cooling:Water:DetailedGeometry: \"" + WaterCoil(CoilNum).Name + "\""); + state.dataWaterCoils->WaterCoil(CoilNum).MinAirFlowArea = TempSize; + if (state.dataWaterCoils->WaterCoil(CoilNum).MinAirFlowArea <= 0.0) { + ShowSevereError("Coil:Cooling:Water:DetailedGeometry: \"" + state.dataWaterCoils->WaterCoil(CoilNum).Name + "\""); ShowContinueError("Coil Minimum Airflow Area must be greater than 0. Coil area = " + - TrimSigDigits(WaterCoil(CoilNum).MinAirFlowArea, 6)); + TrimSigDigits(state.dataWaterCoils->WaterCoil(CoilNum).MinAirFlowArea, 6)); ErrorsFound = true; } FieldNum = 4; // N4 , \field Fin Surface Area - SizingString = WaterCoilNumericFields(CoilNum).FieldNames(FieldNum) + " [m2]"; + SizingString = state.dataWaterCoils->WaterCoilNumericFields(CoilNum).FieldNames(FieldNum) + " [m2]"; // Auto size water coil finned surface area = 78.5 * WaterCoil( CoilNum ).InletAirMassFlowRate DataConstantUsedForSizing = - WaterCoil(CoilNum).InletAirMassFlowRate; // actual autosized air mass flow rate, not calculated from user input + state.dataWaterCoils->WaterCoil(CoilNum).InletAirMassFlowRate; // actual autosized air mass flow rate, not calculated from user input DataFractionUsedForSizing = 78.5; - TempSize = WaterCoil(CoilNum).FinSurfArea; + TempSize = state.dataWaterCoils->WaterCoil(CoilNum).FinSurfArea; RequestSizing(state, CompType, CompName, AutoCalculateSizing, SizingString, TempSize, bPRINT, RoutineName); - WaterCoil(CoilNum).FinSurfArea = TempSize; + state.dataWaterCoils->WaterCoil(CoilNum).FinSurfArea = TempSize; FieldNum = 3; // N3 , \field Total Tube Inside Area - SizingString = WaterCoilNumericFields(CoilNum).FieldNames(FieldNum) + " [m2]"; + SizingString = state.dataWaterCoils->WaterCoilNumericFields(CoilNum).FieldNames(FieldNum) + " [m2]"; // Auto size water coil total tube inside surface area = 4.4 * WaterCoil( CoilNum ).TubeInsideDiam * WaterCoil( CoilNum // ).NumOfTubeRows * WaterCoil( CoilNum ).NumOfTubesPerRow DataConstantUsedForSizing = - WaterCoil(CoilNum).TubeInsideDiam * WaterCoil(CoilNum).NumOfTubeRows * WaterCoil(CoilNum).NumOfTubesPerRow; + state.dataWaterCoils->WaterCoil(CoilNum).TubeInsideDiam * state.dataWaterCoils->WaterCoil(CoilNum).NumOfTubeRows * state.dataWaterCoils->WaterCoil(CoilNum).NumOfTubesPerRow; DataFractionUsedForSizing = 4.4; - TempSize = WaterCoil(CoilNum).TotTubeInsideArea; + TempSize = state.dataWaterCoils->WaterCoil(CoilNum).TotTubeInsideArea; RequestSizing(state, CompType, CompName, AutoCalculateSizing, SizingString, TempSize, bPRINT, RoutineName); - WaterCoil(CoilNum).TotTubeInsideArea = TempSize; + state.dataWaterCoils->WaterCoil(CoilNum).TotTubeInsideArea = TempSize; FieldNum = 2; // N2 , \field Tube Outside Surface Area - SizingString = WaterCoilNumericFields(CoilNum).FieldNames(FieldNum) + " [m2]"; + SizingString = state.dataWaterCoils->WaterCoilNumericFields(CoilNum).FieldNames(FieldNum) + " [m2]"; // Auto size water coil total tube outside surface area = 4.1 * WaterCoil( CoilNum ).TubeOutsideDiam * WaterCoil( CoilNum // ).NumOfTubeRows * WaterCoil( CoilNum ).NumOfTubesPerRow DataConstantUsedForSizing = - WaterCoil(CoilNum).TubeOutsideDiam * WaterCoil(CoilNum).NumOfTubeRows * WaterCoil(CoilNum).NumOfTubesPerRow; + state.dataWaterCoils->WaterCoil(CoilNum).TubeOutsideDiam * state.dataWaterCoils->WaterCoil(CoilNum).NumOfTubeRows * state.dataWaterCoils->WaterCoil(CoilNum).NumOfTubesPerRow; DataFractionUsedForSizing = 4.1; - TempSize = WaterCoil(CoilNum).TubeOutsideSurfArea; + TempSize = state.dataWaterCoils->WaterCoil(CoilNum).TubeOutsideSurfArea; RequestSizing(state, CompType, CompName, AutoCalculateSizing, SizingString, TempSize, bPRINT, RoutineName); - WaterCoil(CoilNum).TubeOutsideSurfArea = TempSize; - if ((WaterCoil(CoilNum).FinSurfArea + WaterCoil(CoilNum).TubeOutsideSurfArea) <= 0.0) { - ShowSevereError("Coil:Cooling:Water:DetailedGeometry: \"" + WaterCoil(CoilNum).Name + "\""); + state.dataWaterCoils->WaterCoil(CoilNum).TubeOutsideSurfArea = TempSize; + if ((state.dataWaterCoils->WaterCoil(CoilNum).FinSurfArea + state.dataWaterCoils->WaterCoil(CoilNum).TubeOutsideSurfArea) <= 0.0) { + ShowSevereError("Coil:Cooling:Water:DetailedGeometry: \"" + state.dataWaterCoils->WaterCoil(CoilNum).Name + "\""); ShowContinueError("Coil Fin Surface Area plus Coil Tube Outside Surface Area must be greater than 0. Total surface area = " + - TrimSigDigits((WaterCoil(CoilNum).FinSurfArea + WaterCoil(CoilNum).TubeOutsideSurfArea), 6)); + TrimSigDigits((state.dataWaterCoils->WaterCoil(CoilNum).FinSurfArea + state.dataWaterCoils->WaterCoil(CoilNum).TubeOutsideSurfArea), 6)); ErrorsFound = true; } FieldNum = 6; // N6 , \field Coil Depth - SizingString = WaterCoilNumericFields(CoilNum).FieldNames(FieldNum) + " [m]"; + SizingString = state.dataWaterCoils->WaterCoilNumericFields(CoilNum).FieldNames(FieldNum) + " [m]"; // Auto size water coil coil depth = WaterCoil( CoilNum ).TubeDepthSpacing * WaterCoil( CoilNum ).NumOfTubeRows - DataConstantUsedForSizing = WaterCoil(CoilNum).TubeDepthSpacing; - DataFractionUsedForSizing = WaterCoil(CoilNum).NumOfTubeRows; - TempSize = WaterCoil(CoilNum).CoilDepth; + DataConstantUsedForSizing = state.dataWaterCoils->WaterCoil(CoilNum).TubeDepthSpacing; + DataFractionUsedForSizing = state.dataWaterCoils->WaterCoil(CoilNum).NumOfTubeRows; + TempSize = state.dataWaterCoils->WaterCoil(CoilNum).CoilDepth; RequestSizing(state, CompType, CompName, AutoCalculateSizing, SizingString, TempSize, bPRINT, RoutineName); - WaterCoil(CoilNum).CoilDepth = TempSize; + state.dataWaterCoils->WaterCoil(CoilNum).CoilDepth = TempSize; } DataPltSizCoolNum = 0; // reset all globals to 0 to ensure correct sizing for other child components DataWaterLoopNum = 0; @@ -2461,9 +2360,9 @@ namespace WaterCoils { DataWaterCoilSizCoolDeltaT = 0.0; } else { // If there is no cooling Plant Sizing object and autosizing was requested, issue fatal error message - if (WaterCoil(CoilNum).RequestingAutoSize) { + if (state.dataWaterCoils->WaterCoil(CoilNum).RequestingAutoSize) { ShowSevereError("Autosizing of water coil requires a cooling loop Sizing:Plant object"); - ShowContinueError("Occurs in water coil object= " + WaterCoil(CoilNum).Name); + ShowContinueError("Occurs in water coil object= " + state.dataWaterCoils->WaterCoil(CoilNum).Name); ErrorsFound = true; } } @@ -2471,20 +2370,20 @@ namespace WaterCoils { } // end cooling coil IF // if this is a heating coil - if (WaterCoil(CoilNum).WaterCoilType == CoilType_Heating && WaterCoil(CoilNum).RequestingAutoSize) { + if (state.dataWaterCoils->WaterCoil(CoilNum).WaterCoilType == state.dataWaterCoils->CoilType_Heating && state.dataWaterCoils->WaterCoil(CoilNum).RequestingAutoSize) { // find the appropriate heating Plant Sizing object PltSizHeatNum = PlantUtilities::MyPlantSizingIndex("hot water coil", - WaterCoil(CoilNum).Name, - WaterCoil(CoilNum).WaterInletNodeNum, - WaterCoil(CoilNum).WaterOutletNodeNum, + state.dataWaterCoils->WaterCoil(CoilNum).Name, + state.dataWaterCoils->WaterCoil(CoilNum).WaterInletNodeNum, + state.dataWaterCoils->WaterCoil(CoilNum).WaterOutletNodeNum, LoopErrorsFound); } - if (WaterCoil(CoilNum).WaterCoilType == CoilType_Heating) { + if (state.dataWaterCoils->WaterCoil(CoilNum).WaterCoilType == state.dataWaterCoils->CoilType_Heating) { - if (WaterCoil(CoilNum).UseDesignWaterDeltaTemp) { + if (state.dataWaterCoils->WaterCoil(CoilNum).UseDesignWaterDeltaTemp) { // use water design deltaT specified in the heating water coils - DataWaterCoilSizHeatDeltaT = WaterCoil(CoilNum).DesignWaterDeltaTemp; + DataWaterCoilSizHeatDeltaT = state.dataWaterCoils->WaterCoil(CoilNum).DesignWaterDeltaTemp; } else { if (PltSizHeatNum > 0) { DataWaterCoilSizHeatDeltaT = PlantSizData(PltSizHeatNum).DeltaT; @@ -2494,14 +2393,14 @@ namespace WaterCoils { if (PltSizHeatNum > 0) { DataPltSizHeatNum = PltSizHeatNum; - DataWaterLoopNum = WaterCoil(CoilNum).WaterLoopNum; - rho = GetDensityGlycol(PlantLoop(WaterCoil(CoilNum).WaterLoopNum).FluidName, + DataWaterLoopNum = state.dataWaterCoils->WaterCoil(CoilNum).WaterLoopNum; + rho = GetDensityGlycol(PlantLoop(state.dataWaterCoils->WaterCoil(CoilNum).WaterLoopNum).FluidName, DataGlobals::HWInitConvTemp, - PlantLoop(WaterCoil(CoilNum).WaterLoopNum).FluidIndex, + PlantLoop(state.dataWaterCoils->WaterCoil(CoilNum).WaterLoopNum).FluidIndex, RoutineName); Cp = GetSpecificHeatGlycol( PlantLoop(DataWaterLoopNum).FluidName, DataGlobals::HWInitConvTemp, PlantLoop(DataWaterLoopNum).FluidIndex, RoutineName); - if (WaterCoil(CoilNum).DesTotWaterCoilLoad > 0.0) { + if (state.dataWaterCoils->WaterCoil(CoilNum).DesTotWaterCoilLoad > 0.0) { NomCapUserInp = true; } else if (CurSysNum > 0 && CurSysNum <= DataHVACGlobals::NumPrimaryAirSys) { if (FinalSysSizing(CurSysNum).HeatingCapMethod == CapacityPerFloorArea) { @@ -2517,10 +2416,10 @@ namespace WaterCoils { TempSize = AutoSize; // get the autosized air volume flow rate for use in other calculations SizingString.clear(); // doesn't matter CompType = cAllCoilTypes(Coil_HeatingWater); // "Coil:Heating:Water" - CompName = WaterCoil(CoilNum).Name; - if (WaterCoil(CoilNum).DesiccantRegenerationCoil) { + CompName = state.dataWaterCoils->WaterCoil(CoilNum).Name; + if (state.dataWaterCoils->WaterCoil(CoilNum).DesiccantRegenerationCoil) { DataDesicRegCoil = true; - DataDesicDehumNum = WaterCoil(CoilNum).DesiccantDehumNum; + DataDesicDehumNum = state.dataWaterCoils->WaterCoil(CoilNum).DesiccantDehumNum; TempSize = AutoSize; RequestSizing(state, CompType, CompName, HeatingCoilDesAirInletTempSizing, SizingString, TempSize, bPRINT, RoutineName); DataDesInletAirTemp = TempSize; @@ -2535,14 +2434,14 @@ namespace WaterCoils { } RequestSizing(state, CompType, CompName, HeatingAirflowSizing, SizingString, TempSize, bPRINT, RoutineName); // reset the design air volume flow rate for air loop coils only - if (CurSysNum > 0) WaterCoil(CoilNum).DesAirVolFlowRate = TempSize; - WaterCoil(CoilNum).InletAirMassFlowRate = StdRhoAir * TempSize; // inlet air mass flow rate is not the autosized value + if (CurSysNum > 0) state.dataWaterCoils->WaterCoil(CoilNum).DesAirVolFlowRate = TempSize; + state.dataWaterCoils->WaterCoil(CoilNum).InletAirMassFlowRate = StdRhoAir * TempSize; // inlet air mass flow rate is not the autosized value DataAirFlowUsedForSizing = TempSize; DataFlowUsedForSizing = TempSize; // many autosized inputs use the design (autosized) air flow rate, save this value bPRINT = true; - if (WaterCoil(CoilNum).CoilPerfInpMeth == NomCap && NomCapUserInp) { - TempSize = WaterCoil(CoilNum).DesTotWaterCoilLoad; + if (state.dataWaterCoils->WaterCoil(CoilNum).CoilPerfInpMeth == state.dataWaterCoils->NomCap && NomCapUserInp) { + TempSize = state.dataWaterCoils->WaterCoil(CoilNum).DesTotWaterCoilLoad; DataNomCapInpMeth = true; } else { TempSize = AutoSize; @@ -2553,46 +2452,46 @@ namespace WaterCoils { SizingType = WaterHeatingCapacitySizing; } FieldNum = 3; // N3 , \field Rated Capacity - SizingString = WaterCoilNumericFields(CoilNum).FieldNames(FieldNum) + " [W]"; + SizingString = state.dataWaterCoils->WaterCoilNumericFields(CoilNum).FieldNames(FieldNum) + " [W]"; RequestSizing(state, CompType, CompName, SizingType, SizingString, TempSize, bPRINT, RoutineName); - WaterCoil(CoilNum).DesWaterHeatingCoilRate = TempSize; - WaterCoil(CoilNum).DesTotWaterCoilLoad = TempSize; - DataCapacityUsedForSizing = WaterCoil(CoilNum).DesWaterHeatingCoilRate; + state.dataWaterCoils->WaterCoil(CoilNum).DesWaterHeatingCoilRate = TempSize; + state.dataWaterCoils->WaterCoil(CoilNum).DesTotWaterCoilLoad = TempSize; + DataCapacityUsedForSizing = state.dataWaterCoils->WaterCoil(CoilNum).DesWaterHeatingCoilRate; // We now have the design load if it was autosized. For the case of CoilPerfInpMeth == NomCap, calculate the air flow rate // specified by the NomCap inputs. This overrides all previous values - if (WaterCoil(CoilNum).CoilPerfInpMeth == NomCap && NomCapUserInp) { - WaterCoil(CoilNum).InletAirMassFlowRate = WaterCoil(CoilNum).DesTotWaterCoilLoad / - (CpAirStd * (WaterCoil(CoilNum).DesOutletAirTemp - WaterCoil(CoilNum).DesInletAirTemp)); - WaterCoil(CoilNum).DesAirVolFlowRate = WaterCoil(CoilNum).InletAirMassFlowRate / StdRhoAir; - DataAirFlowUsedForSizing = WaterCoil(CoilNum).DesAirVolFlowRate; - DataFlowUsedForSizing = WaterCoil(CoilNum).DesAirVolFlowRate; + if (state.dataWaterCoils->WaterCoil(CoilNum).CoilPerfInpMeth == state.dataWaterCoils->NomCap && NomCapUserInp) { + state.dataWaterCoils->WaterCoil(CoilNum).InletAirMassFlowRate = state.dataWaterCoils->WaterCoil(CoilNum).DesTotWaterCoilLoad / + (CpAirStd * (state.dataWaterCoils->WaterCoil(CoilNum).DesOutletAirTemp - state.dataWaterCoils->WaterCoil(CoilNum).DesInletAirTemp)); + state.dataWaterCoils->WaterCoil(CoilNum).DesAirVolFlowRate = state.dataWaterCoils->WaterCoil(CoilNum).InletAirMassFlowRate / StdRhoAir; + DataAirFlowUsedForSizing = state.dataWaterCoils->WaterCoil(CoilNum).DesAirVolFlowRate; + DataFlowUsedForSizing = state.dataWaterCoils->WaterCoil(CoilNum).DesAirVolFlowRate; } FieldNum = 2; // N2 , \field Maximum Water Flow Rate - SizingString = WaterCoilNumericFields(CoilNum).FieldNames(FieldNum) + " [m3/s]"; - TempSize = WaterCoil(CoilNum).MaxWaterVolFlowRate; + SizingString = state.dataWaterCoils->WaterCoilNumericFields(CoilNum).FieldNames(FieldNum) + " [m3/s]"; + TempSize = state.dataWaterCoils->WaterCoil(CoilNum).MaxWaterVolFlowRate; SizingMethod = HeatingWaterflowSizing; - if (WaterCoil(CoilNum).CoilPerfInpMeth == NomCap && NomCapUserInp) { - if (WaterCoil(CoilNum).DesTotWaterCoilLoad > SmallLoad) { - WaterCoil(CoilNum).MaxWaterVolFlowRate = - DataCapacityUsedForSizing / (Cp * rho * (WaterCoil(CoilNum).DesInletWaterTemp - WaterCoil(CoilNum).DesOutletWaterTemp)); + if (state.dataWaterCoils->WaterCoil(CoilNum).CoilPerfInpMeth == state.dataWaterCoils->NomCap && NomCapUserInp) { + if (state.dataWaterCoils->WaterCoil(CoilNum).DesTotWaterCoilLoad > SmallLoad) { + state.dataWaterCoils->WaterCoil(CoilNum).MaxWaterVolFlowRate = + DataCapacityUsedForSizing / (Cp * rho * (state.dataWaterCoils->WaterCoil(CoilNum).DesInletWaterTemp - state.dataWaterCoils->WaterCoil(CoilNum).DesOutletWaterTemp)); } else { - WaterCoil(CoilNum).MaxWaterVolFlowRate = 0.0; + state.dataWaterCoils->WaterCoil(CoilNum).MaxWaterVolFlowRate = 0.0; } SizingMethod = AutoCalculateSizing; - DataConstantUsedForSizing = WaterCoil(CoilNum).MaxWaterVolFlowRate; + DataConstantUsedForSizing = state.dataWaterCoils->WaterCoil(CoilNum).MaxWaterVolFlowRate; DataFractionUsedForSizing = 1.0; } RequestSizing(state, CompType, CompName, SizingMethod, SizingString, TempSize, bPRINT, RoutineName); - WaterCoil(CoilNum).MaxWaterVolFlowRate = TempSize; - DataWaterFlowUsedForSizing = WaterCoil(CoilNum).MaxWaterVolFlowRate; + state.dataWaterCoils->WaterCoil(CoilNum).MaxWaterVolFlowRate = TempSize; + DataWaterFlowUsedForSizing = state.dataWaterCoils->WaterCoil(CoilNum).MaxWaterVolFlowRate; DataConstantUsedForSizing = 0.0; // reset these in case NomCapUserInp was true DataFractionUsedForSizing = 0.0; - if (WaterCoil(CoilNum).MaxWaterVolFlowRate <= 0.0) { + if (state.dataWaterCoils->WaterCoil(CoilNum).MaxWaterVolFlowRate <= 0.0) { // MaxWaterVolFlowRateDes = 0.0; - ShowWarningError("The design coil load is zero for Coil:Heating:Water " + WaterCoil(CoilNum).Name); + ShowWarningError("The design coil load is zero for Coil:Heating:Water " + state.dataWaterCoils->WaterCoil(CoilNum).Name); ShowContinueError("The autosize value for maximum water flow rate is zero"); ShowContinueError("To change this, input a value for UA, change the heating design day, or raise the"); ShowContinueError(" system heating design supply air temperature. Also check to make sure the Preheat"); @@ -2602,80 +2501,80 @@ namespace WaterCoils { // initialize the water coil inlet conditions bPRINT = false; // no need to print to eio since we only need the values DataFlowUsedForSizing = DataAirFlowUsedForSizing; - if (WaterCoil(CoilNum).CoilPerfInpMeth == NomCap && NomCapUserInp) { - WaterCoil(CoilNum).InletAirTemp = WaterCoil(CoilNum).DesInletAirTemp; - WaterCoil(CoilNum).InletAirHumRat = PsyWFnTdbRhPb(WaterCoil(CoilNum).DesInletAirTemp, 0.5, StdBaroPress, RoutineName); - WaterCoil(CoilNum).InletAirMassFlowRate = DataAirFlowUsedForSizing * StdRhoAir; // don't need this - DataDesOutletAirTemp = WaterCoil(CoilNum).DesOutletAirTemp; // for error messages + if (state.dataWaterCoils->WaterCoil(CoilNum).CoilPerfInpMeth == state.dataWaterCoils->NomCap && NomCapUserInp) { + state.dataWaterCoils->WaterCoil(CoilNum).InletAirTemp = state.dataWaterCoils->WaterCoil(CoilNum).DesInletAirTemp; + state.dataWaterCoils->WaterCoil(CoilNum).InletAirHumRat = PsyWFnTdbRhPb(state.dataWaterCoils->WaterCoil(CoilNum).DesInletAirTemp, 0.5, StdBaroPress, RoutineName); + state.dataWaterCoils->WaterCoil(CoilNum).InletAirMassFlowRate = DataAirFlowUsedForSizing * StdRhoAir; // don't need this + DataDesOutletAirTemp = state.dataWaterCoils->WaterCoil(CoilNum).DesOutletAirTemp; // for error messages DataDesOutletAirHumRat = PsyWFnTdbRhPb(DataDesOutletAirTemp, 0.5, StdBaroPress, RoutineName); // for error messages - WaterCoil(CoilNum).InletWaterMassFlowRate = rho * DataWaterFlowUsedForSizing; - WaterCoil(CoilNum).MaxWaterMassFlowRate = rho * DataWaterFlowUsedForSizing; - WaterCoil(CoilNum).InletWaterTemp = WaterCoil(CoilNum).DesInletWaterTemp; - } else if (WaterCoil(CoilNum).DesiccantRegenerationCoil) { + state.dataWaterCoils->WaterCoil(CoilNum).InletWaterMassFlowRate = rho * DataWaterFlowUsedForSizing; + state.dataWaterCoils->WaterCoil(CoilNum).MaxWaterMassFlowRate = rho * DataWaterFlowUsedForSizing; + state.dataWaterCoils->WaterCoil(CoilNum).InletWaterTemp = state.dataWaterCoils->WaterCoil(CoilNum).DesInletWaterTemp; + } else if (state.dataWaterCoils->WaterCoil(CoilNum).DesiccantRegenerationCoil) { TempSize = AutoSize; // these data are initially 0, set to autosize to receive a result from RequestSizing RequestSizing(state, CompType, CompName, HeatingCoilDesAirInletTempSizing, SizingString, TempSize, bPRINT, RoutineName); - WaterCoil(CoilNum).InletAirTemp = TempSize; + state.dataWaterCoils->WaterCoil(CoilNum).InletAirTemp = TempSize; TempSize = AutoSize; // these data are initially 0, set to autosize to receive a result from RequestSizing RequestSizing(state, CompType, CompName, HeatingCoilDesAirInletHumRatSizing, SizingString, TempSize, bPRINT, RoutineName); - WaterCoil(CoilNum).DesInletAirHumRat = TempSize; // coil report - WaterCoil(CoilNum).InletAirHumRat = TempSize; + state.dataWaterCoils->WaterCoil(CoilNum).DesInletAirHumRat = TempSize; // coil report + state.dataWaterCoils->WaterCoil(CoilNum).InletAirHumRat = TempSize; TempSize = AutoSize; // these data are initially 0, set to autosize to receive a result from RequestSizing RequestSizing(state, CompType, CompName, HeatingAirflowUASizing, SizingString, TempSize, bPRINT, RoutineName); - // WaterCoil( CoilNum ).InletAirMassFlowRate = TempSize; - WaterCoil(CoilNum).DesAirVolFlowRate = DataAirFlowUsedForSizing; // coil report - WaterCoil(CoilNum).InletAirMassFlowRate = DataAirFlowUsedForSizing * StdRhoAir; // this is stiil volume flow! + // state.dataWaterCoils->WaterCoil( CoilNum ).InletAirMassFlowRate = TempSize; + state.dataWaterCoils->WaterCoil(CoilNum).DesAirVolFlowRate = DataAirFlowUsedForSizing; // coil report + state.dataWaterCoils->WaterCoil(CoilNum).InletAirMassFlowRate = DataAirFlowUsedForSizing * StdRhoAir; // this is stiil volume flow! } else { TempSize = AutoSize; // these data are initially 0, set to autosize to receive a result from RequestSizing RequestSizing(state, CompType, CompName, HeatingWaterDesAirInletTempSizing, SizingString, TempSize, bPRINT, RoutineName); - WaterCoil(CoilNum).InletAirTemp = TempSize; + state.dataWaterCoils->WaterCoil(CoilNum).InletAirTemp = TempSize; TempSize = AutoSize; // these data are initially 0, set to autosize to receive a result from RequestSizing RequestSizing(state, CompType, CompName, HeatingWaterDesAirInletHumRatSizing, SizingString, TempSize, bPRINT, RoutineName); - WaterCoil(CoilNum).DesInletAirHumRat = TempSize; // coil report - WaterCoil(CoilNum).InletAirHumRat = TempSize; + state.dataWaterCoils->WaterCoil(CoilNum).DesInletAirHumRat = TempSize; // coil report + state.dataWaterCoils->WaterCoil(CoilNum).InletAirHumRat = TempSize; TempSize = AutoSize; // these data are initially 0, set to autosize to receive a result from RequestSizing RequestSizing(state, CompType, CompName, HeatingAirflowUASizing, SizingString, TempSize, bPRINT, RoutineName); - WaterCoil(CoilNum).DesAirMassFlowRate = TempSize; // coil report - WaterCoil(CoilNum).InletAirMassFlowRate = TempSize; + state.dataWaterCoils->WaterCoil(CoilNum).DesAirMassFlowRate = TempSize; // coil report + state.dataWaterCoils->WaterCoil(CoilNum).InletAirMassFlowRate = TempSize; } // zone and air loop coils use different design coil load calculations, air loop coils use air side capacity, // zone coils use water side capacity - DataDesInletAirTemp = WaterCoil(CoilNum).InletAirTemp; // used in error mesages - DataDesInletAirHumRat = WaterCoil(CoilNum).InletAirHumRat; // used in error mesages + DataDesInletAirTemp = state.dataWaterCoils->WaterCoil(CoilNum).InletAirTemp; // used in error mesages + DataDesInletAirHumRat = state.dataWaterCoils->WaterCoil(CoilNum).InletAirHumRat; // used in error mesages DataFlowUsedForSizing = DataAirFlowUsedForSizing * StdRhoAir; // used in error mesages - WaterCoil(CoilNum).MaxWaterVolFlowRate = DataWaterFlowUsedForSizing; // why is this here? - if (!(WaterCoil(CoilNum).CoilPerfInpMeth == NomCap && NomCapUserInp)) { + state.dataWaterCoils->WaterCoil(CoilNum).MaxWaterVolFlowRate = DataWaterFlowUsedForSizing; // why is this here? + if (!(state.dataWaterCoils->WaterCoil(CoilNum).CoilPerfInpMeth == state.dataWaterCoils->NomCap && NomCapUserInp)) { TempSize = AutoSize; RequestSizing(state, CompType, CompName, HeatingWaterDesCoilLoadUsedForUASizing, SizingString, TempSize, bPRINT, RoutineName); DataCapacityUsedForSizing = TempSize; TempSize = AutoSize; // get the water volume flow rate used to size UA RequestSizing(state, CompType, CompName, HeatingWaterDesCoilWaterVolFlowUsedForUASizing, SizingString, TempSize, bPRINT, RoutineName); DataWaterFlowUsedForSizing = TempSize; - WaterCoil(CoilNum).InletWaterTemp = PlantSizData(PltSizHeatNum).ExitTemp; - WaterCoil(CoilNum).InletWaterMassFlowRate = rho * DataWaterFlowUsedForSizing; - WaterCoil(CoilNum).MaxWaterMassFlowRate = rho * DataWaterFlowUsedForSizing; - WaterCoil(CoilNum).DesWaterHeatingCoilRate = DataCapacityUsedForSizing; + state.dataWaterCoils->WaterCoil(CoilNum).InletWaterTemp = PlantSizData(PltSizHeatNum).ExitTemp; + state.dataWaterCoils->WaterCoil(CoilNum).InletWaterMassFlowRate = rho * DataWaterFlowUsedForSizing; + state.dataWaterCoils->WaterCoil(CoilNum).MaxWaterMassFlowRate = rho * DataWaterFlowUsedForSizing; + state.dataWaterCoils->WaterCoil(CoilNum).DesWaterHeatingCoilRate = DataCapacityUsedForSizing; } // calculate UA - if (CurSysNum > 0) WaterCoil(CoilNum).DesTotWaterCoilLoad = DataCapacityUsedForSizing; + if (CurSysNum > 0) state.dataWaterCoils->WaterCoil(CoilNum).DesTotWaterCoilLoad = DataCapacityUsedForSizing; FieldNum = 1; // N1 , \field U-Factor Times Area Value bPRINT = true; // report to eio the UA value - SizingString = WaterCoilNumericFields(CoilNum).FieldNames(FieldNum) + " [W/K]"; + SizingString = state.dataWaterCoils->WaterCoilNumericFields(CoilNum).FieldNames(FieldNum) + " [W/K]"; DataCoilNum = CoilNum; DataFanOpMode = ContFanCycCoil; - if (WaterCoil(CoilNum).CoilPerfInpMeth == NomCap && NomCapUserInp) { + if (state.dataWaterCoils->WaterCoil(CoilNum).CoilPerfInpMeth == state.dataWaterCoils->NomCap && NomCapUserInp) { TempSize = AutoSize; } else { - TempSize = WaterCoil(CoilNum).UACoil; + TempSize = state.dataWaterCoils->WaterCoil(CoilNum).UACoil; } - DataFlowUsedForSizing = WaterCoil(CoilNum).InletAirMassFlowRate; - DesCoilWaterInTempSaved = WaterCoil(DataCoilNum).InletWaterTemp; + DataFlowUsedForSizing = state.dataWaterCoils->WaterCoil(CoilNum).InletAirMassFlowRate; + DesCoilWaterInTempSaved = state.dataWaterCoils->WaterCoil(DataCoilNum).InletWaterTemp; if (DesCoilWaterInTempSaved < DesCoilHWInletTempMin) { // at low coil design water inlet temp, sizing has convergence issue hence slightly higher water inlet temperature // is estimated in "EstimateCoilInletWaterTemp" and used for UA autosizing only - EstimateCoilInletWaterTemp(DataCoilNum, DataFanOpMode, 1.0, DataCapacityUsedForSizing, DesCoilInletWaterTempUsed); - WaterCoil(DataCoilNum).InletWaterTemp = DesCoilInletWaterTempUsed; + EstimateCoilInletWaterTemp(state, DataCoilNum, DataFanOpMode, 1.0, DataCapacityUsedForSizing, DesCoilInletWaterTempUsed); + state.dataWaterCoils->WaterCoil(DataCoilNum).InletWaterTemp = DesCoilInletWaterTempUsed; } // must set DataCapacityUsedForSizing, DataWaterFlowUsedForSizing and DataFlowUsedForSizing to size UA. Any value of 0 will result // in UA = 1. @@ -2686,18 +2585,18 @@ namespace WaterCoils { ShowContinueError(" Plant design loop exit temperature is low for design load and leaving air temperature anticipated."); ShowContinueError( " Heating coil UA-value is sized using coil water inlet temperature = " + TrimSigDigits(DesCoilInletWaterTempUsed, 2) + " C"); - WaterCoil(DataCoilNum).InletWaterTemp = DesCoilWaterInTempSaved; // reset the Design Coil Inlet Water Temperature + state.dataWaterCoils->WaterCoil(DataCoilNum).InletWaterTemp = DesCoilWaterInTempSaved; // reset the Design Coil Inlet Water Temperature } - WaterCoil(CoilNum).UACoil = TempSize; + state.dataWaterCoils->WaterCoil(CoilNum).UACoil = TempSize; // if coil UA did not size due to one of these variables being 0, must set UACoilVariable to avoid crash later on if (DataCapacityUsedForSizing == 0.0 || DataWaterFlowUsedForSizing == 0.0 || DataFlowUsedForSizing == 0.0) { - if (WaterCoil(CoilNum).UACoilVariable == AutoSize) { - WaterCoil(CoilNum).UACoilVariable = TempSize; + if (state.dataWaterCoils->WaterCoil(CoilNum).UACoilVariable == AutoSize) { + state.dataWaterCoils->WaterCoil(CoilNum).UACoilVariable = TempSize; } } - WaterCoil(CoilNum).UACoilVariable = TempSize; - WaterCoil(CoilNum).DesWaterHeatingCoilRate = DataCapacityUsedForSizing; - WaterCoil(DataCoilNum).InletWaterTemp = DesCoilWaterInTempSaved; // reset the Design Coil Inlet Water Temperature + state.dataWaterCoils->WaterCoil(CoilNum).UACoilVariable = TempSize; + state.dataWaterCoils->WaterCoil(CoilNum).DesWaterHeatingCoilRate = DataCapacityUsedForSizing; + state.dataWaterCoils->WaterCoil(DataCoilNum).InletWaterTemp = DesCoilWaterInTempSaved; // reset the Design Coil Inlet Water Temperature DataWaterLoopNum = 0; // reset all globals to 0 to ensure correct sizing for other child components DataPltSizHeatNum = 0; @@ -2718,9 +2617,9 @@ namespace WaterCoils { } else { // if there is no heating Plant Sizing object and autosizng was requested, issue an error message - if (WaterCoil(CoilNum).RequestingAutoSize) { + if (state.dataWaterCoils->WaterCoil(CoilNum).RequestingAutoSize) { ShowSevereError("Autosizing of water coil requires a heating loop Sizing:Plant object"); - ShowContinueError("Occurs in water coil object= " + WaterCoil(CoilNum).Name); + ShowContinueError("Occurs in water coil object= " + state.dataWaterCoils->WaterCoil(CoilNum).Name); ErrorsFound = true; } } @@ -2728,8 +2627,8 @@ namespace WaterCoils { } // end heating coil IF // save the design water volumetric flow rate for use by the water loop sizing algorithms - if (WaterCoil(CoilNum).MaxWaterVolFlowRate > 0.0) { - RegisterPlantCompDesignFlow(WaterCoil(CoilNum).WaterInletNodeNum, WaterCoil(CoilNum).MaxWaterVolFlowRate); + if (state.dataWaterCoils->WaterCoil(CoilNum).MaxWaterVolFlowRate > 0.0) { + RegisterPlantCompDesignFlow(state.dataWaterCoils->WaterCoil(CoilNum).WaterInletNodeNum, state.dataWaterCoils->WaterCoil(CoilNum).MaxWaterVolFlowRate); } if (ErrorsFound || DataErrorsFound) { @@ -2743,7 +2642,7 @@ namespace WaterCoils { // Begin Algorithm Section of the Module //****************************************************************************** - void CalcSimpleHeatingCoil(int const CoilNum, // index to heating coil + void CalcSimpleHeatingCoil(EnergyPlusData &state, int const CoilNum, // index to heating coil int const FanOpMode, // fan operating mode Real64 const PartLoadRatio, // part-load ratio of heating coil int const CalcMode // 1 = design calc; 2 = simulation calculation @@ -2809,31 +2708,31 @@ namespace WaterCoils { Real64 Cp; int Control; - UA = WaterCoil(CoilNum).UACoilVariable; - TempAirIn = WaterCoil(CoilNum).InletAirTemp; - Win = WaterCoil(CoilNum).InletAirHumRat; - Control = WaterCoil(CoilNum).Control; - TempWaterIn = WaterCoil(CoilNum).InletWaterTemp; + UA = state.dataWaterCoils->WaterCoil(CoilNum).UACoilVariable; + TempAirIn = state.dataWaterCoils->WaterCoil(CoilNum).InletAirTemp; + Win = state.dataWaterCoils->WaterCoil(CoilNum).InletAirHumRat; + Control = state.dataWaterCoils->WaterCoil(CoilNum).Control; + TempWaterIn = state.dataWaterCoils->WaterCoil(CoilNum).InletWaterTemp; // adjust mass flow rates for cycling fan cycling coil operation if (FanOpMode == CycFanCycCoil) { if (PartLoadRatio > 0.0) { - AirMassFlow = WaterCoil(CoilNum).InletAirMassFlowRate / PartLoadRatio; - WaterMassFlowRate = min(WaterCoil(CoilNum).InletWaterMassFlowRate / PartLoadRatio, WaterCoil(CoilNum).MaxWaterMassFlowRate); + AirMassFlow = state.dataWaterCoils->WaterCoil(CoilNum).InletAirMassFlowRate / PartLoadRatio; + WaterMassFlowRate = min(state.dataWaterCoils->WaterCoil(CoilNum).InletWaterMassFlowRate / PartLoadRatio, state.dataWaterCoils->WaterCoil(CoilNum).MaxWaterMassFlowRate); } else { AirMassFlow = 0.0; WaterMassFlowRate = 0.0; } } else { - AirMassFlow = WaterCoil(CoilNum).InletAirMassFlowRate; - WaterMassFlowRate = WaterCoil(CoilNum).InletWaterMassFlowRate; + AirMassFlow = state.dataWaterCoils->WaterCoil(CoilNum).InletAirMassFlowRate; + WaterMassFlowRate = state.dataWaterCoils->WaterCoil(CoilNum).InletWaterMassFlowRate; } if (WaterMassFlowRate > MassFlowTolerance) { // If the coil is operating CapacitanceAir = PsyCpAirFnW(Win) * AirMassFlow; - Cp = GetSpecificHeatGlycol(PlantLoop(WaterCoil(CoilNum).WaterLoopNum).FluidName, + Cp = GetSpecificHeatGlycol(PlantLoop(state.dataWaterCoils->WaterCoil(CoilNum).WaterLoopNum).FluidName, TempWaterIn, - PlantLoop(WaterCoil(CoilNum).WaterLoopNum).FluidIndex, + PlantLoop(state.dataWaterCoils->WaterCoil(CoilNum).WaterLoopNum).FluidIndex, RoutineName); CapacitanceWater = Cp * WaterMassFlowRate; CapacitanceMin = min(CapacitanceAir, CapacitanceWater); @@ -2846,11 +2745,11 @@ namespace WaterCoils { // If the coil is operating there should be some heating capacitance // across the coil, so do the simulation. If not set outlet to inlet and no load. // Also the coil has to be scheduled to be available - if (((CapacitanceAir > 0.0) && (CapacitanceWater > 0.0)) && (CalcMode == DesignCalc || MySizeFlag(CoilNum) || MyUAAndFlowCalcFlag(CoilNum) || - GetCurrentScheduleValue(WaterCoil(CoilNum).SchedPtr) > 0.0)) { + if (((CapacitanceAir > 0.0) && (CapacitanceWater > 0.0)) && (CalcMode == state.dataWaterCoils->DesignCalc || state.dataWaterCoils->MySizeFlag(CoilNum) || state.dataWaterCoils->MyUAAndFlowCalcFlag(CoilNum) || + GetCurrentScheduleValue(state.dataWaterCoils->WaterCoil(CoilNum).SchedPtr) > 0.0)) { if (UA <= 0.0) { - ShowFatalError("UA is zero for COIL:Heating:Water " + WaterCoil(CoilNum).Name); + ShowFatalError("UA is zero for COIL:Heating:Water " + state.dataWaterCoils->WaterCoil(CoilNum).Name); } NTU = UA / CapacitanceMin; ETA = std::pow(NTU, 0.22); @@ -2875,17 +2774,17 @@ namespace WaterCoils { TempWaterOut = TempWaterIn - CapacitanceAir * (TempAirOut - TempAirIn) / CapacitanceWater; HeatingCoilLoad = CapacitanceWater * (TempWaterIn - TempWaterOut); // The HeatingCoilLoad is the change in the enthalpy of the water - WaterCoil(CoilNum).OutletWaterEnthalpy = - WaterCoil(CoilNum).InletWaterEnthalpy - HeatingCoilLoad / WaterCoil(CoilNum).InletWaterMassFlowRate; - WaterCoil(CoilNum).OutletWaterMassFlowRate = WaterCoil(CoilNum).InletWaterMassFlowRate; + state.dataWaterCoils->WaterCoil(CoilNum).OutletWaterEnthalpy = + state.dataWaterCoils->WaterCoil(CoilNum).InletWaterEnthalpy - HeatingCoilLoad / state.dataWaterCoils->WaterCoil(CoilNum).InletWaterMassFlowRate; + state.dataWaterCoils->WaterCoil(CoilNum).OutletWaterMassFlowRate = state.dataWaterCoils->WaterCoil(CoilNum).InletWaterMassFlowRate; } else { // If not running Conditions do not change across coil from inlet to outlet TempAirOut = TempAirIn; TempWaterOut = TempWaterIn; HeatingCoilLoad = 0.0; - WaterCoil(CoilNum).OutletWaterEnthalpy = WaterCoil(CoilNum).InletWaterEnthalpy; - WaterCoil(CoilNum).OutletWaterMassFlowRate = 0.0; + state.dataWaterCoils->WaterCoil(CoilNum).OutletWaterEnthalpy = state.dataWaterCoils->WaterCoil(CoilNum).InletWaterEnthalpy; + state.dataWaterCoils->WaterCoil(CoilNum).OutletWaterMassFlowRate = 0.0; } if (FanOpMode == CycFanCycCoil) { @@ -2893,18 +2792,18 @@ namespace WaterCoils { } // Set the outlet conditions - WaterCoil(CoilNum).TotWaterHeatingCoilRate = HeatingCoilLoad; - WaterCoil(CoilNum).OutletAirTemp = TempAirOut; - WaterCoil(CoilNum).OutletWaterTemp = TempWaterOut; + state.dataWaterCoils->WaterCoil(CoilNum).TotWaterHeatingCoilRate = HeatingCoilLoad; + state.dataWaterCoils->WaterCoil(CoilNum).OutletAirTemp = TempAirOut; + state.dataWaterCoils->WaterCoil(CoilNum).OutletWaterTemp = TempWaterOut; // This WaterCoil does not change the moisture or Mass Flow across the component - WaterCoil(CoilNum).OutletAirHumRat = WaterCoil(CoilNum).InletAirHumRat; - WaterCoil(CoilNum).OutletAirMassFlowRate = WaterCoil(CoilNum).InletAirMassFlowRate; + state.dataWaterCoils->WaterCoil(CoilNum).OutletAirHumRat = state.dataWaterCoils->WaterCoil(CoilNum).InletAirHumRat; + state.dataWaterCoils->WaterCoil(CoilNum).OutletAirMassFlowRate = state.dataWaterCoils->WaterCoil(CoilNum).InletAirMassFlowRate; // Set the outlet enthalpys for air and water - WaterCoil(CoilNum).OutletAirEnthalpy = PsyHFnTdbW(WaterCoil(CoilNum).OutletAirTemp, WaterCoil(CoilNum).OutletAirHumRat); + state.dataWaterCoils->WaterCoil(CoilNum).OutletAirEnthalpy = PsyHFnTdbW(state.dataWaterCoils->WaterCoil(CoilNum).OutletAirTemp, state.dataWaterCoils->WaterCoil(CoilNum).OutletAirHumRat); } - void CalcDetailFlatFinCoolingCoil(int const CoilNum, + void CalcDetailFlatFinCoolingCoil(EnergyPlusData &state, int const CoilNum, int const CalcMode, int const FanOpMode, // fan operating mode Real64 const PartLoadRatio // part-load ratio of heating coil @@ -3052,25 +2951,25 @@ namespace WaterCoils { Real64 Cp; // Set derived type variables to shorter local variables - TempAirIn = WaterCoil(CoilNum).InletAirTemp; - InletAirHumRat = WaterCoil(CoilNum).InletAirHumRat; - TempWaterIn = WaterCoil(CoilNum).InletWaterTemp; + TempAirIn = state.dataWaterCoils->WaterCoil(CoilNum).InletAirTemp; + InletAirHumRat = state.dataWaterCoils->WaterCoil(CoilNum).InletAirHumRat; + TempWaterIn = state.dataWaterCoils->WaterCoil(CoilNum).InletWaterTemp; // adjust mass flow rates for cycling fan cycling coil operation if (FanOpMode == CycFanCycCoil) { if (PartLoadRatio > 0.0) { - AirMassFlow = WaterCoil(CoilNum).InletAirMassFlowRate / PartLoadRatio; - WaterMassFlowRate = min(WaterCoil(CoilNum).InletWaterMassFlowRate / PartLoadRatio, WaterCoil(CoilNum).MaxWaterMassFlowRate); + AirMassFlow = state.dataWaterCoils->WaterCoil(CoilNum).InletAirMassFlowRate / PartLoadRatio; + WaterMassFlowRate = min(state.dataWaterCoils->WaterCoil(CoilNum).InletWaterMassFlowRate / PartLoadRatio, state.dataWaterCoils->WaterCoil(CoilNum).MaxWaterMassFlowRate); } else { AirMassFlow = 0.0; WaterMassFlowRate = 0.0; } } else { - AirMassFlow = WaterCoil(CoilNum).InletAirMassFlowRate; - WaterMassFlowRate = WaterCoil(CoilNum).InletWaterMassFlowRate; + AirMassFlow = state.dataWaterCoils->WaterCoil(CoilNum).InletAirMassFlowRate; + WaterMassFlowRate = state.dataWaterCoils->WaterCoil(CoilNum).InletWaterMassFlowRate; } - if (WaterMassFlowRate < WaterCoil(CoilNum).MaxWaterMassFlowRate * MinWaterMassFlowFrac) { + if (WaterMassFlowRate < state.dataWaterCoils->WaterCoil(CoilNum).MaxWaterMassFlowRate * state.dataWaterCoils->MinWaterMassFlowFrac) { WaterMassFlowRate = 0.0; } if (TempAirIn <= TempWaterIn) { @@ -3082,64 +2981,64 @@ namespace WaterCoils { // Warning and error messages for large flow rates for the given user input geometry AirDensity = PsyRhoAirFnPbTdbW(OutBaroPress, TempAirIn, InletAirHumRat, RoutineName); - if (AirMassFlow > (5.0 * WaterCoil(CoilNum).MinAirFlowArea / AirDensity) && CoilWarningOnceFlag(CoilNum)) { - ShowWarningError("Coil:Cooling:Water:DetailedGeometry in Coil =" + WaterCoil(CoilNum).Name); + if (AirMassFlow > (5.0 * state.dataWaterCoils->WaterCoil(CoilNum).MinAirFlowArea / AirDensity) && state.dataWaterCoils->CoilWarningOnceFlag(CoilNum)) { + ShowWarningError("Coil:Cooling:Water:DetailedGeometry in Coil =" + state.dataWaterCoils->WaterCoil(CoilNum).Name); ShowContinueError("Air Flow Rate Velocity has greatly exceeded upper design guidelines of ~2.5 m/s"); ShowContinueError("Air MassFlowRate[kg/s]=" + TrimSigDigits(AirMassFlow, 6)); - AirVelocity = AirMassFlow * AirDensity / WaterCoil(CoilNum).MinAirFlowArea; + AirVelocity = AirMassFlow * AirDensity / state.dataWaterCoils->WaterCoil(CoilNum).MinAirFlowArea; ShowContinueError("Air Face Velocity[m/s]=" + TrimSigDigits(AirVelocity, 6)); ShowContinueError("Approximate MassFlowRate limit for Face Area[kg/s]=" + - TrimSigDigits(2.5 * WaterCoil(CoilNum).MinAirFlowArea / AirDensity, 6)); + TrimSigDigits(2.5 * state.dataWaterCoils->WaterCoil(CoilNum).MinAirFlowArea / AirDensity, 6)); ShowContinueError("Coil:Cooling:Water:DetailedGeometry could be resized/autosized to handle capacity"); - CoilWarningOnceFlag(CoilNum) = false; - } else if (AirMassFlow > (44.7 * WaterCoil(CoilNum).MinAirFlowArea / AirDensity)) { - ShowSevereError("Coil:Cooling:Water:DetailedGeometry in Coil =" + WaterCoil(CoilNum).Name); + state.dataWaterCoils->CoilWarningOnceFlag(CoilNum) = false; + } else if (AirMassFlow > (44.7 * state.dataWaterCoils->WaterCoil(CoilNum).MinAirFlowArea / AirDensity)) { + ShowSevereError("Coil:Cooling:Water:DetailedGeometry in Coil =" + state.dataWaterCoils->WaterCoil(CoilNum).Name); ShowContinueError("Air Flow Rate Velocity is > 100MPH (44.7m/s) and simulation cannot continue"); ShowContinueError("Air Mass Flow Rate[kg/s]=" + TrimSigDigits(AirMassFlow, 6)); - AirVelocity = AirMassFlow * AirDensity / WaterCoil(CoilNum).MinAirFlowArea; + AirVelocity = AirMassFlow * AirDensity / state.dataWaterCoils->WaterCoil(CoilNum).MinAirFlowArea; ShowContinueError("Air Face Velocity[m/s]=" + TrimSigDigits(AirVelocity, 6)); ShowContinueError("Approximate MassFlowRate limit for Face Area[kg/s]=" + - TrimSigDigits(2.5 * WaterCoil(CoilNum).MinAirFlowArea / AirDensity, 6)); + TrimSigDigits(2.5 * state.dataWaterCoils->WaterCoil(CoilNum).MinAirFlowArea / AirDensity, 6)); ShowFatalError("Coil:Cooling:Water:DetailedGeometry needs to be resized/autosized to handle capacity"); } // If Coil is Scheduled ON then do the simulation - if (((GetCurrentScheduleValue(WaterCoil(CoilNum).SchedPtr) > 0.0) && (WaterMassFlowRate > 0.0) && (AirMassFlow >= MinAirMassFlow)) || - (CalcMode == DesignCalc)) { + if (((GetCurrentScheduleValue(state.dataWaterCoils->WaterCoil(CoilNum).SchedPtr) > 0.0) && (WaterMassFlowRate > 0.0) && (AirMassFlow >= state.dataWaterCoils->MinAirMassFlow)) || + (CalcMode == state.dataWaterCoils->DesignCalc)) { // transfer inputs to simulation variables and calculate // known thermodynamic functions // All coil calcs are done in KJoules. Convert to KJ here and then convert // back to Joules at the end of the Subroutine. DryAirSpecHeat = PsyCpAirFnW(zero) * ConvK; MoistAirSpecificHeat = PsyCpAirFnW(InletAirHumRat) * ConvK; - InletAirEnthalpy = WaterCoil(CoilNum).InletAirEnthalpy * ConvK; + InletAirEnthalpy = state.dataWaterCoils->WaterCoil(CoilNum).InletAirEnthalpy * ConvK; EnterAirDewPoint = PsyTdpFnWPb(InletAirHumRat, OutBaroPress, RoutineName); // Ratio of secondary (fin) to total (secondary plus primary) surface areas - FinToTotSurfAreaRatio = WaterCoil(CoilNum).FinSurfArea / WaterCoil(CoilNum).TotCoilOutsideSurfArea; + FinToTotSurfAreaRatio = state.dataWaterCoils->WaterCoil(CoilNum).FinSurfArea / state.dataWaterCoils->WaterCoil(CoilNum).TotCoilOutsideSurfArea; // known water and air flow parameters: - rho = GetDensityGlycol(PlantLoop(WaterCoil(CoilNum).WaterLoopNum).FluidName, + rho = GetDensityGlycol(PlantLoop(state.dataWaterCoils->WaterCoil(CoilNum).WaterLoopNum).FluidName, TempWaterIn, - PlantLoop(WaterCoil(CoilNum).WaterLoopNum).FluidIndex, + PlantLoop(state.dataWaterCoils->WaterCoil(CoilNum).WaterLoopNum).FluidIndex, RoutineName); // water flow velocity - assuming number of water circuits = NumOfTubesPerRow TubeWaterVel = WaterMassFlowRate * 4.0 / - (WaterCoil(CoilNum).NumOfTubesPerRow * rho * Pi * WaterCoil(CoilNum).TubeInsideDiam * WaterCoil(CoilNum).TubeInsideDiam); + (state.dataWaterCoils->WaterCoil(CoilNum).NumOfTubesPerRow * rho * Pi * state.dataWaterCoils->WaterCoil(CoilNum).TubeInsideDiam * state.dataWaterCoils->WaterCoil(CoilNum).TubeInsideDiam); // air mass flow rate per unit area - ScaledAirMassFlowRate = (1.0 + InletAirHumRat) * AirMassFlow / WaterCoil(CoilNum).MinAirFlowArea; + ScaledAirMassFlowRate = (1.0 + InletAirHumRat) * AirMassFlow / state.dataWaterCoils->WaterCoil(CoilNum).MinAirFlowArea; // air flow Reynold's Number - AirReynoldsNo = WaterCoil(CoilNum).CoilEffectiveInsideDiam * ScaledAirMassFlowRate / AirViscosity; + AirReynoldsNo = state.dataWaterCoils->WaterCoil(CoilNum).CoilEffectiveInsideDiam * ScaledAirMassFlowRate / AirViscosity; // heat transfer coefficients and resistance components: // inside (water) WaterToTubeThermResist = - std::pow(WaterCoil(CoilNum).TubeInsideDiam, 0.2) / (WaterCoil(CoilNum).TotTubeInsideArea * 1.429 * std::pow(TubeWaterVel, 0.8)); + std::pow(state.dataWaterCoils->WaterCoil(CoilNum).TubeInsideDiam, 0.2) / (state.dataWaterCoils->WaterCoil(CoilNum).TotTubeInsideArea * 1.429 * std::pow(TubeWaterVel, 0.8)); // metal and fouling TubeFoulThermResist = - (0.5 * (WaterCoil(CoilNum).TubeOutsideDiam - WaterCoil(CoilNum).TubeInsideDiam) / (ConvK * WaterCoil(CoilNum).TubeThermConductivity) + + (0.5 * (state.dataWaterCoils->WaterCoil(CoilNum).TubeOutsideDiam - state.dataWaterCoils->WaterCoil(CoilNum).TubeInsideDiam) / (ConvK * state.dataWaterCoils->WaterCoil(CoilNum).TubeThermConductivity) + TubeFoulFactor) / - WaterCoil(CoilNum).TotTubeInsideArea; + state.dataWaterCoils->WaterCoil(CoilNum).TotTubeInsideArea; // outside (wet and dry coil) - FilmCoefEqnFactor = WaterCoil(CoilNum).GeometryCoef1 * std::pow(AirReynoldsNo, WaterCoil(CoilNum).GeometryCoef2); + FilmCoefEqnFactor = state.dataWaterCoils->WaterCoil(CoilNum).GeometryCoef1 * std::pow(AirReynoldsNo, state.dataWaterCoils->WaterCoil(CoilNum).GeometryCoef2); // (1.23 is 1/Prandt(air)**(2/3)) AirSideDrySurfFilmCoef = 1.23 * FilmCoefEqnFactor * MoistAirSpecificHeat * ScaledAirMassFlowRate; FilmCoefReynldsCorrelatnFact = 1.425 + AirReynoldsNo * (-0.51e-3 + AirReynoldsNo * 0.263e-6); @@ -3169,8 +3068,8 @@ namespace WaterCoils { EnterAirHumRatDiff = InletAirHumRat - RsdInletWaterTempSatAirHumRat; DryFinEfficncy = - 0.5 * (WaterCoil(CoilNum).EffectiveFinDiam - WaterCoil(CoilNum).TubeOutsideDiam) * - std::sqrt(2.0 * AirSideWetSurfFilmCoef / (ConvK * WaterCoil(CoilNum).FinThermConductivity * WaterCoil(CoilNum).FinThickness)); + 0.5 * (state.dataWaterCoils->WaterCoil(CoilNum).EffectiveFinDiam - state.dataWaterCoils->WaterCoil(CoilNum).TubeOutsideDiam) * + std::sqrt(2.0 * AirSideWetSurfFilmCoef / (ConvK * state.dataWaterCoils->WaterCoil(CoilNum).FinThermConductivity * state.dataWaterCoils->WaterCoil(CoilNum).FinThickness)); if (EnterAirHumRatDiff < 0) { // note that this condition indicates dry coil EnterAirHumRatDiff = -EnterAirHumRatDiff; @@ -3204,11 +3103,11 @@ namespace WaterCoils { WetCoilFinEfficncy = 1.0 + FinToTotSurfAreaRatio * (WetFinEfficncy - 1.0); // wet coil outside thermal resistance = [1/UA] (wet coil) CoilToAirThermResistWetSurf = - MoistAirSpecificHeat / (WaterCoil(CoilNum).TotCoilOutsideSurfArea * AirSideWetSurfFilmCoef * WetCoilFinEfficncy); + MoistAirSpecificHeat / (state.dataWaterCoils->WaterCoil(CoilNum).TotCoilOutsideSurfArea * AirSideWetSurfFilmCoef * WetCoilFinEfficncy); //-- and dry fin efficiency DryFinEfficncy = - 0.5 * (WaterCoil(CoilNum).EffectiveFinDiam - WaterCoil(CoilNum).TubeOutsideDiam) * - std::sqrt(2.0 * AirSideDrySurfFilmCoef / (ConvK * WaterCoil(CoilNum).FinThermConductivity * WaterCoil(CoilNum).FinThickness)); + 0.5 * (state.dataWaterCoils->WaterCoil(CoilNum).EffectiveFinDiam - state.dataWaterCoils->WaterCoil(CoilNum).TubeOutsideDiam) * + std::sqrt(2.0 * AirSideDrySurfFilmCoef / (ConvK * state.dataWaterCoils->WaterCoil(CoilNum).FinThermConductivity * state.dataWaterCoils->WaterCoil(CoilNum).FinThickness)); // NOTE: The same caveats on the validity of the FilmCoefReynldsCorrelatnFact equation // hold for the DryFinEfficncy equation. Values of DryFinEfficncy outside the // specified range of validity are not guaranteed to @@ -3224,7 +3123,7 @@ namespace WaterCoils { //- // 1 //); } // CoefPointer - auto const &dry_fin_eff_coef(WaterCoil(CoilNum).DryFinEfficncyCoef); + auto const &dry_fin_eff_coef(state.dataWaterCoils->WaterCoil(CoilNum).DryFinEfficncyCoef); auto DryFinEfficncy_pow(1.0); for (CoefPointer = 1; CoefPointer <= 5; ++CoefPointer) { DryCoilEfficiency += dry_fin_eff_coef(CoefPointer) * DryFinEfficncy_pow; @@ -3232,16 +3131,16 @@ namespace WaterCoils { } // CoefPointer DryCoilEfficiency = 1.0 + FinToTotSurfAreaRatio * (DryCoilEfficiency - 1.0); // dry coil outside thermal resistance = [1/UA] (dry coil) - CoilToAirThermResistDrySurf = 1.0 / (WaterCoil(CoilNum).TotCoilOutsideSurfArea * AirSideDrySurfFilmCoef * DryCoilEfficiency); + CoilToAirThermResistDrySurf = 1.0 / (state.dataWaterCoils->WaterCoil(CoilNum).TotCoilOutsideSurfArea * AirSideDrySurfFilmCoef * DryCoilEfficiency); // definitions made to simplify some of the expressions used below - Cp = GetSpecificHeatGlycol(PlantLoop(WaterCoil(CoilNum).WaterLoopNum).FluidName, + Cp = GetSpecificHeatGlycol(PlantLoop(state.dataWaterCoils->WaterCoil(CoilNum).WaterLoopNum).FluidName, TempWaterIn, - PlantLoop(WaterCoil(CoilNum).WaterLoopNum).FluidIndex, + PlantLoop(state.dataWaterCoils->WaterCoil(CoilNum).WaterLoopNum).FluidIndex, RoutineName); ScaledWaterSpecHeat = WaterMassFlowRate * Cp * ConvK / AirMassFlow; DryCoilCoeff1 = 1.0 / (AirMassFlow * MoistAirSpecificHeat) - 1.0 / (WaterMassFlowRate * Cp * ConvK); // perform initialisations for all wet solution - WetSideEffctvWaterTemp = WaterCoil(CoilNum).MeanWaterTempSaved + (TempWaterIn - WaterCoil(CoilNum).InWaterTempSaved); + WetSideEffctvWaterTemp = state.dataWaterCoils->WaterCoil(CoilNum).MeanWaterTempSaved + (TempWaterIn - state.dataWaterCoils->WaterCoil(CoilNum).InWaterTempSaved); WaterTempConvgLoop = 0; WaterTempConvg = false; // Loop to solve coil as if all wet, converges on MeanWaterTemp eq WetSideEffctvWaterTemp @@ -3250,23 +3149,23 @@ namespace WaterCoils { while (WaterTempConvgLoop < 8 && !WaterTempConvg) { ++WaterTempConvgLoop; ScaledWaterToTubeThermResist = WaterToTubeThermResist / (1.0 + 0.0146 * WetSideEffctvWaterTemp); - ScaledCoilAirThermResistWetSurf = CoilToAirThermResistWetSurf / WaterCoil(CoilNum).SatEnthlCurveSlope; - UACoilAllWet = 1.0 / (WaterCoil(CoilNum).SatEnthlCurveSlope * + ScaledCoilAirThermResistWetSurf = CoilToAirThermResistWetSurf / state.dataWaterCoils->WaterCoil(CoilNum).SatEnthlCurveSlope; + UACoilAllWet = 1.0 / (state.dataWaterCoils->WaterCoil(CoilNum).SatEnthlCurveSlope * (TubeFoulThermResist + ScaledWaterToTubeThermResist + ScaledCoilAirThermResistWetSurf)); // prevents floating point error when taking exponential // of a very large number - expon = UACoilAllWet * (1.0 / AirMassFlow - WaterCoil(CoilNum).SatEnthlCurveSlope / (WaterMassFlowRate * Cp * ConvK)); + expon = UACoilAllWet * (1.0 / AirMassFlow - state.dataWaterCoils->WaterCoil(CoilNum).SatEnthlCurveSlope / (WaterMassFlowRate * Cp * ConvK)); if (expon < 20.0) { // CR7189 changed from ABS(expon) < 20 // negative expon can happen, but lead to tiny WetCoilCoef that aren't a problem WetCoilCoeff = std::exp(expon); // following appears similar to eq. 320 in Eng Ref but neglects K1 term - TempWaterOut = ((1.0 - WetCoilCoeff) * (InletAirEnthalpy - WaterCoil(CoilNum).SatEnthlCurveConstCoef) + - WetCoilCoeff * TempWaterIn * (WaterCoil(CoilNum).SatEnthlCurveSlope - ScaledWaterSpecHeat)) / - (WaterCoil(CoilNum).SatEnthlCurveSlope - WetCoilCoeff * ScaledWaterSpecHeat); + TempWaterOut = ((1.0 - WetCoilCoeff) * (InletAirEnthalpy - state.dataWaterCoils->WaterCoil(CoilNum).SatEnthlCurveConstCoef) + + WetCoilCoeff * TempWaterIn * (state.dataWaterCoils->WaterCoil(CoilNum).SatEnthlCurveSlope - ScaledWaterSpecHeat)) / + (state.dataWaterCoils->WaterCoil(CoilNum).SatEnthlCurveSlope - WetCoilCoeff * ScaledWaterSpecHeat); } else { // following appears to be same as above with equation simplified to use only significant terms when WetCoilCoeff very large - TempWaterOut = ((InletAirEnthalpy - WaterCoil(CoilNum).SatEnthlCurveConstCoef) - - TempWaterIn * (WaterCoil(CoilNum).SatEnthlCurveSlope - ScaledWaterSpecHeat)) / + TempWaterOut = ((InletAirEnthalpy - state.dataWaterCoils->WaterCoil(CoilNum).SatEnthlCurveConstCoef) - + TempWaterIn * (state.dataWaterCoils->WaterCoil(CoilNum).SatEnthlCurveSlope - ScaledWaterSpecHeat)) / ScaledWaterSpecHeat; } // above is inverted form of WaterMassFlowRate*cpw*(TempWaterOut-TempWaterIn) = UA(LMHD) @@ -3277,19 +3176,19 @@ namespace WaterCoils { InsdToOutsdThermResistRatio = (TubeFoulThermResist + ScaledWaterToTubeThermResist) / ScaledCoilAirThermResistWetSurf; InCoilSurfTemp = UACoilAllWet * ScaledCoilAirThermResistWetSurf * - (WaterCoil(CoilNum).SatEnthlCurveSlope * TempWaterIn + - (OutletAirEnthalpy - WaterCoil(CoilNum).SatEnthlCurveConstCoef) * InsdToOutsdThermResistRatio); + (state.dataWaterCoils->WaterCoil(CoilNum).SatEnthlCurveSlope * TempWaterIn + + (OutletAirEnthalpy - state.dataWaterCoils->WaterCoil(CoilNum).SatEnthlCurveConstCoef) * InsdToOutsdThermResistRatio); OutCoilSurfTemp = UACoilAllWet * ScaledCoilAirThermResistWetSurf * - (WaterCoil(CoilNum).SatEnthlCurveSlope * TempWaterOut + - (InletAirEnthalpy - WaterCoil(CoilNum).SatEnthlCurveConstCoef) * InsdToOutsdThermResistRatio); + (state.dataWaterCoils->WaterCoil(CoilNum).SatEnthlCurveSlope * TempWaterOut + + (InletAirEnthalpy - state.dataWaterCoils->WaterCoil(CoilNum).SatEnthlCurveConstCoef) * InsdToOutsdThermResistRatio); if (std::abs(MeanWaterTemp - WetSideEffctvWaterTemp) > 0.01) { WetSideEffctvWaterTemp = MeanWaterTemp; InSurfTempSatAirEnthl = PsyHFnTdbRhPb(InCoilSurfTemp, unity, OutBaroPress, RoutineName) * ConvK; OutSurfTempSatAirEnthl = PsyHFnTdbRhPb(OutCoilSurfTemp, unity, OutBaroPress, RoutineName) * ConvK; - WaterCoil(CoilNum).SatEnthlCurveSlope = (OutSurfTempSatAirEnthl - InSurfTempSatAirEnthl) / (OutCoilSurfTemp - InCoilSurfTemp); - WaterCoil(CoilNum).SatEnthlCurveConstCoef = InSurfTempSatAirEnthl - WaterCoil(CoilNum).SatEnthlCurveSlope * InCoilSurfTemp; + state.dataWaterCoils->WaterCoil(CoilNum).SatEnthlCurveSlope = (OutSurfTempSatAirEnthl - InSurfTempSatAirEnthl) / (OutCoilSurfTemp - InCoilSurfTemp); + state.dataWaterCoils->WaterCoil(CoilNum).SatEnthlCurveConstCoef = InSurfTempSatAirEnthl - state.dataWaterCoils->WaterCoil(CoilNum).SatEnthlCurveSlope * InCoilSurfTemp; } else { WaterTempConvg = true; } @@ -3299,8 +3198,8 @@ namespace WaterCoils { // the dew point coil is apparently all wet but a solution // cannot be obtained if (!WaterTempConvg && !WarmupFlag && (OutCoilSurfTemp < EnterAirDewPoint)) { - ShowRecurringWarningErrorAtEnd(WaterCoil(CoilNum).Name + " not converged (8 iterations) due to \"Wet Convergence\" conditions.", - WaterTempCoolCoilErrs(CoilNum), + ShowRecurringWarningErrorAtEnd(state.dataWaterCoils->WaterCoil(CoilNum).Name + " not converged (8 iterations) due to \"Wet Convergence\" conditions.", + state.dataWaterCoils->WaterTempCoolCoilErrs(CoilNum), std::abs(MeanWaterTemp - WetSideEffctvWaterTemp), std::abs(MeanWaterTemp - WetSideEffctvWaterTemp)); // CoolCoilErrs = CoolCoilErrs + 1 @@ -3308,7 +3207,7 @@ namespace WaterCoils { // CALL ShowWarningError('tp12c0: not converged in 8 CoolCoilErrs') // END IF } - WaterCoil(CoilNum).MeanWaterTempSaved = MeanWaterTemp; + state.dataWaterCoils->WaterCoil(CoilNum).MeanWaterTempSaved = MeanWaterTemp; // now simulate wet dry coil - test outlet condition from all // wet case to give an idea of the expected solution PartWetIterations = 0; @@ -3319,7 +3218,7 @@ namespace WaterCoils { // simulate wet/dry case if (OutCoilSurfTemp < EnterAirDewPoint) { CoilPartWetConvg = true; - WaterCoil(CoilNum).SurfAreaWetFraction = 1.0; + state.dataWaterCoils->WaterCoil(CoilNum).SurfAreaWetFraction = 1.0; TotWaterCoilLoad = AirMassFlow * (InletAirEnthalpy - OutletAirEnthalpy); AirWetDryInterfcTemp = TempAirIn; WetDryInterfcAirEnthl = InletAirEnthalpy; @@ -3328,18 +3227,18 @@ namespace WaterCoils { // initialise with all dry solution } else if (InCoilSurfTemp > EnterAirDewPoint) { SurfAreaWet = 0.0; - WaterCoil(CoilNum).SurfAreaWetFraction = 0.0; + state.dataWaterCoils->WaterCoil(CoilNum).SurfAreaWetFraction = 0.0; WetDryInterfcWaterTemp = TempWaterIn; - TempWaterOut = WaterCoil(CoilNum).OutWaterTempSaved + (TempWaterIn - WaterCoil(CoilNum).InWaterTempSaved); - WetAreaLast = 0.05 * WaterCoil(CoilNum).TotCoilOutsideSurfArea; + TempWaterOut = state.dataWaterCoils->WaterCoil(CoilNum).OutWaterTempSaved + (TempWaterIn - state.dataWaterCoils->WaterCoil(CoilNum).InWaterTempSaved); + WetAreaLast = 0.05 * state.dataWaterCoils->WaterCoil(CoilNum).TotCoilOutsideSurfArea; // General case - must be part-wet/part-dry - initialise // accordingly with some non-zero wet area } else { - if (WaterCoil(CoilNum).SurfAreaWetSaved != 0.0) { - SurfAreaWet = WaterCoil(CoilNum).SurfAreaWetSaved; + if (state.dataWaterCoils->WaterCoil(CoilNum).SurfAreaWetSaved != 0.0) { + SurfAreaWet = state.dataWaterCoils->WaterCoil(CoilNum).SurfAreaWetSaved; } else { SurfAreaWet = - 0.8 * WaterCoil(CoilNum).TotCoilOutsideSurfArea * (EnterAirDewPoint - InCoilSurfTemp) / (OutCoilSurfTemp - InCoilSurfTemp); + 0.8 * state.dataWaterCoils->WaterCoil(CoilNum).TotCoilOutsideSurfArea * (EnterAirDewPoint - InCoilSurfTemp) / (OutCoilSurfTemp - InCoilSurfTemp); } WetDryInterfcWaterTemp = TempWaterIn + EnterAirDewPoint - InCoilSurfTemp; WetAreaLast = 0.0; @@ -3356,8 +3255,8 @@ namespace WaterCoils { DryCoilInThermResist = WaterToTubeThermResist / (1.0 + 0.0146 * DrySideEffectiveWaterTemp); // overall UA, from water to air, of dry portion of coil - UADryCoil = (WaterCoil(CoilNum).TotCoilOutsideSurfArea - SurfAreaWet) / - (WaterCoil(CoilNum).TotCoilOutsideSurfArea * (TubeFoulThermResist + DryCoilInThermResist + CoilToAirThermResistDrySurf)); + UADryCoil = (state.dataWaterCoils->WaterCoil(CoilNum).TotCoilOutsideSurfArea - SurfAreaWet) / + (state.dataWaterCoils->WaterCoil(CoilNum).TotCoilOutsideSurfArea * (TubeFoulThermResist + DryCoilInThermResist + CoilToAirThermResistDrySurf)); // This is a numerical trap for a very small number in the EXP function that is approaching zero if (UADryCoil * DryCoilCoeff1 < -60.0) { @@ -3369,23 +3268,23 @@ namespace WaterCoils { K1 = WaterMassFlowRate * Cp * ConvK * (DryCoilCoeff - 1.0) / (WaterMassFlowRate * Cp * ConvK * DryCoilCoeff - AirMassFlow * MoistAirSpecificHeat); if (SurfAreaWet != 0) { - WaterCoil(CoilNum).SurfAreaWetFraction = SurfAreaWet / WaterCoil(CoilNum).TotCoilOutsideSurfArea; + state.dataWaterCoils->WaterCoil(CoilNum).SurfAreaWetFraction = SurfAreaWet / state.dataWaterCoils->WaterCoil(CoilNum).TotCoilOutsideSurfArea; // effective water temp on wet side of coil WetSideEffctvWaterTemp = 0.5 * (TempWaterIn + WetDryInterfcWaterTemp); // tube inside thermal resistance ScaledWaterToTubeThermResist = WaterToTubeThermResist / (1.0 + 0.0146 * WetSideEffctvWaterTemp); - ScaledCoilAirThermResistWetSurf = CoilToAirThermResistWetSurf / WaterCoil(CoilNum).EnthVsTempCurveAppxSlope; + ScaledCoilAirThermResistWetSurf = CoilToAirThermResistWetSurf / state.dataWaterCoils->WaterCoil(CoilNum).EnthVsTempCurveAppxSlope; // overall UA, from water to air, of wet portion of coil - UACoilAllWet = 1.0 / (WaterCoil(CoilNum).EnthVsTempCurveAppxSlope * + UACoilAllWet = 1.0 / (state.dataWaterCoils->WaterCoil(CoilNum).EnthVsTempCurveAppxSlope * (TubeFoulThermResist + ScaledWaterToTubeThermResist + ScaledCoilAirThermResistWetSurf)); - UACoilPartWet = WaterCoil(CoilNum).SurfAreaWetFraction * UACoilAllWet; - expon = UACoilPartWet * (1.0 / AirMassFlow - WaterCoil(CoilNum).EnthVsTempCurveAppxSlope / (WaterMassFlowRate * Cp * ConvK)); + UACoilPartWet = state.dataWaterCoils->WaterCoil(CoilNum).SurfAreaWetFraction * UACoilAllWet; + expon = UACoilPartWet * (1.0 / AirMassFlow - state.dataWaterCoils->WaterCoil(CoilNum).EnthVsTempCurveAppxSlope / (WaterMassFlowRate * Cp * ConvK)); // prevents floating point error when taking exponential // of a very large number if (expon < 20.0) { WetCoilCoeff = std::exp(expon); // write(outputfiledebug,*) ' wcc=',wetcoilcoeff - denom = (WaterCoil(CoilNum).EnthVsTempCurveAppxSlope - WetCoilCoeff * ScaledWaterSpecHeat - + denom = (state.dataWaterCoils->WaterCoil(CoilNum).EnthVsTempCurveAppxSlope - WetCoilCoeff * ScaledWaterSpecHeat - (1.0 - WetCoilCoeff) * K1 * MoistAirSpecificHeat); // write(outputfiledebug,*) ' denom=',denom // WetDryInterfcWaterTemp = ((1.0 - WetCoilCoeff) * (InletAirEnthalpy - WaterCoil(CoilNum)%EnthVsTempCurveConst - @@ -3396,15 +3295,15 @@ namespace WaterCoils { // ScaledWaterSpecHeat)) / (WaterCoil(CoilNum)%EnthVsTempCurveAppxSlope - & // WetCoilCoeff * ScaledWaterSpecHeat - (1.0 - WetCoilCoeff) * K1 * & // MoistAirSpecificHeat) - WetDryInterfcWaterTemp = ((1.0 - WetCoilCoeff) * (InletAirEnthalpy - WaterCoil(CoilNum).EnthVsTempCurveConst - + WetDryInterfcWaterTemp = ((1.0 - WetCoilCoeff) * (InletAirEnthalpy - state.dataWaterCoils->WaterCoil(CoilNum).EnthVsTempCurveConst - K1 * MoistAirSpecificHeat * TempAirIn) + - WetCoilCoeff * TempWaterIn * (WaterCoil(CoilNum).EnthVsTempCurveAppxSlope - ScaledWaterSpecHeat)) / + WetCoilCoeff * TempWaterIn * (state.dataWaterCoils->WaterCoil(CoilNum).EnthVsTempCurveAppxSlope - ScaledWaterSpecHeat)) / denom; } else { // approximation to equation for WetDryInterfcWaterTemp when WetCoilCoeff-->inf. WetDryInterfcWaterTemp = - (TempWaterIn * (WaterCoil(CoilNum).EnthVsTempCurveAppxSlope - ScaledWaterSpecHeat) - - (InletAirEnthalpy - WaterCoil(CoilNum).EnthVsTempCurveConst - K1 * MoistAirSpecificHeat * TempAirIn)) / + (TempWaterIn * (state.dataWaterCoils->WaterCoil(CoilNum).EnthVsTempCurveAppxSlope - ScaledWaterSpecHeat) - + (InletAirEnthalpy - state.dataWaterCoils->WaterCoil(CoilNum).EnthVsTempCurveConst - K1 * MoistAirSpecificHeat * TempAirIn)) / (K1 * MoistAirSpecificHeat - ScaledWaterSpecHeat); } } @@ -3422,8 +3321,8 @@ namespace WaterCoils { InsdToOutsdThermResistRatio = (TubeFoulThermResist + ScaledWaterToTubeThermResist) / ScaledCoilAirThermResistWetSurf; // coil surface temperature at water inlet (air outlet) InCoilSurfTemp = UACoilAllWet * ScaledCoilAirThermResistWetSurf * - (WaterCoil(CoilNum).EnthVsTempCurveAppxSlope * TempWaterIn + - (OutletAirEnthalpy - WaterCoil(CoilNum).EnthVsTempCurveConst) * InsdToOutsdThermResistRatio); + (state.dataWaterCoils->WaterCoil(CoilNum).EnthVsTempCurveAppxSlope * TempWaterIn + + (OutletAirEnthalpy - state.dataWaterCoils->WaterCoil(CoilNum).EnthVsTempCurveConst) * InsdToOutsdThermResistRatio); WetDryInterSurfTempErrorLast = WetDryInterSurfTempError; // in part-wet/part-dry solution EnterAirDewPoint=WetDryInterfcSurfTemp drives WetDryInterSurfTempError->0 WetDryInterSurfTempError = EnterAirDewPoint - WetDryInterfcSurfTemp; @@ -3448,65 +3347,65 @@ namespace WaterCoils { CoilPartWetConvg = true; } } else if (std::abs(WetDryInterSurfTempError) > 0.00002 || - std::abs(SurfAreaWet - WetAreaLast) / WaterCoil(CoilNum).TotCoilOutsideSurfArea > 0.00001) { + std::abs(SurfAreaWet - WetAreaLast) / state.dataWaterCoils->WaterCoil(CoilNum).TotCoilOutsideSurfArea > 0.00001) { if (WetAreaLast == 0) { WetAreaLast = SurfAreaWet; SurfAreaWet += - 0.4 * WaterCoil(CoilNum).TotCoilOutsideSurfArea * WetDryInterSurfTempError / (OutCoilSurfTemp - InCoilSurfTemp); + 0.4 * state.dataWaterCoils->WaterCoil(CoilNum).TotCoilOutsideSurfArea * WetDryInterSurfTempError / (OutCoilSurfTemp - InCoilSurfTemp); } else if (WetDryInterSurfTempError != WetDryInterSurfTempErrorLast) { WetAreaChange = SurfAreaWet - WetAreaLast; WetAreaLast = SurfAreaWet; SurfAreaWet -= 0.8 * WetDryInterSurfTempError * WetAreaChange / (WetDryInterSurfTempError - WetDryInterSurfTempErrorLast); } - if (SurfAreaWet >= WaterCoil(CoilNum).TotCoilOutsideSurfArea) { - SurfAreaWet = WaterCoil(CoilNum).TotCoilOutsideSurfArea; + if (SurfAreaWet >= state.dataWaterCoils->WaterCoil(CoilNum).TotCoilOutsideSurfArea) { + SurfAreaWet = state.dataWaterCoils->WaterCoil(CoilNum).TotCoilOutsideSurfArea; MeanWaterTemp = 0.5 * (TempWaterIn + WetDryInterfcWaterTemp); - if (WetAreaLast == WaterCoil(CoilNum).TotCoilOutsideSurfArea && std::abs(MeanWaterTemp - WetSideEffctvWaterTemp) <= 0.00002) { + if (WetAreaLast == state.dataWaterCoils->WaterCoil(CoilNum).TotCoilOutsideSurfArea && std::abs(MeanWaterTemp - WetSideEffctvWaterTemp) <= 0.00002) { CoilPartWetConvg = true; } } if (SurfAreaWet <= 0) { SurfAreaWet = 0.0; - WaterCoil(CoilNum).SurfAreaWetFraction = 0.0; + state.dataWaterCoils->WaterCoil(CoilNum).SurfAreaWetFraction = 0.0; WetDryInterfcWaterTemp = TempWaterIn; } InSurfTempSatAirEnthl = PsyHFnTdbRhPb(InCoilSurfTemp, unity, OutBaroPress, RoutineName) * ConvK; if ((EnterAirDewPoint - InCoilSurfTemp) >= 0.0001) { AirEnthAtWetDryIntrfcSurfTemp = PsyHFnTdbRhPb(EnterAirDewPoint, unity, OutBaroPress, RoutineName) * ConvK; - WaterCoil(CoilNum).EnthVsTempCurveAppxSlope = + state.dataWaterCoils->WaterCoil(CoilNum).EnthVsTempCurveAppxSlope = (AirEnthAtWetDryIntrfcSurfTemp - InSurfTempSatAirEnthl) / (EnterAirDewPoint - InCoilSurfTemp); } else { AirEnthAtWetDryIntrfcSurfTemp = PsyHFnTdbRhPb(InCoilSurfTemp + 0.0001, unity, OutBaroPress, RoutineName) * ConvK; - WaterCoil(CoilNum).EnthVsTempCurveAppxSlope = (AirEnthAtWetDryIntrfcSurfTemp - InSurfTempSatAirEnthl) / 0.0001; + state.dataWaterCoils->WaterCoil(CoilNum).EnthVsTempCurveAppxSlope = (AirEnthAtWetDryIntrfcSurfTemp - InSurfTempSatAirEnthl) / 0.0001; } - WaterCoil(CoilNum).EnthVsTempCurveConst = InSurfTempSatAirEnthl - WaterCoil(CoilNum).EnthVsTempCurveAppxSlope * InCoilSurfTemp; + state.dataWaterCoils->WaterCoil(CoilNum).EnthVsTempCurveConst = InSurfTempSatAirEnthl - state.dataWaterCoils->WaterCoil(CoilNum).EnthVsTempCurveAppxSlope * InCoilSurfTemp; } else { CoilPartWetConvg = true; } } // error checking to see if convergence has been achieved if (!CoilPartWetConvg && !WarmupFlag) { - ShowRecurringWarningErrorAtEnd(WaterCoil(CoilNum).Name + + ShowRecurringWarningErrorAtEnd(state.dataWaterCoils->WaterCoil(CoilNum).Name + " not converged (40 iterations) due to \"Partial Wet Convergence\" conditions.", - PartWetCoolCoilErrs(CoilNum)); + state.dataWaterCoils->PartWetCoolCoilErrs(CoilNum)); // CoolCoilErrs = CoolCoilErrs + 1 // IF (CoolCoilErrs .LE. MaxCoolCoilErrs) THEN // CALL ShowWarningError('tp12c0: not converged in 20 CoolCoilErrs') // END IF } - if (WaterCoil(CoilNum).SurfAreaWetFraction > 0 && WaterCoil(CoilNum).SurfAreaWetFraction < 1) { - WaterCoil(CoilNum).SurfAreaWetSaved = SurfAreaWet; + if (state.dataWaterCoils->WaterCoil(CoilNum).SurfAreaWetFraction > 0 && state.dataWaterCoils->WaterCoil(CoilNum).SurfAreaWetFraction < 1) { + state.dataWaterCoils->WaterCoil(CoilNum).SurfAreaWetSaved = SurfAreaWet; } // calculate TempAirOut, OutletAirHumRat, and SensCoolRate based on equations from // TYPE12 and the ASHRAE toolkit - if (WaterCoil(CoilNum).SurfAreaWetFraction == 0) { + if (state.dataWaterCoils->WaterCoil(CoilNum).SurfAreaWetFraction == 0) { // dry coil TempAirOut = TempAirIn - TotWaterCoilLoad / (AirMassFlow * MoistAirSpecificHeat); OutletAirHumRat = InletAirHumRat; SenWaterCoilLoad = TotWaterCoilLoad; } else { // coil effectiveness - expon = WaterCoil(CoilNum).SurfAreaWetFraction / (CoilToAirThermResistWetSurf * AirMassFlow); + expon = state.dataWaterCoils->WaterCoil(CoilNum).SurfAreaWetFraction / (CoilToAirThermResistWetSurf * AirMassFlow); y = 0.0; if (expon < 20.0) y = std::exp(-expon); AirExitEnthlAtCoilSurfTemp = WetDryInterfcAirEnthl - (WetDryInterfcAirEnthl - OutletAirEnthalpy) / (1.0 - y); @@ -3524,44 +3423,44 @@ namespace WaterCoils { } // Set the outlet conditions - WaterCoil(CoilNum).TotWaterCoolingCoilRate = TotWaterCoilLoad * 1000.0; - WaterCoil(CoilNum).SenWaterCoolingCoilRate = SenWaterCoilLoad * 1000.0; - WaterCoil(CoilNum).OutletAirTemp = TempAirOut; - WaterCoil(CoilNum).OutletWaterTemp = TempWaterOut; - WaterCoil(CoilNum).OutletAirEnthalpy = OutletAirEnthalpy * 1000.0; - WaterCoil(CoilNum).OutletAirHumRat = OutletAirHumRat; + state.dataWaterCoils->WaterCoil(CoilNum).TotWaterCoolingCoilRate = TotWaterCoilLoad * 1000.0; + state.dataWaterCoils->WaterCoil(CoilNum).SenWaterCoolingCoilRate = SenWaterCoilLoad * 1000.0; + state.dataWaterCoils->WaterCoil(CoilNum).OutletAirTemp = TempAirOut; + state.dataWaterCoils->WaterCoil(CoilNum).OutletWaterTemp = TempWaterOut; + state.dataWaterCoils->WaterCoil(CoilNum).OutletAirEnthalpy = OutletAirEnthalpy * 1000.0; + state.dataWaterCoils->WaterCoil(CoilNum).OutletAirHumRat = OutletAirHumRat; // The CoolingCoilLoad is the change in the enthalpy of the water - WaterCoil(CoilNum).OutletWaterEnthalpy = - WaterCoil(CoilNum).InletWaterEnthalpy + WaterCoil(CoilNum).TotWaterCoolingCoilRate / WaterCoil(CoilNum).InletWaterMassFlowRate; + state.dataWaterCoils->WaterCoil(CoilNum).OutletWaterEnthalpy = + state.dataWaterCoils->WaterCoil(CoilNum).InletWaterEnthalpy + state.dataWaterCoils->WaterCoil(CoilNum).TotWaterCoolingCoilRate / state.dataWaterCoils->WaterCoil(CoilNum).InletWaterMassFlowRate; // This WaterCoil does not change the Mass Flow across the component - WaterCoil(CoilNum).OutletAirMassFlowRate = WaterCoil(CoilNum).InletAirMassFlowRate; - WaterCoil(CoilNum).OutletWaterMassFlowRate = WaterCoil(CoilNum).InletWaterMassFlowRate; + state.dataWaterCoils->WaterCoil(CoilNum).OutletAirMassFlowRate = state.dataWaterCoils->WaterCoil(CoilNum).InletAirMassFlowRate; + state.dataWaterCoils->WaterCoil(CoilNum).OutletWaterMassFlowRate = state.dataWaterCoils->WaterCoil(CoilNum).InletWaterMassFlowRate; } else { // If Coil is scheduled OFF then Outlet conditions are set to Inlet Conditions - WaterCoil(CoilNum).TotWaterCoolingCoilRate = 0.0; - WaterCoil(CoilNum).SenWaterCoolingCoilRate = 0.0; + state.dataWaterCoils->WaterCoil(CoilNum).TotWaterCoolingCoilRate = 0.0; + state.dataWaterCoils->WaterCoil(CoilNum).SenWaterCoolingCoilRate = 0.0; TempAirOut = TempAirIn; TempWaterOut = TempWaterIn; // set the outlet conditions to the coil derived type - WaterCoil(CoilNum).OutletAirTemp = TempAirOut; - WaterCoil(CoilNum).OutletWaterTemp = TempWaterOut; - WaterCoil(CoilNum).OutletAirEnthalpy = WaterCoil(CoilNum).InletAirEnthalpy; - WaterCoil(CoilNum).OutletAirHumRat = WaterCoil(CoilNum).InletAirHumRat; + state.dataWaterCoils->WaterCoil(CoilNum).OutletAirTemp = TempAirOut; + state.dataWaterCoils->WaterCoil(CoilNum).OutletWaterTemp = TempWaterOut; + state.dataWaterCoils->WaterCoil(CoilNum).OutletAirEnthalpy = state.dataWaterCoils->WaterCoil(CoilNum).InletAirEnthalpy; + state.dataWaterCoils->WaterCoil(CoilNum).OutletAirHumRat = state.dataWaterCoils->WaterCoil(CoilNum).InletAirHumRat; // The CoolingCoilLoad is the change in the enthalpy of the water - WaterCoil(CoilNum).OutletWaterEnthalpy = WaterCoil(CoilNum).InletWaterEnthalpy; + state.dataWaterCoils->WaterCoil(CoilNum).OutletWaterEnthalpy = state.dataWaterCoils->WaterCoil(CoilNum).InletWaterEnthalpy; // This WaterCoil does not change the Mass Flow across the component - WaterCoil(CoilNum).OutletAirMassFlowRate = WaterCoil(CoilNum).InletAirMassFlowRate; - WaterCoil(CoilNum).OutletWaterMassFlowRate = 0.0; + state.dataWaterCoils->WaterCoil(CoilNum).OutletAirMassFlowRate = state.dataWaterCoils->WaterCoil(CoilNum).InletAirMassFlowRate; + state.dataWaterCoils->WaterCoil(CoilNum).OutletWaterMassFlowRate = 0.0; } // Save some of the Values for next Time step - WaterCoil(CoilNum).InWaterTempSaved = TempWaterIn; - WaterCoil(CoilNum).OutWaterTempSaved = TempWaterOut; + state.dataWaterCoils->WaterCoil(CoilNum).InWaterTempSaved = TempWaterIn; + state.dataWaterCoils->WaterCoil(CoilNum).OutWaterTempSaved = TempWaterOut; } - void CoolingCoil(int const CoilNum, + void CoolingCoil(EnergyPlusData &state, int const CoilNum, bool const FirstHVACIteration, int const CalcMode, int const FanOpMode, // fan operating mode @@ -3631,31 +3530,31 @@ namespace WaterCoils { SurfAreaWetFraction = 0.0; // Fraction of surface area wet if (FanOpMode == CycFanCycCoil && PartLoadRatio > 0.0) { // FB Start - AirMassFlowRate = WaterCoil(CoilNum).InletAirMassFlowRate / PartLoadRatio; + AirMassFlowRate = state.dataWaterCoils->WaterCoil(CoilNum).InletAirMassFlowRate / PartLoadRatio; } else { - AirMassFlowRate = WaterCoil(CoilNum).InletAirMassFlowRate; + AirMassFlowRate = state.dataWaterCoils->WaterCoil(CoilNum).InletAirMassFlowRate; } // If Coil is Scheduled ON then do the simulation - if (((GetCurrentScheduleValue(WaterCoil(CoilNum).SchedPtr) > 0.0) && (WaterCoil(CoilNum).InletWaterMassFlowRate > 0.0) && - (AirMassFlowRate >= MinAirMassFlow) && (WaterCoil(CoilNum).DesAirVolFlowRate > 0.0) && - (WaterCoil(CoilNum).MaxWaterMassFlowRate > 0.0)) || - (CalcMode == DesignCalc)) { + if (((GetCurrentScheduleValue(state.dataWaterCoils->WaterCoil(CoilNum).SchedPtr) > 0.0) && (state.dataWaterCoils->WaterCoil(CoilNum).InletWaterMassFlowRate > 0.0) && + (AirMassFlowRate >= state.dataWaterCoils->MinAirMassFlow) && (state.dataWaterCoils->WaterCoil(CoilNum).DesAirVolFlowRate > 0.0) && + (state.dataWaterCoils->WaterCoil(CoilNum).MaxWaterMassFlowRate > 0.0)) || + (CalcMode == state.dataWaterCoils->DesignCalc)) { // Calculate Temperature Dew Point at operating conditions. - AirDewPointTemp = PsyTdpFnWPb(WaterCoil(CoilNum).InletAirHumRat, OutBaroPress); + AirDewPointTemp = PsyTdpFnWPb(state.dataWaterCoils->WaterCoil(CoilNum).InletAirHumRat, OutBaroPress); { - auto const SELECT_CASE_var(WaterCoil(CoilNum).CoolingCoilAnalysisMode); - if (SELECT_CASE_var == DetailedAnalysis) { + auto const SELECT_CASE_var(state.dataWaterCoils->WaterCoil(CoilNum).CoolingCoilAnalysisMode); + if (SELECT_CASE_var == state.dataWaterCoils->DetailedAnalysis) { // Coil is completely dry if AirDewPointTemp is less than InletWaterTemp,hence Call CoilCompletelyDry - if (AirDewPointTemp <= WaterCoil(CoilNum).InletWaterTemp) { + if (AirDewPointTemp <= state.dataWaterCoils->WaterCoil(CoilNum).InletWaterTemp) { // Calculate the leaving conditions and performance of dry coil - CoilCompletelyDry(CoilNum, - WaterCoil(CoilNum).InletWaterTemp, - WaterCoil(CoilNum).InletAirTemp, - WaterCoil(CoilNum).UACoilTotal, + CoilCompletelyDry(state, CoilNum, + state.dataWaterCoils->WaterCoil(CoilNum).InletWaterTemp, + state.dataWaterCoils->WaterCoil(CoilNum).InletAirTemp, + state.dataWaterCoils->WaterCoil(CoilNum).UACoilTotal, OutletWaterTemp, OutletAirTemp, OutletAirHumRat, @@ -3670,12 +3569,12 @@ namespace WaterCoils { // Else If AirDewPointTemp is greater than InletWaterTemp then assume the // external surface of coil is completely wet,hence Call CoilCompletelyWet // Calculate the leaving conditions and performance of wet coil - CoilCompletelyWet(CoilNum, - WaterCoil(CoilNum).InletWaterTemp, - WaterCoil(CoilNum).InletAirTemp, - WaterCoil(CoilNum).InletAirHumRat, - WaterCoil(CoilNum).UACoilInternal, - WaterCoil(CoilNum).UACoilExternal, + CoilCompletelyWet(state, CoilNum, + state.dataWaterCoils->WaterCoil(CoilNum).InletWaterTemp, + state.dataWaterCoils->WaterCoil(CoilNum).InletAirTemp, + state.dataWaterCoils->WaterCoil(CoilNum).InletAirHumRat, + state.dataWaterCoils->WaterCoil(CoilNum).UACoilInternal, + state.dataWaterCoils->WaterCoil(CoilNum).UACoilExternal, OutletWaterTemp, OutletAirTemp, OutletAirHumRat, @@ -3691,10 +3590,10 @@ namespace WaterCoils { // Then coil is partially wet and dry hence call CoilPartWetPartDry // Calculate the leaving conditions and performance of dry coil - CoilPartWetPartDry(CoilNum, + CoilPartWetPartDry(state, CoilNum, FirstHVACIteration, - WaterCoil(CoilNum).InletWaterTemp, - WaterCoil(CoilNum).InletAirTemp, + state.dataWaterCoils->WaterCoil(CoilNum).InletWaterTemp, + state.dataWaterCoils->WaterCoil(CoilNum).InletAirTemp, AirDewPointTemp, OutletWaterTemp, OutletAirTemp, @@ -3708,15 +3607,15 @@ namespace WaterCoils { } // End if for part wet part dry coil } // End if for dry coil - } else if (SELECT_CASE_var == SimpleAnalysis) { + } else if (SELECT_CASE_var == state.dataWaterCoils->SimpleAnalysis) { // Coil is completely dry if AirDewPointTemp is less than InletWaterTemp,hence Call CoilCompletelyDry - if (AirDewPointTemp <= WaterCoil(CoilNum).InletWaterTemp) { + if (AirDewPointTemp <= state.dataWaterCoils->WaterCoil(CoilNum).InletWaterTemp) { // Calculate the leaving conditions and performance of dry coil - CoilCompletelyDry(CoilNum, - WaterCoil(CoilNum).InletWaterTemp, - WaterCoil(CoilNum).InletAirTemp, - WaterCoil(CoilNum).UACoilTotal, + CoilCompletelyDry(state, CoilNum, + state.dataWaterCoils->WaterCoil(CoilNum).InletWaterTemp, + state.dataWaterCoils->WaterCoil(CoilNum).InletAirTemp, + state.dataWaterCoils->WaterCoil(CoilNum).UACoilTotal, OutletWaterTemp, OutletAirTemp, OutletAirHumRat, @@ -3731,12 +3630,12 @@ namespace WaterCoils { // Else If AirDewPointTemp is greater than InletWaterTemp then assume the // external surface of coil is completely wet,hence Call CoilCompletelyWet // Calculate the leaving conditions and performance of wet coil - CoilCompletelyWet(CoilNum, - WaterCoil(CoilNum).InletWaterTemp, - WaterCoil(CoilNum).InletAirTemp, - WaterCoil(CoilNum).InletAirHumRat, - WaterCoil(CoilNum).UACoilInternal, - WaterCoil(CoilNum).UACoilExternal, + CoilCompletelyWet(state, CoilNum, + state.dataWaterCoils->WaterCoil(CoilNum).InletWaterTemp, + state.dataWaterCoils->WaterCoil(CoilNum).InletAirTemp, + state.dataWaterCoils->WaterCoil(CoilNum).InletAirHumRat, + state.dataWaterCoils->WaterCoil(CoilNum).UACoilInternal, + state.dataWaterCoils->WaterCoil(CoilNum).UACoilExternal, OutletWaterTemp, OutletAirTemp, OutletAirHumRat, @@ -3752,9 +3651,9 @@ namespace WaterCoils { } // Report outlet variables at nodes - WaterCoil(CoilNum).OutletAirTemp = OutletAirTemp; - WaterCoil(CoilNum).OutletAirHumRat = OutletAirHumRat; - WaterCoil(CoilNum).OutletWaterTemp = OutletWaterTemp; + state.dataWaterCoils->WaterCoil(CoilNum).OutletAirTemp = OutletAirTemp; + state.dataWaterCoils->WaterCoil(CoilNum).OutletAirHumRat = OutletAirHumRat; + state.dataWaterCoils->WaterCoil(CoilNum).OutletWaterTemp = OutletWaterTemp; // Report output results if the coil was operating if (FanOpMode == CycFanCycCoil) { @@ -3762,35 +3661,35 @@ namespace WaterCoils { SenWaterCoilLoad *= PartLoadRatio; } - WaterCoil(CoilNum).TotWaterCoolingCoilRate = TotWaterCoilLoad; - WaterCoil(CoilNum).SenWaterCoolingCoilRate = SenWaterCoilLoad; - WaterCoil(CoilNum).SurfAreaWetFraction = SurfAreaWetFraction; + state.dataWaterCoils->WaterCoil(CoilNum).TotWaterCoolingCoilRate = TotWaterCoilLoad; + state.dataWaterCoils->WaterCoil(CoilNum).SenWaterCoolingCoilRate = SenWaterCoilLoad; + state.dataWaterCoils->WaterCoil(CoilNum).SurfAreaWetFraction = SurfAreaWetFraction; // WaterCoil(CoilNum)%OutletWaterEnthalpy = WaterCoil(CoilNum)%InletWaterEnthalpy+ & // WaterCoil(CoilNum)%TotWaterCoolingCoilRate/WaterCoil(CoilNum)%InletWaterMassFlowRate - WaterCoil(CoilNum).OutletWaterEnthalpy = WaterCoil(CoilNum).InletWaterEnthalpy + SafeDivide(WaterCoil(CoilNum).TotWaterCoolingCoilRate, - WaterCoil(CoilNum).InletWaterMassFlowRate); + state.dataWaterCoils->WaterCoil(CoilNum).OutletWaterEnthalpy = state.dataWaterCoils->WaterCoil(CoilNum).InletWaterEnthalpy + SafeDivide(state.dataWaterCoils->WaterCoil(CoilNum).TotWaterCoolingCoilRate, + state.dataWaterCoils->WaterCoil(CoilNum).InletWaterMassFlowRate); } else { // If both mass flow rates are zero, set outputs to inputs and return - WaterCoil(CoilNum).OutletWaterTemp = WaterCoil(CoilNum).InletWaterTemp; - WaterCoil(CoilNum).OutletAirTemp = WaterCoil(CoilNum).InletAirTemp; - WaterCoil(CoilNum).OutletAirHumRat = WaterCoil(CoilNum).InletAirHumRat; - WaterCoil(CoilNum).OutletWaterEnthalpy = WaterCoil(CoilNum).InletWaterEnthalpy; - WaterCoil(CoilNum).TotWaterCoolingCoilEnergy = 0.0; - WaterCoil(CoilNum).SenWaterCoolingCoilEnergy = 0.0; - WaterCoil(CoilNum).SurfAreaWetFraction = 0.0; + state.dataWaterCoils->WaterCoil(CoilNum).OutletWaterTemp = state.dataWaterCoils->WaterCoil(CoilNum).InletWaterTemp; + state.dataWaterCoils->WaterCoil(CoilNum).OutletAirTemp = state.dataWaterCoils->WaterCoil(CoilNum).InletAirTemp; + state.dataWaterCoils->WaterCoil(CoilNum).OutletAirHumRat = state.dataWaterCoils->WaterCoil(CoilNum).InletAirHumRat; + state.dataWaterCoils->WaterCoil(CoilNum).OutletWaterEnthalpy = state.dataWaterCoils->WaterCoil(CoilNum).InletWaterEnthalpy; + state.dataWaterCoils->WaterCoil(CoilNum).TotWaterCoolingCoilEnergy = 0.0; + state.dataWaterCoils->WaterCoil(CoilNum).SenWaterCoolingCoilEnergy = 0.0; + state.dataWaterCoils->WaterCoil(CoilNum).SurfAreaWetFraction = 0.0; } // End of the Flow or No flow If block - WaterCoil(CoilNum).OutletWaterMassFlowRate = WaterCoil(CoilNum).InletWaterMassFlowRate; - WaterCoil(CoilNum).OutletAirMassFlowRate = WaterCoil(CoilNum).InletAirMassFlowRate; - WaterCoil(CoilNum).OutletAirEnthalpy = PsyHFnTdbW(WaterCoil(CoilNum).OutletAirTemp, WaterCoil(CoilNum).OutletAirHumRat); + state.dataWaterCoils->WaterCoil(CoilNum).OutletWaterMassFlowRate = state.dataWaterCoils->WaterCoil(CoilNum).InletWaterMassFlowRate; + state.dataWaterCoils->WaterCoil(CoilNum).OutletAirMassFlowRate = state.dataWaterCoils->WaterCoil(CoilNum).InletAirMassFlowRate; + state.dataWaterCoils->WaterCoil(CoilNum).OutletAirEnthalpy = PsyHFnTdbW(state.dataWaterCoils->WaterCoil(CoilNum).OutletAirTemp, state.dataWaterCoils->WaterCoil(CoilNum).OutletAirHumRat); } // End Algorithm Section of the Module // Coil Completely Dry Subroutine for Cooling Coil - void CoilCompletelyDry(int const CoilNum, + void CoilCompletelyDry(EnergyPlusData &state, int const CoilNum, Real64 const WaterTempIn, // Entering water temperature Real64 const AirTempIn, // Entering air dry bulb temperature Real64 const CoilUA, // Overall heat transfer coefficient @@ -3848,38 +3747,38 @@ namespace WaterCoils { // adjust mass flow rates for cycling fan cycling coil operation if (FanOpMode == CycFanCycCoil) { if (PartLoadRatio > 0.0) { - AirMassFlow = WaterCoil(CoilNum).InletAirMassFlowRate / PartLoadRatio; - WaterMassFlowRate = min(WaterCoil(CoilNum).InletWaterMassFlowRate / PartLoadRatio, WaterCoil(CoilNum).MaxWaterMassFlowRate); + AirMassFlow = state.dataWaterCoils->WaterCoil(CoilNum).InletAirMassFlowRate / PartLoadRatio; + WaterMassFlowRate = min(state.dataWaterCoils->WaterCoil(CoilNum).InletWaterMassFlowRate / PartLoadRatio, state.dataWaterCoils->WaterCoil(CoilNum).MaxWaterMassFlowRate); } else { AirMassFlow = 0.0; WaterMassFlowRate = 0.0; } } else { - AirMassFlow = WaterCoil(CoilNum).InletAirMassFlowRate; - WaterMassFlowRate = WaterCoil(CoilNum).InletWaterMassFlowRate; + AirMassFlow = state.dataWaterCoils->WaterCoil(CoilNum).InletAirMassFlowRate; + WaterMassFlowRate = state.dataWaterCoils->WaterCoil(CoilNum).InletWaterMassFlowRate; } // Calculate air and water capacity rates - CapacitanceAir = AirMassFlow * PsyCpAirFnW(WaterCoil(CoilNum).InletAirHumRat); + CapacitanceAir = AirMassFlow * PsyCpAirFnW(state.dataWaterCoils->WaterCoil(CoilNum).InletAirHumRat); // Water Capacity Rate Cp = GetSpecificHeatGlycol( - PlantLoop(WaterCoil(CoilNum).WaterLoopNum).FluidName, WaterTempIn, PlantLoop(WaterCoil(CoilNum).WaterLoopNum).FluidIndex, RoutineName); + PlantLoop(state.dataWaterCoils->WaterCoil(CoilNum).WaterLoopNum).FluidName, WaterTempIn, PlantLoop(state.dataWaterCoils->WaterCoil(CoilNum).WaterLoopNum).FluidIndex, RoutineName); CapacitanceWater = WaterMassFlowRate * Cp; // Determine the air and water outlet conditions - CoilOutletStreamCondition(CoilNum, CapacitanceWater, WaterTempIn, CapacitanceAir, AirTempIn, CoilUA, OutletWaterTemp, OutletAirTemp); + CoilOutletStreamCondition(state, CoilNum, CapacitanceWater, WaterTempIn, CapacitanceAir, AirTempIn, CoilUA, OutletWaterTemp, OutletAirTemp); // Calculate the total and sensible heat transfer rate both are equal in case of Dry Coil Q = CapacitanceAir * (AirTempIn - OutletAirTemp); // Outlet humidity is equal to Inlet Humidity because its a dry coil - OutletAirHumRat = WaterCoil(CoilNum).InletAirHumRat; + OutletAirHumRat = state.dataWaterCoils->WaterCoil(CoilNum).InletAirHumRat; } // Coil Completely Wet Subroutine for Cooling Coil - void CoilCompletelyWet(int const CoilNum, // Number of Coil + void CoilCompletelyWet(EnergyPlusData &state, int const CoilNum, // Number of Coil Real64 const WaterTempIn, // Water temperature IN to this function (C) Real64 const AirTempIn, // Air dry bulb temperature IN to this function(C) Real64 const AirHumRat, // Air Humidity Ratio IN to this funcation (C) @@ -3973,15 +3872,15 @@ namespace WaterCoils { // adjust mass flow rates for cycling fan cycling coil operation if (FanOpMode == CycFanCycCoil) { if (PartLoadRatio > 0.0) { - AirMassFlow = WaterCoil(CoilNum).InletAirMassFlowRate / PartLoadRatio; - WaterMassFlowRate = min(WaterCoil(CoilNum).InletWaterMassFlowRate / PartLoadRatio, WaterCoil(CoilNum).MaxWaterMassFlowRate); + AirMassFlow = state.dataWaterCoils->WaterCoil(CoilNum).InletAirMassFlowRate / PartLoadRatio; + WaterMassFlowRate = min(state.dataWaterCoils->WaterCoil(CoilNum).InletWaterMassFlowRate / PartLoadRatio, state.dataWaterCoils->WaterCoil(CoilNum).MaxWaterMassFlowRate); } else { AirMassFlow = 0.0; WaterMassFlowRate = 0.0; } } else { - AirMassFlow = WaterCoil(CoilNum).InletAirMassFlowRate; - WaterMassFlowRate = WaterCoil(CoilNum).InletWaterMassFlowRate; + AirMassFlow = state.dataWaterCoils->WaterCoil(CoilNum).InletAirMassFlowRate; + WaterMassFlowRate = state.dataWaterCoils->WaterCoil(CoilNum).InletWaterMassFlowRate; } // Calculate enthalpies of entering air and water @@ -4004,9 +3903,9 @@ namespace WaterCoils { UACoilTotalEnth = 1.0 / (IntermediateCpSat * WaterSideResist + AirSideResist * PsyCpAirFnW(0.0)); CapacityRateAirWet = AirMassFlow; Cp = GetSpecificHeatGlycol( - PlantLoop(WaterCoil(CoilNum).WaterLoopNum).FluidName, WaterTempIn, PlantLoop(WaterCoil(CoilNum).WaterLoopNum).FluidIndex, RoutineName); + PlantLoop(state.dataWaterCoils->WaterCoil(CoilNum).WaterLoopNum).FluidName, WaterTempIn, PlantLoop(state.dataWaterCoils->WaterCoil(CoilNum).WaterLoopNum).FluidIndex, RoutineName); CapacityRateWaterWet = WaterMassFlowRate * (Cp / IntermediateCpSat); - CoilOutletStreamCondition(CoilNum, + CoilOutletStreamCondition(state, CoilNum, CapacityRateAirWet, EnthAirInlet, CapacityRateWaterWet, @@ -4029,12 +3928,12 @@ namespace WaterCoils { OutletWaterTemp = WaterTempIn + TotWaterCoilLoad / max(WaterMassFlowRate, SmallNo) / Cp; // Calculates out put variable for the completely wet coil - WetCoilOutletCondition(CoilNum, AirTempIn, EnthAirInlet, EnthAirOutlet, UAExternalTotal, OutletAirTemp, OutletAirHumRat, SenWaterCoilLoad); + WetCoilOutletCondition(state, CoilNum, AirTempIn, EnthAirInlet, EnthAirOutlet, UAExternalTotal, OutletAirTemp, OutletAirHumRat, SenWaterCoilLoad); } // Coil Part Wet Part Dry Subroutine for Cooling Coil - void CoilPartWetPartDry(int const CoilNum, // Number of Coil + void CoilPartWetPartDry(EnergyPlusData &state, int const CoilNum, // Number of Coil bool const FirstHVACIteration, // Saving Old values Real64 const InletWaterTemp, // Entering liquid temperature(C) Real64 const InletAirTemp, // Entering air dry bulb temperature(C) @@ -4143,7 +4042,7 @@ namespace WaterCoils { } } else { - SurfAreaWetFraction = WaterCoil(CoilNum).SurfAreaWetFractionSaved; + SurfAreaWetFraction = state.dataWaterCoils->WaterCoil(CoilNum).SurfAreaWetFractionSaved; } // BEGIN LOOP to converge on SurfAreaWetFraction // The method employed in this loop is as follows: The coil is partially wet and partially dry, @@ -4167,15 +4066,15 @@ namespace WaterCoils { for (iter = 1; iter <= itmax; ++iter) { // Calculating Surface Area Wet and Surface Area Dry - SurfAreaWet = SurfAreaWetFraction * WaterCoil(CoilNum).TotCoilOutsideSurfArea; - SurfAreaDry = WaterCoil(CoilNum).TotCoilOutsideSurfArea - SurfAreaWet; + SurfAreaWet = SurfAreaWetFraction * state.dataWaterCoils->WaterCoil(CoilNum).TotCoilOutsideSurfArea; + SurfAreaDry = state.dataWaterCoils->WaterCoil(CoilNum).TotCoilOutsideSurfArea - SurfAreaWet; // Calculating UA values for the Dry Part of the Coil - DryCoilUA = SurfAreaDry / (1.0 / WaterCoil(CoilNum).UACoilInternalPerUnitArea + 1.0 / WaterCoil(CoilNum).UADryExtPerUnitArea); + DryCoilUA = SurfAreaDry / (1.0 / state.dataWaterCoils->WaterCoil(CoilNum).UACoilInternalPerUnitArea + 1.0 / state.dataWaterCoils->WaterCoil(CoilNum).UADryExtPerUnitArea); // Calculating UA Value for the Wet part of the Coil - WetPartUAExternal = WaterCoil(CoilNum).UAWetExtPerUnitArea * SurfAreaWet; - WetPartUAInternal = WaterCoil(CoilNum).UACoilInternalPerUnitArea * SurfAreaWet; + WetPartUAExternal = state.dataWaterCoils->WaterCoil(CoilNum).UAWetExtPerUnitArea * SurfAreaWet; + WetPartUAInternal = state.dataWaterCoils->WaterCoil(CoilNum).UACoilInternalPerUnitArea * SurfAreaWet; // Calculating Water Temperature at Wet Dry Interface of the coil WetDryInterfcWaterTemp = InletWaterTemp + SurfAreaWetFraction * (OutletWaterTemp - InletWaterTemp); @@ -4184,7 +4083,7 @@ namespace WaterCoils { for (itT = 1; itT <= itmax; ++itT) { // Calculate dry coil performance with estimated liquid temperature at the boundary. - CoilCompletelyDry(CoilNum, + CoilCompletelyDry(state, CoilNum, WetDryInterfcWaterTemp, InletAirTemp, DryCoilUA, @@ -4196,7 +4095,7 @@ namespace WaterCoils { PartLoadRatio); // Calculate wet coil performance with calculated air temperature at the boundary. - CoilCompletelyWet(CoilNum, + CoilCompletelyWet(state, CoilNum, InletWaterTemp, WetDryInterfcAirTemp, WetDryInterfcHumRat, @@ -4225,7 +4124,7 @@ namespace WaterCoils { // Wet Dry Interface temperature not converged after maximum specified iterations. // Print error message, set return error flag if ((itT > itmax) && (!WarmupFlag)) { - ShowWarningError("For Coil:Cooling:Water " + WaterCoil(CoilNum).Name); + ShowWarningError("For Coil:Cooling:Water " + state.dataWaterCoils->WaterCoil(CoilNum).Name); ShowContinueError("CoilPartWetPartDry: Maximum iterations exceeded for Liq Temp, at Interface"); } @@ -4233,11 +4132,11 @@ namespace WaterCoils { if (SurfAreaWetFraction <= 0.0 && WetDryInterfcSurfTemp >= AirDewPointTemp) { // Calculating Value of Dry UA for the coil - DryCoilUA = WaterCoil(CoilNum).TotCoilOutsideSurfArea / - (1.0 / WaterCoil(CoilNum).UACoilInternalPerUnitArea + 1.0 / WaterCoil(CoilNum).UADryExtPerUnitArea); + DryCoilUA = state.dataWaterCoils->WaterCoil(CoilNum).TotCoilOutsideSurfArea / + (1.0 / state.dataWaterCoils->WaterCoil(CoilNum).UACoilInternalPerUnitArea + 1.0 / state.dataWaterCoils->WaterCoil(CoilNum).UADryExtPerUnitArea); // Calling the Completely Dry Coil for outputs - CoilCompletelyDry(CoilNum, + CoilCompletelyDry(state, CoilNum, InletWaterTemp, InletAirTemp, DryCoilUA, @@ -4277,12 +4176,12 @@ namespace WaterCoils { SenWaterCoilLoad = DryCoilHeatTranfer + WetCoilSensibleHeatTransfer; // Save last iterations values for this current time step - WaterCoil(CoilNum).SurfAreaWetFractionSaved = SurfAreaWetFraction; + state.dataWaterCoils->WaterCoil(CoilNum).SurfAreaWetFractionSaved = SurfAreaWetFraction; } // Calculating coil UA for Cooling Coil - Real64 CalcCoilUAbyEffectNTU(int const CoilNum, + Real64 CalcCoilUAbyEffectNTU(EnergyPlusData &state, int const CoilNum, Real64 const CapacityStream1, // Capacity rate of stream1.(W/C) Real64 const EnergyInStreamOne, // Inlet state of stream1.(C) Real64 const CapacityStream2, // Capacity rate of stream2.(W/C) @@ -4348,7 +4247,7 @@ namespace WaterCoils { // Error Message if ((std::abs(DesTotalHeatTransfer) - MaxHeatTransfer) / max(MaxHeatTransfer, SmallNo) > SmallNo) { - ShowWarningError("For Coil:Cooling:Water " + WaterCoil(CoilNum).Name); + ShowWarningError("For Coil:Cooling:Water " + state.dataWaterCoils->WaterCoil(CoilNum).Name); ShowContinueError("CalcCoilUAbyEffectNTU:Given Q impossible for given inlet states, proceeding with MaxHeat Transfer"); ShowContinueError("Check the Sizing:System and Sizing:Zone cooling design supply air temperature and "); ShowContinueError("the Sizing:Plant design Loop exit temperature. There must be sufficient difference between these two temperatures."); @@ -4372,7 +4271,7 @@ namespace WaterCoils { for (iter = 1; iter <= itmax; ++iter) { // Calculate heat transfer rate for estimated CalcCoilUAbyEffectNTU - CoilOutletStreamCondition( + CoilOutletStreamCondition(state, CoilNum, CapacityStream1, EnergyInStreamOne, CapacityStream2, EnergyInStreamTwo, CoilUA, EnergyOutStreamOne, EnergyOutStreamTwo); // Initial Guess for a value of heat transfer @@ -4392,7 +4291,7 @@ namespace WaterCoils { // If not converged after itmax iterations, return error code if ((iter > itmax) && (!WarmupFlag)) { - ShowWarningError("For Coil:Cooling:Water " + WaterCoil(CoilNum).Name); + ShowWarningError("For Coil:Cooling:Water " + state.dataWaterCoils->WaterCoil(CoilNum).Name); ShowContinueError("CalcCoilUAbyEffectNTU: Maximum iterations exceeded:Coil UA calculation"); CalcCoilUAbyEffectNTU = 0.0; // Autodesk:Return Line added to set return value: Using non-converged CoilUA value may be preferred but // that was not happening @@ -4407,7 +4306,7 @@ namespace WaterCoils { // Calculating coil outlet stream conditions and coil UA for Cooling Coil - void CoilOutletStreamCondition(int const CoilNum, + void CoilOutletStreamCondition(EnergyPlusData &state, int const CoilNum, Real64 const CapacityStream1, // Capacity rate of stream1(W/C) Real64 const EnergyInStreamOne, // Inlet state of stream1 (C) Real64 const CapacityStream2, // Capacity rate of stream2 (W/C) @@ -4493,7 +4392,7 @@ namespace WaterCoils { effectiveness = 1.0 - std::exp(-NTU); } // Calculate effectiveness depending on heat exchanger configuration - } else if (WaterCoil(CoilNum).HeatExchType == CounterFlow) { + } else if (state.dataWaterCoils->WaterCoil(CoilNum).HeatExchType == state.dataWaterCoils->CounterFlow) { // Counterflow Heat Exchanger Configuration if (std::abs(RatioStreamCapacity - 1.0) < SmallNo) { @@ -4507,7 +4406,7 @@ namespace WaterCoils { effectiveness = (1.0 - e) / (1.0 - RatioStreamCapacity * e); } - } else if (WaterCoil(CoilNum).HeatExchType == CrossFlow) { + } else if (state.dataWaterCoils->WaterCoil(CoilNum).HeatExchType == state.dataWaterCoils->CrossFlow) { // Cross flow, both streams unmixed eta = std::pow(NTU, -0.22); if ((NTU * RatioStreamCapacity * eta) > 20.0) { @@ -4537,7 +4436,7 @@ namespace WaterCoils { // Subroutine for caculating outlet condition if coil is wet , for Cooling Coil - void WetCoilOutletCondition(int const CoilNum, + void WetCoilOutletCondition(EnergyPlusData &state, int const CoilNum, Real64 const AirTempIn, // Entering air dry bulb temperature(C) Real64 const EnthAirInlet, // Entering air enthalpy(J/kg) Real64 const EnthAirOutlet, // Leaving air enthalpy(J/kg) @@ -4593,7 +4492,7 @@ namespace WaterCoils { // Determine the temperature effectiveness, assuming the temperature // of the condensate is constant (MinimumCapacityStream/MaximumCapacityStream = 0) and the specific heat // of moist air is constant - CapacitanceAir = WaterCoil(CoilNum).InletAirMassFlowRate * PsyCpAirFnW(WaterCoil(CoilNum).InletAirHumRat); + CapacitanceAir = state.dataWaterCoils->WaterCoil(CoilNum).InletAirMassFlowRate * PsyCpAirFnW(state.dataWaterCoils->WaterCoil(CoilNum).InletAirHumRat); // Calculating NTU from UA and Capacitance. // del NTU = UACoilExternal/MAX(CapacitanceAir,SmallNo) @@ -4619,7 +4518,7 @@ namespace WaterCoils { // at given saturation enthalpy TempCondensation = PsyTsatFnHPb(EnthAirCondensateTemp, OutBaroPress); - TempAirDewPoint = PsyTdpFnWPb(WaterCoil(CoilNum).InletAirHumRat, OutBaroPress); + TempAirDewPoint = PsyTdpFnWPb(state.dataWaterCoils->WaterCoil(CoilNum).InletAirHumRat, OutBaroPress); if ((TempAirDewPoint - TempCondensation) > 0.1) { @@ -4629,7 +4528,7 @@ namespace WaterCoils { OutletAirHumRat = PsyWFnTdbH(OutletAirTemp, EnthAirOutlet); } else { - OutletAirHumRat = WaterCoil(CoilNum).InletAirHumRat; + OutletAirHumRat = state.dataWaterCoils->WaterCoil(CoilNum).InletAirHumRat; OutletAirTemp = PsyTdbFnHW(EnthAirOutlet, OutletAirHumRat); } @@ -4640,7 +4539,7 @@ namespace WaterCoils { // Beginning of Update subroutines for the WaterCoil Module // ***************************************************************************** - void UpdateWaterCoil(int const CoilNum) + void UpdateWaterCoil(EnergyPlusData &state, int const CoilNum) { // SUBROUTINE INFORMATION: // AUTHOR Richard Liesen @@ -4680,19 +4579,19 @@ namespace WaterCoils { int AirOutletNode; int WaterOutletNode; - AirInletNode = WaterCoil(CoilNum).AirInletNodeNum; - WaterInletNode = WaterCoil(CoilNum).WaterInletNodeNum; - AirOutletNode = WaterCoil(CoilNum).AirOutletNodeNum; - WaterOutletNode = WaterCoil(CoilNum).WaterOutletNodeNum; + AirInletNode = state.dataWaterCoils->WaterCoil(CoilNum).AirInletNodeNum; + WaterInletNode = state.dataWaterCoils->WaterCoil(CoilNum).WaterInletNodeNum; + AirOutletNode = state.dataWaterCoils->WaterCoil(CoilNum).AirOutletNodeNum; + WaterOutletNode = state.dataWaterCoils->WaterCoil(CoilNum).WaterOutletNodeNum; // Set the outlet air nodes of the WaterCoil - Node(AirOutletNode).MassFlowRate = WaterCoil(CoilNum).OutletAirMassFlowRate; - Node(AirOutletNode).Temp = WaterCoil(CoilNum).OutletAirTemp; - Node(AirOutletNode).HumRat = WaterCoil(CoilNum).OutletAirHumRat; - Node(AirOutletNode).Enthalpy = WaterCoil(CoilNum).OutletAirEnthalpy; + Node(AirOutletNode).MassFlowRate = state.dataWaterCoils->WaterCoil(CoilNum).OutletAirMassFlowRate; + Node(AirOutletNode).Temp = state.dataWaterCoils->WaterCoil(CoilNum).OutletAirTemp; + Node(AirOutletNode).HumRat = state.dataWaterCoils->WaterCoil(CoilNum).OutletAirHumRat; + Node(AirOutletNode).Enthalpy = state.dataWaterCoils->WaterCoil(CoilNum).OutletAirEnthalpy; - Node(WaterOutletNode).Temp = WaterCoil(CoilNum).OutletWaterTemp; - Node(WaterOutletNode).Enthalpy = WaterCoil(CoilNum).OutletWaterEnthalpy; + Node(WaterOutletNode).Temp = state.dataWaterCoils->WaterCoil(CoilNum).OutletWaterTemp; + Node(WaterOutletNode).Enthalpy = state.dataWaterCoils->WaterCoil(CoilNum).OutletWaterEnthalpy; // Set the outlet nodes for properties that just pass through & not used Node(AirOutletNode).Quality = Node(AirInletNode).Quality; @@ -4715,7 +4614,7 @@ namespace WaterCoils { // Beginning of Reporting subroutines for the WaterCoil Module // ***************************************************************************** - void ReportWaterCoil(int const CoilNum) + void ReportWaterCoil(EnergyPlusData &state, int const CoilNum) { // SUBROUTINE INFORMATION: @@ -4755,66 +4654,66 @@ namespace WaterCoils { Real64 SpecHumIn; Real64 ReportingConstant; - if (WaterCoil(CoilNum).reportCoilFinalSizes) { + if (state.dataWaterCoils->WaterCoil(CoilNum).reportCoilFinalSizes) { if (!DataGlobals::WarmupFlag && !DataGlobals::DoingHVACSizingSimulations && !DataGlobals::DoingSizing) { std::string coilObjClassName; - if (WaterCoil(CoilNum).WaterCoilType_Num == WaterCoil_SimpleHeating) { + if (state.dataWaterCoils->WaterCoil(CoilNum).WaterCoilType_Num == state.dataWaterCoils->WaterCoil_SimpleHeating) { coilObjClassName = "Coil:Heating:Water"; - coilSelectionReportObj->setCoilFinalSizes(WaterCoil(CoilNum).Name, + coilSelectionReportObj->setCoilFinalSizes(state.dataWaterCoils->WaterCoil(CoilNum).Name, coilObjClassName, - WaterCoil(CoilNum).DesWaterHeatingCoilRate, - WaterCoil(CoilNum).DesWaterHeatingCoilRate, - WaterCoil(CoilNum).DesAirVolFlowRate, - WaterCoil(CoilNum).MaxWaterVolFlowRate); - WaterCoil(CoilNum).reportCoilFinalSizes = false; - } else if (WaterCoil(CoilNum).WaterCoilType_Num == WaterCoil_DetFlatFinCooling) { + state.dataWaterCoils->WaterCoil(CoilNum).DesWaterHeatingCoilRate, + state.dataWaterCoils->WaterCoil(CoilNum).DesWaterHeatingCoilRate, + state.dataWaterCoils->WaterCoil(CoilNum).DesAirVolFlowRate, + state.dataWaterCoils->WaterCoil(CoilNum).MaxWaterVolFlowRate); + state.dataWaterCoils->WaterCoil(CoilNum).reportCoilFinalSizes = false; + } else if (state.dataWaterCoils->WaterCoil(CoilNum).WaterCoilType_Num == state.dataWaterCoils->WaterCoil_DetFlatFinCooling) { coilObjClassName = "Coil:Cooling:Water:DetailedGeometry"; - coilSelectionReportObj->setCoilFinalSizes(WaterCoil(CoilNum).Name, + coilSelectionReportObj->setCoilFinalSizes(state.dataWaterCoils->WaterCoil(CoilNum).Name, coilObjClassName, - WaterCoil(CoilNum).DesWaterCoolingCoilRate, + state.dataWaterCoils->WaterCoil(CoilNum).DesWaterCoolingCoilRate, -999.0, - WaterCoil(CoilNum).DesAirVolFlowRate, - WaterCoil(CoilNum).MaxWaterVolFlowRate); - WaterCoil(CoilNum).reportCoilFinalSizes = false; - } else if (WaterCoil(CoilNum).WaterCoilType_Num == WaterCoil_Cooling) { + state.dataWaterCoils->WaterCoil(CoilNum).DesAirVolFlowRate, + state.dataWaterCoils->WaterCoil(CoilNum).MaxWaterVolFlowRate); + state.dataWaterCoils->WaterCoil(CoilNum).reportCoilFinalSizes = false; + } else if (state.dataWaterCoils->WaterCoil(CoilNum).WaterCoilType_Num == state.dataWaterCoils->WaterCoil_Cooling) { coilObjClassName = "Coil:Cooling:Water"; - coilSelectionReportObj->setCoilFinalSizes(WaterCoil(CoilNum).Name, + coilSelectionReportObj->setCoilFinalSizes(state.dataWaterCoils->WaterCoil(CoilNum).Name, coilObjClassName, - WaterCoil(CoilNum).DesWaterCoolingCoilRate, + state.dataWaterCoils->WaterCoil(CoilNum).DesWaterCoolingCoilRate, -999.0, - WaterCoil(CoilNum).DesAirVolFlowRate, - WaterCoil(CoilNum).MaxWaterVolFlowRate); - WaterCoil(CoilNum).reportCoilFinalSizes = false; + state.dataWaterCoils->WaterCoil(CoilNum).DesAirVolFlowRate, + state.dataWaterCoils->WaterCoil(CoilNum).MaxWaterVolFlowRate); + state.dataWaterCoils->WaterCoil(CoilNum).reportCoilFinalSizes = false; } } } ReportingConstant = TimeStepSys * SecInHour; // report the WaterCoil energy from this component - WaterCoil(CoilNum).TotWaterHeatingCoilEnergy = WaterCoil(CoilNum).TotWaterHeatingCoilRate * ReportingConstant; - WaterCoil(CoilNum).TotWaterCoolingCoilEnergy = WaterCoil(CoilNum).TotWaterCoolingCoilRate * ReportingConstant; - WaterCoil(CoilNum).SenWaterCoolingCoilEnergy = WaterCoil(CoilNum).SenWaterCoolingCoilRate * ReportingConstant; + state.dataWaterCoils->WaterCoil(CoilNum).TotWaterHeatingCoilEnergy = state.dataWaterCoils->WaterCoil(CoilNum).TotWaterHeatingCoilRate * ReportingConstant; + state.dataWaterCoils->WaterCoil(CoilNum).TotWaterCoolingCoilEnergy = state.dataWaterCoils->WaterCoil(CoilNum).TotWaterCoolingCoilRate * ReportingConstant; + state.dataWaterCoils->WaterCoil(CoilNum).SenWaterCoolingCoilEnergy = state.dataWaterCoils->WaterCoil(CoilNum).SenWaterCoolingCoilRate * ReportingConstant; // report the WaterCoil water collection to water storage tank (if needed) - if (WaterCoil(CoilNum).CondensateCollectMode == CondensateToTank) { + if (state.dataWaterCoils->WaterCoil(CoilNum).CondensateCollectMode == state.dataWaterCoils->CondensateToTank) { // calculate and report condensation rates (how much water extracted from the air stream) // water volumetric flow of water in m3/s for water system interactions // put here to catch all types of DX coils - Tavg = (WaterCoil(CoilNum).InletAirTemp - WaterCoil(CoilNum).OutletAirTemp) / 2.0; + Tavg = (state.dataWaterCoils->WaterCoil(CoilNum).InletAirTemp - state.dataWaterCoils->WaterCoil(CoilNum).OutletAirTemp) / 2.0; RhoWater = GetDensityGlycol( - PlantLoop(WaterCoil(CoilNum).WaterLoopNum).FluidName, Tavg, PlantLoop(WaterCoil(CoilNum).WaterLoopNum).FluidIndex, RoutineName); + PlantLoop(state.dataWaterCoils->WaterCoil(CoilNum).WaterLoopNum).FluidName, Tavg, PlantLoop(state.dataWaterCoils->WaterCoil(CoilNum).WaterLoopNum).FluidIndex, RoutineName); // CR9155 Remove specific humidity calculations - SpecHumIn = WaterCoil(CoilNum).InletAirHumRat; - SpecHumOut = WaterCoil(CoilNum).OutletAirHumRat; + SpecHumIn = state.dataWaterCoils->WaterCoil(CoilNum).InletAirHumRat; + SpecHumOut = state.dataWaterCoils->WaterCoil(CoilNum).OutletAirHumRat; // mdot * del HumRat / rho water - WaterCoil(CoilNum).CondensateVdot = max(0.0, (WaterCoil(CoilNum).InletAirMassFlowRate * (SpecHumIn - SpecHumOut) / RhoWater)); - WaterCoil(CoilNum).CondensateVol = WaterCoil(CoilNum).CondensateVdot * ReportingConstant; + state.dataWaterCoils->WaterCoil(CoilNum).CondensateVdot = max(0.0, (state.dataWaterCoils->WaterCoil(CoilNum).InletAirMassFlowRate * (SpecHumIn - SpecHumOut) / RhoWater)); + state.dataWaterCoils->WaterCoil(CoilNum).CondensateVol = state.dataWaterCoils->WaterCoil(CoilNum).CondensateVdot * ReportingConstant; - WaterStorage(WaterCoil(CoilNum).CondensateTankID).VdotAvailSupply(WaterCoil(CoilNum).CondensateTankSupplyARRID) = - WaterCoil(CoilNum).CondensateVdot; - WaterStorage(WaterCoil(CoilNum).CondensateTankID).TwaterSupply(WaterCoil(CoilNum).CondensateTankSupplyARRID) = - WaterCoil(CoilNum).OutletAirTemp; + WaterStorage(state.dataWaterCoils->WaterCoil(CoilNum).CondensateTankID).VdotAvailSupply(state.dataWaterCoils->WaterCoil(CoilNum).CondensateTankSupplyARRID) = + state.dataWaterCoils->WaterCoil(CoilNum).CondensateVdot; + WaterStorage(state.dataWaterCoils->WaterCoil(CoilNum).CondensateTankID).TwaterSupply(state.dataWaterCoils->WaterCoil(CoilNum).CondensateTankSupplyARRID) = + state.dataWaterCoils->WaterCoil(CoilNum).OutletAirTemp; } } @@ -4824,7 +4723,7 @@ namespace WaterCoils { // Beginning of Coil Utility subroutines for the Detailed Model // ***************************************************************************** - void CalcDryFinEffCoef(Real64 const OutTubeEffFinDiamRatio, Array1D &PolynomCoef) + void CalcDryFinEffCoef(EnergyPlusData &state, Real64 const OutTubeEffFinDiamRatio, Array1D &PolynomCoef) { // SUBROUTINE INFORMATION: // AUTHOR Unknown @@ -4860,7 +4759,7 @@ namespace WaterCoils { // na // SUBROUTINE LOCAL VARIABLE DECLARATIONS: - static Array2D OrderedPair(MaxOrderedPairs, 2); // Tuned Changed to static: Set before use + static Array2D OrderedPair(state.dataWaterCoils->MaxOrderedPairs, 2); // Tuned Changed to static: Set before use Real64 FAI; Real64 FED; Real64 FEDnumerator; @@ -4882,7 +4781,7 @@ namespace WaterCoils { Real64 RO; FAI = 0.02; - for (I = 1; I <= MaxOrderedPairs; ++I) { + for (I = 1; I <= state.dataWaterCoils->MaxOrderedPairs; ++I) { FAI += 0.035; R1 = FAI / (1.0 - OutTubeEffFinDiamRatio); R2 = R1 * OutTubeEffFinDiamRatio; @@ -4903,7 +4802,7 @@ namespace WaterCoils { OrderedPair(I, 1) = FAI; OrderedPair(I, 2) = FED; } - CalcPolynomCoef(OrderedPair, PolynomCoef); + CalcPolynomCoef(state, OrderedPair, PolynomCoef); } void CalcIBesselFunc(Real64 const BessFuncArg, int const BessFuncOrd, Real64 &IBessFunc, int &ErrorCode) @@ -5172,7 +5071,7 @@ namespace WaterCoils { KBessFunc = GJ; } - void CalcPolynomCoef(Array2 const &OrderedPair, Array1D &PolynomCoef) + void CalcPolynomCoef(EnergyPlusData &state, Array2 const &OrderedPair, Array1D &PolynomCoef) { // SUBROUTINE INFORMATION: // AUTHOR Unknown @@ -5215,9 +5114,9 @@ namespace WaterCoils { Real64 S2; OrdPairSum = 0.0; - OrdPairSum(1, 1) = MaxOrderedPairs; + OrdPairSum(1, 1) = state.dataWaterCoils->MaxOrderedPairs; PolynomCoef = 0.0; - for (CurrentOrdPair = 1; CurrentOrdPair <= MaxOrderedPairs; ++CurrentOrdPair) { + for (CurrentOrdPair = 1; CurrentOrdPair <= state.dataWaterCoils->MaxOrderedPairs; ++CurrentOrdPair) { OrdPairSum(2, 1) += OrderedPair(CurrentOrdPair, 1); OrdPairSum(3, 1) += OrderedPair(CurrentOrdPair, 1) * OrderedPair(CurrentOrdPair, 1); OrdPairSum(1, 2) += OrderedPair(CurrentOrdPair, 2); @@ -5252,7 +5151,7 @@ namespace WaterCoils { } // End of CurrentOrder loop S2 = 0.0; - for (CurrentOrdPair = 1; CurrentOrdPair <= MaxOrderedPairs; ++CurrentOrdPair) { + for (CurrentOrdPair = 1; CurrentOrdPair <= state.dataWaterCoils->MaxOrderedPairs; ++CurrentOrdPair) { S1 = OrdPairSumMatrix(PolynomOrder + 2, 1); auto const OrderedPair1C(OrderedPair(CurrentOrdPair, 1)); auto OrderedPair1C_pow(1.0); @@ -5262,18 +5161,18 @@ namespace WaterCoils { } // End of CurrentOrder loop S2 += (S1 - OrderedPair(CurrentOrdPair, 2)) * (S1 - OrderedPair(CurrentOrdPair, 2)); } // End of CurrentOrdPair loop - B = MaxOrderedPairs - (PolynomOrder + 1); + B = state.dataWaterCoils->MaxOrderedPairs - (PolynomOrder + 1); if (S2 > 0.0001) S2 = std::sqrt(S2 / B); for (CurrentOrder = 1; CurrentOrder <= PolynomOrder + 1; ++CurrentOrder) { PolynomCoef(CurrentOrder) = OrdPairSumMatrix(PolynomOrder + 2, CurrentOrder); } // End of CurrentOrder loop - if ((PolynomOrder - MaxPolynomOrder < 0) && (S2 - PolyConvgTol > 0.0)) { + if ((PolynomOrder - state.dataWaterCoils->MaxPolynomOrder < 0) && (S2 - state.dataWaterCoils->PolyConvgTol > 0.0)) { ++PolynomOrder; J = 2 * PolynomOrder; OrdPairSum(J, 1) = OrdPairSum(J + 1, 1) = 0.0; auto OrdPairSum2P = OrdPairSum(PolynomOrder + 1, 2) = 0.0; - for (I = 1; I <= MaxOrderedPairs; ++I) { + for (I = 1; I <= state.dataWaterCoils->MaxOrderedPairs; ++I) { auto const OrderedPair1I(OrderedPair(I, 1)); auto OrderedPair_pow(std::pow(OrderedPair1I, J - 1)); OrdPairSum(J, 1) += OrderedPair_pow; @@ -5288,7 +5187,7 @@ namespace WaterCoils { } } - Real64 SimpleHeatingCoilUAResidual(Real64 const UA, // UA of coil + Real64 SimpleHeatingCoilUAResidual(EnergyPlusData &state, Real64 const UA, // UA of coil Array1D const &Par // par(1) = design coil load [W] ) { @@ -5315,20 +5214,6 @@ namespace WaterCoils { // Return value Real64 Residuum; // residual to be minimized to zero - // Argument array dimensioning - - // Locals - // SUBROUTINE ARGUMENT DEFINITIONS: - - // FUNCTION PARAMETER DEFINITIONS: - // na - - // INTERFACE BLOCK SPECIFICATIONS - // na - - // DERIVED TYPE DEFINITIONS - // na - // FUNCTION LOCAL VARIABLE DECLARATIONS: int CoilIndex; int FanOpMode; @@ -5337,15 +5222,15 @@ namespace WaterCoils { CoilIndex = int(Par(2)); FanOpMode = (Par(3) == 1.0 ? CycFanCycCoil : ContFanCycCoil); PartLoadRatio = Par(4); - WaterCoil(CoilIndex).UACoilVariable = UA; - CalcSimpleHeatingCoil(CoilIndex, FanOpMode, PartLoadRatio, SimCalc); - Residuum = (Par(1) - WaterCoil(CoilIndex).TotWaterHeatingCoilRate) / Par(1); - DataDesignCoilCapacity = WaterCoil(CoilIndex).TotWaterHeatingCoilRate; + state.dataWaterCoils->WaterCoil(CoilIndex).UACoilVariable = UA; + CalcSimpleHeatingCoil(state, CoilIndex, FanOpMode, PartLoadRatio, state.dataWaterCoils->SimCalc); + Residuum = (Par(1) - state.dataWaterCoils->WaterCoil(CoilIndex).TotWaterHeatingCoilRate) / Par(1); + DataDesignCoilCapacity = state.dataWaterCoils->WaterCoil(CoilIndex).TotWaterHeatingCoilRate; return Residuum; } - Real64 SimpleCoolingCoilUAResidual(Real64 const UA, // UA of coil + Real64 SimpleCoolingCoilUAResidual(EnergyPlusData &state, Real64 const UA, // UA of coil Array1D const &Par // par(1) = design coil load [W] ) { @@ -5394,17 +5279,17 @@ namespace WaterCoils { CoilIndex = int(Par(2)); FanOpMode = (Par(3) == 1.0 ? CycFanCycCoil : ContFanCycCoil); PartLoadRatio = Par(4); - WaterCoil(CoilIndex).UACoilExternal = UA; - WaterCoil(CoilIndex).UACoilInternal = WaterCoil(CoilIndex).UACoilExternal * 3.3; - WaterCoil(CoilIndex).UACoilTotal = 1.0 / (1.0 / WaterCoil(CoilIndex).UACoilExternal + 1.0 / WaterCoil(CoilIndex).UACoilInternal); - WaterCoil(CoilIndex).TotCoilOutsideSurfArea = EstimateHEXSurfaceArea(CoilIndex); - WaterCoil(CoilIndex).UACoilInternalPerUnitArea = WaterCoil(CoilIndex).UACoilInternal / WaterCoil(CoilIndex).TotCoilOutsideSurfArea; - WaterCoil(CoilIndex).UAWetExtPerUnitArea = WaterCoil(CoilIndex).UACoilExternal / WaterCoil(CoilIndex).TotCoilOutsideSurfArea; - WaterCoil(CoilIndex).UADryExtPerUnitArea = WaterCoil(CoilIndex).UAWetExtPerUnitArea; + state.dataWaterCoils->WaterCoil(CoilIndex).UACoilExternal = UA; + state.dataWaterCoils->WaterCoil(CoilIndex).UACoilInternal = state.dataWaterCoils->WaterCoil(CoilIndex).UACoilExternal * 3.3; + state.dataWaterCoils->WaterCoil(CoilIndex).UACoilTotal = 1.0 / (1.0 / state.dataWaterCoils->WaterCoil(CoilIndex).UACoilExternal + 1.0 / state.dataWaterCoils->WaterCoil(CoilIndex).UACoilInternal); + state.dataWaterCoils->WaterCoil(CoilIndex).TotCoilOutsideSurfArea = EstimateHEXSurfaceArea(state, CoilIndex); + state.dataWaterCoils->WaterCoil(CoilIndex).UACoilInternalPerUnitArea = state.dataWaterCoils->WaterCoil(CoilIndex).UACoilInternal / state.dataWaterCoils->WaterCoil(CoilIndex).TotCoilOutsideSurfArea; + state.dataWaterCoils->WaterCoil(CoilIndex).UAWetExtPerUnitArea = state.dataWaterCoils->WaterCoil(CoilIndex).UACoilExternal / state.dataWaterCoils->WaterCoil(CoilIndex).TotCoilOutsideSurfArea; + state.dataWaterCoils->WaterCoil(CoilIndex).UADryExtPerUnitArea = state.dataWaterCoils->WaterCoil(CoilIndex).UAWetExtPerUnitArea; - CoolingCoil(CoilIndex, true, DesignCalc, FanOpMode, PartLoadRatio); + CoolingCoil(state, CoilIndex, true, state.dataWaterCoils->DesignCalc, FanOpMode, PartLoadRatio); - Residuum = (Par(1) - WaterCoil(CoilIndex).TotWaterCoolingCoilRate) / Par(1); + Residuum = (Par(1) - state.dataWaterCoils->WaterCoil(CoilIndex).TotWaterCoolingCoilRate) / Par(1); return Residuum; } @@ -5626,30 +5511,30 @@ namespace WaterCoils { int CoilNum; // Obtains and Allocates WaterCoil related parameters from input file - if (GetWaterCoilsInputFlag) { // First time subroutine has been entered + if (state.dataWaterCoils->GetWaterCoilsInputFlag) { // First time subroutine has been entered GetWaterCoilInput(state); - GetWaterCoilsInputFlag = false; + state.dataWaterCoils->GetWaterCoilsInputFlag = false; } // Find the correct Coil number if (CompIndex == 0) { - CoilNum = UtilityRoutines::FindItemInList(CompName, WaterCoil); + CoilNum = UtilityRoutines::FindItemInList(CompName, state.dataWaterCoils->WaterCoil); if (CoilNum == 0) { ShowFatalError("CheckWaterCoilSchedule: Coil not found=" + CompName); } CompIndex = CoilNum; - Value = GetCurrentScheduleValue(WaterCoil(CoilNum).SchedPtr); // not scheduled? + Value = GetCurrentScheduleValue(state.dataWaterCoils->WaterCoil(CoilNum).SchedPtr); // not scheduled? } else { CoilNum = CompIndex; - if (CoilNum > NumWaterCoils || CoilNum < 1) { + if (CoilNum > state.dataWaterCoils->NumWaterCoils || CoilNum < 1) { ShowFatalError("CheckWaterCoilSchedule: Invalid CompIndex passed=" + TrimSigDigits(CoilNum) + - ", Number of Heating Coils=" + TrimSigDigits(NumWaterCoils) + ", Coil name=" + CompName); + ", Number of Heating Coils=" + TrimSigDigits(state.dataWaterCoils->NumWaterCoils) + ", Coil name=" + CompName); } - if (CompName != WaterCoil(CoilNum).Name) { + if (CompName != state.dataWaterCoils->WaterCoil(CoilNum).Name) { ShowFatalError("CheckWaterCoilSchedule: Invalid CompIndex passed=" + TrimSigDigits(CoilNum) + ", Coil name=" + CompName + - ", stored Coil Name for that index=" + WaterCoil(CoilNum).Name); + ", stored Coil Name for that index=" + state.dataWaterCoils->WaterCoil(CoilNum).Name); } - Value = GetCurrentScheduleValue(WaterCoil(CoilNum).SchedPtr); // not scheduled? + Value = GetCurrentScheduleValue(state.dataWaterCoils->WaterCoil(CoilNum).SchedPtr); // not scheduled? } } @@ -5677,19 +5562,19 @@ namespace WaterCoils { int WhichCoil; // Obtains and Allocates WaterCoil related parameters from input file - if (GetWaterCoilsInputFlag) { // First time subroutine has been entered + if (state.dataWaterCoils->GetWaterCoilsInputFlag) { // First time subroutine has been entered GetWaterCoilInput(state); - GetWaterCoilsInputFlag = false; + state.dataWaterCoils->GetWaterCoilsInputFlag = false; } WhichCoil = 0; if (UtilityRoutines::SameString(CoilType, "Coil:Heating:Water") || UtilityRoutines::SameString(CoilType, "Coil:Cooling:Water:DetailedGeometry") || UtilityRoutines::SameString(CoilType, "Coil:Cooling:Water")) { - WhichCoil = UtilityRoutines::FindItem(CoilName, WaterCoil); + WhichCoil = UtilityRoutines::FindItem(CoilName, state.dataWaterCoils->WaterCoil); if (WhichCoil != 0) { // coil does not specify MaxWaterFlowRate - MaxWaterFlowRate = WaterCoil(WhichCoil).MaxWaterVolFlowRate; + MaxWaterFlowRate = state.dataWaterCoils->WaterCoil(WhichCoil).MaxWaterVolFlowRate; } } else { WhichCoil = 0; @@ -5729,9 +5614,9 @@ namespace WaterCoils { int WhichCoil; // Obtains and Allocates DXCoils - if (GetWaterCoilsInputFlag) { + if (state.dataWaterCoils->GetWaterCoilsInputFlag) { GetWaterCoilInput(state); - GetWaterCoilsInputFlag = false; + state.dataWaterCoils->GetWaterCoilsInputFlag = false; } NodeNumber = 0; @@ -5739,9 +5624,9 @@ namespace WaterCoils { if (UtilityRoutines::SameString(CoilType, "Coil:Heating:Water") || UtilityRoutines::SameString(CoilType, "Coil:Cooling:Water:DetailedGeometry") || UtilityRoutines::SameString(CoilType, "Coil:Cooling:Water")) { - WhichCoil = UtilityRoutines::FindItem(CoilName, WaterCoil); + WhichCoil = UtilityRoutines::FindItem(CoilName, state.dataWaterCoils->WaterCoil); if (WhichCoil != 0) { - NodeNumber = WaterCoil(WhichCoil).AirInletNodeNum; + NodeNumber = state.dataWaterCoils->WaterCoil(WhichCoil).AirInletNodeNum; } } else { WhichCoil = 0; @@ -5780,9 +5665,9 @@ namespace WaterCoils { int WhichCoil; // Obtains and Allocates DXCoils - if (GetWaterCoilsInputFlag) { + if (state.dataWaterCoils->GetWaterCoilsInputFlag) { GetWaterCoilInput(state); - GetWaterCoilsInputFlag = false; + state.dataWaterCoils->GetWaterCoilsInputFlag = false; } WhichCoil = 0; @@ -5790,9 +5675,9 @@ namespace WaterCoils { if (UtilityRoutines::SameString(CoilType, "Coil:Heating:Water") || UtilityRoutines::SameString(CoilType, "Coil:Cooling:Water:DetailedGeometry") || UtilityRoutines::SameString(CoilType, "Coil:Cooling:Water")) { - WhichCoil = UtilityRoutines::FindItem(CoilName, WaterCoil); + WhichCoil = UtilityRoutines::FindItem(CoilName, state.dataWaterCoils->WaterCoil); if (WhichCoil != 0) { - NodeNumber = WaterCoil(WhichCoil).AirOutletNodeNum; + NodeNumber = state.dataWaterCoils->WaterCoil(WhichCoil).AirOutletNodeNum; } } else { WhichCoil = 0; @@ -5832,9 +5717,9 @@ namespace WaterCoils { int WhichCoil; // Obtains and Allocates DXCoils - if (GetWaterCoilsInputFlag) { + if (state.dataWaterCoils->GetWaterCoilsInputFlag) { GetWaterCoilInput(state); - GetWaterCoilsInputFlag = false; + state.dataWaterCoils->GetWaterCoilsInputFlag = false; } NodeNumber = 0; @@ -5842,9 +5727,9 @@ namespace WaterCoils { if (UtilityRoutines::SameString(CoilType, "Coil:Heating:Water") || UtilityRoutines::SameString(CoilType, "Coil:Cooling:Water:DetailedGeometry") || UtilityRoutines::SameString(CoilType, "Coil:Cooling:Water")) { - WhichCoil = UtilityRoutines::FindItem(CoilName, WaterCoil); + WhichCoil = UtilityRoutines::FindItem(CoilName, state.dataWaterCoils->WaterCoil); if (WhichCoil != 0) { - NodeNumber = WaterCoil(WhichCoil).WaterInletNodeNum; + NodeNumber = state.dataWaterCoils->WaterCoil(WhichCoil).WaterInletNodeNum; } } else { WhichCoil = 0; @@ -5883,9 +5768,9 @@ namespace WaterCoils { int WhichCoil; // Obtains and Allocates DXCoils - if (GetWaterCoilsInputFlag) { + if (state.dataWaterCoils->GetWaterCoilsInputFlag) { GetWaterCoilInput(state); - GetWaterCoilsInputFlag = false; + state.dataWaterCoils->GetWaterCoilsInputFlag = false; } NodeNumber = 0; @@ -5893,9 +5778,9 @@ namespace WaterCoils { if (UtilityRoutines::SameString(CoilType, "Coil:Heating:Water") || UtilityRoutines::SameString(CoilType, "Coil:Cooling:Water:DetailedGeometry") || UtilityRoutines::SameString(CoilType, "Coil:Cooling:Water")) { - WhichCoil = UtilityRoutines::FindItem(CoilName, WaterCoil); + WhichCoil = UtilityRoutines::FindItem(CoilName, state.dataWaterCoils->WaterCoil); if (WhichCoil != 0) { - NodeNumber = WaterCoil(WhichCoil).WaterOutletNodeNum; + NodeNumber = state.dataWaterCoils->WaterCoil(WhichCoil).WaterOutletNodeNum; } } else { WhichCoil = 0; @@ -5931,20 +5816,20 @@ namespace WaterCoils { // SUBROUTINE LOCAL VARIABLE DECLARATIONS: int WhichCoil; // index to coil - if (GetWaterCoilsInputFlag) { // First time subroutine has been entered + if (state.dataWaterCoils->GetWaterCoilsInputFlag) { // First time subroutine has been entered GetWaterCoilInput(state); - GetWaterCoilsInputFlag = false; + state.dataWaterCoils->GetWaterCoilsInputFlag = false; } if (UtilityRoutines::SameString(CoilType, "Coil:Heating:Water") || UtilityRoutines::SameString(CoilType, "Coil:Cooling:Water:DetailedGeometry") || UtilityRoutines::SameString(CoilType, "Coil:Cooling:Water")) { - WhichCoil = UtilityRoutines::FindItem(CoilName, WaterCoil); + WhichCoil = UtilityRoutines::FindItem(CoilName, state.dataWaterCoils->WaterCoil); if (WhichCoil != 0) { - if (UtilityRoutines::SameString(CoilType, "Coil:Cooling:Water") && WaterCoil(WhichCoil).DesAirVolFlowRate < 0.0) { - WaterCoil(WhichCoil).DesAirVolFlowRate = CoilDesFlow; + if (UtilityRoutines::SameString(CoilType, "Coil:Cooling:Water") && state.dataWaterCoils->WaterCoil(WhichCoil).DesAirVolFlowRate < 0.0) { + state.dataWaterCoils->WaterCoil(WhichCoil).DesAirVolFlowRate = CoilDesFlow; } else { - WaterCoil(WhichCoil).DesAirVolFlowRate = CoilDesFlow; + state.dataWaterCoils->WaterCoil(WhichCoil).DesAirVolFlowRate = CoilDesFlow; } } else { ShowSevereError("GetCoilMaxWaterFlowRate: Could not find Coil, Type=\"" + CoilType + "\" Name=\"" + CoilName + "\""); @@ -5976,15 +5861,15 @@ namespace WaterCoils { CoilDesAirFlow = 0.0; - if (GetWaterCoilsInputFlag) { // First time subroutine has been entered + if (state.dataWaterCoils->GetWaterCoilsInputFlag) { // First time subroutine has been entered GetWaterCoilInput(state); - GetWaterCoilsInputFlag = false; + state.dataWaterCoils->GetWaterCoilsInputFlag = false; } if (UtilityRoutines::SameString(CoilType, "Coil:Cooling:Water")) { - WhichCoil = UtilityRoutines::FindItem(CoilName, WaterCoil); + WhichCoil = UtilityRoutines::FindItem(CoilName, state.dataWaterCoils->WaterCoil); if (WhichCoil != 0) { - CoilDesAirFlow = WaterCoil(WhichCoil).DesAirVolFlowRate; + CoilDesAirFlow = state.dataWaterCoils->WaterCoil(WhichCoil).DesAirVolFlowRate; } else { ShowSevereError("GetWaterCoilDesAirFlowRate: Could not find Coil, Type=\"" + CoilType + "\" Name=\"" + CoilName + "\""); ErrorsFound = true; @@ -6018,18 +5903,18 @@ namespace WaterCoils { int CoilNum; // Obtains and Allocates DXCoils - if (GetWaterCoilsInputFlag) { + if (state.dataWaterCoils->GetWaterCoilsInputFlag) { GetWaterCoilInput(state); - GetWaterCoilsInputFlag = false; + state.dataWaterCoils->GetWaterCoilsInputFlag = false; } WhichCoil = 0; iNodeType = 0; NodeNotFound = true; - for (CoilNum = 1; CoilNum <= NumWaterCoils; ++CoilNum) { - if (WaterCoil(CoilNum).WaterInletNodeNum == ActuatorNodeNum) { + for (CoilNum = 1; CoilNum <= state.dataWaterCoils->NumWaterCoils; ++CoilNum) { + if (state.dataWaterCoils->WaterCoil(CoilNum).WaterInletNodeNum == ActuatorNodeNum) { WhichCoil = CoilNum; - iNodeType = WaterCoil(CoilNum).WaterCoilType; + iNodeType = state.dataWaterCoils->WaterCoil(CoilNum).WaterCoilType; NodeNotFound = false; } } @@ -6089,16 +5974,16 @@ namespace WaterCoils { bool EMSSetPointErrorFlag; // flag true is EMS is used to set node setpoints // Obtains and Allocates DXCoils - if (GetWaterCoilsInputFlag) { + if (state.dataWaterCoils->GetWaterCoilsInputFlag) { GetWaterCoilInput(state); - GetWaterCoilsInputFlag = false; + state.dataWaterCoils->GetWaterCoilsInputFlag = false; } WhichCoil = 0; NodeNotFound = true; - for (CoilNum = 1; CoilNum <= NumWaterCoils; ++CoilNum) { - if (SensorNodeNum != WaterCoil(CoilNum).AirOutletNodeNum) continue; + for (CoilNum = 1; CoilNum <= state.dataWaterCoils->NumWaterCoils; ++CoilNum) { + if (SensorNodeNum != state.dataWaterCoils->WaterCoil(CoilNum).AirOutletNodeNum) continue; NodeNotFound = false; WhichCoil = CoilNum; break; @@ -6107,11 +5992,11 @@ namespace WaterCoils { // a setpoint is also specified on the water coil outlet node if (!NodeNotFound) { if (WhichCoil > 0) { - if (WaterCoil(CoilNum).WaterCoilType_Num == WaterCoil_DetFlatFinCooling) { + if (state.dataWaterCoils->WaterCoil(CoilNum).WaterCoilType_Num == state.dataWaterCoils->WaterCoil_DetFlatFinCooling) { WaterCoilType = "Coil:Cooling:Water:DetailedGeometry"; - } else if (WaterCoil(CoilNum).WaterCoilType_Num == WaterCoil_Cooling) { + } else if (state.dataWaterCoils->WaterCoil(CoilNum).WaterCoilType_Num == state.dataWaterCoils->WaterCoil_Cooling) { WaterCoilType = "Coil:Cooling:Water"; - } else if (WaterCoil(CoilNum).WaterCoilType_Num == WaterCoil_SimpleHeating) { + } else if (state.dataWaterCoils->WaterCoil(CoilNum).WaterCoilType_Num == state.dataWaterCoils->WaterCoil_SimpleHeating) { WaterCoilType = "Coil:Heating:Water"; } EMSSetPointErrorFlag = false; @@ -6121,7 +6006,7 @@ namespace WaterCoils { CheckIfNodeSetPointManagedByEMS(SensorNodeNum, iTemperatureSetPoint, EMSSetPointErrorFlag); if (EMSSetPointErrorFlag) { if (!NodeHasSPMCtrlVarType(state, SensorNodeNum, iCtrlVarType_Temp)) { - ShowWarningError(RoutineName + WaterCoilType + "=\"" + WaterCoil(WhichCoil).Name + "\". "); + ShowWarningError(RoutineName + WaterCoilType + "=\"" + state.dataWaterCoils->WaterCoil(WhichCoil).Name + "\". "); ShowContinueError(" ..Temperature setpoint not found on coil air outlet node."); ShowContinueError( " ..The setpoint may have been placed on a node downstream of the coil or on an airloop outlet node."); @@ -6132,7 +6017,7 @@ namespace WaterCoils { CheckIfNodeSetPointManagedByEMS(SensorNodeNum, iHumidityRatioMaxSetPoint, EMSSetPointErrorFlag); if (EMSSetPointErrorFlag) { if (!NodeHasSPMCtrlVarType(state, SensorNodeNum, iCtrlVarType_MaxHumRat)) { - ShowWarningError(RoutineName + WaterCoilType + "=\"" + WaterCoil(WhichCoil).Name + "\". "); + ShowWarningError(RoutineName + WaterCoilType + "=\"" + state.dataWaterCoils->WaterCoil(WhichCoil).Name + "\". "); ShowContinueError(" ..Humidity ratio setpoint not found on coil air outlet node."); ShowContinueError( " ..The setpoint may have been placed on a node downstream of the coil or on an airloop outlet node."); @@ -6143,7 +6028,7 @@ namespace WaterCoils { CheckIfNodeSetPointManagedByEMS(SensorNodeNum, iTemperatureSetPoint, EMSSetPointErrorFlag); if (EMSSetPointErrorFlag) { if (!NodeHasSPMCtrlVarType(state, SensorNodeNum, iCtrlVarType_Temp)) { - ShowWarningError(RoutineName + WaterCoilType + "=\"" + WaterCoil(WhichCoil).Name + "\". "); + ShowWarningError(RoutineName + WaterCoilType + "=\"" + state.dataWaterCoils->WaterCoil(WhichCoil).Name + "\". "); ShowContinueError(" ..Temperature setpoint not found on coil air outlet node."); ShowContinueError( " ..The setpoint may have been placed on a node downstream of the coil or on an airloop outlet node."); @@ -6154,7 +6039,7 @@ namespace WaterCoils { CheckIfNodeSetPointManagedByEMS(SensorNodeNum, iHumidityRatioMaxSetPoint, EMSSetPointErrorFlag); if (EMSSetPointErrorFlag) { if (!NodeHasSPMCtrlVarType(state, SensorNodeNum, iCtrlVarType_MaxHumRat)) { - ShowWarningError(RoutineName + WaterCoilType + "=\"" + WaterCoil(WhichCoil).Name + "\". "); + ShowWarningError(RoutineName + WaterCoilType + "=\"" + state.dataWaterCoils->WaterCoil(WhichCoil).Name + "\". "); ShowContinueError(" ..Humidity ratio setpoint not found on coil air outlet node."); ShowContinueError( " ..The setpoint may have been placed on a node downstream of the coil or on an airloop outlet node."); @@ -6291,7 +6176,7 @@ namespace WaterCoils { return Residuum; } - Real64 EstimateHEXSurfaceArea(int const CoilNum) // coil number, [-] + Real64 EstimateHEXSurfaceArea(EnergyPlusData &state, int const CoilNum) // coil number, [-] { // FUNCTION INFORMATION: @@ -6357,10 +6242,10 @@ namespace WaterCoils { // FUNCTION LOCAL VARIABLE DECLARATIONS: - WaterCoil(CoilNum).UACoilTotal = 1.0 / (1.0 / WaterCoil(CoilNum).UACoilExternal + 1.0 / WaterCoil(CoilNum).UACoilInternal); + state.dataWaterCoils->WaterCoil(CoilNum).UACoilTotal = 1.0 / (1.0 / state.dataWaterCoils->WaterCoil(CoilNum).UACoilExternal + 1.0 / state.dataWaterCoils->WaterCoil(CoilNum).UACoilInternal); // the heat exchanger surface area is calculated as follows: - return WaterCoil(CoilNum).UACoilTotal * UOverallHeatTransferCoef_inv; // Heat exchanger surface area [m2] + return state.dataWaterCoils->WaterCoil(CoilNum).UACoilTotal * UOverallHeatTransferCoef_inv; // Heat exchanger surface area [m2] } int GetWaterCoilIndex(EnergyPlusData &state, std::string const &CoilType, // must match coil types in this module @@ -6384,18 +6269,18 @@ namespace WaterCoils { int IndexNum; // returned coil index if matched coil // Obtains and allocates WaterCoil related parameters from input file - if (GetWaterCoilsInputFlag) { + if (state.dataWaterCoils->GetWaterCoilsInputFlag) { GetWaterCoilInput(state); - GetWaterCoilsInputFlag = false; + state.dataWaterCoils->GetWaterCoilsInputFlag = false; } IndexNum = 0; if (CoilType == "COIL:HEATING:WATER") { - IndexNum = UtilityRoutines::FindItemInList(CoilName, WaterCoil); + IndexNum = UtilityRoutines::FindItemInList(CoilName, state.dataWaterCoils->WaterCoil); } else if (CoilType == "COIL:COOLING:WATER") { - IndexNum = UtilityRoutines::FindItemInList(CoilName, WaterCoil); + IndexNum = UtilityRoutines::FindItemInList(CoilName, state.dataWaterCoils->WaterCoil); } else if (CoilType == "COIL:COOLING:WATER:DETAILEDGEOMETRY") { - IndexNum = UtilityRoutines::FindItemInList(CoilName, WaterCoil); + IndexNum = UtilityRoutines::FindItemInList(CoilName, state.dataWaterCoils->WaterCoil); } else { IndexNum = 0; } @@ -6432,22 +6317,22 @@ namespace WaterCoils { int IndexNum; // index to water coil // Obtains and allocates WaterCoil related parameters from input file - if (GetWaterCoilsInputFlag) { + if (state.dataWaterCoils->GetWaterCoilsInputFlag) { GetWaterCoilInput(state); - GetWaterCoilsInputFlag = false; + state.dataWaterCoils->GetWaterCoilsInputFlag = false; } Capacity = -1.0; if (CoilType == "COIL:HEATING:WATER") { - IndexNum = UtilityRoutines::FindItemInList(CoilName, WaterCoil); - Capacity = WaterCoil(IndexNum).DesWaterHeatingCoilRate; + IndexNum = UtilityRoutines::FindItemInList(CoilName, state.dataWaterCoils->WaterCoil); + Capacity = state.dataWaterCoils->WaterCoil(IndexNum).DesWaterHeatingCoilRate; } else if (CoilType == "COIL:COOLING:WATER") { - IndexNum = UtilityRoutines::FindItemInList(CoilName, WaterCoil); - Capacity = WaterCoil(IndexNum).DesWaterCoolingCoilRate; + IndexNum = UtilityRoutines::FindItemInList(CoilName, state.dataWaterCoils->WaterCoil); + Capacity = state.dataWaterCoils->WaterCoil(IndexNum).DesWaterCoolingCoilRate; } else if (CoilType == "COIL:COOLING:WATER:DETAILEDGEOMETRY") { - IndexNum = UtilityRoutines::FindItemInList(CoilName, WaterCoil); - Capacity = WaterCoil(IndexNum).DesWaterCoolingCoilRate; + IndexNum = UtilityRoutines::FindItemInList(CoilName, state.dataWaterCoils->WaterCoil); + Capacity = state.dataWaterCoils->WaterCoil(IndexNum).DesWaterCoolingCoilRate; } else { IndexNum = 0; } @@ -6460,7 +6345,7 @@ namespace WaterCoils { return Capacity; } - void UpdateWaterToAirCoilPlantConnection(int const CoilTypeNum, + void UpdateWaterToAirCoilPlantConnection(EnergyPlusData &state, int const CoilTypeNum, std::string const &CoilName, int const EP_UNUSED(EquipFlowCtrl), // Flow control mode for the equipment int const LoopNum, // Plant loop index for where called from @@ -6498,23 +6383,23 @@ namespace WaterCoils { // Find the correct water coil if (CompIndex == 0) { - CoilNum = UtilityRoutines::FindItemInList(CoilName, WaterCoil); + CoilNum = UtilityRoutines::FindItemInList(CoilName, state.dataWaterCoils->WaterCoil); if (CoilNum == 0) { ShowFatalError("UpdateWaterToAirCoilPlantConnection: Specified Coil not one of Valid water coils=" + CoilName); } CompIndex = CoilNum; } else { CoilNum = CompIndex; - if (CoilNum > NumWaterCoils || CoilNum < 1) { + if (CoilNum > state.dataWaterCoils->NumWaterCoils || CoilNum < 1) { ShowFatalError("UpdateWaterToAirCoilPlantConnection: Invalid CompIndex passed=" + TrimSigDigits(CoilNum) + - ", Number of Coils=" + TrimSigDigits(NumWaterCoils) + ", Entered Coil name=" + CoilName); + ", Number of Coils=" + TrimSigDigits(state.dataWaterCoils->NumWaterCoils) + ", Entered Coil name=" + CoilName); } if (KickOffSimulation) { - if (CoilName != WaterCoil(CoilNum).Name) { + if (CoilName != state.dataWaterCoils->WaterCoil(CoilNum).Name) { ShowFatalError("UpdateWaterToAirCoilPlantConnection: Invalid CompIndex passed=" + TrimSigDigits(CoilNum) + - ", Coil name=" + CoilName + ", stored Coil Name for that index=" + WaterCoil(CoilNum).Name); + ", Coil name=" + CoilName + ", stored Coil Name for that index=" + state.dataWaterCoils->WaterCoil(CoilNum).Name); } - if (CoilTypeNum != WaterCoil(CoilNum).WaterCoilType_Num) { + if (CoilTypeNum != state.dataWaterCoils->WaterCoil(CoilNum).WaterCoilType_Num) { ShowFatalError("UpdateWaterToAirCoilPlantConnection: Invalid CompIndex passed=" + TrimSigDigits(CoilNum) + ", Coil name=" + CoilName + ", stored Coil Name for that index=" + ccSimPlantEquipTypes(CoilTypeNum)); } @@ -6527,19 +6412,19 @@ namespace WaterCoils { DidAnythingChange = false; - InletNodeNum = WaterCoil(CoilNum).WaterInletNodeNum; - OutletNodeNum = WaterCoil(CoilNum).WaterOutletNodeNum; + InletNodeNum = state.dataWaterCoils->WaterCoil(CoilNum).WaterInletNodeNum; + OutletNodeNum = state.dataWaterCoils->WaterCoil(CoilNum).WaterOutletNodeNum; - if (Node(InletNodeNum).Temp != WaterCoil(CoilNum).InletWaterTemp) DidAnythingChange = true; + if (Node(InletNodeNum).Temp != state.dataWaterCoils->WaterCoil(CoilNum).InletWaterTemp) DidAnythingChange = true; - if (Node(OutletNodeNum).Temp != WaterCoil(CoilNum).OutletWaterTemp) DidAnythingChange = true; + if (Node(OutletNodeNum).Temp != state.dataWaterCoils->WaterCoil(CoilNum).OutletWaterTemp) DidAnythingChange = true; - if (Node(InletNodeNum).MassFlowRate != WaterCoil(CoilNum).OutletWaterMassFlowRate) { + if (Node(InletNodeNum).MassFlowRate != state.dataWaterCoils->WaterCoil(CoilNum).OutletWaterMassFlowRate) { DidAnythingChange = true; Node(OutletNodeNum).MassFlowRate = Node(InletNodeNum).MassFlowRate; // make sure flows are consistent } - if (Node(OutletNodeNum).MassFlowRate != WaterCoil(CoilNum).OutletWaterMassFlowRate) DidAnythingChange = true; + if (Node(OutletNodeNum).MassFlowRate != state.dataWaterCoils->WaterCoil(CoilNum).OutletWaterMassFlowRate) DidAnythingChange = true; if (DidAnythingChange) { // set sim flag for this loop @@ -6578,9 +6463,9 @@ namespace WaterCoils { // Obtains and Allocates HeatingCoil related parameters from input file // Obtains and Allocates DXCoils - if (GetWaterCoilsInputFlag) { + if (state.dataWaterCoils->GetWaterCoilsInputFlag) { GetWaterCoilInput(state); - GetWaterCoilsInputFlag = false; + state.dataWaterCoils->GetWaterCoilsInputFlag = false; } WhichCoil = 0; @@ -6588,9 +6473,9 @@ namespace WaterCoils { if (UtilityRoutines::SameString(CoilType, "Coil:Heating:Water") || UtilityRoutines::SameString(CoilType, "Coil:Cooling:Water") || UtilityRoutines::SameString(CoilType, "Coil:Cooling:Water:DetailedGeometry")) { - WhichCoil = UtilityRoutines::FindItem(CoilName, WaterCoil); + WhichCoil = UtilityRoutines::FindItem(CoilName, state.dataWaterCoils->WaterCoil); if (WhichCoil != 0) { - AvailSchIndex = WaterCoil(WhichCoil).SchedPtr; + AvailSchIndex = state.dataWaterCoils->WaterCoil(WhichCoil).SchedPtr; } } else { WhichCoil = 0; @@ -6624,28 +6509,28 @@ namespace WaterCoils { // Using/Aliasing using General::TrimSigDigits; - if (GetWaterCoilsInputFlag) { + if (state.dataWaterCoils->GetWaterCoilsInputFlag) { GetWaterCoilInput(state); - GetWaterCoilsInputFlag = false; + state.dataWaterCoils->GetWaterCoilsInputFlag = false; } - if (CoilNum <= 0 || CoilNum > NumWaterCoils) { + if (CoilNum <= 0 || CoilNum > state.dataWaterCoils->NumWaterCoils) { ShowSevereError("SetHeatingCoilData: called with heating coil Number out of range=" + TrimSigDigits(CoilNum) + " should be >0 and <" + - TrimSigDigits(NumWaterCoils)); + TrimSigDigits(state.dataWaterCoils->NumWaterCoils)); ErrorsFound = true; return; } if (present(DesiccantRegenerationCoil)) { - WaterCoil(CoilNum).DesiccantRegenerationCoil = DesiccantRegenerationCoil; + state.dataWaterCoils->WaterCoil(CoilNum).DesiccantRegenerationCoil = DesiccantRegenerationCoil; } if (present(DesiccantDehumIndex)) { - WaterCoil(CoilNum).DesiccantDehumNum = DesiccantDehumIndex; + state.dataWaterCoils->WaterCoil(CoilNum).DesiccantDehumNum = DesiccantDehumIndex; } } - void EstimateCoilInletWaterTemp(int const CoilNum, // index to heating coil + void EstimateCoilInletWaterTemp(EnergyPlusData &state, int const CoilNum, // index to heating coil int const FanOpMode, // fan operating mode Real64 const PartLoadRatio, // part-load ratio of heating coil Real64 const UAMax, // maximum UA-Value = design heating capacity @@ -6704,28 +6589,28 @@ namespace WaterCoils { UA = UAMax; DesCoilInletWaterTempUsed = DesCoilHWInletTempMin; - TempAirIn = WaterCoil(CoilNum).InletAirTemp; - Win = WaterCoil(CoilNum).InletAirHumRat; - TempWaterIn = WaterCoil(CoilNum).InletWaterTemp; + TempAirIn = state.dataWaterCoils->WaterCoil(CoilNum).InletAirTemp; + Win = state.dataWaterCoils->WaterCoil(CoilNum).InletAirHumRat; + TempWaterIn = state.dataWaterCoils->WaterCoil(CoilNum).InletWaterTemp; // adjust mass flow rates for cycling fan cycling coil operation if (FanOpMode == CycFanCycCoil) { if (PartLoadRatio > 0.0) { - AirMassFlow = WaterCoil(CoilNum).InletAirMassFlowRate / PartLoadRatio; - WaterMassFlowRate = min(WaterCoil(CoilNum).InletWaterMassFlowRate / PartLoadRatio, WaterCoil(CoilNum).MaxWaterMassFlowRate); + AirMassFlow = state.dataWaterCoils->WaterCoil(CoilNum).InletAirMassFlowRate / PartLoadRatio; + WaterMassFlowRate = min(state.dataWaterCoils->WaterCoil(CoilNum).InletWaterMassFlowRate / PartLoadRatio, state.dataWaterCoils->WaterCoil(CoilNum).MaxWaterMassFlowRate); } else { AirMassFlow = 0.0; WaterMassFlowRate = 0.0; return; } } else { - AirMassFlow = WaterCoil(CoilNum).InletAirMassFlowRate; - WaterMassFlowRate = WaterCoil(CoilNum).InletWaterMassFlowRate; + AirMassFlow = state.dataWaterCoils->WaterCoil(CoilNum).InletAirMassFlowRate; + WaterMassFlowRate = state.dataWaterCoils->WaterCoil(CoilNum).InletWaterMassFlowRate; } if (WaterMassFlowRate > MassFlowTolerance) { // if the coil is operating CapacitanceAir = PsyCpAirFnW(Win) * AirMassFlow; - Cp = GetSpecificHeatGlycol(PlantLoop(WaterCoil(CoilNum).WaterLoopNum).FluidName, + Cp = GetSpecificHeatGlycol(PlantLoop(state.dataWaterCoils->WaterCoil(CoilNum).WaterLoopNum).FluidName, TempWaterIn, - PlantLoop(WaterCoil(CoilNum).WaterLoopNum).FluidIndex, + PlantLoop(state.dataWaterCoils->WaterCoil(CoilNum).WaterLoopNum).FluidIndex, RoutineName); CapacitanceWater = Cp * WaterMassFlowRate; CapacitanceMin = min(CapacitanceAir, CapacitanceWater); @@ -6739,7 +6624,7 @@ namespace WaterCoils { if (((CapacitanceAir > 0.0) && (CapacitanceWater > 0.0))) { if (UA <= 0.0) { - ShowWarningError("UA is zero for COIL:Heating:Water " + WaterCoil(CoilNum).Name); + ShowWarningError("UA is zero for COIL:Heating:Water " + state.dataWaterCoils->WaterCoil(CoilNum).Name); return; } NTU = UA / CapacitanceMin; diff --git a/src/EnergyPlus/WaterCoils.hh b/src/EnergyPlus/WaterCoils.hh index 6f7dfe2f054..4f9542c6edb 100644 --- a/src/EnergyPlus/WaterCoils.hh +++ b/src/EnergyPlus/WaterCoils.hh @@ -53,89 +53,18 @@ #include // EnergyPlus Headers +#include #include #include +#include namespace EnergyPlus { // Forward declarations struct EnergyPlusData; + struct WaterCoilsData; namespace WaterCoils { - // Using/Aliasing - - // Data - // PRIVATE ! Everything private unless explicitly made public - - // MODULE PARAMETER DEFINITIONS - - extern int const MaxPolynomOrder; - extern int const MaxOrderedPairs; - - extern Real64 const PolyConvgTol; - extern Real64 const MinWaterMassFlowFrac; - extern Real64 const MinAirMassFlow; - - // coil types in this module - extern int const WaterCoil_SimpleHeating; - extern int const WaterCoil_DetFlatFinCooling; - extern int const WaterCoil_Cooling; - - extern int const CoilType_Cooling; - extern int const CoilType_Heating; - - extern int const CoilModel_Simple; - extern int const CoilModel_Cooling; - extern int const CoilModel_Detailed; - - // Parameters for Heat Exchanger Configuration - extern int const CounterFlow; - extern int const CrossFlow; - extern int const SimpleAnalysis; - extern int const DetailedAnalysis; - - // Water Systems - extern int const CondensateDiscarded; // default mode where water is "lost" - extern int const CondensateToTank; // collect coil condensate from air and store in water storage tank - - // Parameters for COIL:Water:SimpleHeating Coil Performance Input Method - extern int const UAandFlow; // for Coil Performance Input Method = UA and Design Water Flow Rate - extern int const NomCap; // for Coil Performance Input Method = Nominal Capacity - - // Parameters Subroutine CoolingCoil: design calc or simulation calc. - extern int const DesignCalc; // ignore on/off check in CoolingCoil - extern int const SimCalc; // pay attention to on/off check in CoolingCoil - - // DERIVED TYPE DEFINITIONS - - // MODULE VARIABLE DECLARATIONS: - extern int NumWaterCoils; // The Number of WaterCoils found in the Input - extern Array1D_bool MySizeFlag; - extern Array1D_bool MyUAAndFlowCalcFlag; - extern Array1D_bool MyCoilDesignFlag; - extern Array1D_bool CoilWarningOnceFlag; - extern Array1D_int WaterTempCoolCoilErrs; // error counting for detailed coils - extern Array1D_int PartWetCoolCoilErrs; // error counting for detailed coils - extern bool GetWaterCoilsInputFlag; // Flag set to make sure you get input once - extern Array1D_bool CheckEquipName; - - // Subroutine Specifications for the Module - // Driver/Manager Routines - - // Get Input routines for module - - // Initialization routines for module - - // Algorithms for the module - - // Update routine to check convergence and update nodes - - // Reporting routines for module - - // Other routines - - // Types - struct WaterCoilEquipConditions { // Members @@ -298,7 +227,7 @@ namespace WaterCoils { HeatExchType(0), CoolingCoilAnalysisMode(0), UACoilInternalPerUnitArea(0.0), UAWetExtPerUnitArea(0.0), UADryExtPerUnitArea(0.0), SurfAreaWetFractionSaved(0.0), UACoilVariable(0.0), RatioAirSideToWaterSideConvect(1.0), AirSideNominalConvect(0.0), LiquidSideNominalConvect(0.0), Control(0), AirInletNodeNum(0), AirOutletNodeNum(0), WaterInletNodeNum(0), WaterOutletNodeNum(0), - WaterLoopNum(0), WaterLoopSide(0), WaterLoopBranchNum(0), WaterLoopCompNum(0), CondensateCollectMode(CondensateDiscarded), + WaterLoopNum(0), WaterLoopSide(0), WaterLoopBranchNum(0), WaterLoopCompNum(0), CondensateCollectMode(1001), CondensateTankID(0), CondensateTankSupplyARRID(0), CondensateVdot(0.0), CondensateVol(0.0), CoilPerfInpMeth(0), FaultyCoilFoulingFlag(false), FaultyCoilFoulingIndex(0), FaultyCoilFoulingFactor(0.0), DesiccantRegenerationCoil(false), DesiccantDehumNum(0), DesignWaterDeltaTemp(0.0), UseDesignWaterDeltaTemp(false), ControllerName(""), @@ -318,12 +247,7 @@ namespace WaterCoils { } }; - // Object Data - extern Array1D WaterCoil; - extern Array1D WaterCoilNumericFields; - // Functions - void clear_state(); void SimulateWaterCoilComponents(EnergyPlusData &state, std::string const &CompName, bool const FirstHVACIteration, @@ -337,30 +261,30 @@ namespace WaterCoils { void InitWaterCoil(EnergyPlusData &state, int const CoilNum, bool const FirstHVACIteration); void // refactor for coil report - CalcAdjustedCoilUA(int const CoilNum); // refactor for coil report + CalcAdjustedCoilUA(EnergyPlusData &state, int const CoilNum); // refactor for coil report void SizeWaterCoil(EnergyPlusData &state, int const CoilNum); - void CalcSimpleHeatingCoil(int const CoilNum, // index to heating coil + void CalcSimpleHeatingCoil(EnergyPlusData &state, int const CoilNum, // index to heating coil int const FanOpMode, // fan operating mode Real64 const PartLoadRatio, // part-load ratio of heating coil int const CalcMode // 1 = design calc; 2 = simulation calculation ); - void CalcDetailFlatFinCoolingCoil(int const CoilNum, + void CalcDetailFlatFinCoolingCoil(EnergyPlusData &state, int const CoilNum, int const CalcMode, int const FanOpMode, // fan operating mode Real64 const PartLoadRatio // part-load ratio of heating coil ); - void CoolingCoil(int const CoilNum, + void CoolingCoil(EnergyPlusData &state, int const CoilNum, bool const FirstHVACIteration, int const CalcMode, int const FanOpMode, // fan operating mode Real64 const PartLoadRatio // part-load ratio of heating coil ); - void CoilCompletelyDry(int const CoilNum, + void CoilCompletelyDry(EnergyPlusData &state, int const CoilNum, Real64 const WaterTempIn, // Entering water temperature Real64 const AirTempIn, // Entering air dry bulb temperature Real64 const CoilUA, // Overall heat transfer coefficient @@ -374,7 +298,7 @@ namespace WaterCoils { // Coil Completely Wet Subroutine for Cooling Coil - void CoilCompletelyWet(int const CoilNum, // Number of Coil + void CoilCompletelyWet(EnergyPlusData &state, int const CoilNum, // Number of Coil Real64 const WaterTempIn, // Water temperature IN to this function (C) Real64 const AirTempIn, // Air dry bulb temperature IN to this function(C) Real64 const AirHumRat, // Air Humidity Ratio IN to this funcation (C) @@ -393,7 +317,7 @@ namespace WaterCoils { // Coil Part Wet Part Dry Subroutine for Cooling Coil - void CoilPartWetPartDry(int const CoilNum, // Number of Coil + void CoilPartWetPartDry(EnergyPlusData &state, int const CoilNum, // Number of Coil bool const FirstHVACIteration, // Saving Old values Real64 const InletWaterTemp, // Entering liquid temperature(C) Real64 const InletAirTemp, // Entering air dry bulb temperature(C) @@ -410,7 +334,7 @@ namespace WaterCoils { // Calculating coil UA for Cooling Coil - Real64 CalcCoilUAbyEffectNTU(int const CoilNum, + Real64 CalcCoilUAbyEffectNTU(EnergyPlusData &state, int const CoilNum, Real64 const CapacityStream1, // Capacity rate of stream1.(W/C) Real64 const EnergyInStreamOne, // Inlet state of stream1.(C) Real64 const CapacityStream2, // Capacity rate of stream2.(W/C) @@ -420,7 +344,7 @@ namespace WaterCoils { // Calculating coil outlet stream conditions and coil UA for Cooling Coil - void CoilOutletStreamCondition(int const CoilNum, + void CoilOutletStreamCondition(EnergyPlusData &state, int const CoilNum, Real64 const CapacityStream1, // Capacity rate of stream1(W/C) Real64 const EnergyInStreamOne, // Inlet state of stream1 (C) Real64 const CapacityStream2, // Capacity rate of stream2 (W/C) @@ -432,7 +356,7 @@ namespace WaterCoils { // Subroutine for caculating outlet condition if coil is wet , for Cooling Coil - void WetCoilOutletCondition(int const CoilNum, + void WetCoilOutletCondition(EnergyPlusData &state, int const CoilNum, Real64 const AirTempIn, // Entering air dry bulb temperature(C) Real64 const EnthAirInlet, // Entering air enthalpy(J/kg) Real64 const EnthAirOutlet, // Leaving air enthalpy(J/kg) @@ -442,38 +366,23 @@ namespace WaterCoils { Real64 &SenWaterCoilLoad // Sensible heat transfer rate(W) ); - // Beginning of Update subroutines for the WaterCoil Module - // ***************************************************************************** + void UpdateWaterCoil(EnergyPlusData &state, int const CoilNum); - void UpdateWaterCoil(int const CoilNum); + void ReportWaterCoil(EnergyPlusData &state, int const CoilNum); - // End of Update subroutines for the WaterCoil Module - // ***************************************************************************** - - // Beginning of Reporting subroutines for the WaterCoil Module - // ***************************************************************************** - - void ReportWaterCoil(int const CoilNum); - - // End of Reporting subroutines for the WaterCoil Module - // ***************************************************************************** - - // Beginning of Coil Utility subroutines for the Detailed Model - // ***************************************************************************** - - void CalcDryFinEffCoef(Real64 const OutTubeEffFinDiamRatio, Array1D &PolynomCoef); + void CalcDryFinEffCoef(EnergyPlusData &state, Real64 const OutTubeEffFinDiamRatio, Array1D &PolynomCoef); void CalcIBesselFunc(Real64 const BessFuncArg, int const BessFuncOrd, Real64 &IBessFunc, int &ErrorCode); void CalcKBesselFunc(Real64 const BessFuncArg, int const BessFuncOrd, Real64 &KBessFunc, int &ErrorCode); - void CalcPolynomCoef(Array2 const &OrderedPair, Array1D &PolynomCoef); + void CalcPolynomCoef(EnergyPlusData &state, Array2 const &OrderedPair, Array1D &PolynomCoef); - Real64 SimpleHeatingCoilUAResidual(Real64 const UA, // UA of coil + Real64 SimpleHeatingCoilUAResidual(EnergyPlusData &state, Real64 const UA, // UA of coil Array1D const &Par // par(1) = design coil load [W] ); - Real64 SimpleCoolingCoilUAResidual(Real64 const UA, // UA of coil + Real64 SimpleCoolingCoilUAResidual(EnergyPlusData &state, Real64 const UA, // UA of coil Array1D const &Par // par(1) = design coil load [W] ); @@ -550,7 +459,7 @@ namespace WaterCoils { Array1D const &Par // Par(1) = desired enthaply H [J/kg] ); - Real64 EstimateHEXSurfaceArea(int const CoilNum); // coil number, [-] + Real64 EstimateHEXSurfaceArea(EnergyPlusData &state, int const CoilNum); // coil number, [-] int GetWaterCoilIndex(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 @@ -562,7 +471,7 @@ namespace WaterCoils { bool &ErrorsFound // set to true if problem ); - void UpdateWaterToAirCoilPlantConnection(int const CoilTypeNum, + void UpdateWaterToAirCoilPlantConnection(EnergyPlusData &state, int const CoilTypeNum, std::string const &CoilName, int const EquipFlowCtrl, // Flow control mode for the equipment int const LoopNum, // Plant loop index for where called from @@ -586,18 +495,101 @@ namespace WaterCoils { ); // estimate heating coil design inlet water temperature for autosizing UA-value - void EstimateCoilInletWaterTemp(int const CoilNum, // index to heating coil + void EstimateCoilInletWaterTemp(EnergyPlusData &state, int const CoilNum, // index to heating coil int const FanOpMode, // fan operating mode Real64 const PartLoadRatio, // part-load ratio of heating coil Real64 const UAMax, // maximum UA-Value Real64 &DesCoilInletWaterTempUsed // estimated coil design inlet water temperature ); - // End of Coil Utility subroutines - // ***************************************************************************** - } // namespace WaterCoils +struct WaterCoilsData : BaseGlobalStruct { + + int const MaxPolynomOrder; + int const MaxOrderedPairs; + + Real64 const PolyConvgTol; + Real64 const MinWaterMassFlowFrac; + Real64 const MinAirMassFlow; + + int const CoilType_Cooling; + int const CoilType_Heating; + + int const CoilModel_Simple; + int const CoilModel_Cooling; + int const CoilModel_Detailed; + + // Parameters for Heat Exchanger Configuration + int const CounterFlow; + int const CrossFlow; + int const SimpleAnalysis; + int const DetailedAnalysis; + + // Water Systems + int const CondensateDiscarded; // default mode where water is "lost" + int const CondensateToTank; // collect coil condensate from air and store in water storage tank + + // Parameters for COIL:Water:SimpleHeating Coil Performance Input Method + int const UAandFlow; // for Coil Performance Input Method = UA and Design Water Flow Rate + int const NomCap; // for Coil Performance Input Method = Nominal Capacity + + // Parameters Subroutine CoolingCoil: design calc or simulation calc. + int const DesignCalc; // ignore on/off check in CoolingCoil + int const SimCalc; // pay attention to on/off check in CoolingCoil + + // DERIVED TYPE DEFINITIONS + + // MODULE VARIABLE DECLARATIONS: + int NumWaterCoils; // The Number of WaterCoils found in the Input + Array1D_bool MySizeFlag; + Array1D_bool MyUAAndFlowCalcFlag; + Array1D_bool MyCoilDesignFlag; + Array1D_bool CoilWarningOnceFlag; + Array1D_int WaterTempCoolCoilErrs; // error counting for detailed coils + Array1D_int PartWetCoolCoilErrs; // error counting for detailed coils + bool GetWaterCoilsInputFlag; // Flag set to make sure you get input once + bool WaterCoilControllerCheckOneTimeFlag; // flg used to check water coil controller + Array1D_bool CheckEquipName; + + bool InitWaterCoilOneTimeFlag; + + // coil types in this module + int const WaterCoil_SimpleHeating; + int const WaterCoil_DetFlatFinCooling; + int const WaterCoil_Cooling; + + Array1D WaterCoil; + Array1D WaterCoilNumericFields; + + void clear_state() override + { + NumWaterCoils = 0; + InitWaterCoilOneTimeFlag = true; + MySizeFlag.deallocate(); + MyUAAndFlowCalcFlag.deallocate(); + MyCoilDesignFlag.deallocate(); + CoilWarningOnceFlag.deallocate(); + WaterTempCoolCoilErrs.deallocate(); + PartWetCoolCoilErrs.deallocate(); + GetWaterCoilsInputFlag = true; + CheckEquipName.deallocate(); + WaterCoil.deallocate(); + WaterCoilNumericFields.deallocate(); + WaterCoilControllerCheckOneTimeFlag = true; + } + + // Default Constructor + WaterCoilsData() + : MaxPolynomOrder(4), MaxOrderedPairs(60), PolyConvgTol(1.E-05), MinWaterMassFlowFrac(0.000001), + MinAirMassFlow(0.001), CoilType_Cooling(1), CoilType_Heating(2), CoilModel_Simple(1), CoilModel_Cooling(2), CoilModel_Detailed(3), + CounterFlow(1), CrossFlow(2), SimpleAnalysis(1), DetailedAnalysis(2), CondensateDiscarded(1001), + CondensateToTank(1002), UAandFlow(1), NomCap(2), DesignCalc(1), SimCalc(2), NumWaterCoils(0), + GetWaterCoilsInputFlag(true), WaterCoilControllerCheckOneTimeFlag(true), + InitWaterCoilOneTimeFlag(true), WaterCoil_SimpleHeating(DataPlant::TypeOf_CoilWaterSimpleHeating), WaterCoil_DetFlatFinCooling(DataPlant::TypeOf_CoilWaterDetailedFlatCooling), WaterCoil_Cooling(DataPlant::TypeOf_CoilWaterCooling) + { + } +}; } // namespace EnergyPlus #endif diff --git a/tst/EnergyPlus/unit/AirTerminalSingleDuctMixer.unit.cc b/tst/EnergyPlus/unit/AirTerminalSingleDuctMixer.unit.cc index 237da70906d..452a179d198 100644 --- a/tst/EnergyPlus/unit/AirTerminalSingleDuctMixer.unit.cc +++ b/tst/EnergyPlus/unit/AirTerminalSingleDuctMixer.unit.cc @@ -7533,7 +7533,7 @@ TEST_F(EnergyPlusFixture, AirTerminalSingleDuctMixer_SimFCU_ATMInletSideTest) DataSizing::CurZoneEqNum = 1; DataEnvironment::OutBaroPress = 101325.0; DataEnvironment::StdRhoAir = Psychrometrics::PsyRhoAirFnPbTdbW(OutBaroPress, 20.0, 0.0); - WaterCoils::GetWaterCoilsInputFlag = true; + state.dataWaterCoils->GetWaterCoilsInputFlag = true; DataGlobals::NumOfTimeStepInHour = 1; DataGlobals::TimeStep = 1; DataGlobals::MinutesPerTimeStep = 60; @@ -7568,7 +7568,7 @@ TEST_F(EnergyPlusFixture, AirTerminalSingleDuctMixer_SimFCU_ATMInletSideTest) NumPltSizInput = 2; PlantSizData.allocate(NumPltSizInput); // chilled water coil - auto &CWCoil(WaterCoil(2)); + auto &CWCoil(state.dataWaterCoils->WaterCoil(2)); thisFanCoil.CCoilName_Index = 2; Node(CWCoil.WaterInletNodeNum).Temp = 6.0; CWCoil.WaterLoopNum = 2; @@ -7576,7 +7576,7 @@ TEST_F(EnergyPlusFixture, AirTerminalSingleDuctMixer_SimFCU_ATMInletSideTest) CWCoil.WaterLoopBranchNum = 1; CWCoil.WaterLoopCompNum = 1; // hot water coil - auto &HWCoil(WaterCoil(1)); + auto &HWCoil(state.dataWaterCoils->WaterCoil(1)); thisFanCoil.HCoilName_Index = 1; Node(HWCoil.WaterInletNodeNum).Temp = 60.0; HWCoil.WaterLoopNum = 1; @@ -7600,7 +7600,7 @@ TEST_F(EnergyPlusFixture, AirTerminalSingleDuctMixer_SimFCU_ATMInletSideTest) CWLoop.FluidIndex = 1; CWLoop.FluidName = "WATER"; CWLoop.LoopSide(1).Branch(1).Comp(1).Name = CWCoil.Name; - CWLoop.LoopSide(1).Branch(1).Comp(1).TypeOf_Num = WaterCoil_Cooling; + CWLoop.LoopSide(1).Branch(1).Comp(1).TypeOf_Num = state.dataWaterCoils->WaterCoil_Cooling; CWLoop.LoopSide(1).Branch(1).Comp(1).NodeNumIn = CWCoil.WaterInletNodeNum; CWLoop.LoopSide(1).Branch(1).Comp(1).NodeNumOut = CWCoil.WaterOutletNodeNum; auto &CWLoopSizingData(DataSizing::PlantSizData(2)); @@ -7617,7 +7617,7 @@ TEST_F(EnergyPlusFixture, AirTerminalSingleDuctMixer_SimFCU_ATMInletSideTest) HWLoop.FluidIndex = 1; HWLoop.FluidName = "WATER"; HWLoop.LoopSide(1).Branch(1).Comp(1).Name = HWCoil.Name; - HWLoop.LoopSide(1).Branch(1).Comp(1).TypeOf_Num = WaterCoil_SimpleHeating; + HWLoop.LoopSide(1).Branch(1).Comp(1).TypeOf_Num = state.dataWaterCoils->WaterCoil_SimpleHeating; HWLoop.LoopSide(1).Branch(1).Comp(1).NodeNumIn = HWCoil.WaterInletNodeNum; HWLoop.LoopSide(1).Branch(1).Comp(1).NodeNumOut = HWCoil.WaterOutletNodeNum; auto &HWLoopSizingData(DataSizing::PlantSizData(1)); @@ -7961,7 +7961,7 @@ TEST_F(EnergyPlusFixture, AirTerminalSingleDuctMixer_FCU_NightCycleTest) DataSizing::CurZoneEqNum = 1; DataEnvironment::OutBaroPress = 101325.0; DataEnvironment::StdRhoAir = Psychrometrics::PsyRhoAirFnPbTdbW(OutBaroPress, 20.0, 0.0); - WaterCoils::GetWaterCoilsInputFlag = true; + state.dataWaterCoils->GetWaterCoilsInputFlag = true; DataGlobals::NumOfTimeStepInHour = 1; DataGlobals::TimeStep = 1; DataGlobals::MinutesPerTimeStep = 60; @@ -7999,7 +7999,7 @@ TEST_F(EnergyPlusFixture, AirTerminalSingleDuctMixer_FCU_NightCycleTest) NumPltSizInput = 2; PlantSizData.allocate(NumPltSizInput); // chilled water coil - auto &CWCoil(WaterCoil(2)); + auto &CWCoil(state.dataWaterCoils->WaterCoil(2)); thisFanCoil.CCoilName_Index = 2; Node(CWCoil.WaterInletNodeNum).Temp = 6.0; CWCoil.WaterLoopNum = 2; @@ -8007,7 +8007,7 @@ TEST_F(EnergyPlusFixture, AirTerminalSingleDuctMixer_FCU_NightCycleTest) CWCoil.WaterLoopBranchNum = 1; CWCoil.WaterLoopCompNum = 1; // hot water coil - auto &HWCoil(WaterCoil(1)); + auto &HWCoil(state.dataWaterCoils->WaterCoil(1)); thisFanCoil.HCoilName_Index = 1; Node(HWCoil.WaterInletNodeNum).Temp = 60.0; HWCoil.WaterLoopNum = 1; @@ -8031,7 +8031,7 @@ TEST_F(EnergyPlusFixture, AirTerminalSingleDuctMixer_FCU_NightCycleTest) CWLoop.FluidIndex = 1; CWLoop.FluidName = "WATER"; CWLoop.LoopSide(1).Branch(1).Comp(1).Name = CWCoil.Name; - CWLoop.LoopSide(1).Branch(1).Comp(1).TypeOf_Num = WaterCoil_Cooling; + CWLoop.LoopSide(1).Branch(1).Comp(1).TypeOf_Num = state.dataWaterCoils->WaterCoil_Cooling; CWLoop.LoopSide(1).Branch(1).Comp(1).NodeNumIn = CWCoil.WaterInletNodeNum; CWLoop.LoopSide(1).Branch(1).Comp(1).NodeNumOut = CWCoil.WaterOutletNodeNum; auto &CWLoopSizingData(DataSizing::PlantSizData(2)); @@ -8048,7 +8048,7 @@ TEST_F(EnergyPlusFixture, AirTerminalSingleDuctMixer_FCU_NightCycleTest) HWLoop.FluidIndex = 1; HWLoop.FluidName = "WATER"; HWLoop.LoopSide(1).Branch(1).Comp(1).Name = HWCoil.Name; - HWLoop.LoopSide(1).Branch(1).Comp(1).TypeOf_Num = WaterCoil_SimpleHeating; + HWLoop.LoopSide(1).Branch(1).Comp(1).TypeOf_Num = state.dataWaterCoils->WaterCoil_SimpleHeating; HWLoop.LoopSide(1).Branch(1).Comp(1).NodeNumIn = HWCoil.WaterInletNodeNum; HWLoop.LoopSide(1).Branch(1).Comp(1).NodeNumOut = HWCoil.WaterOutletNodeNum; auto &HWLoopSizingData(DataSizing::PlantSizData(1)); diff --git a/tst/EnergyPlus/unit/DesiccantDehumidifiers.unit.cc b/tst/EnergyPlus/unit/DesiccantDehumidifiers.unit.cc index 9eeb316b1be..48e73ad1bb1 100644 --- a/tst/EnergyPlus/unit/DesiccantDehumidifiers.unit.cc +++ b/tst/EnergyPlus/unit/DesiccantDehumidifiers.unit.cc @@ -5446,13 +5446,13 @@ TEST_F(EnergyPlusFixture, DesiccantDehum_RegenAirHeaterHWCoilSizingTest) // simulate to determine HW coil design capacity SimDesiccantDehumidifier(state, CompName, FirstHVACIteration, CompIndex); - for (loop = 1; loop <= NumWaterCoils; ++loop) { - if (WaterCoil(loop).Name == DesicDehum(DesicDehumNum).RegenCoilName) { + for (loop = 1; loop <= state.dataWaterCoils->NumWaterCoils; ++loop) { + if (state.dataWaterCoils->WaterCoil(loop).Name == DesicDehum(DesicDehumNum).RegenCoilName) { CoilIndex = loop; } } // verify results - EXPECT_EQ(RegCoilCapacity, WaterCoil(CoilIndex).DesWaterHeatingCoilRate); + EXPECT_EQ(RegCoilCapacity, state.dataWaterCoils->WaterCoil(CoilIndex).DesWaterHeatingCoilRate); } TEST_F(EnergyPlusFixture, DesiccantDehum_VSCoolingCoilOnPrimaryAirSystemTest) diff --git a/tst/EnergyPlus/unit/FanCoilUnits.unit.cc b/tst/EnergyPlus/unit/FanCoilUnits.unit.cc index e49be9b2004..e92d70b4472 100644 --- a/tst/EnergyPlus/unit/FanCoilUnits.unit.cc +++ b/tst/EnergyPlus/unit/FanCoilUnits.unit.cc @@ -129,7 +129,7 @@ namespace EnergyPlus { DataEnvironment::OutBaroPress = 101325.0; DataEnvironment::StdRhoAir = 1.20; - WaterCoils::GetWaterCoilsInputFlag = true; + state.dataWaterCoils->GetWaterCoilsInputFlag = true; NumCoils = 0; DataGlobals::NumOfTimeStepInHour = 1; DataGlobals::TimeStep = 1; @@ -313,34 +313,34 @@ namespace EnergyPlus { Node(Fan(1).InletNodeNum).MassFlowRateMax = AirMassFlow; Node(Fan(1).InletNodeNum).MassFlowRateMaxAvail = AirMassFlow; - WaterCoil(2).UACoilTotal = 470.0; - WaterCoil(2).UACoilExternal = 611.0; - WaterCoil(2).UACoilInternal = 2010.0; - WaterCoil(2).TotCoilOutsideSurfArea = 50.0; - - Node(WaterCoil(2).AirInletNodeNum).MassFlowRate = AirMassFlow; - Node(WaterCoil(2).AirInletNodeNum).MassFlowRateMin = AirMassFlow; - Node(WaterCoil(2).AirInletNodeNum).MassFlowRateMax = AirMassFlow; - Node(WaterCoil(2).AirInletNodeNum).MassFlowRateMaxAvail = AirMassFlow; - - WaterCoil(2).InletWaterMassFlowRate = ColdWaterMassFlowRate; - WaterCoil(2).MaxWaterMassFlowRate = ColdWaterMassFlowRate; - Node(WaterCoil(2).WaterInletNodeNum).MassFlowRate = ColdWaterMassFlowRate; - Node(WaterCoil(2).WaterInletNodeNum).MassFlowRateMaxAvail = ColdWaterMassFlowRate; - Node(WaterCoil(2).WaterInletNodeNum).Temp = 6.0; - Node(WaterCoil(2).WaterOutletNodeNum).MassFlowRate = ColdWaterMassFlowRate; - Node(WaterCoil(2).WaterOutletNodeNum).MassFlowRateMaxAvail = ColdWaterMassFlowRate; - - Node(WaterCoil(1).AirInletNodeNum).MassFlowRate = AirMassFlow; - Node(WaterCoil(1).AirInletNodeNum).MassFlowRateMaxAvail = AirMassFlow; - - Node(WaterCoil(1).WaterInletNodeNum).Temp = 60.0; - Node(WaterCoil(1).WaterInletNodeNum).MassFlowRate = HotWaterMassFlowRate; - Node(WaterCoil(1).WaterInletNodeNum).MassFlowRateMaxAvail = HotWaterMassFlowRate; - Node(WaterCoil(1).WaterOutletNodeNum).MassFlowRate = HotWaterMassFlowRate; - Node(WaterCoil(1).WaterOutletNodeNum).MassFlowRateMaxAvail = HotWaterMassFlowRate; - WaterCoil(1).InletWaterMassFlowRate = HotWaterMassFlowRate; - WaterCoil(1).MaxWaterMassFlowRate = HotWaterMassFlowRate; + state.dataWaterCoils->WaterCoil(2).UACoilTotal = 470.0; + state.dataWaterCoils->WaterCoil(2).UACoilExternal = 611.0; + state.dataWaterCoils->WaterCoil(2).UACoilInternal = 2010.0; + state.dataWaterCoils->WaterCoil(2).TotCoilOutsideSurfArea = 50.0; + + Node(state.dataWaterCoils->WaterCoil(2).AirInletNodeNum).MassFlowRate = AirMassFlow; + Node(state.dataWaterCoils->WaterCoil(2).AirInletNodeNum).MassFlowRateMin = AirMassFlow; + Node(state.dataWaterCoils->WaterCoil(2).AirInletNodeNum).MassFlowRateMax = AirMassFlow; + Node(state.dataWaterCoils->WaterCoil(2).AirInletNodeNum).MassFlowRateMaxAvail = AirMassFlow; + + state.dataWaterCoils->WaterCoil(2).InletWaterMassFlowRate = ColdWaterMassFlowRate; + state.dataWaterCoils->WaterCoil(2).MaxWaterMassFlowRate = ColdWaterMassFlowRate; + Node(state.dataWaterCoils->WaterCoil(2).WaterInletNodeNum).MassFlowRate = ColdWaterMassFlowRate; + Node(state.dataWaterCoils->WaterCoil(2).WaterInletNodeNum).MassFlowRateMaxAvail = ColdWaterMassFlowRate; + Node(state.dataWaterCoils->WaterCoil(2).WaterInletNodeNum).Temp = 6.0; + Node(state.dataWaterCoils->WaterCoil(2).WaterOutletNodeNum).MassFlowRate = ColdWaterMassFlowRate; + Node(state.dataWaterCoils->WaterCoil(2).WaterOutletNodeNum).MassFlowRateMaxAvail = ColdWaterMassFlowRate; + + Node(state.dataWaterCoils->WaterCoil(1).AirInletNodeNum).MassFlowRate = AirMassFlow; + Node(state.dataWaterCoils->WaterCoil(1).AirInletNodeNum).MassFlowRateMaxAvail = AirMassFlow; + + Node(state.dataWaterCoils->WaterCoil(1).WaterInletNodeNum).Temp = 60.0; + Node(state.dataWaterCoils->WaterCoil(1).WaterInletNodeNum).MassFlowRate = HotWaterMassFlowRate; + Node(state.dataWaterCoils->WaterCoil(1).WaterInletNodeNum).MassFlowRateMaxAvail = HotWaterMassFlowRate; + Node(state.dataWaterCoils->WaterCoil(1).WaterOutletNodeNum).MassFlowRate = HotWaterMassFlowRate; + Node(state.dataWaterCoils->WaterCoil(1).WaterOutletNodeNum).MassFlowRateMaxAvail = HotWaterMassFlowRate; + state.dataWaterCoils->WaterCoil(1).InletWaterMassFlowRate = HotWaterMassFlowRate; + state.dataWaterCoils->WaterCoil(1).MaxWaterMassFlowRate = HotWaterMassFlowRate; for (int l = 1; l <= TotNumLoops; ++l) { auto &loop(PlantLoop(l)); @@ -353,31 +353,31 @@ namespace EnergyPlus { loopsidebranch.Comp.allocate(1); } - WaterCoil(2).WaterLoopNum = 1; - WaterCoil(2).WaterLoopSide = 1; - WaterCoil(2).WaterLoopBranchNum = 1; - WaterCoil(2).WaterLoopCompNum = 1; + state.dataWaterCoils->WaterCoil(2).WaterLoopNum = 1; + state.dataWaterCoils->WaterCoil(2).WaterLoopSide = 1; + state.dataWaterCoils->WaterCoil(2).WaterLoopBranchNum = 1; + state.dataWaterCoils->WaterCoil(2).WaterLoopCompNum = 1; - WaterCoil(1).WaterLoopNum = 2; - WaterCoil(1).WaterLoopSide = 1; - WaterCoil(1).WaterLoopBranchNum = 1; - WaterCoil(1).WaterLoopCompNum = 1; + state.dataWaterCoils->WaterCoil(1).WaterLoopNum = 2; + state.dataWaterCoils->WaterCoil(1).WaterLoopSide = 1; + state.dataWaterCoils->WaterCoil(1).WaterLoopBranchNum = 1; + state.dataWaterCoils->WaterCoil(1).WaterLoopCompNum = 1; PlantLoop(2).Name = "ChilledWaterLoop"; PlantLoop(2).FluidName = "ChilledWater"; PlantLoop(2).FluidIndex = 1; PlantLoop(2).FluidName = "WATER"; - PlantLoop(2).LoopSide(1).Branch(1).Comp(1).Name = WaterCoil(2).Name; - PlantLoop(2).LoopSide(1).Branch(1).Comp(1).TypeOf_Num = WaterCoil_Cooling; - PlantLoop(2).LoopSide(1).Branch(1).Comp(1).NodeNumIn = WaterCoil(2).WaterInletNodeNum; + PlantLoop(2).LoopSide(1).Branch(1).Comp(1).Name = state.dataWaterCoils->WaterCoil(2).Name; + PlantLoop(2).LoopSide(1).Branch(1).Comp(1).TypeOf_Num = state.dataWaterCoils->WaterCoil_Cooling; + PlantLoop(2).LoopSide(1).Branch(1).Comp(1).NodeNumIn = state.dataWaterCoils->WaterCoil(2).WaterInletNodeNum; PlantLoop(1).Name = "HotWaterLoop"; PlantLoop(1).FluidName = "HotWater"; PlantLoop(1).FluidIndex = 1; PlantLoop(1).FluidName = "WATER"; - PlantLoop(1).LoopSide(1).Branch(1).Comp(1).Name = WaterCoil(1).Name; - PlantLoop(1).LoopSide(1).Branch(1).Comp(1).TypeOf_Num = WaterCoil_SimpleHeating; - PlantLoop(1).LoopSide(1).Branch(1).Comp(1).NodeNumIn = WaterCoil(1).WaterInletNodeNum; + PlantLoop(1).LoopSide(1).Branch(1).Comp(1).Name = state.dataWaterCoils->WaterCoil(1).Name; + PlantLoop(1).LoopSide(1).Branch(1).Comp(1).TypeOf_Num = state.dataWaterCoils->WaterCoil_SimpleHeating; + PlantLoop(1).LoopSide(1).Branch(1).Comp(1).NodeNumIn = state.dataWaterCoils->WaterCoil(1).WaterInletNodeNum; CoolingLoad = false; HeatingLoad = true; @@ -388,9 +388,9 @@ namespace EnergyPlus { QUnitOut = 0.0; QZnReq = 4000.0; - MyUAAndFlowCalcFlag.allocate(2); - MyUAAndFlowCalcFlag(1) = true; - MyUAAndFlowCalcFlag(2) = true; + state.dataWaterCoils->MyUAAndFlowCalcFlag.allocate(2); + state.dataWaterCoils->MyUAAndFlowCalcFlag(1) = true; + state.dataWaterCoils->MyUAAndFlowCalcFlag(2) = true; DataGlobals::DoingSizing = true; state.fans.LocalTurnFansOff = false; @@ -417,7 +417,7 @@ namespace EnergyPlus { ZoneSysEnergyDemand.deallocate(); FanCoil.deallocate(); Node.deallocate(); - WaterCoil.deallocate(); + state.dataWaterCoils->WaterCoil.deallocate(); ZoneEquipConfig.deallocate(); Zone.deallocate(); CoilNames.clear(); @@ -440,7 +440,7 @@ namespace EnergyPlus { DataEnvironment::OutBaroPress = 101325.0; DataEnvironment::StdRhoAir = 1.20; - WaterCoils::GetWaterCoilsInputFlag = true; + state.dataWaterCoils->GetWaterCoilsInputFlag = true; NumCoils = 0; DataGlobals::NumOfTimeStepInHour = 1; DataGlobals::TimeStep = 1; @@ -627,34 +627,34 @@ namespace EnergyPlus { Node(Fan(1).InletNodeNum).MassFlowRateMax = AirMassFlow; Node(Fan(1).InletNodeNum).MassFlowRateMaxAvail = AirMassFlow; - WaterCoil(2).UACoilTotal = 470.0; - WaterCoil(2).UACoilExternal = 611.0; - WaterCoil(2).UACoilInternal = 2010.0; - WaterCoil(2).TotCoilOutsideSurfArea = 50.0; - - Node(WaterCoil(2).AirInletNodeNum).MassFlowRate = AirMassFlow; - Node(WaterCoil(2).AirInletNodeNum).MassFlowRateMin = AirMassFlow; - Node(WaterCoil(2).AirInletNodeNum).MassFlowRateMax = AirMassFlow; - Node(WaterCoil(2).AirInletNodeNum).MassFlowRateMaxAvail = AirMassFlow; - - WaterCoil(2).InletWaterMassFlowRate = ColdWaterMassFlowRate; - WaterCoil(2).MaxWaterMassFlowRate = ColdWaterMassFlowRate; - Node(WaterCoil(2).WaterInletNodeNum).MassFlowRate = ColdWaterMassFlowRate; - Node(WaterCoil(2).WaterInletNodeNum).MassFlowRateMaxAvail = ColdWaterMassFlowRate; - Node(WaterCoil(2).WaterInletNodeNum).Temp = 6.0; - Node(WaterCoil(2).WaterOutletNodeNum).MassFlowRate = ColdWaterMassFlowRate; - Node(WaterCoil(2).WaterOutletNodeNum).MassFlowRateMaxAvail = ColdWaterMassFlowRate; - - Node(WaterCoil(1).AirInletNodeNum).MassFlowRate = AirMassFlow; - Node(WaterCoil(1).AirInletNodeNum).MassFlowRateMaxAvail = AirMassFlow; - - Node(WaterCoil(1).WaterInletNodeNum).Temp = 60.0; - Node(WaterCoil(1).WaterInletNodeNum).MassFlowRate = HotWaterMassFlowRate; - Node(WaterCoil(1).WaterInletNodeNum).MassFlowRateMaxAvail = HotWaterMassFlowRate; - Node(WaterCoil(1).WaterOutletNodeNum).MassFlowRate = HotWaterMassFlowRate; - Node(WaterCoil(1).WaterOutletNodeNum).MassFlowRateMaxAvail = HotWaterMassFlowRate; - WaterCoil(1).InletWaterMassFlowRate = HotWaterMassFlowRate; - WaterCoil(1).MaxWaterMassFlowRate = HotWaterMassFlowRate; + state.dataWaterCoils->WaterCoil(2).UACoilTotal = 470.0; + state.dataWaterCoils->WaterCoil(2).UACoilExternal = 611.0; + state.dataWaterCoils->WaterCoil(2).UACoilInternal = 2010.0; + state.dataWaterCoils->WaterCoil(2).TotCoilOutsideSurfArea = 50.0; + + Node(state.dataWaterCoils->WaterCoil(2).AirInletNodeNum).MassFlowRate = AirMassFlow; + Node(state.dataWaterCoils->WaterCoil(2).AirInletNodeNum).MassFlowRateMin = AirMassFlow; + Node(state.dataWaterCoils->WaterCoil(2).AirInletNodeNum).MassFlowRateMax = AirMassFlow; + Node(state.dataWaterCoils->WaterCoil(2).AirInletNodeNum).MassFlowRateMaxAvail = AirMassFlow; + + state.dataWaterCoils->WaterCoil(2).InletWaterMassFlowRate = ColdWaterMassFlowRate; + state.dataWaterCoils->WaterCoil(2).MaxWaterMassFlowRate = ColdWaterMassFlowRate; + Node(state.dataWaterCoils->WaterCoil(2).WaterInletNodeNum).MassFlowRate = ColdWaterMassFlowRate; + Node(state.dataWaterCoils->WaterCoil(2).WaterInletNodeNum).MassFlowRateMaxAvail = ColdWaterMassFlowRate; + Node(state.dataWaterCoils->WaterCoil(2).WaterInletNodeNum).Temp = 6.0; + Node(state.dataWaterCoils->WaterCoil(2).WaterOutletNodeNum).MassFlowRate = ColdWaterMassFlowRate; + Node(state.dataWaterCoils->WaterCoil(2).WaterOutletNodeNum).MassFlowRateMaxAvail = ColdWaterMassFlowRate; + + Node(state.dataWaterCoils->WaterCoil(1).AirInletNodeNum).MassFlowRate = AirMassFlow; + Node(state.dataWaterCoils->WaterCoil(1).AirInletNodeNum).MassFlowRateMaxAvail = AirMassFlow; + + Node(state.dataWaterCoils->WaterCoil(1).WaterInletNodeNum).Temp = 60.0; + Node(state.dataWaterCoils->WaterCoil(1).WaterInletNodeNum).MassFlowRate = HotWaterMassFlowRate; + Node(state.dataWaterCoils->WaterCoil(1).WaterInletNodeNum).MassFlowRateMaxAvail = HotWaterMassFlowRate; + Node(state.dataWaterCoils->WaterCoil(1).WaterOutletNodeNum).MassFlowRate = HotWaterMassFlowRate; + Node(state.dataWaterCoils->WaterCoil(1).WaterOutletNodeNum).MassFlowRateMaxAvail = HotWaterMassFlowRate; + state.dataWaterCoils->WaterCoil(1).InletWaterMassFlowRate = HotWaterMassFlowRate; + state.dataWaterCoils->WaterCoil(1).MaxWaterMassFlowRate = HotWaterMassFlowRate; for (int l = 1; l <= TotNumLoops; ++l) { auto &loop(PlantLoop(l)); @@ -667,31 +667,31 @@ namespace EnergyPlus { loopsidebranch.Comp.allocate(1); } - WaterCoil(2).WaterLoopNum = 1; - WaterCoil(2).WaterLoopSide = 1; - WaterCoil(2).WaterLoopBranchNum = 1; - WaterCoil(2).WaterLoopCompNum = 1; + state.dataWaterCoils->WaterCoil(2).WaterLoopNum = 1; + state.dataWaterCoils->WaterCoil(2).WaterLoopSide = 1; + state.dataWaterCoils->WaterCoil(2).WaterLoopBranchNum = 1; + state.dataWaterCoils->WaterCoil(2).WaterLoopCompNum = 1; - WaterCoil(1).WaterLoopNum = 2; - WaterCoil(1).WaterLoopSide = 1; - WaterCoil(1).WaterLoopBranchNum = 1; - WaterCoil(1).WaterLoopCompNum = 1; + state.dataWaterCoils->WaterCoil(1).WaterLoopNum = 2; + state.dataWaterCoils->WaterCoil(1).WaterLoopSide = 1; + state.dataWaterCoils->WaterCoil(1).WaterLoopBranchNum = 1; + state.dataWaterCoils->WaterCoil(1).WaterLoopCompNum = 1; PlantLoop(2).Name = "ChilledWaterLoop"; PlantLoop(2).FluidName = "ChilledWater"; PlantLoop(2).FluidIndex = 1; PlantLoop(2).FluidName = "WATER"; - PlantLoop(2).LoopSide(1).Branch(1).Comp(1).Name = WaterCoil(2).Name; - PlantLoop(2).LoopSide(1).Branch(1).Comp(1).TypeOf_Num = WaterCoil_Cooling; - PlantLoop(2).LoopSide(1).Branch(1).Comp(1).NodeNumIn = WaterCoil(2).WaterInletNodeNum; + PlantLoop(2).LoopSide(1).Branch(1).Comp(1).Name = state.dataWaterCoils->WaterCoil(2).Name; + PlantLoop(2).LoopSide(1).Branch(1).Comp(1).TypeOf_Num = state.dataWaterCoils->WaterCoil_Cooling; + PlantLoop(2).LoopSide(1).Branch(1).Comp(1).NodeNumIn = state.dataWaterCoils->WaterCoil(2).WaterInletNodeNum; PlantLoop(1).Name = "HotWaterLoop"; PlantLoop(1).FluidName = "HotWater"; PlantLoop(1).FluidIndex = 1; PlantLoop(1).FluidName = "WATER"; - PlantLoop(1).LoopSide(1).Branch(1).Comp(1).Name = WaterCoil(1).Name; - PlantLoop(1).LoopSide(1).Branch(1).Comp(1).TypeOf_Num = WaterCoil_SimpleHeating; - PlantLoop(1).LoopSide(1).Branch(1).Comp(1).NodeNumIn = WaterCoil(1).WaterInletNodeNum; + PlantLoop(1).LoopSide(1).Branch(1).Comp(1).Name = state.dataWaterCoils->WaterCoil(1).Name; + PlantLoop(1).LoopSide(1).Branch(1).Comp(1).TypeOf_Num = state.dataWaterCoils->WaterCoil_SimpleHeating; + PlantLoop(1).LoopSide(1).Branch(1).Comp(1).NodeNumIn = state.dataWaterCoils->WaterCoil(1).WaterInletNodeNum; HeatingLoad = false; CoolingLoad = true; @@ -702,9 +702,9 @@ namespace EnergyPlus { QUnitOut = 0.0; QZnReq = -4000.0; - MyUAAndFlowCalcFlag.allocate(2); - MyUAAndFlowCalcFlag(1) = true; - MyUAAndFlowCalcFlag(2) = true; + state.dataWaterCoils->MyUAAndFlowCalcFlag.allocate(2); + state.dataWaterCoils->MyUAAndFlowCalcFlag(1) = true; + state.dataWaterCoils->MyUAAndFlowCalcFlag(2) = true; DataGlobals::DoingSizing = true; state.fans.LocalTurnFansOff = false; @@ -730,7 +730,7 @@ namespace EnergyPlus { ZoneSysEnergyDemand.deallocate(); FanCoil.deallocate(); Node.deallocate(); - WaterCoil.deallocate(); + state.dataWaterCoils->WaterCoil.deallocate(); ZoneEquipConfig.deallocate(); Zone.deallocate(); CoilNames.clear(); @@ -753,7 +753,7 @@ namespace EnergyPlus { DataEnvironment::OutBaroPress = 101325.0; DataEnvironment::StdRhoAir = 1.20; - WaterCoils::GetWaterCoilsInputFlag = true; + state.dataWaterCoils->GetWaterCoilsInputFlag = true; NumCoils = 0; DataGlobals::NumOfTimeStepInHour = 1; DataGlobals::TimeStep = 1; @@ -944,34 +944,34 @@ namespace EnergyPlus { Node(Fan(1).InletNodeNum).MassFlowRateMax = AirMassFlow; Node(Fan(1).InletNodeNum).MassFlowRateMaxAvail = AirMassFlow; - WaterCoil(2).UACoilTotal = 470.0; - WaterCoil(2).UACoilExternal = 611.0; - WaterCoil(2).UACoilInternal = 2010.0; - WaterCoil(2).TotCoilOutsideSurfArea = 50.0; - - Node(WaterCoil(2).AirInletNodeNum).MassFlowRate = AirMassFlow; - Node(WaterCoil(2).AirInletNodeNum).MassFlowRateMin = AirMassFlow; - Node(WaterCoil(2).AirInletNodeNum).MassFlowRateMax = AirMassFlow; - Node(WaterCoil(2).AirInletNodeNum).MassFlowRateMaxAvail = AirMassFlow; - - WaterCoil(2).InletWaterMassFlowRate = ColdWaterMassFlowRate; - WaterCoil(2).MaxWaterMassFlowRate = ColdWaterMassFlowRate; - Node(WaterCoil(2).WaterInletNodeNum).MassFlowRate = ColdWaterMassFlowRate; - Node(WaterCoil(2).WaterInletNodeNum).MassFlowRateMaxAvail = ColdWaterMassFlowRate; - Node(WaterCoil(2).WaterInletNodeNum).Temp = 6.0; - Node(WaterCoil(2).WaterOutletNodeNum).MassFlowRate = ColdWaterMassFlowRate; - Node(WaterCoil(2).WaterOutletNodeNum).MassFlowRateMaxAvail = ColdWaterMassFlowRate; - - Node(WaterCoil(1).AirInletNodeNum).MassFlowRate = AirMassFlow; - Node(WaterCoil(1).AirInletNodeNum).MassFlowRateMaxAvail = AirMassFlow; - - Node(WaterCoil(1).WaterInletNodeNum).Temp = 60.0; - Node(WaterCoil(1).WaterInletNodeNum).MassFlowRate = HotWaterMassFlowRate; - Node(WaterCoil(1).WaterInletNodeNum).MassFlowRateMaxAvail = HotWaterMassFlowRate; - Node(WaterCoil(1).WaterOutletNodeNum).MassFlowRate = HotWaterMassFlowRate; - Node(WaterCoil(1).WaterOutletNodeNum).MassFlowRateMaxAvail = HotWaterMassFlowRate; - WaterCoil(1).InletWaterMassFlowRate = HotWaterMassFlowRate; - WaterCoil(1).MaxWaterMassFlowRate = HotWaterMassFlowRate; + state.dataWaterCoils->WaterCoil(2).UACoilTotal = 470.0; + state.dataWaterCoils->WaterCoil(2).UACoilExternal = 611.0; + state.dataWaterCoils->WaterCoil(2).UACoilInternal = 2010.0; + state.dataWaterCoils->WaterCoil(2).TotCoilOutsideSurfArea = 50.0; + + Node(state.dataWaterCoils->WaterCoil(2).AirInletNodeNum).MassFlowRate = AirMassFlow; + Node(state.dataWaterCoils->WaterCoil(2).AirInletNodeNum).MassFlowRateMin = AirMassFlow; + Node(state.dataWaterCoils->WaterCoil(2).AirInletNodeNum).MassFlowRateMax = AirMassFlow; + Node(state.dataWaterCoils->WaterCoil(2).AirInletNodeNum).MassFlowRateMaxAvail = AirMassFlow; + + state.dataWaterCoils->WaterCoil(2).InletWaterMassFlowRate = ColdWaterMassFlowRate; + state.dataWaterCoils->WaterCoil(2).MaxWaterMassFlowRate = ColdWaterMassFlowRate; + Node(state.dataWaterCoils->WaterCoil(2).WaterInletNodeNum).MassFlowRate = ColdWaterMassFlowRate; + Node(state.dataWaterCoils->WaterCoil(2).WaterInletNodeNum).MassFlowRateMaxAvail = ColdWaterMassFlowRate; + Node(state.dataWaterCoils->WaterCoil(2).WaterInletNodeNum).Temp = 6.0; + Node(state.dataWaterCoils->WaterCoil(2).WaterOutletNodeNum).MassFlowRate = ColdWaterMassFlowRate; + Node(state.dataWaterCoils->WaterCoil(2).WaterOutletNodeNum).MassFlowRateMaxAvail = ColdWaterMassFlowRate; + + Node(state.dataWaterCoils->WaterCoil(1).AirInletNodeNum).MassFlowRate = AirMassFlow; + Node(state.dataWaterCoils->WaterCoil(1).AirInletNodeNum).MassFlowRateMaxAvail = AirMassFlow; + + Node(state.dataWaterCoils->WaterCoil(1).WaterInletNodeNum).Temp = 60.0; + Node(state.dataWaterCoils->WaterCoil(1).WaterInletNodeNum).MassFlowRate = HotWaterMassFlowRate; + Node(state.dataWaterCoils->WaterCoil(1).WaterInletNodeNum).MassFlowRateMaxAvail = HotWaterMassFlowRate; + Node(state.dataWaterCoils->WaterCoil(1).WaterOutletNodeNum).MassFlowRate = HotWaterMassFlowRate; + Node(state.dataWaterCoils->WaterCoil(1).WaterOutletNodeNum).MassFlowRateMaxAvail = HotWaterMassFlowRate; + state.dataWaterCoils->WaterCoil(1).InletWaterMassFlowRate = HotWaterMassFlowRate; + state.dataWaterCoils->WaterCoil(1).MaxWaterMassFlowRate = HotWaterMassFlowRate; for (int l = 1; l <= TotNumLoops; ++l) { auto &loop(PlantLoop(l)); @@ -987,42 +987,42 @@ namespace EnergyPlus { TempControlType.allocate(1); TempControlType(1) = 4; - WaterCoil(2).WaterLoopNum = 1; - WaterCoil(2).WaterLoopSide = 1; - WaterCoil(2).WaterLoopBranchNum = 1; - WaterCoil(2).WaterLoopCompNum = 1; + state.dataWaterCoils->WaterCoil(2).WaterLoopNum = 1; + state.dataWaterCoils->WaterCoil(2).WaterLoopSide = 1; + state.dataWaterCoils->WaterCoil(2).WaterLoopBranchNum = 1; + state.dataWaterCoils->WaterCoil(2).WaterLoopCompNum = 1; - WaterCoil(1).WaterLoopNum = 2; - WaterCoil(1).WaterLoopSide = 1; - WaterCoil(1).WaterLoopBranchNum = 1; - WaterCoil(1).WaterLoopCompNum = 1; + state.dataWaterCoils->WaterCoil(1).WaterLoopNum = 2; + state.dataWaterCoils->WaterCoil(1).WaterLoopSide = 1; + state.dataWaterCoils->WaterCoil(1).WaterLoopBranchNum = 1; + state.dataWaterCoils->WaterCoil(1).WaterLoopCompNum = 1; PlantLoop(2).Name = "ChilledWaterLoop"; PlantLoop(2).FluidName = "ChilledWater"; PlantLoop(2).FluidIndex = 1; PlantLoop(2).FluidName = "WATER"; - PlantLoop(2).LoopSide(1).Branch(1).Comp(1).Name = WaterCoil(2).Name; - PlantLoop(2).LoopSide(1).Branch(1).Comp(1).TypeOf_Num = WaterCoil_Cooling; - PlantLoop(2).LoopSide(1).Branch(1).Comp(1).NodeNumIn = WaterCoil(2).WaterInletNodeNum; - PlantLoop(2).LoopSide(1).Branch(1).Comp(1).NodeNumOut = WaterCoil(2).WaterOutletNodeNum; + PlantLoop(2).LoopSide(1).Branch(1).Comp(1).Name = state.dataWaterCoils->WaterCoil(2).Name; + PlantLoop(2).LoopSide(1).Branch(1).Comp(1).TypeOf_Num = state.dataWaterCoils->WaterCoil_Cooling; + PlantLoop(2).LoopSide(1).Branch(1).Comp(1).NodeNumIn = state.dataWaterCoils->WaterCoil(2).WaterInletNodeNum; + PlantLoop(2).LoopSide(1).Branch(1).Comp(1).NodeNumOut = state.dataWaterCoils->WaterCoil(2).WaterOutletNodeNum; PlantLoop(2).LoopSide(1).FlowLock = 0; PlantLoop(1).Name = "HotWaterLoop"; PlantLoop(1).FluidName = "HotWater"; PlantLoop(1).FluidIndex = 1; PlantLoop(1).FluidName = "WATER"; - PlantLoop(1).LoopSide(1).Branch(1).Comp(1).Name = WaterCoil(1).Name; - PlantLoop(1).LoopSide(1).Branch(1).Comp(1).TypeOf_Num = WaterCoil_SimpleHeating; - PlantLoop(1).LoopSide(1).Branch(1).Comp(1).NodeNumIn = WaterCoil(1).WaterInletNodeNum; - PlantLoop(1).LoopSide(1).Branch(1).Comp(1).NodeNumOut = WaterCoil(1).WaterOutletNodeNum; + PlantLoop(1).LoopSide(1).Branch(1).Comp(1).Name = state.dataWaterCoils->WaterCoil(1).Name; + PlantLoop(1).LoopSide(1).Branch(1).Comp(1).TypeOf_Num = state.dataWaterCoils->WaterCoil_SimpleHeating; + PlantLoop(1).LoopSide(1).Branch(1).Comp(1).NodeNumIn = state.dataWaterCoils->WaterCoil(1).WaterInletNodeNum; + PlantLoop(1).LoopSide(1).Branch(1).Comp(1).NodeNumOut = state.dataWaterCoils->WaterCoil(1).WaterOutletNodeNum; PlantLoop(1).LoopSide(1).FlowLock = 0; FanCoil(1).CoolCoilLoopNum = 2; FanCoil(1).HeatCoilLoopNum = 1; FanCoil(1).CoolCoilLoopSide = 1; FanCoil(1).HeatCoilLoopSide = 1; - FanCoil(1).HeatCoilFluidOutletNodeNum = WaterCoil(1).WaterOutletNodeNum; - FanCoil(1).CoolCoilFluidOutletNodeNum = WaterCoil(2).WaterOutletNodeNum; + FanCoil(1).HeatCoilFluidOutletNodeNum = state.dataWaterCoils->WaterCoil(1).WaterOutletNodeNum; + FanCoil(1).CoolCoilFluidOutletNodeNum = state.dataWaterCoils->WaterCoil(2).WaterOutletNodeNum; FanCoil(1).CoolCoilBranchNum = 1; FanCoil(1).CoolCoilCompNum = 1; FanCoil(1).HeatCoilBranchNum = 1; @@ -1037,9 +1037,9 @@ namespace EnergyPlus { QUnitOut = 0.0; QZnReq = 4000.0; - MyUAAndFlowCalcFlag.allocate(2); - MyUAAndFlowCalcFlag(1) = true; - MyUAAndFlowCalcFlag(2) = true; + state.dataWaterCoils->MyUAAndFlowCalcFlag.allocate(2); + state.dataWaterCoils->MyUAAndFlowCalcFlag(1) = true; + state.dataWaterCoils->MyUAAndFlowCalcFlag(2) = true; DataGlobals::DoingSizing = true; state.fans.LocalTurnFansOff = false; @@ -1140,7 +1140,7 @@ namespace EnergyPlus { DataEnvironment::OutBaroPress = 101325.0; DataEnvironment::StdRhoAir = 1.20; - WaterCoils::GetWaterCoilsInputFlag = true; + state.dataWaterCoils->GetWaterCoilsInputFlag = true; NumCoils = 0; DataGlobals::NumOfTimeStepInHour = 1; DataGlobals::TimeStep = 1; @@ -1320,26 +1320,26 @@ namespace EnergyPlus { Node(Fan(1).InletNodeNum).MassFlowRateMax = AirMassFlow; Node(Fan(1).InletNodeNum).MassFlowRateMaxAvail = AirMassFlow; - WaterCoil(1).UACoilTotal = 470.0; - WaterCoil(1).UACoilExternal = 611.0; - WaterCoil(1).UACoilInternal = 2010.0; - WaterCoil(1).TotCoilOutsideSurfArea = 50.0; + state.dataWaterCoils->WaterCoil(1).UACoilTotal = 470.0; + state.dataWaterCoils->WaterCoil(1).UACoilExternal = 611.0; + state.dataWaterCoils->WaterCoil(1).UACoilInternal = 2010.0; + state.dataWaterCoils->WaterCoil(1).TotCoilOutsideSurfArea = 50.0; - Node(WaterCoil(1).AirInletNodeNum).MassFlowRate = AirMassFlow; - Node(WaterCoil(1).AirInletNodeNum).MassFlowRateMin = AirMassFlow; - Node(WaterCoil(1).AirInletNodeNum).MassFlowRateMax = AirMassFlow; - Node(WaterCoil(1).AirInletNodeNum).MassFlowRateMaxAvail = AirMassFlow; + Node(state.dataWaterCoils->WaterCoil(1).AirInletNodeNum).MassFlowRate = AirMassFlow; + Node(state.dataWaterCoils->WaterCoil(1).AirInletNodeNum).MassFlowRateMin = AirMassFlow; + Node(state.dataWaterCoils->WaterCoil(1).AirInletNodeNum).MassFlowRateMax = AirMassFlow; + Node(state.dataWaterCoils->WaterCoil(1).AirInletNodeNum).MassFlowRateMaxAvail = AirMassFlow; - WaterCoil(1).InletWaterMassFlowRate = ColdWaterMassFlowRate; - WaterCoil(1).MaxWaterMassFlowRate = ColdWaterMassFlowRate; - Node(WaterCoil(1).WaterInletNodeNum).MassFlowRate = ColdWaterMassFlowRate; - Node(WaterCoil(1).WaterInletNodeNum).MassFlowRateMaxAvail = ColdWaterMassFlowRate; - Node(WaterCoil(1).WaterInletNodeNum).Temp = 6.0; - Node(WaterCoil(1).WaterOutletNodeNum).MassFlowRate = ColdWaterMassFlowRate; - Node(WaterCoil(1).WaterOutletNodeNum).MassFlowRateMaxAvail = ColdWaterMassFlowRate; + state.dataWaterCoils->WaterCoil(1).InletWaterMassFlowRate = ColdWaterMassFlowRate; + state.dataWaterCoils->WaterCoil(1).MaxWaterMassFlowRate = ColdWaterMassFlowRate; + Node(state.dataWaterCoils->WaterCoil(1).WaterInletNodeNum).MassFlowRate = ColdWaterMassFlowRate; + Node(state.dataWaterCoils->WaterCoil(1).WaterInletNodeNum).MassFlowRateMaxAvail = ColdWaterMassFlowRate; + Node(state.dataWaterCoils->WaterCoil(1).WaterInletNodeNum).Temp = 6.0; + Node(state.dataWaterCoils->WaterCoil(1).WaterOutletNodeNum).MassFlowRate = ColdWaterMassFlowRate; + Node(state.dataWaterCoils->WaterCoil(1).WaterOutletNodeNum).MassFlowRateMaxAvail = ColdWaterMassFlowRate; - Node(WaterCoil(1).AirInletNodeNum).MassFlowRate = AirMassFlow; - Node(WaterCoil(1).AirInletNodeNum).MassFlowRateMaxAvail = AirMassFlow; + Node(state.dataWaterCoils->WaterCoil(1).AirInletNodeNum).MassFlowRate = AirMassFlow; + Node(state.dataWaterCoils->WaterCoil(1).AirInletNodeNum).MassFlowRateMaxAvail = AirMassFlow; for (int l = 1; l <= TotNumLoops; ++l) { auto &loop(PlantLoop(l)); @@ -1355,19 +1355,19 @@ namespace EnergyPlus { TempControlType.allocate(1); TempControlType(1) = 4; - WaterCoil(1).WaterLoopNum = 1; - WaterCoil(1).WaterLoopSide = 1; - WaterCoil(1).WaterLoopBranchNum = 1; - WaterCoil(1).WaterLoopCompNum = 1; + state.dataWaterCoils->WaterCoil(1).WaterLoopNum = 1; + state.dataWaterCoils->WaterCoil(1).WaterLoopSide = 1; + state.dataWaterCoils->WaterCoil(1).WaterLoopBranchNum = 1; + state.dataWaterCoils->WaterCoil(1).WaterLoopCompNum = 1; PlantLoop(1).Name = "ChilledWaterLoop"; PlantLoop(1).FluidName = "ChilledWater"; PlantLoop(1).FluidIndex = 1; PlantLoop(1).FluidName = "WATER"; - PlantLoop(1).LoopSide(1).Branch(1).Comp(1).Name = WaterCoil(1).Name; - PlantLoop(1).LoopSide(1).Branch(1).Comp(1).TypeOf_Num = WaterCoil_Cooling; - PlantLoop(1).LoopSide(1).Branch(1).Comp(1).NodeNumIn = WaterCoil(1).WaterInletNodeNum; - PlantLoop(1).LoopSide(1).Branch(1).Comp(1).NodeNumOut = WaterCoil(1).WaterOutletNodeNum; + PlantLoop(1).LoopSide(1).Branch(1).Comp(1).Name = state.dataWaterCoils->WaterCoil(1).Name; + PlantLoop(1).LoopSide(1).Branch(1).Comp(1).TypeOf_Num = state.dataWaterCoils->WaterCoil_Cooling; + PlantLoop(1).LoopSide(1).Branch(1).Comp(1).NodeNumIn = state.dataWaterCoils->WaterCoil(1).WaterInletNodeNum; + PlantLoop(1).LoopSide(1).Branch(1).Comp(1).NodeNumOut = state.dataWaterCoils->WaterCoil(1).WaterOutletNodeNum; PlantLoop(1).LoopSide(1).FlowLock = 0; FanCoil(1).CoolCoilLoopNum = 1; @@ -1375,7 +1375,7 @@ namespace EnergyPlus { FanCoil(1).CoolCoilLoopSide = 1; FanCoil(1).HeatCoilLoopSide = 0; FanCoil(1).HeatCoilFluidOutletNodeNum = 0; - FanCoil(1).CoolCoilFluidOutletNodeNum = WaterCoil(1).WaterOutletNodeNum; + FanCoil(1).CoolCoilFluidOutletNodeNum = state.dataWaterCoils->WaterCoil(1).WaterOutletNodeNum; FanCoil(1).CoolCoilBranchNum = 1; FanCoil(1).CoolCoilCompNum = 1; FanCoil(1).HeatCoilBranchNum = 0; @@ -1390,9 +1390,9 @@ namespace EnergyPlus { QUnitOut = 0.0; QZnReq = 4000.0; - MyUAAndFlowCalcFlag.allocate(2); - MyUAAndFlowCalcFlag(1) = true; - MyUAAndFlowCalcFlag(2) = true; + state.dataWaterCoils->MyUAAndFlowCalcFlag.allocate(2); + state.dataWaterCoils->MyUAAndFlowCalcFlag(1) = true; + state.dataWaterCoils->MyUAAndFlowCalcFlag(2) = true; DataGlobals::DoingSizing = true; state.fans.LocalTurnFansOff = false; @@ -1425,7 +1425,7 @@ namespace EnergyPlus { ZoneSysEnergyDemand.deallocate(); FanCoil.deallocate(); Node.deallocate(); - WaterCoil.deallocate(); + state.dataWaterCoils->WaterCoil.deallocate(); ZoneEquipConfig.deallocate(); Zone.deallocate(); CoilNames.clear(); @@ -1448,7 +1448,7 @@ namespace EnergyPlus { DataEnvironment::OutBaroPress = 101325.0; DataEnvironment::StdRhoAir = 1.20; - WaterCoils::GetWaterCoilsInputFlag = true; + state.dataWaterCoils->GetWaterCoilsInputFlag = true; NumCoils = 0; DataGlobals::NumOfTimeStepInHour = 1; DataGlobals::TimeStep = 1; @@ -1642,34 +1642,34 @@ namespace EnergyPlus { Node(Fan(1).InletNodeNum).MassFlowRateMax = AirMassFlow; Node(Fan(1).InletNodeNum).MassFlowRateMaxAvail = AirMassFlow; - WaterCoil(2).UACoilTotal = 470.0; - WaterCoil(2).UACoilExternal = 611.0; - WaterCoil(2).UACoilInternal = 2010.0; - WaterCoil(2).TotCoilOutsideSurfArea = 50.0; - - Node(WaterCoil(2).AirInletNodeNum).MassFlowRate = AirMassFlow; - Node(WaterCoil(2).AirInletNodeNum).MassFlowRateMin = AirMassFlow; - Node(WaterCoil(2).AirInletNodeNum).MassFlowRateMax = AirMassFlow; - Node(WaterCoil(2).AirInletNodeNum).MassFlowRateMaxAvail = AirMassFlow; - - WaterCoil(2).InletWaterMassFlowRate = ColdWaterMassFlowRate; - WaterCoil(2).MaxWaterMassFlowRate = ColdWaterMassFlowRate; - Node(WaterCoil(2).WaterInletNodeNum).MassFlowRate = ColdWaterMassFlowRate; - Node(WaterCoil(2).WaterInletNodeNum).MassFlowRateMaxAvail = ColdWaterMassFlowRate; - Node(WaterCoil(2).WaterInletNodeNum).Temp = 6.0; - Node(WaterCoil(2).WaterOutletNodeNum).MassFlowRate = ColdWaterMassFlowRate; - Node(WaterCoil(2).WaterOutletNodeNum).MassFlowRateMaxAvail = ColdWaterMassFlowRate; - - Node(WaterCoil(1).AirInletNodeNum).MassFlowRate = AirMassFlow; - Node(WaterCoil(1).AirInletNodeNum).MassFlowRateMaxAvail = AirMassFlow; - - Node(WaterCoil(1).WaterInletNodeNum).Temp = 60.0; - Node(WaterCoil(1).WaterInletNodeNum).MassFlowRate = HotWaterMassFlowRate; - Node(WaterCoil(1).WaterInletNodeNum).MassFlowRateMaxAvail = HotWaterMassFlowRate; - Node(WaterCoil(1).WaterOutletNodeNum).MassFlowRate = HotWaterMassFlowRate; - Node(WaterCoil(1).WaterOutletNodeNum).MassFlowRateMaxAvail = HotWaterMassFlowRate; - WaterCoil(1).InletWaterMassFlowRate = HotWaterMassFlowRate; - WaterCoil(1).MaxWaterMassFlowRate = HotWaterMassFlowRate; + state.dataWaterCoils->WaterCoil(2).UACoilTotal = 470.0; + state.dataWaterCoils->WaterCoil(2).UACoilExternal = 611.0; + state.dataWaterCoils->WaterCoil(2).UACoilInternal = 2010.0; + state.dataWaterCoils->WaterCoil(2).TotCoilOutsideSurfArea = 50.0; + + Node(state.dataWaterCoils->WaterCoil(2).AirInletNodeNum).MassFlowRate = AirMassFlow; + Node(state.dataWaterCoils->WaterCoil(2).AirInletNodeNum).MassFlowRateMin = AirMassFlow; + Node(state.dataWaterCoils->WaterCoil(2).AirInletNodeNum).MassFlowRateMax = AirMassFlow; + Node(state.dataWaterCoils->WaterCoil(2).AirInletNodeNum).MassFlowRateMaxAvail = AirMassFlow; + + state.dataWaterCoils->WaterCoil(2).InletWaterMassFlowRate = ColdWaterMassFlowRate; + state.dataWaterCoils->WaterCoil(2).MaxWaterMassFlowRate = ColdWaterMassFlowRate; + Node(state.dataWaterCoils->WaterCoil(2).WaterInletNodeNum).MassFlowRate = ColdWaterMassFlowRate; + Node(state.dataWaterCoils->WaterCoil(2).WaterInletNodeNum).MassFlowRateMaxAvail = ColdWaterMassFlowRate; + Node(state.dataWaterCoils->WaterCoil(2).WaterInletNodeNum).Temp = 6.0; + Node(state.dataWaterCoils->WaterCoil(2).WaterOutletNodeNum).MassFlowRate = ColdWaterMassFlowRate; + Node(state.dataWaterCoils->WaterCoil(2).WaterOutletNodeNum).MassFlowRateMaxAvail = ColdWaterMassFlowRate; + + Node(state.dataWaterCoils->WaterCoil(1).AirInletNodeNum).MassFlowRate = AirMassFlow; + Node(state.dataWaterCoils->WaterCoil(1).AirInletNodeNum).MassFlowRateMaxAvail = AirMassFlow; + + Node(state.dataWaterCoils->WaterCoil(1).WaterInletNodeNum).Temp = 60.0; + Node(state.dataWaterCoils->WaterCoil(1).WaterInletNodeNum).MassFlowRate = HotWaterMassFlowRate; + Node(state.dataWaterCoils->WaterCoil(1).WaterInletNodeNum).MassFlowRateMaxAvail = HotWaterMassFlowRate; + Node(state.dataWaterCoils->WaterCoil(1).WaterOutletNodeNum).MassFlowRate = HotWaterMassFlowRate; + Node(state.dataWaterCoils->WaterCoil(1).WaterOutletNodeNum).MassFlowRateMaxAvail = HotWaterMassFlowRate; + state.dataWaterCoils->WaterCoil(1).InletWaterMassFlowRate = HotWaterMassFlowRate; + state.dataWaterCoils->WaterCoil(1).MaxWaterMassFlowRate = HotWaterMassFlowRate; for (int l = 1; l <= TotNumLoops; ++l) { auto &loop(PlantLoop(l)); @@ -1685,42 +1685,42 @@ namespace EnergyPlus { TempControlType.allocate(1); TempControlType(1) = 4; - WaterCoil(2).WaterLoopNum = 1; - WaterCoil(2).WaterLoopSide = 1; - WaterCoil(2).WaterLoopBranchNum = 1; - WaterCoil(2).WaterLoopCompNum = 1; + state.dataWaterCoils->WaterCoil(2).WaterLoopNum = 1; + state.dataWaterCoils->WaterCoil(2).WaterLoopSide = 1; + state.dataWaterCoils->WaterCoil(2).WaterLoopBranchNum = 1; + state.dataWaterCoils->WaterCoil(2).WaterLoopCompNum = 1; - WaterCoil(1).WaterLoopNum = 2; - WaterCoil(1).WaterLoopSide = 1; - WaterCoil(1).WaterLoopBranchNum = 1; - WaterCoil(1).WaterLoopCompNum = 1; + state.dataWaterCoils->WaterCoil(1).WaterLoopNum = 2; + state.dataWaterCoils->WaterCoil(1).WaterLoopSide = 1; + state.dataWaterCoils->WaterCoil(1).WaterLoopBranchNum = 1; + state.dataWaterCoils->WaterCoil(1).WaterLoopCompNum = 1; PlantLoop(2).Name = "ChilledWaterLoop"; PlantLoop(2).FluidName = "ChilledWater"; PlantLoop(2).FluidIndex = 1; PlantLoop(2).FluidName = "WATER"; - PlantLoop(2).LoopSide(1).Branch(1).Comp(1).Name = WaterCoil(2).Name; - PlantLoop(2).LoopSide(1).Branch(1).Comp(1).TypeOf_Num = WaterCoil_Cooling; - PlantLoop(2).LoopSide(1).Branch(1).Comp(1).NodeNumIn = WaterCoil(2).WaterInletNodeNum; - PlantLoop(2).LoopSide(1).Branch(1).Comp(1).NodeNumOut = WaterCoil(2).WaterOutletNodeNum; + PlantLoop(2).LoopSide(1).Branch(1).Comp(1).Name = state.dataWaterCoils->WaterCoil(2).Name; + PlantLoop(2).LoopSide(1).Branch(1).Comp(1).TypeOf_Num = state.dataWaterCoils->WaterCoil_Cooling; + PlantLoop(2).LoopSide(1).Branch(1).Comp(1).NodeNumIn = state.dataWaterCoils->WaterCoil(2).WaterInletNodeNum; + PlantLoop(2).LoopSide(1).Branch(1).Comp(1).NodeNumOut = state.dataWaterCoils->WaterCoil(2).WaterOutletNodeNum; PlantLoop(2).LoopSide(1).FlowLock = 0; PlantLoop(1).Name = "HotWaterLoop"; PlantLoop(1).FluidName = "HotWater"; PlantLoop(1).FluidIndex = 1; PlantLoop(1).FluidName = "WATER"; - PlantLoop(1).LoopSide(1).Branch(1).Comp(1).Name = WaterCoil(1).Name; - PlantLoop(1).LoopSide(1).Branch(1).Comp(1).TypeOf_Num = WaterCoil_SimpleHeating; - PlantLoop(1).LoopSide(1).Branch(1).Comp(1).NodeNumIn = WaterCoil(1).WaterInletNodeNum; - PlantLoop(1).LoopSide(1).Branch(1).Comp(1).NodeNumOut = WaterCoil(1).WaterOutletNodeNum; + PlantLoop(1).LoopSide(1).Branch(1).Comp(1).Name = state.dataWaterCoils->WaterCoil(1).Name; + PlantLoop(1).LoopSide(1).Branch(1).Comp(1).TypeOf_Num = state.dataWaterCoils->WaterCoil_SimpleHeating; + PlantLoop(1).LoopSide(1).Branch(1).Comp(1).NodeNumIn = state.dataWaterCoils->WaterCoil(1).WaterInletNodeNum; + PlantLoop(1).LoopSide(1).Branch(1).Comp(1).NodeNumOut = state.dataWaterCoils->WaterCoil(1).WaterOutletNodeNum; PlantLoop(1).LoopSide(1).FlowLock = 0; FanCoil(1).CoolCoilLoopNum = 2; FanCoil(1).HeatCoilLoopNum = 1; FanCoil(1).CoolCoilLoopSide = 1; FanCoil(1).HeatCoilLoopSide = 1; - FanCoil(1).HeatCoilFluidOutletNodeNum = WaterCoil(1).WaterOutletNodeNum; - FanCoil(1).CoolCoilFluidOutletNodeNum = WaterCoil(2).WaterOutletNodeNum; + FanCoil(1).HeatCoilFluidOutletNodeNum = state.dataWaterCoils->WaterCoil(1).WaterOutletNodeNum; + FanCoil(1).CoolCoilFluidOutletNodeNum = state.dataWaterCoils->WaterCoil(2).WaterOutletNodeNum; FanCoil(1).CoolCoilBranchNum = 1; FanCoil(1).CoolCoilCompNum = 1; FanCoil(1).HeatCoilBranchNum = 1; @@ -1735,9 +1735,9 @@ namespace EnergyPlus { QUnitOut = 0.0; QZnReq = -4000.0; - MyUAAndFlowCalcFlag.allocate(2); - MyUAAndFlowCalcFlag(1) = true; - MyUAAndFlowCalcFlag(2) = true; + state.dataWaterCoils->MyUAAndFlowCalcFlag.allocate(2); + state.dataWaterCoils->MyUAAndFlowCalcFlag(1) = true; + state.dataWaterCoils->MyUAAndFlowCalcFlag(2) = true; DataGlobals::DoingSizing = true; state.fans.LocalTurnFansOff = false; @@ -1800,7 +1800,7 @@ namespace EnergyPlus { DataEnvironment::OutBaroPress = 101325.0; DataEnvironment::StdRhoAir = 1.20; - WaterCoils::GetWaterCoilsInputFlag = true; + state.dataWaterCoils->GetWaterCoilsInputFlag = true; NumCoils = 0; DataGlobals::NumOfTimeStepInHour = 1; DataGlobals::TimeStep = 1; @@ -1991,34 +1991,34 @@ namespace EnergyPlus { Node(Fan(1).InletNodeNum).MassFlowRateMax = AirMassFlow; Node(Fan(1).InletNodeNum).MassFlowRateMaxAvail = AirMassFlow; - WaterCoil(2).UACoilTotal = 470.0; - WaterCoil(2).UACoilExternal = 611.0; - WaterCoil(2).UACoilInternal = 2010.0; - WaterCoil(2).TotCoilOutsideSurfArea = 50.0; - - Node(WaterCoil(2).AirInletNodeNum).MassFlowRate = AirMassFlow; - Node(WaterCoil(2).AirInletNodeNum).MassFlowRateMin = AirMassFlow; - Node(WaterCoil(2).AirInletNodeNum).MassFlowRateMax = AirMassFlow; - Node(WaterCoil(2).AirInletNodeNum).MassFlowRateMaxAvail = AirMassFlow; - - WaterCoil(2).InletWaterMassFlowRate = ColdWaterMassFlowRate; - WaterCoil(2).MaxWaterMassFlowRate = ColdWaterMassFlowRate; - Node(WaterCoil(2).WaterInletNodeNum).MassFlowRate = ColdWaterMassFlowRate; - Node(WaterCoil(2).WaterInletNodeNum).MassFlowRateMaxAvail = ColdWaterMassFlowRate; - Node(WaterCoil(2).WaterInletNodeNum).Temp = 6.0; - Node(WaterCoil(2).WaterOutletNodeNum).MassFlowRate = ColdWaterMassFlowRate; - Node(WaterCoil(2).WaterOutletNodeNum).MassFlowRateMaxAvail = ColdWaterMassFlowRate; - - Node(WaterCoil(1).AirInletNodeNum).MassFlowRate = AirMassFlow; - Node(WaterCoil(1).AirInletNodeNum).MassFlowRateMaxAvail = AirMassFlow; - - Node(WaterCoil(1).WaterInletNodeNum).Temp = 60.0; - Node(WaterCoil(1).WaterInletNodeNum).MassFlowRate = HotWaterMassFlowRate; - Node(WaterCoil(1).WaterInletNodeNum).MassFlowRateMaxAvail = HotWaterMassFlowRate; - Node(WaterCoil(1).WaterOutletNodeNum).MassFlowRate = HotWaterMassFlowRate; - Node(WaterCoil(1).WaterOutletNodeNum).MassFlowRateMaxAvail = HotWaterMassFlowRate; - WaterCoil(1).InletWaterMassFlowRate = HotWaterMassFlowRate; - WaterCoil(1).MaxWaterMassFlowRate = HotWaterMassFlowRate; + state.dataWaterCoils->WaterCoil(2).UACoilTotal = 470.0; + state.dataWaterCoils->WaterCoil(2).UACoilExternal = 611.0; + state.dataWaterCoils->WaterCoil(2).UACoilInternal = 2010.0; + state.dataWaterCoils->WaterCoil(2).TotCoilOutsideSurfArea = 50.0; + + Node(state.dataWaterCoils->WaterCoil(2).AirInletNodeNum).MassFlowRate = AirMassFlow; + Node(state.dataWaterCoils->WaterCoil(2).AirInletNodeNum).MassFlowRateMin = AirMassFlow; + Node(state.dataWaterCoils->WaterCoil(2).AirInletNodeNum).MassFlowRateMax = AirMassFlow; + Node(state.dataWaterCoils->WaterCoil(2).AirInletNodeNum).MassFlowRateMaxAvail = AirMassFlow; + + state.dataWaterCoils->WaterCoil(2).InletWaterMassFlowRate = ColdWaterMassFlowRate; + state.dataWaterCoils->WaterCoil(2).MaxWaterMassFlowRate = ColdWaterMassFlowRate; + Node(state.dataWaterCoils->WaterCoil(2).WaterInletNodeNum).MassFlowRate = ColdWaterMassFlowRate; + Node(state.dataWaterCoils->WaterCoil(2).WaterInletNodeNum).MassFlowRateMaxAvail = ColdWaterMassFlowRate; + Node(state.dataWaterCoils->WaterCoil(2).WaterInletNodeNum).Temp = 6.0; + Node(state.dataWaterCoils->WaterCoil(2).WaterOutletNodeNum).MassFlowRate = ColdWaterMassFlowRate; + Node(state.dataWaterCoils->WaterCoil(2).WaterOutletNodeNum).MassFlowRateMaxAvail = ColdWaterMassFlowRate; + + Node(state.dataWaterCoils->WaterCoil(1).AirInletNodeNum).MassFlowRate = AirMassFlow; + Node(state.dataWaterCoils->WaterCoil(1).AirInletNodeNum).MassFlowRateMaxAvail = AirMassFlow; + + Node(state.dataWaterCoils->WaterCoil(1).WaterInletNodeNum).Temp = 60.0; + Node(state.dataWaterCoils->WaterCoil(1).WaterInletNodeNum).MassFlowRate = HotWaterMassFlowRate; + Node(state.dataWaterCoils->WaterCoil(1).WaterInletNodeNum).MassFlowRateMaxAvail = HotWaterMassFlowRate; + Node(state.dataWaterCoils->WaterCoil(1).WaterOutletNodeNum).MassFlowRate = HotWaterMassFlowRate; + Node(state.dataWaterCoils->WaterCoil(1).WaterOutletNodeNum).MassFlowRateMaxAvail = HotWaterMassFlowRate; + state.dataWaterCoils->WaterCoil(1).InletWaterMassFlowRate = HotWaterMassFlowRate; + state.dataWaterCoils->WaterCoil(1).MaxWaterMassFlowRate = HotWaterMassFlowRate; for (int l = 1; l <= TotNumLoops; ++l) { auto &loop(PlantLoop(l)); @@ -2031,33 +2031,33 @@ namespace EnergyPlus { loopsidebranch.Comp.allocate(1); } - WaterCoil(2).WaterLoopNum = 1; - WaterCoil(2).WaterLoopSide = 1; - WaterCoil(2).WaterLoopBranchNum = 1; - WaterCoil(2).WaterLoopCompNum = 1; + state.dataWaterCoils->WaterCoil(2).WaterLoopNum = 1; + state.dataWaterCoils->WaterCoil(2).WaterLoopSide = 1; + state.dataWaterCoils->WaterCoil(2).WaterLoopBranchNum = 1; + state.dataWaterCoils->WaterCoil(2).WaterLoopCompNum = 1; - WaterCoil(1).WaterLoopNum = 2; - WaterCoil(1).WaterLoopSide = 1; - WaterCoil(1).WaterLoopBranchNum = 1; - WaterCoil(1).WaterLoopCompNum = 1; + state.dataWaterCoils->WaterCoil(1).WaterLoopNum = 2; + state.dataWaterCoils->WaterCoil(1).WaterLoopSide = 1; + state.dataWaterCoils->WaterCoil(1).WaterLoopBranchNum = 1; + state.dataWaterCoils->WaterCoil(1).WaterLoopCompNum = 1; PlantLoop(2).Name = "ChilledWaterLoop"; PlantLoop(2).FluidName = "ChilledWater"; PlantLoop(2).FluidIndex = 1; PlantLoop(2).FluidName = "WATER"; - PlantLoop(2).LoopSide(1).Branch(1).Comp(1).Name = WaterCoil(2).Name; - PlantLoop(2).LoopSide(1).Branch(1).Comp(1).TypeOf_Num = WaterCoil_Cooling; - PlantLoop(2).LoopSide(1).Branch(1).Comp(1).NodeNumIn = WaterCoil(2).WaterInletNodeNum; - PlantLoop(2).LoopSide(1).Branch(1).Comp(1).NodeNumOut = WaterCoil(2).WaterOutletNodeNum; + PlantLoop(2).LoopSide(1).Branch(1).Comp(1).Name = state.dataWaterCoils->WaterCoil(2).Name; + PlantLoop(2).LoopSide(1).Branch(1).Comp(1).TypeOf_Num = state.dataWaterCoils->WaterCoil_Cooling; + PlantLoop(2).LoopSide(1).Branch(1).Comp(1).NodeNumIn = state.dataWaterCoils->WaterCoil(2).WaterInletNodeNum; + PlantLoop(2).LoopSide(1).Branch(1).Comp(1).NodeNumOut = state.dataWaterCoils->WaterCoil(2).WaterOutletNodeNum; PlantLoop(1).Name = "HotWaterLoop"; PlantLoop(1).FluidName = "HotWater"; PlantLoop(1).FluidIndex = 1; PlantLoop(1).FluidName = "WATER"; - PlantLoop(1).LoopSide(1).Branch(1).Comp(1).Name = WaterCoil(1).Name; - PlantLoop(1).LoopSide(1).Branch(1).Comp(1).TypeOf_Num = WaterCoil_SimpleHeating; - PlantLoop(1).LoopSide(1).Branch(1).Comp(1).NodeNumIn = WaterCoil(1).WaterInletNodeNum; - PlantLoop(1).LoopSide(1).Branch(1).Comp(1).NodeNumOut = WaterCoil(1).WaterOutletNodeNum; + PlantLoop(1).LoopSide(1).Branch(1).Comp(1).Name = state.dataWaterCoils->WaterCoil(1).Name; + PlantLoop(1).LoopSide(1).Branch(1).Comp(1).TypeOf_Num = state.dataWaterCoils->WaterCoil_SimpleHeating; + PlantLoop(1).LoopSide(1).Branch(1).Comp(1).NodeNumIn = state.dataWaterCoils->WaterCoil(1).WaterInletNodeNum; + PlantLoop(1).LoopSide(1).Branch(1).Comp(1).NodeNumOut = state.dataWaterCoils->WaterCoil(1).WaterOutletNodeNum; CoolingLoad = false; HeatingLoad = true; @@ -2069,9 +2069,9 @@ namespace EnergyPlus { QLatOut = 0.0; QZnReq = 4000.0; - MyUAAndFlowCalcFlag.allocate(2); - MyUAAndFlowCalcFlag(1) = true; - MyUAAndFlowCalcFlag(2) = true; + state.dataWaterCoils->MyUAAndFlowCalcFlag.allocate(2); + state.dataWaterCoils->MyUAAndFlowCalcFlag(1) = true; + state.dataWaterCoils->MyUAAndFlowCalcFlag(2) = true; DataGlobals::DoingSizing = true; state.fans.LocalTurnFansOff = false; @@ -2177,7 +2177,7 @@ namespace EnergyPlus { ZoneSysEnergyDemand.deallocate(); FanCoil.deallocate(); Node.deallocate(); - WaterCoil.deallocate(); + state.dataWaterCoils->WaterCoil.deallocate(); ZoneEquipConfig.deallocate(); Zone.deallocate(); CoilNames.clear(); @@ -2216,7 +2216,7 @@ namespace EnergyPlus { DataPlant::TotNumLoops = 2; DataEnvironment::OutBaroPress = 101325.0; DataEnvironment::StdRhoAir = 1.20; - WaterCoils::GetWaterCoilsInputFlag = true; + state.dataWaterCoils->GetWaterCoilsInputFlag = true; NumCoils = 0; DataGlobals::NumOfTimeStepInHour = 1; DataGlobals::TimeStep = 1; @@ -2292,33 +2292,33 @@ namespace EnergyPlus { loopsidebranch.Comp.allocate(1); } - WaterCoil(2).WaterLoopNum = 1; - WaterCoil(2).WaterLoopSide = 1; - WaterCoil(2).WaterLoopBranchNum = 1; - WaterCoil(2).WaterLoopCompNum = 1; + state.dataWaterCoils->WaterCoil(2).WaterLoopNum = 1; + state.dataWaterCoils->WaterCoil(2).WaterLoopSide = 1; + state.dataWaterCoils->WaterCoil(2).WaterLoopBranchNum = 1; + state.dataWaterCoils->WaterCoil(2).WaterLoopCompNum = 1; - WaterCoil(1).WaterLoopNum = 2; - WaterCoil(1).WaterLoopSide = 1; - WaterCoil(1).WaterLoopBranchNum = 1; - WaterCoil(1).WaterLoopCompNum = 1; + state.dataWaterCoils->WaterCoil(1).WaterLoopNum = 2; + state.dataWaterCoils->WaterCoil(1).WaterLoopSide = 1; + state.dataWaterCoils->WaterCoil(1).WaterLoopBranchNum = 1; + state.dataWaterCoils->WaterCoil(1).WaterLoopCompNum = 1; PlantLoop(2).Name = "ChilledWaterLoop"; PlantLoop(2).FluidName = "ChilledWater"; PlantLoop(2).FluidIndex = 1; PlantLoop(2).FluidName = "WATER"; - PlantLoop(2).LoopSide(1).Branch(1).Comp(1).Name = WaterCoil(2).Name; - PlantLoop(2).LoopSide(1).Branch(1).Comp(1).TypeOf_Num = WaterCoil_Cooling; - PlantLoop(2).LoopSide(1).Branch(1).Comp(1).NodeNumIn = WaterCoil(2).WaterInletNodeNum; - PlantLoop(2).LoopSide(1).Branch(1).Comp(1).NodeNumOut = WaterCoil(2).WaterOutletNodeNum; + PlantLoop(2).LoopSide(1).Branch(1).Comp(1).Name = state.dataWaterCoils->WaterCoil(2).Name; + PlantLoop(2).LoopSide(1).Branch(1).Comp(1).TypeOf_Num = state.dataWaterCoils->WaterCoil_Cooling; + PlantLoop(2).LoopSide(1).Branch(1).Comp(1).NodeNumIn = state.dataWaterCoils->WaterCoil(2).WaterInletNodeNum; + PlantLoop(2).LoopSide(1).Branch(1).Comp(1).NodeNumOut = state.dataWaterCoils->WaterCoil(2).WaterOutletNodeNum; PlantLoop(1).Name = "HotWaterLoop"; PlantLoop(1).FluidName = "HotWater"; PlantLoop(1).FluidIndex = 1; PlantLoop(1).FluidName = "WATER"; - PlantLoop(1).LoopSide(1).Branch(1).Comp(1).Name = WaterCoil(1).Name; - PlantLoop(1).LoopSide(1).Branch(1).Comp(1).TypeOf_Num = WaterCoil_SimpleHeating; - PlantLoop(1).LoopSide(1).Branch(1).Comp(1).NodeNumIn = WaterCoil(1).WaterInletNodeNum; - PlantLoop(1).LoopSide(1).Branch(1).Comp(1).NodeNumOut = WaterCoil(1).WaterOutletNodeNum; + PlantLoop(1).LoopSide(1).Branch(1).Comp(1).Name = state.dataWaterCoils->WaterCoil(1).Name; + PlantLoop(1).LoopSide(1).Branch(1).Comp(1).TypeOf_Num = state.dataWaterCoils->WaterCoil_SimpleHeating; + PlantLoop(1).LoopSide(1).Branch(1).Comp(1).NodeNumIn = state.dataWaterCoils->WaterCoil(1).WaterInletNodeNum; + PlantLoop(1).LoopSide(1).Branch(1).Comp(1).NodeNumOut = state.dataWaterCoils->WaterCoil(1).WaterOutletNodeNum; bool CoolingLoad = true; bool HeatingLoad = false; @@ -2501,7 +2501,7 @@ namespace EnergyPlus { DataEnvironment::OutBaroPress = 101325.0; DataEnvironment::StdRhoAir = 1.20; - WaterCoils::GetWaterCoilsInputFlag = true; + state.dataWaterCoils->GetWaterCoilsInputFlag = true; NumCoils = 0; DataGlobals::NumOfTimeStepInHour = 1; DataGlobals::TimeStep = 1; @@ -2698,34 +2698,34 @@ namespace EnergyPlus { Node(Fan(1).InletNodeNum).MassFlowRateMax = AirMassFlow; Node(Fan(1).InletNodeNum).MassFlowRateMaxAvail = AirMassFlow; - WaterCoil(2).UACoilTotal = 470.0; - WaterCoil(2).UACoilExternal = 611.0; - WaterCoil(2).UACoilInternal = 2010.0; - WaterCoil(2).TotCoilOutsideSurfArea = 50.0; - - Node(WaterCoil(2).AirInletNodeNum).MassFlowRate = AirMassFlow; - Node(WaterCoil(2).AirInletNodeNum).MassFlowRateMin = AirMassFlow; - Node(WaterCoil(2).AirInletNodeNum).MassFlowRateMax = AirMassFlow; - Node(WaterCoil(2).AirInletNodeNum).MassFlowRateMaxAvail = AirMassFlow; - - WaterCoil(2).InletWaterMassFlowRate = ColdWaterMassFlowRate; - WaterCoil(2).MaxWaterMassFlowRate = ColdWaterMassFlowRate; - Node(WaterCoil(2).WaterInletNodeNum).MassFlowRate = ColdWaterMassFlowRate; - Node(WaterCoil(2).WaterInletNodeNum).MassFlowRateMaxAvail = ColdWaterMassFlowRate; - Node(WaterCoil(2).WaterInletNodeNum).Temp = 6.0; - Node(WaterCoil(2).WaterOutletNodeNum).MassFlowRate = ColdWaterMassFlowRate; - Node(WaterCoil(2).WaterOutletNodeNum).MassFlowRateMaxAvail = ColdWaterMassFlowRate; - - Node(WaterCoil(1).AirInletNodeNum).MassFlowRate = AirMassFlow; - Node(WaterCoil(1).AirInletNodeNum).MassFlowRateMaxAvail = AirMassFlow; - - Node(WaterCoil(1).WaterInletNodeNum).Temp = 60.0; - Node(WaterCoil(1).WaterInletNodeNum).MassFlowRate = HotWaterMassFlowRate; - Node(WaterCoil(1).WaterInletNodeNum).MassFlowRateMaxAvail = HotWaterMassFlowRate; - Node(WaterCoil(1).WaterOutletNodeNum).MassFlowRate = HotWaterMassFlowRate; - Node(WaterCoil(1).WaterOutletNodeNum).MassFlowRateMaxAvail = HotWaterMassFlowRate; - WaterCoil(1).InletWaterMassFlowRate = HotWaterMassFlowRate; - WaterCoil(1).MaxWaterMassFlowRate = HotWaterMassFlowRate; + state.dataWaterCoils->WaterCoil(2).UACoilTotal = 470.0; + state.dataWaterCoils->WaterCoil(2).UACoilExternal = 611.0; + state.dataWaterCoils->WaterCoil(2).UACoilInternal = 2010.0; + state.dataWaterCoils->WaterCoil(2).TotCoilOutsideSurfArea = 50.0; + + Node(state.dataWaterCoils->WaterCoil(2).AirInletNodeNum).MassFlowRate = AirMassFlow; + Node(state.dataWaterCoils->WaterCoil(2).AirInletNodeNum).MassFlowRateMin = AirMassFlow; + Node(state.dataWaterCoils->WaterCoil(2).AirInletNodeNum).MassFlowRateMax = AirMassFlow; + Node(state.dataWaterCoils->WaterCoil(2).AirInletNodeNum).MassFlowRateMaxAvail = AirMassFlow; + + state.dataWaterCoils->WaterCoil(2).InletWaterMassFlowRate = ColdWaterMassFlowRate; + state.dataWaterCoils->WaterCoil(2).MaxWaterMassFlowRate = ColdWaterMassFlowRate; + Node(state.dataWaterCoils->WaterCoil(2).WaterInletNodeNum).MassFlowRate = ColdWaterMassFlowRate; + Node(state.dataWaterCoils->WaterCoil(2).WaterInletNodeNum).MassFlowRateMaxAvail = ColdWaterMassFlowRate; + Node(state.dataWaterCoils->WaterCoil(2).WaterInletNodeNum).Temp = 6.0; + Node(state.dataWaterCoils->WaterCoil(2).WaterOutletNodeNum).MassFlowRate = ColdWaterMassFlowRate; + Node(state.dataWaterCoils->WaterCoil(2).WaterOutletNodeNum).MassFlowRateMaxAvail = ColdWaterMassFlowRate; + + Node(state.dataWaterCoils->WaterCoil(1).AirInletNodeNum).MassFlowRate = AirMassFlow; + Node(state.dataWaterCoils->WaterCoil(1).AirInletNodeNum).MassFlowRateMaxAvail = AirMassFlow; + + Node(state.dataWaterCoils->WaterCoil(1).WaterInletNodeNum).Temp = 60.0; + Node(state.dataWaterCoils->WaterCoil(1).WaterInletNodeNum).MassFlowRate = HotWaterMassFlowRate; + Node(state.dataWaterCoils->WaterCoil(1).WaterInletNodeNum).MassFlowRateMaxAvail = HotWaterMassFlowRate; + Node(state.dataWaterCoils->WaterCoil(1).WaterOutletNodeNum).MassFlowRate = HotWaterMassFlowRate; + Node(state.dataWaterCoils->WaterCoil(1).WaterOutletNodeNum).MassFlowRateMaxAvail = HotWaterMassFlowRate; + state.dataWaterCoils->WaterCoil(1).InletWaterMassFlowRate = HotWaterMassFlowRate; + state.dataWaterCoils->WaterCoil(1).MaxWaterMassFlowRate = HotWaterMassFlowRate; for (int l = 1; l <= TotNumLoops; ++l) { auto &loop(PlantLoop(l)); @@ -2738,33 +2738,33 @@ namespace EnergyPlus { loopsidebranch.Comp.allocate(1); } - WaterCoil(2).WaterLoopNum = 1; - WaterCoil(2).WaterLoopSide = 1; - WaterCoil(2).WaterLoopBranchNum = 1; - WaterCoil(2).WaterLoopCompNum = 1; + state.dataWaterCoils->WaterCoil(2).WaterLoopNum = 1; + state.dataWaterCoils->WaterCoil(2).WaterLoopSide = 1; + state.dataWaterCoils->WaterCoil(2).WaterLoopBranchNum = 1; + state.dataWaterCoils->WaterCoil(2).WaterLoopCompNum = 1; - WaterCoil(1).WaterLoopNum = 2; - WaterCoil(1).WaterLoopSide = 1; - WaterCoil(1).WaterLoopBranchNum = 1; - WaterCoil(1).WaterLoopCompNum = 1; + state.dataWaterCoils->WaterCoil(1).WaterLoopNum = 2; + state.dataWaterCoils->WaterCoil(1).WaterLoopSide = 1; + state.dataWaterCoils->WaterCoil(1).WaterLoopBranchNum = 1; + state.dataWaterCoils->WaterCoil(1).WaterLoopCompNum = 1; PlantLoop(2).Name = "ChilledWaterLoop"; PlantLoop(2).FluidName = "ChilledWater"; PlantLoop(2).FluidIndex = 1; PlantLoop(2).FluidName = "WATER"; - PlantLoop(2).LoopSide(1).Branch(1).Comp(1).Name = WaterCoil(2).Name; - PlantLoop(2).LoopSide(1).Branch(1).Comp(1).TypeOf_Num = WaterCoil_Cooling; - PlantLoop(2).LoopSide(1).Branch(1).Comp(1).NodeNumIn = WaterCoil(2).WaterInletNodeNum; - PlantLoop(2).LoopSide(1).Branch(1).Comp(1).NodeNumOut = WaterCoil(2).WaterOutletNodeNum; + PlantLoop(2).LoopSide(1).Branch(1).Comp(1).Name = state.dataWaterCoils->WaterCoil(2).Name; + PlantLoop(2).LoopSide(1).Branch(1).Comp(1).TypeOf_Num = state.dataWaterCoils->WaterCoil_Cooling; + PlantLoop(2).LoopSide(1).Branch(1).Comp(1).NodeNumIn = state.dataWaterCoils->WaterCoil(2).WaterInletNodeNum; + PlantLoop(2).LoopSide(1).Branch(1).Comp(1).NodeNumOut = state.dataWaterCoils->WaterCoil(2).WaterOutletNodeNum; PlantLoop(1).Name = "HotWaterLoop"; PlantLoop(1).FluidName = "HotWater"; PlantLoop(1).FluidIndex = 1; PlantLoop(1).FluidName = "WATER"; - PlantLoop(1).LoopSide(1).Branch(1).Comp(1).Name = WaterCoil(1).Name; - PlantLoop(1).LoopSide(1).Branch(1).Comp(1).TypeOf_Num = WaterCoil_SimpleHeating; - PlantLoop(1).LoopSide(1).Branch(1).Comp(1).NodeNumIn = WaterCoil(1).WaterInletNodeNum; - PlantLoop(1).LoopSide(1).Branch(1).Comp(1).NodeNumOut = WaterCoil(1).WaterOutletNodeNum; + PlantLoop(1).LoopSide(1).Branch(1).Comp(1).Name = state.dataWaterCoils->WaterCoil(1).Name; + PlantLoop(1).LoopSide(1).Branch(1).Comp(1).TypeOf_Num = state.dataWaterCoils->WaterCoil_SimpleHeating; + PlantLoop(1).LoopSide(1).Branch(1).Comp(1).NodeNumIn = state.dataWaterCoils->WaterCoil(1).WaterInletNodeNum; + PlantLoop(1).LoopSide(1).Branch(1).Comp(1).NodeNumOut = state.dataWaterCoils->WaterCoil(1).WaterOutletNodeNum; CoolingLoad = false; HeatingLoad = true; @@ -2777,9 +2777,9 @@ namespace EnergyPlus { QLatOut = 0.0; QZnReq = 4000.0; - MyUAAndFlowCalcFlag.allocate(2); - MyUAAndFlowCalcFlag(1) = true; - MyUAAndFlowCalcFlag(2) = true; + state.dataWaterCoils->MyUAAndFlowCalcFlag.allocate(2); + state.dataWaterCoils->MyUAAndFlowCalcFlag(1) = true; + state.dataWaterCoils->MyUAAndFlowCalcFlag(2) = true; DataGlobals::DoingSizing = true; state.fans.LocalTurnFansOff = false; @@ -2904,7 +2904,7 @@ namespace EnergyPlus { DataEnvironment::OutBaroPress = 101325.0; DataEnvironment::StdRhoAir = 1.20; - WaterCoils::GetWaterCoilsInputFlag = true; + state.dataWaterCoils->GetWaterCoilsInputFlag = true; NumCoils = 0; DataGlobals::NumOfTimeStepInHour = 1; DataGlobals::TimeStep = 1; @@ -3108,7 +3108,7 @@ namespace EnergyPlus { Node(MixerOA.InletNode).HumRat = PsyWFnTdbH(Node(MixerOA.InletNode).Temp, Node(MixerOA.InletNode).Enthalpy); // chilled water coil - auto &CWCoil(WaterCoil(2)); + auto &CWCoil(state.dataWaterCoils->WaterCoil(2)); CWCoil.UACoilTotal = 470.0; CWCoil.UACoilExternal = 611.0; CWCoil.UACoilInternal = 2010.0; @@ -3130,7 +3130,7 @@ namespace EnergyPlus { CWCoil.WaterLoopCompNum = 1; // hot water coil - auto &HWCoil(WaterCoil(1)); + auto &HWCoil(state.dataWaterCoils->WaterCoil(1)); HWCoil.InletWaterMassFlowRate = HotWaterMassFlowRate; HWCoil.MaxWaterMassFlowRate = HotWaterMassFlowRate; Node(HWCoil.AirInletNodeNum).MassFlowRate = AirMassFlow; @@ -3162,7 +3162,7 @@ namespace EnergyPlus { CWLoop.FluidIndex = 1; CWLoop.FluidName = "WATER"; CWLoop.LoopSide(1).Branch(1).Comp(1).Name = CWCoil.Name; - CWLoop.LoopSide(1).Branch(1).Comp(1).TypeOf_Num = WaterCoil_Cooling; + CWLoop.LoopSide(1).Branch(1).Comp(1).TypeOf_Num = state.dataWaterCoils->WaterCoil_Cooling; CWLoop.LoopSide(1).Branch(1).Comp(1).NodeNumIn = CWCoil.WaterInletNodeNum; CWLoop.LoopSide(1).Branch(1).Comp(1).NodeNumOut = CWCoil.WaterOutletNodeNum; // hot water plant loop @@ -3172,7 +3172,7 @@ namespace EnergyPlus { HWLoop.FluidIndex = 1; HWLoop.FluidName = "WATER"; HWLoop.LoopSide(1).Branch(1).Comp(1).Name = HWCoil.Name; - HWLoop.LoopSide(1).Branch(1).Comp(1).TypeOf_Num = WaterCoil_SimpleHeating; + HWLoop.LoopSide(1).Branch(1).Comp(1).TypeOf_Num = state.dataWaterCoils->WaterCoil_SimpleHeating; HWLoop.LoopSide(1).Branch(1).Comp(1).NodeNumIn = HWCoil.WaterInletNodeNum; HWLoop.LoopSide(1).Branch(1).Comp(1).NodeNumOut = HWCoil.WaterOutletNodeNum; @@ -3188,9 +3188,9 @@ namespace EnergyPlus { QLatOut = 0.0; QZnReq = 4000.0; - MyUAAndFlowCalcFlag.allocate(2); - MyUAAndFlowCalcFlag(1) = true; - MyUAAndFlowCalcFlag(2) = true; + state.dataWaterCoils->MyUAAndFlowCalcFlag.allocate(2); + state.dataWaterCoils->MyUAAndFlowCalcFlag(1) = true; + state.dataWaterCoils->MyUAAndFlowCalcFlag(2) = true; DataGlobals::DoingSizing = true; state.fans.LocalTurnFansOff = false; @@ -3306,7 +3306,7 @@ namespace EnergyPlus { DataEnvironment::OutBaroPress = 101325.0; DataEnvironment::StdRhoAir = 1.20; - WaterCoils::GetWaterCoilsInputFlag = true; + state.dataWaterCoils->GetWaterCoilsInputFlag = true; NumCoils = 0; DataGlobals::NumOfTimeStepInHour = 1; DataGlobals::TimeStep = 1; @@ -3499,7 +3499,7 @@ namespace EnergyPlus { Node(MixerOA.InletNode).Enthalpy = 18000; Node(MixerOA.InletNode).HumRat = PsyWFnTdbH(Node(MixerOA.InletNode).Temp, Node(MixerOA.InletNode).Enthalpy); // chilled water coil - auto &CWCoil(WaterCoil(1)); + auto &CWCoil(state.dataWaterCoils->WaterCoil(1)); CWCoil.UACoilTotal = 470.0; CWCoil.UACoilExternal = 611.0; CWCoil.UACoilInternal = 2010.0; @@ -3541,12 +3541,12 @@ namespace EnergyPlus { CWLoop.FluidIndex = 1; CWLoop.FluidName = "WATER"; CWLoop.LoopSide(1).Branch(1).Comp(1).Name = CWCoil.Name; - CWLoop.LoopSide(1).Branch(1).Comp(1).TypeOf_Num = WaterCoil_Cooling; + CWLoop.LoopSide(1).Branch(1).Comp(1).TypeOf_Num = state.dataWaterCoils->WaterCoil_Cooling; CWLoop.LoopSide(1).Branch(1).Comp(1).NodeNumIn = CWCoil.WaterInletNodeNum; CWLoop.LoopSide(1).Branch(1).Comp(1).NodeNumOut = CWCoil.WaterOutletNodeNum; - MyUAAndFlowCalcFlag.allocate(1); - MyUAAndFlowCalcFlag(1) = true; + state.dataWaterCoils->MyUAAndFlowCalcFlag.allocate(1); + state.dataWaterCoils->MyUAAndFlowCalcFlag(1) = true; DataGlobals::DoingSizing = true; state.fans.LocalTurnFansOff = false; state.fans.LocalTurnFansOn = true; @@ -3671,7 +3671,7 @@ namespace EnergyPlus { DataEnvironment::OutBaroPress = 101325.0; DataEnvironment::StdRhoAir = 1.20; - WaterCoils::GetWaterCoilsInputFlag = true; + state.dataWaterCoils->GetWaterCoilsInputFlag = true; NumCoils = 0; DataGlobals::NumOfTimeStepInHour = 1; DataGlobals::TimeStep = 1; @@ -3864,7 +3864,7 @@ namespace EnergyPlus { Node(MixerOA.InletNode).Enthalpy = 18000; Node(MixerOA.InletNode).HumRat = PsyWFnTdbH(Node(MixerOA.InletNode).Temp, Node(MixerOA.InletNode).Enthalpy); // chilled water coil - auto &CWCoil(WaterCoil(1)); + auto &CWCoil(state.dataWaterCoils->WaterCoil(1)); CWCoil.UACoilTotal = 470.0; CWCoil.UACoilExternal = 611.0; CWCoil.UACoilInternal = 2010.0; @@ -3906,12 +3906,12 @@ namespace EnergyPlus { CWLoop.FluidIndex = 1; CWLoop.FluidName = "WATER"; CWLoop.LoopSide(1).Branch(1).Comp(1).Name = CWCoil.Name; - CWLoop.LoopSide(1).Branch(1).Comp(1).TypeOf_Num = WaterCoil_Cooling; + CWLoop.LoopSide(1).Branch(1).Comp(1).TypeOf_Num = state.dataWaterCoils->WaterCoil_Cooling; CWLoop.LoopSide(1).Branch(1).Comp(1).NodeNumIn = CWCoil.WaterInletNodeNum; CWLoop.LoopSide(1).Branch(1).Comp(1).NodeNumOut = CWCoil.WaterOutletNodeNum; - MyUAAndFlowCalcFlag.allocate(1); - MyUAAndFlowCalcFlag(1) = true; + state.dataWaterCoils->MyUAAndFlowCalcFlag.allocate(1); + state.dataWaterCoils->MyUAAndFlowCalcFlag(1) = true; DataGlobals::DoingSizing = true; state.fans.LocalTurnFansOff = false; state.fans.LocalTurnFansOn = true; @@ -4036,7 +4036,7 @@ namespace EnergyPlus { DataEnvironment::OutBaroPress = 101325.0; DataEnvironment::StdRhoAir = 1.20; - WaterCoils::GetWaterCoilsInputFlag = true; + state.dataWaterCoils->GetWaterCoilsInputFlag = true; NumCoils = 0; DataGlobals::NumOfTimeStepInHour = 1; DataGlobals::TimeStep = 1; @@ -4229,7 +4229,7 @@ namespace EnergyPlus { Node(MixerOA.InletNode).Enthalpy = 18000; Node(MixerOA.InletNode).HumRat = PsyWFnTdbH(Node(MixerOA.InletNode).Temp, Node(MixerOA.InletNode).Enthalpy); // chilled water coil - auto &CWCoil(WaterCoil(1)); + auto &CWCoil(state.dataWaterCoils->WaterCoil(1)); CWCoil.UACoilTotal = 470.0; CWCoil.UACoilExternal = 611.0; CWCoil.UACoilInternal = 2010.0; @@ -4271,12 +4271,12 @@ namespace EnergyPlus { CWLoop.FluidIndex = 1; CWLoop.FluidName = "WATER"; CWLoop.LoopSide(1).Branch(1).Comp(1).Name = CWCoil.Name; - CWLoop.LoopSide(1).Branch(1).Comp(1).TypeOf_Num = WaterCoil_Cooling; + CWLoop.LoopSide(1).Branch(1).Comp(1).TypeOf_Num = state.dataWaterCoils->WaterCoil_Cooling; CWLoop.LoopSide(1).Branch(1).Comp(1).NodeNumIn = CWCoil.WaterInletNodeNum; CWLoop.LoopSide(1).Branch(1).Comp(1).NodeNumOut = CWCoil.WaterOutletNodeNum; - MyUAAndFlowCalcFlag.allocate(1); - MyUAAndFlowCalcFlag(1) = true; + state.dataWaterCoils->MyUAAndFlowCalcFlag.allocate(1); + state.dataWaterCoils->MyUAAndFlowCalcFlag(1) = true; DataGlobals::DoingSizing = true; state.fans.LocalTurnFansOff = false; state.fans.LocalTurnFansOn = true; @@ -4503,7 +4503,7 @@ namespace EnergyPlus { DataEnvironment::OutBaroPress = 101325.0; DataEnvironment::StdRhoAir = 1.20; - WaterCoils::GetWaterCoilsInputFlag = true; + state.dataWaterCoils->GetWaterCoilsInputFlag = true; //NumCoils = 0; DataGlobals::NumOfTimeStepInHour = 1; DataGlobals::TimeStep = 1; @@ -4542,7 +4542,7 @@ namespace EnergyPlus { Node(MixerOA.InletNode).Enthalpy = 18000; Node(MixerOA.InletNode).HumRat = PsyWFnTdbH(Node(MixerOA.InletNode).Temp, Node(MixerOA.InletNode).Enthalpy); // chilled water coil - auto &CWCoil(WaterCoil(1)); + auto &CWCoil(state.dataWaterCoils->WaterCoil(1)); CWCoil.UACoilTotal = 470.0; CWCoil.UACoilExternal = 611.0; CWCoil.UACoilInternal = 2010.0; @@ -4581,12 +4581,12 @@ namespace EnergyPlus { CWLoop.FluidIndex = 1; CWLoop.FluidName = "WATER"; CWLoop.LoopSide(1).Branch(1).Comp(1).Name = CWCoil.Name; - CWLoop.LoopSide(1).Branch(1).Comp(1).TypeOf_Num = WaterCoil_Cooling; + CWLoop.LoopSide(1).Branch(1).Comp(1).TypeOf_Num = state.dataWaterCoils->WaterCoil_Cooling; CWLoop.LoopSide(1).Branch(1).Comp(1).NodeNumIn = CWCoil.WaterInletNodeNum; CWLoop.LoopSide(1).Branch(1).Comp(1).NodeNumOut = CWCoil.WaterOutletNodeNum; - MyUAAndFlowCalcFlag.allocate(1); - MyUAAndFlowCalcFlag(1) = true; + state.dataWaterCoils->MyUAAndFlowCalcFlag.allocate(1); + state.dataWaterCoils->MyUAAndFlowCalcFlag(1) = true; DataGlobals::DoingSizing = true; state.fans.LocalTurnFansOff = false; state.fans.LocalTurnFansOn = true; diff --git a/tst/EnergyPlus/unit/FaultsManager.unit.cc b/tst/EnergyPlus/unit/FaultsManager.unit.cc index 444021c5ca8..21d8a6169aa 100644 --- a/tst/EnergyPlus/unit/FaultsManager.unit.cc +++ b/tst/EnergyPlus/unit/FaultsManager.unit.cc @@ -904,22 +904,22 @@ TEST_F(EnergyPlusFixture, FaultsManager_FoulingCoil_AssignmentAndCalc) EXPECT_EQ(2, FaultsManager::NumFouledCoil); // This should also have called WaterCoil::GetWaterCoilInput - EXPECT_EQ(3, WaterCoils::NumWaterCoils); + EXPECT_EQ(3, state.dataWaterCoils->NumWaterCoils); // Check that fault association actually happened { int CoilNum = 1; int FaultIndex = 1; - EXPECT_EQ("AHU HW HEATING COIL", WaterCoils::WaterCoil(CoilNum).Name); - EXPECT_NEAR(6.64, WaterCoils::WaterCoil(CoilNum).UACoil, 0.0001); - EXPECT_EQ(WaterCoils::WaterCoil_SimpleHeating, WaterCoils::WaterCoil(CoilNum).WaterCoilType_Num); + EXPECT_EQ("AHU HW HEATING COIL", state.dataWaterCoils->WaterCoil(CoilNum).Name); + EXPECT_NEAR(6.64, state.dataWaterCoils->WaterCoil(CoilNum).UACoil, 0.0001); + EXPECT_EQ(state.dataWaterCoils->WaterCoil_SimpleHeating, state.dataWaterCoils->WaterCoil(CoilNum).WaterCoilType_Num); EXPECT_EQ(CoilNum, FaultsManager::FouledCoils(FaultIndex).FouledCoilNum); - EXPECT_EQ(WaterCoils::WaterCoil_SimpleHeating, FaultsManager::FouledCoils(FaultIndex).FouledCoiledType); + EXPECT_EQ(state.dataWaterCoils->WaterCoil_SimpleHeating, FaultsManager::FouledCoils(FaultIndex).FouledCoiledType); - EXPECT_TRUE(WaterCoils::WaterCoil(CoilNum).FaultyCoilFoulingFlag); - EXPECT_EQ(FaultIndex, WaterCoils::WaterCoil(CoilNum).FaultyCoilFoulingIndex); + EXPECT_TRUE(state.dataWaterCoils->WaterCoil(CoilNum).FaultyCoilFoulingFlag); + EXPECT_EQ(FaultIndex, state.dataWaterCoils->WaterCoil(CoilNum).FaultyCoilFoulingIndex); // Doesn't have an Availability Schedule EXPECT_EQ(-1, FaultsManager::FouledCoils(FaultIndex).AvaiSchedPtr); @@ -940,14 +940,14 @@ TEST_F(EnergyPlusFixture, FaultsManager_FoulingCoil_AssignmentAndCalc) { int CoilNum = 2; int FaultIndex = 2; - EXPECT_EQ("AHU CHW COOLING COIL", WaterCoils::WaterCoil(CoilNum).Name); - EXPECT_EQ(WaterCoils::WaterCoil_Cooling, WaterCoils::WaterCoil(CoilNum).WaterCoilType_Num); + EXPECT_EQ("AHU CHW COOLING COIL", state.dataWaterCoils->WaterCoil(CoilNum).Name); + EXPECT_EQ(state.dataWaterCoils->WaterCoil_Cooling, state.dataWaterCoils->WaterCoil(CoilNum).WaterCoilType_Num); EXPECT_EQ(CoilNum, FaultsManager::FouledCoils(FaultIndex).FouledCoilNum); - EXPECT_EQ(WaterCoils::WaterCoil_Cooling, FaultsManager::FouledCoils(FaultIndex).FouledCoiledType); + EXPECT_EQ(state.dataWaterCoils->WaterCoil_Cooling, FaultsManager::FouledCoils(FaultIndex).FouledCoiledType); - EXPECT_TRUE(WaterCoils::WaterCoil(CoilNum).FaultyCoilFoulingFlag); - EXPECT_EQ(FaultIndex, WaterCoils::WaterCoil(CoilNum).FaultyCoilFoulingIndex); + EXPECT_TRUE(state.dataWaterCoils->WaterCoil(CoilNum).FaultyCoilFoulingFlag); + EXPECT_EQ(FaultIndex, state.dataWaterCoils->WaterCoil(CoilNum).FaultyCoilFoulingIndex); // Has an Availabity Schedule EXPECT_EQ("AVAILSCHED", FaultsManager::FouledCoils(FaultIndex).AvaiSchedule); @@ -973,11 +973,11 @@ TEST_F(EnergyPlusFixture, FaultsManager_FoulingCoil_AssignmentAndCalc) // No association if not meant! { int CoilNum = 3; - EXPECT_EQ("AHU CHW COIL WITH NO FAULT", WaterCoils::WaterCoil(CoilNum).Name); - EXPECT_EQ(WaterCoils::WaterCoil_Cooling, WaterCoils::WaterCoil(CoilNum).WaterCoilType_Num); + EXPECT_EQ("AHU CHW COIL WITH NO FAULT", state.dataWaterCoils->WaterCoil(CoilNum).Name); + EXPECT_EQ(state.dataWaterCoils->WaterCoil_Cooling, state.dataWaterCoils->WaterCoil(CoilNum).WaterCoilType_Num); - EXPECT_FALSE(WaterCoils::WaterCoil(CoilNum).FaultyCoilFoulingFlag); - EXPECT_EQ(0, WaterCoils::WaterCoil(CoilNum).FaultyCoilFoulingIndex); + EXPECT_FALSE(state.dataWaterCoils->WaterCoil(CoilNum).FaultyCoilFoulingFlag); + EXPECT_EQ(0, state.dataWaterCoils->WaterCoil(CoilNum).FaultyCoilFoulingIndex); } } diff --git a/tst/EnergyPlus/unit/HVACControllers.unit.cc b/tst/EnergyPlus/unit/HVACControllers.unit.cc index 91eaf1da1b8..78022d6c97c 100644 --- a/tst/EnergyPlus/unit/HVACControllers.unit.cc +++ b/tst/EnergyPlus/unit/HVACControllers.unit.cc @@ -254,7 +254,7 @@ TEST_F(EnergyPlusFixture, HVACControllers_TestTempAndHumidityRatioCtrlVarType) DataAirSystems::PrimaryAirSystem(1).Branch(1).NodeNum(1) = 1; DataAirSystems::PrimaryAirSystem(1).Branch(1).Comp.allocate(1); DataAirSystems::PrimaryAirSystem(1).Branch(1).Comp(1).Name = "CHILLED WATER COIL"; - DataAirSystems::PrimaryAirSystem(1).Branch(1).Comp(1).CompType_Num = 5; // WaterCoil_Cooling + DataAirSystems::PrimaryAirSystem(1).Branch(1).Comp(1).CompType_Num = 5; // state.dataWaterCoils->WaterCoil_Cooling DataPlant::PlantLoop.allocate(1); DataPlant::TotNumLoops = 1; DataPlant::PlantLoop(1).LoopSide.allocate(2); @@ -404,8 +404,8 @@ TEST_F(EnergyPlusFixture, HVACControllers_WaterCoilOnPrimaryLoopCheckTest) GetControllerInput(state); - ASSERT_EQ(WaterCoil(1).Name, "CHILLED WATER COIL"); - ASSERT_EQ(WaterCoil(1).WaterCoilType_Num, WaterCoils::WaterCoil_Cooling); + ASSERT_EQ(state.dataWaterCoils->WaterCoil(1).Name, "CHILLED WATER COIL"); + ASSERT_EQ(state.dataWaterCoils->WaterCoil(1).WaterCoilType_Num, state.dataWaterCoils->WaterCoil_Cooling); OutputReportPredefined::SetPredefinedTables(); SimAirServingZones::GetAirLoopInputFlag = false; @@ -426,7 +426,7 @@ TEST_F(EnergyPlusFixture, HVACControllers_WaterCoilOnPrimaryLoopCheckTest) DataAirSystems::PrimaryAirSystem(1).Branch(1).NodeNum.allocate(1); DataAirSystems::PrimaryAirSystem(1).Branch(1).NodeNum(1) = 1; DataAirSystems::PrimaryAirSystem(1).Branch(1).Comp.allocate(1); - DataAirSystems::PrimaryAirSystem(1).Branch(1).Comp(1).Name = WaterCoil(1).Name; + DataAirSystems::PrimaryAirSystem(1).Branch(1).Comp(1).Name = state.dataWaterCoils->WaterCoil(1).Name; DataAirSystems::PrimaryAirSystem(1).Branch(1).Comp(1).CompType_Num = SimAirServingZones::WaterCoil_Cooling; bool WaterCoilOnAirLoop = true; @@ -450,7 +450,7 @@ TEST_F(EnergyPlusFixture, HVACControllers_WaterCoilOnPrimaryLoopCheckTest) EXPECT_TRUE(WaterCoilOnAirLoop); // now test a different water coil type - CoilTypeNum = WaterCoils::WaterCoil_DetFlatFinCooling; + CoilTypeNum = state.dataWaterCoils->WaterCoil_DetFlatFinCooling; WaterCoilOnAirLoop = SimAirServingZones::CheckWaterCoilOnPrimaryAirLoopBranch(state, CoilTypeNum, CompName); EXPECT_FALSE(WaterCoilOnAirLoop); } @@ -497,8 +497,8 @@ TEST_F(EnergyPlusFixture, HVACControllers_WaterCoilOnOutsideAirSystemCheckTest) GetControllerInput(state); - ASSERT_EQ(WaterCoil(1).Name, "OA PREHEAT HW COIL"); - ASSERT_EQ(WaterCoil(1).WaterCoilType_Num, WaterCoils::WaterCoil_SimpleHeating); + ASSERT_EQ(state.dataWaterCoils->WaterCoil(1).Name, "OA PREHEAT HW COIL"); + ASSERT_EQ(state.dataWaterCoils->WaterCoil(1).WaterCoilType_Num, state.dataWaterCoils->WaterCoil_SimpleHeating); OutputReportPredefined::SetPredefinedTables(); SimAirServingZones::GetAirLoopInputFlag = false; @@ -514,7 +514,7 @@ TEST_F(EnergyPlusFixture, HVACControllers_WaterCoilOnOutsideAirSystemCheckTest) DataAirLoop::OutsideAirSys(1).ComponentType(1) = DataHVACGlobals::cAllCoilTypes(DataHVACGlobals::Coil_HeatingWater); DataAirLoop::OutsideAirSys(1).ComponentType(2) = "OutdoorAir:Mixer"; DataAirLoop::OutsideAirSys(1).ComponentName.allocate(2); - DataAirLoop::OutsideAirSys(1).ComponentName(1) = WaterCoil(1).Name; + DataAirLoop::OutsideAirSys(1).ComponentName(1) = state.dataWaterCoils->WaterCoil(1).Name; DataAirLoop::OutsideAirSys(1).ComponentName(2) = "OAMixer"; DataAirLoop::OutsideAirSys(1).ComponentType_Num.allocate(2); DataAirLoop::OutsideAirSys(1).ComponentType_Num(1) = SimAirServingZones::WaterCoil_SimpleHeat; @@ -536,7 +536,7 @@ TEST_F(EnergyPlusFixture, HVACControllers_WaterCoilOnOutsideAirSystemCheckTest) bool WaterCoilOnAirLoop = true; std::string CompType = DataHVACGlobals::cAllCoilTypes(DataHVACGlobals::Coil_HeatingWater); - std::string CompName = WaterCoil(1).Name; + std::string CompName = state.dataWaterCoils->WaterCoil(1).Name; int CoilTypeNum = SimAirServingZones::WaterCoil_SimpleHeat; WaterCoilOnAirLoop = SimAirServingZones::CheckWaterCoilOnPrimaryAirLoopBranch(state, CoilTypeNum, CompName); @@ -629,8 +629,8 @@ TEST_F(EnergyPlusFixture, HVACControllers_CoilSystemCoolingWaterOnOutsideAirSyst GetControllerInput(state); - ASSERT_EQ(WaterCoil(1).Name, "DETAILED PRE COOLING COIL"); - ASSERT_EQ(WaterCoil(1).WaterCoilType_Num, WaterCoils::WaterCoil_DetFlatFinCooling); + ASSERT_EQ(state.dataWaterCoils->WaterCoil(1).Name, "DETAILED PRE COOLING COIL"); + ASSERT_EQ(state.dataWaterCoils->WaterCoil(1).WaterCoilType_Num, state.dataWaterCoils->WaterCoil_DetFlatFinCooling); OutputReportPredefined::SetPredefinedTables(); SimAirServingZones::GetAirLoopInputFlag = false; @@ -668,7 +668,7 @@ TEST_F(EnergyPlusFixture, HVACControllers_CoilSystemCoolingWaterOnOutsideAirSyst bool WaterCoilOnAirLoop = true; std::string CompType = DataHVACGlobals::cAllCoilTypes(DataHVACGlobals::Coil_CoolingWaterDetailed); - std::string CompName = WaterCoil(1).Name; + std::string CompName = state.dataWaterCoils->WaterCoil(1).Name; int CoilTypeNum = SimAirServingZones::WaterCoil_DetailedCool; WaterCoilOnAirLoop = SimAirServingZones::CheckWaterCoilOnPrimaryAirLoopBranch(state, CoilTypeNum, CompName); diff --git a/tst/EnergyPlus/unit/HVACVariableRefrigerantFlow.unit.cc b/tst/EnergyPlus/unit/HVACVariableRefrigerantFlow.unit.cc index c078b0648f8..2756d41319c 100644 --- a/tst/EnergyPlus/unit/HVACVariableRefrigerantFlow.unit.cc +++ b/tst/EnergyPlus/unit/HVACVariableRefrigerantFlow.unit.cc @@ -8044,31 +8044,31 @@ TEST_F(EnergyPlusFixture, VRFTU_CalcVRFSupplementalHeatingCoilWater) int CoilNum(1); DataLoopNode::Node.allocate(4); - WaterCoils::NumWaterCoils = 1; - WaterCoils::WaterCoil.allocate(WaterCoils::NumWaterCoils); - WaterCoils::WaterCoil(CoilNum).Name = thisVRFTU.SuppHeatCoilName; - WaterCoils::WaterCoil(CoilNum).WaterCoilType_Num = WaterCoils::WaterCoil_SimpleHeating; - WaterCoils::WaterCoil(CoilNum).WaterCoilModel = WaterCoils::CoilType_Heating; - WaterCoils::WaterCoil(CoilNum).WaterCoilType = WaterCoils::CoilType_Heating; - WaterCoils::WaterCoil(CoilNum).WaterCoilTypeA = "Heating"; - WaterCoils::WaterCoil(CoilNum).SchedPtr = DataGlobals::ScheduleAlwaysOn; - WaterCoils::WaterCoil(CoilNum).WaterLoopNum = 1; - - // WaterCoils::WaterCoil(CoilNum).FuelType_Num = DataGlobalConstants::iRT_Natural_Gas; - WaterCoils::WaterCoil(CoilNum).AirInletNodeNum = thisVRFTU.SuppHeatCoilAirInletNode; - WaterCoils::WaterCoil(CoilNum).AirOutletNodeNum = thisVRFTU.SuppHeatCoilAirOutletNode; - WaterCoils::WaterCoil(CoilNum).WaterInletNodeNum = thisVRFTU.SuppHeatCoilFluidInletNode; - WaterCoils::WaterCoil(CoilNum).WaterOutletNodeNum = thisVRFTU.SuppHeatCoilFluidOutletNode; - - WaterCoils::WaterCoil(CoilNum).UACoil = 1000; - WaterCoils::WaterCoil(CoilNum).MaxWaterVolFlowRate = 0.001; - - WaterCoils::GetWaterCoilsInputFlag = false; - - WaterCoils::WaterCoil(CoilNum).WaterLoopNum = 1; - WaterCoils::WaterCoil(CoilNum).WaterLoopSide = 1; - WaterCoils::WaterCoil(CoilNum).WaterLoopBranchNum = 1; - WaterCoils::WaterCoil(CoilNum).WaterLoopCompNum = 1; + state.dataWaterCoils->NumWaterCoils = 1; + state.dataWaterCoils->WaterCoil.allocate(state.dataWaterCoils->NumWaterCoils); + state.dataWaterCoils->WaterCoil(CoilNum).Name = thisVRFTU.SuppHeatCoilName; + state.dataWaterCoils->WaterCoil(CoilNum).WaterCoilType_Num = state.dataWaterCoils->WaterCoil_SimpleHeating; + state.dataWaterCoils->WaterCoil(CoilNum).WaterCoilModel = state.dataWaterCoils->CoilType_Heating; + state.dataWaterCoils->WaterCoil(CoilNum).WaterCoilType = state.dataWaterCoils->CoilType_Heating; + state.dataWaterCoils->WaterCoil(CoilNum).WaterCoilTypeA = "Heating"; + state.dataWaterCoils->WaterCoil(CoilNum).SchedPtr = DataGlobals::ScheduleAlwaysOn; + state.dataWaterCoils->WaterCoil(CoilNum).WaterLoopNum = 1; + + // state.dataWaterCoils->WaterCoil(CoilNum).FuelType_Num = DataGlobalConstants::iRT_Natural_Gas; + state.dataWaterCoils->WaterCoil(CoilNum).AirInletNodeNum = thisVRFTU.SuppHeatCoilAirInletNode; + state.dataWaterCoils->WaterCoil(CoilNum).AirOutletNodeNum = thisVRFTU.SuppHeatCoilAirOutletNode; + state.dataWaterCoils->WaterCoil(CoilNum).WaterInletNodeNum = thisVRFTU.SuppHeatCoilFluidInletNode; + state.dataWaterCoils->WaterCoil(CoilNum).WaterOutletNodeNum = thisVRFTU.SuppHeatCoilFluidOutletNode; + + state.dataWaterCoils->WaterCoil(CoilNum).UACoil = 1000; + state.dataWaterCoils->WaterCoil(CoilNum).MaxWaterVolFlowRate = 0.001; + + state.dataWaterCoils->GetWaterCoilsInputFlag = false; + + state.dataWaterCoils->WaterCoil(CoilNum).WaterLoopNum = 1; + state.dataWaterCoils->WaterCoil(CoilNum).WaterLoopSide = 1; + state.dataWaterCoils->WaterCoil(CoilNum).WaterLoopBranchNum = 1; + state.dataWaterCoils->WaterCoil(CoilNum).WaterLoopCompNum = 1; NumPltSizInput = 1; PlantSizData.allocate(NumPltSizInput); @@ -8093,30 +8093,30 @@ TEST_F(EnergyPlusFixture, VRFTU_CalcVRFSupplementalHeatingCoilWater) PlantLoop(1).Name = "HotWaterLoop"; PlantLoop(1).FluidName = "WATER"; PlantLoop(1).FluidIndex = 1; - PlantLoop(1).LoopSide(1).Branch(1).Comp(1).Name = WaterCoils::WaterCoil(CoilNum).Name; - PlantLoop(1).LoopSide(1).Branch(1).Comp(1).TypeOf_Num = WaterCoils::WaterCoil_SimpleHeating; - PlantLoop(1).LoopSide(1).Branch(1).Comp(1).NodeNumIn = WaterCoils::WaterCoil(1).WaterInletNodeNum; - WaterCoils::CheckEquipName.dimension(WaterCoils::NumWaterCoils, true); + PlantLoop(1).LoopSide(1).Branch(1).Comp(1).Name = state.dataWaterCoils->WaterCoil(CoilNum).Name; + PlantLoop(1).LoopSide(1).Branch(1).Comp(1).TypeOf_Num = state.dataWaterCoils->WaterCoil_SimpleHeating; + PlantLoop(1).LoopSide(1).Branch(1).Comp(1).NodeNumIn = state.dataWaterCoils->WaterCoil(1).WaterInletNodeNum; + state.dataWaterCoils->CheckEquipName.dimension(state.dataWaterCoils->NumWaterCoils, true); - WaterCoils::MyUAAndFlowCalcFlag.allocate(CoilNum); - WaterCoils::MyUAAndFlowCalcFlag(CoilNum) = true; - WaterCoils::MySizeFlag.allocate(CoilNum); - WaterCoils::MySizeFlag(CoilNum) = true; + state.dataWaterCoils->MyUAAndFlowCalcFlag.allocate(CoilNum); + state.dataWaterCoils->MyUAAndFlowCalcFlag(CoilNum) = true; + state.dataWaterCoils->MySizeFlag.allocate(CoilNum); + state.dataWaterCoils->MySizeFlag(CoilNum) = true; DataGlobals::DoingSizing = true; SysSizingCalc = true; DataEnvironment::OutDryBulbTemp = 5.0; // init coil inlet condition - DataLoopNode::Node(WaterCoils::WaterCoil(CoilNum).AirInletNodeNum).MassFlowRate = 1.0; - DataLoopNode::Node(WaterCoils::WaterCoil(CoilNum).AirInletNodeNum).Temp = 15.0; - DataLoopNode::Node(WaterCoils::WaterCoil(CoilNum).AirInletNodeNum).HumRat = 0.0070; - DataLoopNode::Node(WaterCoils::WaterCoil(CoilNum).AirInletNodeNum).Enthalpy = - Psychrometrics::PsyHFnTdbW(DataLoopNode::Node(WaterCoils::WaterCoil(CoilNum).AirInletNodeNum).Temp, - DataLoopNode::Node(WaterCoils::WaterCoil(CoilNum).AirInletNodeNum).HumRat); + DataLoopNode::Node(state.dataWaterCoils->WaterCoil(CoilNum).AirInletNodeNum).MassFlowRate = 1.0; + DataLoopNode::Node(state.dataWaterCoils->WaterCoil(CoilNum).AirInletNodeNum).Temp = 15.0; + DataLoopNode::Node(state.dataWaterCoils->WaterCoil(CoilNum).AirInletNodeNum).HumRat = 0.0070; + DataLoopNode::Node(state.dataWaterCoils->WaterCoil(CoilNum).AirInletNodeNum).Enthalpy = + Psychrometrics::PsyHFnTdbW(DataLoopNode::Node(state.dataWaterCoils->WaterCoil(CoilNum).AirInletNodeNum).Temp, + DataLoopNode::Node(state.dataWaterCoils->WaterCoil(CoilNum).AirInletNodeNum).HumRat); - DataLoopNode::Node(WaterCoils::WaterCoil(CoilNum).WaterInletNodeNum).MassFlowRate = thisVRFTU.SuppHeatCoilFluidMaxFlow; - DataLoopNode::Node(WaterCoils::WaterCoil(CoilNum).WaterInletNodeNum).MassFlowRateMax = thisVRFTU.SuppHeatCoilFluidMaxFlow; - DataLoopNode::Node(WaterCoils::WaterCoil(CoilNum).WaterInletNodeNum).Temp = 60.0; + DataLoopNode::Node(state.dataWaterCoils->WaterCoil(CoilNum).WaterInletNodeNum).MassFlowRate = thisVRFTU.SuppHeatCoilFluidMaxFlow; + DataLoopNode::Node(state.dataWaterCoils->WaterCoil(CoilNum).WaterInletNodeNum).MassFlowRateMax = thisVRFTU.SuppHeatCoilFluidMaxFlow; + DataLoopNode::Node(state.dataWaterCoils->WaterCoil(CoilNum).WaterInletNodeNum).Temp = 60.0; bool FirstHVACIteration(false); Real64 SuppHeatCoilLoad = 10000.0; @@ -8128,13 +8128,13 @@ TEST_F(EnergyPlusFixture, VRFTU_CalcVRFSupplementalHeatingCoilWater) thisVRFTU.CalcVRFSuppHeatingCoil(state, VRFTUNum, FirstHVACIteration, thisVRFTU.SuppHeatPartLoadRatio, SuppHeatCoilLoad); // check the coil load delivered EXPECT_NEAR(10000.0, SuppHeatCoilLoad, 5.0); - EXPECT_NEAR(10000.0, WaterCoils::WaterCoil(CoilNum).TotWaterHeatingCoilRate, 5.0); + EXPECT_NEAR(10000.0, state.dataWaterCoils->WaterCoil(CoilNum).TotWaterHeatingCoilRate, 5.0); // test larger heating load SuppHeatCoilLoad = 12000.0; thisVRFTU.CalcVRFSuppHeatingCoil(state, VRFTUNum, FirstHVACIteration, thisVRFTU.SuppHeatPartLoadRatio, SuppHeatCoilLoad); // delivered heating capacity EXPECT_NEAR(12000.0, SuppHeatCoilLoad, 5.0); - EXPECT_NEAR(12000.0, WaterCoils::WaterCoil(CoilNum).TotWaterHeatingCoilRate, 5.0); + EXPECT_NEAR(12000.0, state.dataWaterCoils->WaterCoil(CoilNum).TotWaterHeatingCoilRate, 5.0); } TEST_F(EnergyPlusFixture, VRFTU_CalcVRFSupplementalHeatingCoilSteam) diff --git a/tst/EnergyPlus/unit/OASystemHWPreheatCoil.unit.cc b/tst/EnergyPlus/unit/OASystemHWPreheatCoil.unit.cc index 295a27e651a..67048117206 100644 --- a/tst/EnergyPlus/unit/OASystemHWPreheatCoil.unit.cc +++ b/tst/EnergyPlus/unit/OASystemHWPreheatCoil.unit.cc @@ -1048,16 +1048,16 @@ TEST_F(EnergyPlusFixture, OASystem_HotWaterPreheatCoilScheduledOffSim) EXPECT_EQ("OA SYS 1", OutsideAirSys(OASysNum).Name); EXPECT_EQ(2, OutsideAirSys(OASysNum).NumComponents); // there are two components in OA system EXPECT_EQ("OA PREHEAT HW COIL", OutsideAirSys(OASysNum).ComponentName(1)); // pre heat hot water coil - EXPECT_EQ(WaterCoil(1).Name, OutsideAirSys(OASysNum).ComponentName(1)); // pre heat hot water coil + EXPECT_EQ(state.dataWaterCoils->WaterCoil(1).Name, OutsideAirSys(OASysNum).ComponentName(1)); // pre heat hot water coil EXPECT_EQ("OA MIXING BOX", OutsideAirSys(OASysNum).ComponentName(2)); // OA mixer // simulate the outdoor air system ManageOutsideAirSystem(state, OutsideAirSys(OASysNum).Name, false, AirLoopNum, OASysNum); // Hot water coil is scheduled off, inlet and outlet conditions are the same - EXPECT_DOUBLE_EQ(WaterCoil(1).InletAirTemp, -17.3); // preheat Hot Water coil air inlet temp is the heating design day outdoor air temp - EXPECT_DOUBLE_EQ(WaterCoil(1).OutletAirTemp, -17.3); // preheat Hot Water coil is scheduled off - EXPECT_DOUBLE_EQ(0.0, WaterCoil(1).TotWaterHeatingCoilRate); // preheat Hot Water coil is scheduled off + EXPECT_DOUBLE_EQ(state.dataWaterCoils->WaterCoil(1).InletAirTemp, -17.3); // preheat Hot Water coil air inlet temp is the heating design day outdoor air temp + EXPECT_DOUBLE_EQ(state.dataWaterCoils->WaterCoil(1).OutletAirTemp, -17.3); // preheat Hot Water coil is scheduled off + EXPECT_DOUBLE_EQ(0.0, state.dataWaterCoils->WaterCoil(1).TotWaterHeatingCoilRate); // preheat Hot Water coil is scheduled off } TEST_F(EnergyPlusFixture, OASystem_HotWaterPreheatCoilScheduledOnSim) @@ -2026,28 +2026,28 @@ TEST_F(EnergyPlusFixture, OASystem_HotWaterPreheatCoilScheduledOnSim) EXPECT_EQ("OA SYS 1", OutsideAirSys(OASysNum).Name); EXPECT_EQ(2, OutsideAirSys(OASysNum).NumComponents); // there are two components in OA system EXPECT_EQ("OA PREHEAT HW COIL", OutsideAirSys(OASysNum).ComponentName(1)); // pre heat hot water coil - EXPECT_EQ(WaterCoil(1).Name, OutsideAirSys(OASysNum).ComponentName(1)); // pre heat hot water coil + EXPECT_EQ(state.dataWaterCoils->WaterCoil(1).Name, OutsideAirSys(OASysNum).ComponentName(1)); // pre heat hot water coil EXPECT_EQ("OA MIXING BOX", OutsideAirSys(OASysNum).ComponentName(2)); // OA mixer // simulate the outdoor air system ManageOutsideAirSystem(state, OutsideAirSys(OASysNum).Name, false, AirLoopNum, OASysNum); - EXPECT_DOUBLE_EQ(WaterCoil(1).InletAirTemp, -17.3); // preheat Hot Water coil air inlet temp is the heating design day outdoor air temp + EXPECT_DOUBLE_EQ(state.dataWaterCoils->WaterCoil(1).InletAirTemp, -17.3); // preheat Hot Water coil air inlet temp is the heating design day outdoor air temp - EXPECT_DOUBLE_EQ(11.6, Node(WaterCoil(1).AirOutletNodeNum).TempSetPoint); // check the setpoint at the preheat Hot Water coil air outlet node - EXPECT_NEAR(11.6, WaterCoil(1).OutletAirTemp, 0.01); // preheat hot water coil is on and is heating the OA air stream + EXPECT_DOUBLE_EQ(11.6, Node(state.dataWaterCoils->WaterCoil(1).AirOutletNodeNum).TempSetPoint); // check the setpoint at the preheat Hot Water coil air outlet node + EXPECT_NEAR(11.6, state.dataWaterCoils->WaterCoil(1).OutletAirTemp, 0.01); // preheat hot water coil is on and is heating the OA air stream - AirInletNodeNum = WaterCoil(1).AirInletNodeNum; + AirInletNodeNum = state.dataWaterCoils->WaterCoil(1).AirInletNodeNum; CpAir = PsyCpAirFnW(Node(AirInletNodeNum).HumRat); - EXPECT_NEAR(WaterCoil(1).TotWaterHeatingCoilRate, - WaterCoil(1).InletAirMassFlowRate * CpAir * (WaterCoil(1).OutletAirTemp - WaterCoil(1).InletAirTemp), + EXPECT_NEAR(state.dataWaterCoils->WaterCoil(1).TotWaterHeatingCoilRate, + state.dataWaterCoils->WaterCoil(1).InletAirMassFlowRate * CpAir * (state.dataWaterCoils->WaterCoil(1).OutletAirTemp - state.dataWaterCoils->WaterCoil(1).InletAirTemp), 1.0); // test that OA sys water coil bypasses normal controller calls before air loop simulation EXPECT_EQ("PREHEAT COIL CONTROLLER", HVACControllers::ControllerProps(1).ControllerName); EXPECT_TRUE(HVACControllers::ControllerProps(1).BypassControllerCalc); // test that water coil knows which controller controls the HW coil - EXPECT_EQ(WaterCoil(1).ControllerIndex, 1); + EXPECT_EQ(state.dataWaterCoils->WaterCoil(1).ControllerIndex, 1); } } // namespace EnergyPlus diff --git a/tst/EnergyPlus/unit/OutdoorAirUnit.unit.cc b/tst/EnergyPlus/unit/OutdoorAirUnit.unit.cc index 9ea47ff4229..288e77cc253 100644 --- a/tst/EnergyPlus/unit/OutdoorAirUnit.unit.cc +++ b/tst/EnergyPlus/unit/OutdoorAirUnit.unit.cc @@ -595,27 +595,27 @@ TEST_F(EnergyPlusFixture, OutdoorAirUnit_WaterCoolingCoilAutoSizeTest) loopsidebranch.Comp.allocate(1); } - WaterCoil(1).WaterLoopNum = 1; - WaterCoil(1).WaterLoopSide = 1; - WaterCoil(1).WaterLoopBranchNum = 1; - WaterCoil(1).WaterLoopCompNum = 1; + state.dataWaterCoils->WaterCoil(1).WaterLoopNum = 1; + state.dataWaterCoils->WaterCoil(1).WaterLoopSide = 1; + state.dataWaterCoils->WaterCoil(1).WaterLoopBranchNum = 1; + state.dataWaterCoils->WaterCoil(1).WaterLoopCompNum = 1; PlantLoop(1).Name = "ChilledWaterLoop"; PlantLoop(1).FluidIndex = 1; PlantLoop(1).FluidName = "WATER"; - PlantLoop(1).LoopSide(1).Branch(1).Comp(1).Name = WaterCoil(1).Name; + PlantLoop(1).LoopSide(1).Branch(1).Comp(1).Name = state.dataWaterCoils->WaterCoil(1).Name; PlantLoop(1).LoopSide(1).Branch(1).Comp(1).TypeOf_Num = TypeOf_CoilWaterCooling; - PlantLoop(1).LoopSide(1).Branch(1).Comp(1).NodeNumIn = WaterCoil(1).WaterInletNodeNum; - PlantLoop(1).LoopSide(1).Branch(1).Comp(1).NodeNumOut = WaterCoil(1).WaterOutletNodeNum; + PlantLoop(1).LoopSide(1).Branch(1).Comp(1).NodeNumIn = state.dataWaterCoils->WaterCoil(1).WaterInletNodeNum; + PlantLoop(1).LoopSide(1).Branch(1).Comp(1).NodeNumOut = state.dataWaterCoils->WaterCoil(1).WaterOutletNodeNum; PlantSizData(1).PlantLoopName = "ChilledWaterLoop"; PlantSizData(1).ExitTemp = 6.7; PlantSizData(1).DeltaT = 5.0; PlantSizData(1).LoopType = DataSizing::CoolingLoop; - MyUAAndFlowCalcFlag.allocate(1); - MyUAAndFlowCalcFlag(1) = true; - MyUAAndFlowCalcFlag(1) = true; + state.dataWaterCoils->MyUAAndFlowCalcFlag.allocate(1); + state.dataWaterCoils->MyUAAndFlowCalcFlag(1) = true; + state.dataWaterCoils->MyUAAndFlowCalcFlag(1) = true; DataGlobals::HourOfDay = 15; DataEnvironment::DSTIndicator = 0; @@ -659,7 +659,7 @@ TEST_F(EnergyPlusFixture, OutdoorAirUnit_WaterCoolingCoilAutoSizeTest) int ZoneNum(1); InitOutdoorAirUnit(state, OAUnitNum, ZoneNum, FirstHVACIteration); - EXPECT_EQ(WaterCoil(1).MaxWaterVolFlowRate, OutAirUnit(OAUnitNum).OAEquip(1).MaxVolWaterFlow); + EXPECT_EQ(state.dataWaterCoils->WaterCoil(1).MaxWaterVolFlowRate, OutAirUnit(OAUnitNum).OAEquip(1).MaxVolWaterFlow); // calculate fan heat to get fan air-side delta T DataSizing::DataFanEnumType = DataAirSystems::objectVectorOOFanSystemModel; @@ -678,8 +678,8 @@ TEST_F(EnergyPlusFixture, OutdoorAirUnit_WaterCoolingCoilAutoSizeTest) Real64 rho = GetDensityGlycol(PlantLoop(1).FluidName, DataGlobals::CWInitConvTemp, PlantLoop(1).FluidIndex, " "); Real64 DesCoolingCoilWaterVolFlowRate = DesWaterCoolingCoilLoad / (CoilDesWaterDeltaT * Cp * rho); // check water coil water flow rate calc - EXPECT_EQ(DesWaterCoolingCoilLoad, WaterCoil(1).DesWaterCoolingCoilRate); - EXPECT_EQ(DesCoolingCoilWaterVolFlowRate, WaterCoil(1).MaxWaterVolFlowRate); + EXPECT_EQ(DesWaterCoolingCoilLoad, state.dataWaterCoils->WaterCoil(1).DesWaterCoolingCoilRate); + EXPECT_EQ(DesCoolingCoilWaterVolFlowRate, state.dataWaterCoils->WaterCoil(1).MaxWaterVolFlowRate); } TEST_F(EnergyPlusFixture, OutdoorAirUnit_SteamHeatingCoilAutoSizeTest) @@ -919,9 +919,9 @@ TEST_F(EnergyPlusFixture, OutdoorAirUnit_SteamHeatingCoilAutoSizeTest) PlantSizData(1).DeltaT = 5.0; PlantSizData(1).LoopType = DataSizing::SteamLoop; - MyUAAndFlowCalcFlag.allocate(2); - MyUAAndFlowCalcFlag(1) = true; - MyUAAndFlowCalcFlag(2) = true; + state.dataWaterCoils->MyUAAndFlowCalcFlag.allocate(2); + state.dataWaterCoils->MyUAAndFlowCalcFlag(1) = true; + state.dataWaterCoils->MyUAAndFlowCalcFlag(2) = true; DataGlobals::HourOfDay = 15; DataEnvironment::DSTIndicator = 0; diff --git a/tst/EnergyPlus/unit/SZVAVModel.unit.cc b/tst/EnergyPlus/unit/SZVAVModel.unit.cc index c3d75678fbe..272de2396c9 100644 --- a/tst/EnergyPlus/unit/SZVAVModel.unit.cc +++ b/tst/EnergyPlus/unit/SZVAVModel.unit.cc @@ -431,7 +431,7 @@ TEST_F(EnergyPlusFixture, SZVAV_FanCoilUnit_Testing) DataEnvironment::OutBaroPress = 101325.0; DataEnvironment::StdRhoAir = 1.20; - WaterCoils::GetWaterCoilsInputFlag = true; + state.dataWaterCoils->GetWaterCoilsInputFlag = true; DataGlobals::NumOfTimeStepInHour = 1; DataGlobals::TimeStep = 1; DataGlobals::MinutesPerTimeStep = 60; @@ -558,7 +558,7 @@ TEST_F(EnergyPlusFixture, SZVAV_FanCoilUnit_Testing) DataEnvironment::OutBaroPress = 101325.0; DataEnvironment::StdRhoAir = 1.20; - WaterCoils::GetWaterCoilsInputFlag = true; + state.dataWaterCoils->GetWaterCoilsInputFlag = true; DataGlobals::NumOfTimeStepInHour = 1; DataGlobals::TimeStep = 1; DataGlobals::MinutesPerTimeStep = 60; @@ -594,7 +594,7 @@ TEST_F(EnergyPlusFixture, SZVAV_FanCoilUnit_Testing) DataLoopNode::Node(MixerOA.InletNode).Enthalpy = 18000; DataLoopNode::Node(MixerOA.InletNode).HumRat = PsyWFnTdbH(DataLoopNode::Node(MixerOA.InletNode).Temp, DataLoopNode::Node(MixerOA.InletNode).Enthalpy); // chilled water coil - auto &CWCoil(WaterCoil(1)); + auto &CWCoil(state.dataWaterCoils->WaterCoil(1)); CWCoil.UACoilTotal = 470.0; CWCoil.UACoilExternal = 611.0; CWCoil.UACoilInternal = 2010.0; @@ -633,12 +633,12 @@ TEST_F(EnergyPlusFixture, SZVAV_FanCoilUnit_Testing) CWLoop.FluidIndex = 1; CWLoop.FluidName = "WATER"; CWLoop.LoopSide(1).Branch(1).Comp(1).Name = CWCoil.Name; - CWLoop.LoopSide(1).Branch(1).Comp(1).TypeOf_Num = WaterCoil_Cooling; + CWLoop.LoopSide(1).Branch(1).Comp(1).TypeOf_Num = state.dataWaterCoils->WaterCoil_Cooling; CWLoop.LoopSide(1).Branch(1).Comp(1).NodeNumIn = CWCoil.WaterInletNodeNum; CWLoop.LoopSide(1).Branch(1).Comp(1).NodeNumOut = CWCoil.WaterOutletNodeNum; - MyUAAndFlowCalcFlag.allocate(1); - MyUAAndFlowCalcFlag(1) = true; + state.dataWaterCoils->MyUAAndFlowCalcFlag.allocate(1); + state.dataWaterCoils->MyUAAndFlowCalcFlag(1) = true; DataGlobals::DoingSizing = true; state.fans.LocalTurnFansOff = false; state.fans.LocalTurnFansOn = true; diff --git a/tst/EnergyPlus/unit/SizeWaterHeatingCoil.unit.cc b/tst/EnergyPlus/unit/SizeWaterHeatingCoil.unit.cc index c8019e19426..8947a43810b 100644 --- a/tst/EnergyPlus/unit/SizeWaterHeatingCoil.unit.cc +++ b/tst/EnergyPlus/unit/SizeWaterHeatingCoil.unit.cc @@ -236,8 +236,8 @@ TEST_F(EnergyPlusFixture, TestSizingRoutineForHotWaterCoils1) TotNumLoops = 1; PlantLoop.allocate(TotNumLoops); PlantSizData.allocate(1); - WaterCoils::MySizeFlag.allocate(1); - WaterCoils::MyUAAndFlowCalcFlag.allocate(1); + state.dataWaterCoils->MySizeFlag.allocate(1); + state.dataWaterCoils->MyUAAndFlowCalcFlag.allocate(1); NumPltSizInput = 1; for (int l = 1; l <= TotNumLoops; ++l) { auto &loop(PlantLoop(l)); @@ -259,23 +259,23 @@ TEST_F(EnergyPlusFixture, TestSizingRoutineForHotWaterCoils1) ScheduleInputProcessed = true; GetZoneAirLoopEquipment(*state.dataZoneAirLoopEquipmentManager); GetWaterCoilInput(state); - WaterCoils::GetWaterCoilsInputFlag = false; - WaterCoils::MySizeFlag(1) = true; - WaterCoils::MyUAAndFlowCalcFlag(1) = false; + state.dataWaterCoils->GetWaterCoilsInputFlag = false; + state.dataWaterCoils->MySizeFlag(1) = true; + state.dataWaterCoils->MyUAAndFlowCalcFlag(1) = false; GetSysInput(state); DataSizing::TermUnitSingDuct = true; - WaterCoil(1).WaterLoopNum = 1; - WaterCoil(1).WaterLoopSide = 1; - WaterCoil(1).WaterLoopBranchNum = 1; - WaterCoil(1).WaterLoopCompNum = 1; + state.dataWaterCoils->WaterCoil(1).WaterLoopNum = 1; + state.dataWaterCoils->WaterCoil(1).WaterLoopSide = 1; + state.dataWaterCoils->WaterCoil(1).WaterLoopBranchNum = 1; + state.dataWaterCoils->WaterCoil(1).WaterLoopCompNum = 1; PlantLoop(1).Name = "HotWaterLoop"; PlantLoop(1).FluidName = "HotWater"; PlantLoop(1).FluidIndex = 1; PlantLoop(1).FluidName = "WATER"; - PlantLoop(1).LoopSide(1).Branch(1).Comp(1).Name = WaterCoil(1).Name; - PlantLoop(1).LoopSide(1).Branch(1).Comp(1).TypeOf_Num = WaterCoil_SimpleHeating; - PlantLoop(1).LoopSide(1).Branch(1).Comp(1).NodeNumIn = WaterCoil(1).WaterInletNodeNum; - PlantLoop(1).LoopSide(1).Branch(1).Comp(1).NodeNumOut = WaterCoil(1).WaterOutletNodeNum; + PlantLoop(1).LoopSide(1).Branch(1).Comp(1).Name = state.dataWaterCoils->WaterCoil(1).Name; + PlantLoop(1).LoopSide(1).Branch(1).Comp(1).TypeOf_Num = state.dataWaterCoils->WaterCoil_SimpleHeating; + PlantLoop(1).LoopSide(1).Branch(1).Comp(1).NodeNumIn = state.dataWaterCoils->WaterCoil(1).WaterInletNodeNum; + PlantLoop(1).LoopSide(1).Branch(1).Comp(1).NodeNumOut = state.dataWaterCoils->WaterCoil(1).WaterOutletNodeNum; sd_airterminal(1).HWLoopNum = 1; sd_airterminal(1).HWLoopSide = 1; sd_airterminal(1).HWBranchIndex = 1; @@ -323,7 +323,7 @@ TEST_F(EnergyPlusFixture, TestSizingRoutineForHotWaterCoils1) OutputReportPredefined::SetPredefinedTables(); sd_airterminal(1).SizeSys(state); SizeWaterCoil(state, 1); - EXPECT_NEAR(WaterCoil(1).UACoil, 199.86, 0.01); + EXPECT_NEAR(state.dataWaterCoils->WaterCoil(1).UACoil, 199.86, 0.01); Node.deallocate(); ZoneEquipConfig.deallocate(); @@ -336,8 +336,8 @@ TEST_F(EnergyPlusFixture, TestSizingRoutineForHotWaterCoils1) ZoneEqSizing.deallocate(); PlantLoop.deallocate(); PlantSizData.deallocate(); - WaterCoils::MySizeFlag.deallocate(); - WaterCoils::MyUAAndFlowCalcFlag.deallocate(); + state.dataWaterCoils->MySizeFlag.deallocate(); + state.dataWaterCoils->MyUAAndFlowCalcFlag.deallocate(); } TEST_F(EnergyPlusFixture, TestSizingRoutineForHotWaterCoils2) @@ -474,8 +474,8 @@ TEST_F(EnergyPlusFixture, TestSizingRoutineForHotWaterCoils2) TotNumLoops = 1; PlantLoop.allocate(TotNumLoops); PlantSizData.allocate(1); - WaterCoils::MySizeFlag.allocate(1); - WaterCoils::MyUAAndFlowCalcFlag.allocate(1); + state.dataWaterCoils->MySizeFlag.allocate(1); + state.dataWaterCoils->MyUAAndFlowCalcFlag.allocate(1); NumPltSizInput = 1; for (int l = 1; l <= TotNumLoops; ++l) { auto &loop(PlantLoop(l)); @@ -497,23 +497,23 @@ TEST_F(EnergyPlusFixture, TestSizingRoutineForHotWaterCoils2) ScheduleInputProcessed = true; GetZoneAirLoopEquipment(*state.dataZoneAirLoopEquipmentManager); GetWaterCoilInput(state); - WaterCoils::GetWaterCoilsInputFlag = false; - WaterCoils::MySizeFlag(1) = true; - WaterCoils::MyUAAndFlowCalcFlag(1) = false; + state.dataWaterCoils->GetWaterCoilsInputFlag = false; + state.dataWaterCoils->MySizeFlag(1) = true; + state.dataWaterCoils->MyUAAndFlowCalcFlag(1) = false; GetSysInput(state); DataSizing::TermUnitSingDuct = true; - WaterCoil(1).WaterLoopNum = 1; - WaterCoil(1).WaterLoopSide = 1; - WaterCoil(1).WaterLoopBranchNum = 1; - WaterCoil(1).WaterLoopCompNum = 1; + state.dataWaterCoils->WaterCoil(1).WaterLoopNum = 1; + state.dataWaterCoils->WaterCoil(1).WaterLoopSide = 1; + state.dataWaterCoils->WaterCoil(1).WaterLoopBranchNum = 1; + state.dataWaterCoils->WaterCoil(1).WaterLoopCompNum = 1; PlantLoop(1).Name = "HotWaterLoop"; PlantLoop(1).FluidName = "HotWater"; PlantLoop(1).FluidIndex = 1; PlantLoop(1).FluidName = "WATER"; - PlantLoop(1).LoopSide(1).Branch(1).Comp(1).Name = WaterCoil(1).Name; - PlantLoop(1).LoopSide(1).Branch(1).Comp(1).TypeOf_Num = WaterCoil_SimpleHeating; - PlantLoop(1).LoopSide(1).Branch(1).Comp(1).NodeNumIn = WaterCoil(1).WaterInletNodeNum; - PlantLoop(1).LoopSide(1).Branch(1).Comp(1).NodeNumOut = WaterCoil(1).WaterOutletNodeNum; + PlantLoop(1).LoopSide(1).Branch(1).Comp(1).Name = state.dataWaterCoils->WaterCoil(1).Name; + PlantLoop(1).LoopSide(1).Branch(1).Comp(1).TypeOf_Num = state.dataWaterCoils->WaterCoil_SimpleHeating; + PlantLoop(1).LoopSide(1).Branch(1).Comp(1).NodeNumIn = state.dataWaterCoils->WaterCoil(1).WaterInletNodeNum; + PlantLoop(1).LoopSide(1).Branch(1).Comp(1).NodeNumOut = state.dataWaterCoils->WaterCoil(1).WaterOutletNodeNum; sd_airterminal(1).HWLoopNum = 1; sd_airterminal(1).HWLoopSide = 1; sd_airterminal(1).HWBranchIndex = 1; @@ -560,8 +560,8 @@ TEST_F(EnergyPlusFixture, TestSizingRoutineForHotWaterCoils2) sd_airterminal(1).ZoneFloorArea = Zone(1).FloorArea; sd_airterminal(1).SizeSys(state); SizeWaterCoil(state, 1); - EXPECT_NEAR(WaterCoil(1).MaxWaterVolFlowRate, .0000850575, 0.000000001); - EXPECT_NEAR(WaterCoil(1).UACoil, 85.97495, 0.01); + EXPECT_NEAR(state.dataWaterCoils->WaterCoil(1).MaxWaterVolFlowRate, .0000850575, 0.000000001); + EXPECT_NEAR(state.dataWaterCoils->WaterCoil(1).UACoil, 85.97495, 0.01); Node.deallocate(); ZoneEquipConfig.deallocate(); @@ -574,8 +574,8 @@ TEST_F(EnergyPlusFixture, TestSizingRoutineForHotWaterCoils2) ZoneEqSizing.deallocate(); PlantLoop.deallocate(); PlantSizData.deallocate(); - WaterCoils::MySizeFlag.deallocate(); - WaterCoils::MyUAAndFlowCalcFlag.deallocate(); + state.dataWaterCoils->MySizeFlag.deallocate(); + state.dataWaterCoils->MyUAAndFlowCalcFlag.deallocate(); } TEST_F(EnergyPlusFixture, TestSizingRoutineForHotWaterCoils3) @@ -711,8 +711,8 @@ TEST_F(EnergyPlusFixture, TestSizingRoutineForHotWaterCoils3) TotNumLoops = 1; PlantLoop.allocate(TotNumLoops); PlantSizData.allocate(1); - WaterCoils::MySizeFlag.allocate(1); - WaterCoils::MyUAAndFlowCalcFlag.allocate(1); + state.dataWaterCoils->MySizeFlag.allocate(1); + state.dataWaterCoils->MyUAAndFlowCalcFlag.allocate(1); NumPltSizInput = 1; for (int l = 1; l <= TotNumLoops; ++l) { auto &loop(PlantLoop(l)); @@ -734,23 +734,23 @@ TEST_F(EnergyPlusFixture, TestSizingRoutineForHotWaterCoils3) ScheduleInputProcessed = true; GetZoneAirLoopEquipment(*state.dataZoneAirLoopEquipmentManager); GetWaterCoilInput(state); - WaterCoils::GetWaterCoilsInputFlag = false; - WaterCoils::MySizeFlag(1) = true; - WaterCoils::MyUAAndFlowCalcFlag(1) = false; + state.dataWaterCoils->GetWaterCoilsInputFlag = false; + state.dataWaterCoils->MySizeFlag(1) = true; + state.dataWaterCoils->MyUAAndFlowCalcFlag(1) = false; GetSysInput(state); DataSizing::TermUnitSingDuct = true; - WaterCoil(1).WaterLoopNum = 1; - WaterCoil(1).WaterLoopSide = 1; - WaterCoil(1).WaterLoopBranchNum = 1; - WaterCoil(1).WaterLoopCompNum = 1; + state.dataWaterCoils->WaterCoil(1).WaterLoopNum = 1; + state.dataWaterCoils->WaterCoil(1).WaterLoopSide = 1; + state.dataWaterCoils->WaterCoil(1).WaterLoopBranchNum = 1; + state.dataWaterCoils->WaterCoil(1).WaterLoopCompNum = 1; PlantLoop(1).Name = "HotWaterLoop"; PlantLoop(1).FluidName = "HotWater"; PlantLoop(1).FluidIndex = 1; PlantLoop(1).FluidName = "WATER"; - PlantLoop(1).LoopSide(1).Branch(1).Comp(1).Name = WaterCoil(1).Name; - PlantLoop(1).LoopSide(1).Branch(1).Comp(1).TypeOf_Num = WaterCoil_SimpleHeating; - PlantLoop(1).LoopSide(1).Branch(1).Comp(1).NodeNumIn = WaterCoil(1).WaterInletNodeNum; - PlantLoop(1).LoopSide(1).Branch(1).Comp(1).NodeNumOut = WaterCoil(1).WaterOutletNodeNum; + PlantLoop(1).LoopSide(1).Branch(1).Comp(1).Name = state.dataWaterCoils->WaterCoil(1).Name; + PlantLoop(1).LoopSide(1).Branch(1).Comp(1).TypeOf_Num = state.dataWaterCoils->WaterCoil_SimpleHeating; + PlantLoop(1).LoopSide(1).Branch(1).Comp(1).NodeNumIn = state.dataWaterCoils->WaterCoil(1).WaterInletNodeNum; + PlantLoop(1).LoopSide(1).Branch(1).Comp(1).NodeNumOut = state.dataWaterCoils->WaterCoil(1).WaterOutletNodeNum; sd_airterminal(1).HWLoopNum = 1; sd_airterminal(1).HWLoopSide = 1; sd_airterminal(1).HWBranchIndex = 1; @@ -796,8 +796,8 @@ TEST_F(EnergyPlusFixture, TestSizingRoutineForHotWaterCoils3) sd_airterminal(1).ZoneFloorArea = Zone(1).FloorArea; sd_airterminal(1).SizeSys(state); SizeWaterCoil(state, 1); - EXPECT_NEAR(WaterCoil(1).MaxWaterVolFlowRate, .0000850575, 0.000000001); - EXPECT_NEAR(WaterCoil(1).UACoil, 85.97495, 0.01); + EXPECT_NEAR(state.dataWaterCoils->WaterCoil(1).MaxWaterVolFlowRate, .0000850575, 0.000000001); + EXPECT_NEAR(state.dataWaterCoils->WaterCoil(1).UACoil, 85.97495, 0.01); Node.deallocate(); ZoneEquipConfig.deallocate(); @@ -810,8 +810,8 @@ TEST_F(EnergyPlusFixture, TestSizingRoutineForHotWaterCoils3) ZoneEqSizing.deallocate(); PlantLoop.deallocate(); PlantSizData.deallocate(); - WaterCoils::MySizeFlag.deallocate(); - WaterCoils::MyUAAndFlowCalcFlag.deallocate(); + state.dataWaterCoils->MySizeFlag.deallocate(); + state.dataWaterCoils->MyUAAndFlowCalcFlag.deallocate(); } TEST_F(EnergyPlusFixture, TestSizingRoutineForHotWaterCoils4) @@ -948,8 +948,8 @@ TEST_F(EnergyPlusFixture, TestSizingRoutineForHotWaterCoils4) TotNumLoops = 1; PlantLoop.allocate(TotNumLoops); PlantSizData.allocate(1); - WaterCoils::MySizeFlag.allocate(1); - WaterCoils::MyUAAndFlowCalcFlag.allocate(1); + state.dataWaterCoils->MySizeFlag.allocate(1); + state.dataWaterCoils->MyUAAndFlowCalcFlag.allocate(1); NumPltSizInput = 1; for (int l = 1; l <= TotNumLoops; ++l) { auto &loop(PlantLoop(l)); @@ -971,23 +971,23 @@ TEST_F(EnergyPlusFixture, TestSizingRoutineForHotWaterCoils4) ScheduleInputProcessed = true; GetZoneAirLoopEquipment(*state.dataZoneAirLoopEquipmentManager); GetWaterCoilInput(state); - WaterCoils::GetWaterCoilsInputFlag = false; - WaterCoils::MySizeFlag(1) = true; - WaterCoils::MyUAAndFlowCalcFlag(1) = false; + state.dataWaterCoils->GetWaterCoilsInputFlag = false; + state.dataWaterCoils->MySizeFlag(1) = true; + state.dataWaterCoils->MyUAAndFlowCalcFlag(1) = false; GetSysInput(state); DataSizing::TermUnitSingDuct = true; - WaterCoil(1).WaterLoopNum = 1; - WaterCoil(1).WaterLoopSide = 1; - WaterCoil(1).WaterLoopBranchNum = 1; - WaterCoil(1).WaterLoopCompNum = 1; + state.dataWaterCoils->WaterCoil(1).WaterLoopNum = 1; + state.dataWaterCoils->WaterCoil(1).WaterLoopSide = 1; + state.dataWaterCoils->WaterCoil(1).WaterLoopBranchNum = 1; + state.dataWaterCoils->WaterCoil(1).WaterLoopCompNum = 1; PlantLoop(1).Name = "HotWaterLoop"; PlantLoop(1).FluidName = "HotWater"; PlantLoop(1).FluidIndex = 1; PlantLoop(1).FluidName = "WATER"; - PlantLoop(1).LoopSide(1).Branch(1).Comp(1).Name = WaterCoil(1).Name; - PlantLoop(1).LoopSide(1).Branch(1).Comp(1).TypeOf_Num = WaterCoil_SimpleHeating; - PlantLoop(1).LoopSide(1).Branch(1).Comp(1).NodeNumIn = WaterCoil(1).WaterInletNodeNum; - PlantLoop(1).LoopSide(1).Branch(1).Comp(1).NodeNumOut = WaterCoil(1).WaterOutletNodeNum; + PlantLoop(1).LoopSide(1).Branch(1).Comp(1).Name = state.dataWaterCoils->WaterCoil(1).Name; + PlantLoop(1).LoopSide(1).Branch(1).Comp(1).TypeOf_Num = state.dataWaterCoils->WaterCoil_SimpleHeating; + PlantLoop(1).LoopSide(1).Branch(1).Comp(1).NodeNumIn = state.dataWaterCoils->WaterCoil(1).WaterInletNodeNum; + PlantLoop(1).LoopSide(1).Branch(1).Comp(1).NodeNumOut = state.dataWaterCoils->WaterCoil(1).WaterOutletNodeNum; sd_airterminal(1).HWLoopNum = 1; sd_airterminal(1).HWLoopSide = 1; sd_airterminal(1).HWBranchIndex = 1; @@ -1033,8 +1033,8 @@ TEST_F(EnergyPlusFixture, TestSizingRoutineForHotWaterCoils4) sd_airterminal(1).ZoneFloorArea = Zone(1).FloorArea; sd_airterminal(1).SizeSys(state); SizeWaterCoil(state, 1); - EXPECT_NEAR(WaterCoil(1).MaxWaterVolFlowRate, .0000850575, 0.000000001); - EXPECT_NEAR(WaterCoil(1).UACoil, 300.00, 0.01); + EXPECT_NEAR(state.dataWaterCoils->WaterCoil(1).MaxWaterVolFlowRate, .0000850575, 0.000000001); + EXPECT_NEAR(state.dataWaterCoils->WaterCoil(1).UACoil, 300.00, 0.01); Node.deallocate(); ZoneEquipConfig.deallocate(); @@ -1047,8 +1047,8 @@ TEST_F(EnergyPlusFixture, TestSizingRoutineForHotWaterCoils4) ZoneEqSizing.deallocate(); PlantLoop.deallocate(); PlantSizData.deallocate(); - WaterCoils::MySizeFlag.deallocate(); - WaterCoils::MyUAAndFlowCalcFlag.deallocate(); + state.dataWaterCoils->MySizeFlag.deallocate(); + state.dataWaterCoils->MyUAAndFlowCalcFlag.deallocate(); } TEST_F(EnergyPlusFixture, TestSizingRoutineForHotWaterCoils5) @@ -1149,8 +1149,8 @@ TEST_F(EnergyPlusFixture, TestSizingRoutineForHotWaterCoils5) TotNumLoops = 1; PlantLoop.allocate(TotNumLoops); PlantSizData.allocate(1); - WaterCoils::MySizeFlag.allocate(1); - WaterCoils::MyUAAndFlowCalcFlag.allocate(1); + state.dataWaterCoils->MySizeFlag.allocate(1); + state.dataWaterCoils->MyUAAndFlowCalcFlag.allocate(1); NumPltSizInput = 1; for (int l = 1; l <= TotNumLoops; ++l) { auto &loop(PlantLoop(l)); @@ -1167,22 +1167,22 @@ TEST_F(EnergyPlusFixture, TestSizingRoutineForHotWaterCoils5) ProcessScheduleInput(state.files); ScheduleInputProcessed = true; GetWaterCoilInput(state); - WaterCoils::GetWaterCoilsInputFlag = false; - WaterCoils::MySizeFlag(1) = true; - WaterCoils::MyUAAndFlowCalcFlag(1) = false; + state.dataWaterCoils->GetWaterCoilsInputFlag = false; + state.dataWaterCoils->MySizeFlag(1) = true; + state.dataWaterCoils->MyUAAndFlowCalcFlag(1) = false; DataSizing::TermUnitSingDuct = true; - WaterCoil(1).WaterLoopNum = 1; - WaterCoil(1).WaterLoopSide = 1; - WaterCoil(1).WaterLoopBranchNum = 1; - WaterCoil(1).WaterLoopCompNum = 1; + state.dataWaterCoils->WaterCoil(1).WaterLoopNum = 1; + state.dataWaterCoils->WaterCoil(1).WaterLoopSide = 1; + state.dataWaterCoils->WaterCoil(1).WaterLoopBranchNum = 1; + state.dataWaterCoils->WaterCoil(1).WaterLoopCompNum = 1; PlantLoop(1).Name = "HotWaterLoop"; PlantLoop(1).FluidName = "HotWater"; PlantLoop(1).FluidIndex = 1; PlantLoop(1).FluidName = "WATER"; - PlantLoop(1).LoopSide(1).Branch(1).Comp(1).Name = WaterCoil(1).Name; - PlantLoop(1).LoopSide(1).Branch(1).Comp(1).TypeOf_Num = WaterCoil_SimpleHeating; - PlantLoop(1).LoopSide(1).Branch(1).Comp(1).NodeNumIn = WaterCoil(1).WaterInletNodeNum; - PlantLoop(1).LoopSide(1).Branch(1).Comp(1).NodeNumOut = WaterCoil(1).WaterOutletNodeNum; + PlantLoop(1).LoopSide(1).Branch(1).Comp(1).Name = state.dataWaterCoils->WaterCoil(1).Name; + PlantLoop(1).LoopSide(1).Branch(1).Comp(1).TypeOf_Num = state.dataWaterCoils->WaterCoil_SimpleHeating; + PlantLoop(1).LoopSide(1).Branch(1).Comp(1).NodeNumIn = state.dataWaterCoils->WaterCoil(1).WaterInletNodeNum; + PlantLoop(1).LoopSide(1).Branch(1).Comp(1).NodeNumOut = state.dataWaterCoils->WaterCoil(1).WaterOutletNodeNum; PlantSizData(1).DeltaT = 11.0; PlantSizData(1).ExitTemp = 82; PlantSizData(1).PlantLoopName = "HotWaterLoop"; @@ -1205,15 +1205,15 @@ TEST_F(EnergyPlusFixture, TestSizingRoutineForHotWaterCoils5) UnitarySysEqSizing(CurSysNum).HeatingCapacity = false; DataHVACGlobals::NumPrimaryAirSys = 1; SizeWaterCoil(state, 1); - EXPECT_NEAR(WaterCoil(1).MaxWaterMassFlowRate, .258323, 0.00001); - EXPECT_NEAR(WaterCoil(1).UACoil, 239.835, 0.01); + EXPECT_NEAR(state.dataWaterCoils->WaterCoil(1).MaxWaterMassFlowRate, .258323, 0.00001); + EXPECT_NEAR(state.dataWaterCoils->WaterCoil(1).UACoil, 239.835, 0.01); Node.deallocate(); Zone.deallocate(); PlantLoop.deallocate(); PlantSizData.deallocate(); - WaterCoils::MySizeFlag.deallocate(); - WaterCoils::MyUAAndFlowCalcFlag.deallocate(); + state.dataWaterCoils->MySizeFlag.deallocate(); + state.dataWaterCoils->MyUAAndFlowCalcFlag.deallocate(); FinalSysSizing.deallocate(); UnitarySysEqSizing.deallocate(); PrimaryAirSystem.deallocate(); @@ -1360,8 +1360,8 @@ TEST_F(EnergyPlusFixture, TestSizingRoutineForHotWaterCoils6) TermUnitSizing.allocate(1); TotNumLoops = 1; PlantLoop.allocate(TotNumLoops); - WaterCoils::MySizeFlag.allocate(1); - WaterCoils::MyUAAndFlowCalcFlag.allocate(1); + state.dataWaterCoils->MySizeFlag.allocate(1); + state.dataWaterCoils->MyUAAndFlowCalcFlag.allocate(1); for (int l = 1; l <= TotNumLoops; ++l) { auto &loop(PlantLoop(l)); loop.LoopSide.allocate(2); @@ -1382,23 +1382,23 @@ TEST_F(EnergyPlusFixture, TestSizingRoutineForHotWaterCoils6) ScheduleInputProcessed = true; GetZoneAirLoopEquipment(*state.dataZoneAirLoopEquipmentManager); GetWaterCoilInput(state); - WaterCoils::GetWaterCoilsInputFlag = false; - WaterCoils::MySizeFlag(1) = true; - WaterCoils::MyUAAndFlowCalcFlag(1) = false; + state.dataWaterCoils->GetWaterCoilsInputFlag = false; + state.dataWaterCoils->MySizeFlag(1) = true; + state.dataWaterCoils->MyUAAndFlowCalcFlag(1) = false; GetSysInput(state); DataSizing::TermUnitSingDuct = true; - WaterCoil(1).WaterLoopNum = 1; - WaterCoil(1).WaterLoopSide = 1; - WaterCoil(1).WaterLoopBranchNum = 1; - WaterCoil(1).WaterLoopCompNum = 1; + state.dataWaterCoils->WaterCoil(1).WaterLoopNum = 1; + state.dataWaterCoils->WaterCoil(1).WaterLoopSide = 1; + state.dataWaterCoils->WaterCoil(1).WaterLoopBranchNum = 1; + state.dataWaterCoils->WaterCoil(1).WaterLoopCompNum = 1; PlantLoop(1).Name = "HotWaterLoop"; PlantLoop(1).FluidName = "HotWater"; PlantLoop(1).FluidIndex = 1; PlantLoop(1).FluidName = "WATER"; - PlantLoop(1).LoopSide(1).Branch(1).Comp(1).Name = WaterCoil(1).Name; - PlantLoop(1).LoopSide(1).Branch(1).Comp(1).TypeOf_Num = WaterCoil_SimpleHeating; - PlantLoop(1).LoopSide(1).Branch(1).Comp(1).NodeNumIn = WaterCoil(1).WaterInletNodeNum; - PlantLoop(1).LoopSide(1).Branch(1).Comp(1).NodeNumOut = WaterCoil(1).WaterOutletNodeNum; + PlantLoop(1).LoopSide(1).Branch(1).Comp(1).Name = state.dataWaterCoils->WaterCoil(1).Name; + PlantLoop(1).LoopSide(1).Branch(1).Comp(1).TypeOf_Num = state.dataWaterCoils->WaterCoil_SimpleHeating; + PlantLoop(1).LoopSide(1).Branch(1).Comp(1).NodeNumIn = state.dataWaterCoils->WaterCoil(1).WaterInletNodeNum; + PlantLoop(1).LoopSide(1).Branch(1).Comp(1).NodeNumOut = state.dataWaterCoils->WaterCoil(1).WaterOutletNodeNum; sd_airterminal(1).HWLoopNum = 1; sd_airterminal(1).HWLoopSide = 1; sd_airterminal(1).HWBranchIndex = 1; @@ -1414,16 +1414,16 @@ TEST_F(EnergyPlusFixture, TestSizingRoutineForHotWaterCoils6) // water coil is user input for water flow and UA with performance input method = UFactorTimesAreaAndDesignWaterFlowRate and Rated Capacity = // autosize - EXPECT_NEAR(WaterCoil(1).MaxWaterVolFlowRate, .0000850575, 0.000000001); // water flow rate input by user - EXPECT_NEAR(WaterCoil(1).UACoil, 300.00, 0.01); // Ua input by user - EXPECT_EQ(WaterCoil(1).DesTotWaterCoilLoad, DataSizing::AutoSize); // Rated Capacity input by user - EXPECT_EQ(WaterCoil(1).DesWaterHeatingCoilRate, 0.0); // model output not yet set + EXPECT_NEAR(state.dataWaterCoils->WaterCoil(1).MaxWaterVolFlowRate, .0000850575, 0.000000001); // water flow rate input by user + EXPECT_NEAR(state.dataWaterCoils->WaterCoil(1).UACoil, 300.00, 0.01); // Ua input by user + EXPECT_EQ(state.dataWaterCoils->WaterCoil(1).DesTotWaterCoilLoad, DataSizing::AutoSize); // Rated Capacity input by user + EXPECT_EQ(state.dataWaterCoils->WaterCoil(1).DesWaterHeatingCoilRate, 0.0); // model output not yet set // sizing will be called and skipped with Init setting DesWaterHeatingCoilRate based on above inputs InitWaterCoil(state, 1, false); - EXPECT_NEAR(WaterCoil(1).DesWaterHeatingCoilRate, 7390.73, 0.01); + EXPECT_NEAR(state.dataWaterCoils->WaterCoil(1).DesWaterHeatingCoilRate, 7390.73, 0.01); // not set in Init for water heating coils and not used elsewhere other than sizing - EXPECT_EQ(WaterCoil(1).DesTotWaterCoilLoad, DataSizing::AutoSize); + EXPECT_EQ(state.dataWaterCoils->WaterCoil(1).DesTotWaterCoilLoad, DataSizing::AutoSize); sd_airterminal.deallocate(); } diff --git a/tst/EnergyPlus/unit/SizingAnalysisObjects.unit.cc b/tst/EnergyPlus/unit/SizingAnalysisObjects.unit.cc index 9d5ecdc6130..b9320e56cbe 100644 --- a/tst/EnergyPlus/unit/SizingAnalysisObjects.unit.cc +++ b/tst/EnergyPlus/unit/SizingAnalysisObjects.unit.cc @@ -64,6 +64,7 @@ #include #include #include +#include #include #include #include diff --git a/tst/EnergyPlus/unit/UnitHeater.unit.cc b/tst/EnergyPlus/unit/UnitHeater.unit.cc index 055f4dcd710..7625faef8ee 100644 --- a/tst/EnergyPlus/unit/UnitHeater.unit.cc +++ b/tst/EnergyPlus/unit/UnitHeater.unit.cc @@ -1140,12 +1140,12 @@ TEST_F(EnergyPlusFixture, UnitHeater_HWHeatingCoilUAAutoSizingTest) PltSizHeatNum = PlantUtilities::MyPlantSizingIndex("Coil:Heating:Water", UnitHeat(UnitHeatNum).HCoilName, - WaterCoils::WaterCoil(CoilNum).WaterInletNodeNum, - WaterCoils::WaterCoil(CoilNum).WaterOutletNodeNum, + state.dataWaterCoils->WaterCoil(CoilNum).WaterInletNodeNum, + state.dataWaterCoils->WaterCoil(CoilNum).WaterOutletNodeNum, ErrorsFound); EXPECT_FALSE(ErrorsFound); - HWMaxVolFlowRate = WaterCoils::WaterCoil(CoilNum).MaxWaterVolFlowRate; + HWMaxVolFlowRate = state.dataWaterCoils->WaterCoil(CoilNum).MaxWaterVolFlowRate; HWDensity = GetDensityGlycol(PlantLoop(UnitHeat(UnitHeatNum).HWLoopNum).FluidName, DataGlobals::HWInitConvTemp, PlantLoop(UnitHeat(UnitHeatNum).HWLoopNum).FluidIndex, @@ -1157,8 +1157,8 @@ TEST_F(EnergyPlusFixture, UnitHeater_HWHeatingCoilUAAutoSizingTest) HWPlantDeltaTDesign = PlantSizData(PltSizHeatNum).DeltaT; // calculate hot water coil design capacity HWCoilDesignCapacity = HWMaxVolFlowRate * HWDensity * CpHW * HWPlantDeltaTDesign; - EXPECT_NEAR(HWCoilDesignCapacity, WaterCoils::WaterCoil(CoilNum).DesWaterHeatingCoilRate, 1.0); - EXPECT_NEAR(189.06, WaterCoils::WaterCoil(CoilNum).UACoil, 0.02); + EXPECT_NEAR(HWCoilDesignCapacity, state.dataWaterCoils->WaterCoil(CoilNum).DesWaterHeatingCoilRate, 1.0); + EXPECT_NEAR(189.06, state.dataWaterCoils->WaterCoil(CoilNum).UACoil, 0.02); } TEST_F(EnergyPlusFixture, UnitHeater_SimUnitHeaterTest) @@ -1295,7 +1295,7 @@ TEST_F(EnergyPlusFixture, UnitHeater_SimUnitHeaterTest) ErrorsFound = false; GetWaterCoilInput(state); EXPECT_FALSE(ErrorsFound); - GetWaterCoilsInputFlag = false; + state.dataWaterCoils->GetWaterCoilsInputFlag = false; ErrorsFound = false; GetFanInput(state); @@ -1329,10 +1329,10 @@ TEST_F(EnergyPlusFixture, UnitHeater_SimUnitHeaterTest) PlantLoop(1).FluidName = "HotWater"; PlantLoop(1).FluidIndex = 1; PlantLoop(1).FluidName = "WATER"; - PlantLoop(1).LoopSide(1).Branch(1).Comp(1).Name = WaterCoils::WaterCoil(1).Name; - PlantLoop(1).LoopSide(1).Branch(1).Comp(1).TypeOf_Num = WaterCoils::WaterCoil_SimpleHeating; - PlantLoop(1).LoopSide(1).Branch(1).Comp(1).NodeNumIn = WaterCoils::WaterCoil(1).WaterInletNodeNum; - PlantLoop(1).LoopSide(1).Branch(1).Comp(1).NodeNumOut = WaterCoils::WaterCoil(1).WaterOutletNodeNum; + PlantLoop(1).LoopSide(1).Branch(1).Comp(1).Name = state.dataWaterCoils->WaterCoil(1).Name; + PlantLoop(1).LoopSide(1).Branch(1).Comp(1).TypeOf_Num = state.dataWaterCoils->WaterCoil_SimpleHeating; + PlantLoop(1).LoopSide(1).Branch(1).Comp(1).NodeNumIn = state.dataWaterCoils->WaterCoil(1).WaterInletNodeNum; + PlantLoop(1).LoopSide(1).Branch(1).Comp(1).NodeNumOut = state.dataWaterCoils->WaterCoil(1).WaterOutletNodeNum; ZoneSysEnergyDemand.allocate(1); ZoneSysEnergyDemand(1).RemainingOutputReqToHeatSP = 2000.0; @@ -1354,8 +1354,8 @@ TEST_F(EnergyPlusFixture, UnitHeater_SimUnitHeaterTest) Node(Fan(1).InletNodeNum).Enthalpy = Psychrometrics::PsyHFnTdbW(Node(Fan(1).InletNodeNum).Temp, Node(Fan(1).InletNodeNum).HumRat); DataEnvironment::StdRhoAir = PsyRhoAirFnPbTdbW(101325.0, 20.0, 0.0); - WCWaterInletNode = WaterCoils::WaterCoil(CoilNum).WaterInletNodeNum; - WCWaterOutletNode = WaterCoils::WaterCoil(CoilNum).WaterOutletNodeNum; + WCWaterInletNode = state.dataWaterCoils->WaterCoil(CoilNum).WaterInletNodeNum; + WCWaterOutletNode = state.dataWaterCoils->WaterCoil(CoilNum).WaterOutletNodeNum; Node(WCWaterInletNode).Temp = 60.0; DataGlobals::BeginEnvrnFlag = true; @@ -1375,11 +1375,11 @@ TEST_F(EnergyPlusFixture, UnitHeater_SimUnitHeaterTest) UHHeatingRate = UHAirMassFlowRate * (UHLeavingAirEnthalpy - UHEnteringAirEnthalpy); EXPECT_NEAR(UHHeatingRate, UnitHeat(UnitHeatNum).HeatPower, ConvTol); // verify the heat rate delivered by the hot water heating coil - HWMassFlowRate = WaterCoils::WaterCoil(CoilNum).InletWaterMassFlowRate; + HWMassFlowRate = state.dataWaterCoils->WaterCoil(CoilNum).InletWaterMassFlowRate; CpHW = GetSpecificHeatGlycol( PlantLoop(UnitHeat(UnitHeatNum).HWLoopNum).FluidName, 60.0, PlantLoop(UnitHeat(UnitHeatNum).HWLoopNum).FluidIndex, "UnitTest"); HWCoilHeatingRate = HWMassFlowRate * CpHW * (Node(WCWaterInletNode).Temp - Node(WCWaterOutletNode).Temp); - EXPECT_NEAR(HWCoilHeatingRate, WaterCoils::WaterCoil(CoilNum).TotWaterHeatingCoilRate, ConvTol); + EXPECT_NEAR(HWCoilHeatingRate, state.dataWaterCoils->WaterCoil(CoilNum).TotWaterHeatingCoilRate, ConvTol); } TEST_F(EnergyPlusFixture, UnitHeater_SecondPriorityZoneEquipment) diff --git a/tst/EnergyPlus/unit/UnitarySystem.unit.cc b/tst/EnergyPlus/unit/UnitarySystem.unit.cc index 21caae9224a..2e19b40d99b 100644 --- a/tst/EnergyPlus/unit/UnitarySystem.unit.cc +++ b/tst/EnergyPlus/unit/UnitarySystem.unit.cc @@ -250,11 +250,11 @@ class AirloopUnitarySysTest : public EnergyPlusFixture DataSizing::CurZoneEqNum = 0; DataSizing::CurSysNum = 0; DataSizing::CurOASysNum = 0; - WaterCoils::NumWaterCoils = 2; - WaterCoils::WaterCoil.allocate(WaterCoils::NumWaterCoils); - WaterCoils::WaterCoilNumericFields.allocate(WaterCoils::NumWaterCoils); - for (int i = 1; i <= WaterCoils::NumWaterCoils; ++i) { - WaterCoils::WaterCoilNumericFields(i).FieldNames.allocate(17); // max N fields for water coil + state.dataWaterCoils->NumWaterCoils = 2; + state.dataWaterCoils->WaterCoil.allocate(state.dataWaterCoils->NumWaterCoils); + state.dataWaterCoils->WaterCoilNumericFields.allocate(state.dataWaterCoils->NumWaterCoils); + for (int i = 1; i <= state.dataWaterCoils->NumWaterCoils; ++i) { + state.dataWaterCoils->WaterCoilNumericFields(i).FieldNames.allocate(17); // max N fields for water coil } DataPlant::TotNumLoops = 2; DataPlant::PlantLoop.allocate(DataPlant::TotNumLoops); @@ -284,9 +284,9 @@ class AirloopUnitarySysTest : public EnergyPlusFixture { EnergyPlusFixture::TearDown(); // Remember to tear down the base fixture after cleaning up derived fixture! - WaterCoils::NumWaterCoils = 0; - WaterCoils::WaterCoil.clear(); - WaterCoils::WaterCoilNumericFields.clear(); + state.dataWaterCoils->NumWaterCoils = 0; + state.dataWaterCoils->WaterCoil.clear(); + state.dataWaterCoils->WaterCoilNumericFields.clear(); DataPlant::PlantLoop.clear(); DataSizing::PlantSizData.clear(); DataSizing::ZoneEqSizing.clear(); @@ -359,28 +359,28 @@ TEST_F(AirloopUnitarySysTest, MultipleWaterCoolingCoilSizing) // set up water coil int CoilNum = 1; - WaterCoils::WaterCoil(CoilNum).Name = "Test Water Cooling Coil"; - WaterCoils::WaterCoil(CoilNum).WaterLoopNum = 1; - WaterCoils::WaterCoil(CoilNum).WaterLoopSide = 1; - WaterCoils::WaterCoil(CoilNum).WaterLoopBranchNum = 1; - WaterCoils::WaterCoil(CoilNum).WaterLoopCompNum = 1; - WaterCoils::WaterCoil(CoilNum).WaterCoilType = WaterCoils::CoilType_Cooling; - WaterCoils::WaterCoil(CoilNum).WaterCoilType_Num = WaterCoils::WaterCoil_Cooling; - WaterCoils::WaterCoil(CoilNum).RequestingAutoSize = true; - WaterCoils::WaterCoil(CoilNum).DesAirVolFlowRate = DataSizing::AutoSize; - WaterCoils::WaterCoil(CoilNum).DesInletAirTemp = DataSizing::AutoSize; - WaterCoils::WaterCoil(CoilNum).DesOutletAirTemp = DataSizing::AutoSize; - WaterCoils::WaterCoil(CoilNum).DesInletWaterTemp = DataSizing::AutoSize; - WaterCoils::WaterCoil(CoilNum).DesInletAirHumRat = DataSizing::AutoSize; - WaterCoils::WaterCoil(CoilNum).DesOutletAirHumRat = DataSizing::AutoSize; - WaterCoils::WaterCoil(CoilNum).MaxWaterVolFlowRate = DataSizing::AutoSize; - - WaterCoils::WaterCoilNumericFields(CoilNum).FieldNames(3) = "Maximum Flow Rate"; - WaterCoils::WaterCoil(CoilNum).WaterInletNodeNum = 1; - WaterCoils::WaterCoil(CoilNum).WaterOutletNodeNum = 2; - WaterCoils::WaterCoil(CoilNum).AirInletNodeNum = 3; - WaterCoils::WaterCoil(CoilNum).AirOutletNodeNum = 4; - DataPlant::PlantLoop(1).LoopSide(1).Branch(1).Comp(1).NodeNumIn = WaterCoils::WaterCoil(CoilNum).WaterInletNodeNum; + state.dataWaterCoils->WaterCoil(CoilNum).Name = "Test Water Cooling Coil"; + state.dataWaterCoils->WaterCoil(CoilNum).WaterLoopNum = 1; + state.dataWaterCoils->WaterCoil(CoilNum).WaterLoopSide = 1; + state.dataWaterCoils->WaterCoil(CoilNum).WaterLoopBranchNum = 1; + state.dataWaterCoils->WaterCoil(CoilNum).WaterLoopCompNum = 1; + state.dataWaterCoils->WaterCoil(CoilNum).WaterCoilType = state.dataWaterCoils->CoilType_Cooling; + state.dataWaterCoils->WaterCoil(CoilNum).WaterCoilType_Num = state.dataWaterCoils->WaterCoil_Cooling; + state.dataWaterCoils->WaterCoil(CoilNum).RequestingAutoSize = true; + state.dataWaterCoils->WaterCoil(CoilNum).DesAirVolFlowRate = DataSizing::AutoSize; + state.dataWaterCoils->WaterCoil(CoilNum).DesInletAirTemp = DataSizing::AutoSize; + state.dataWaterCoils->WaterCoil(CoilNum).DesOutletAirTemp = DataSizing::AutoSize; + state.dataWaterCoils->WaterCoil(CoilNum).DesInletWaterTemp = DataSizing::AutoSize; + state.dataWaterCoils->WaterCoil(CoilNum).DesInletAirHumRat = DataSizing::AutoSize; + state.dataWaterCoils->WaterCoil(CoilNum).DesOutletAirHumRat = DataSizing::AutoSize; + state.dataWaterCoils->WaterCoil(CoilNum).MaxWaterVolFlowRate = DataSizing::AutoSize; + + state.dataWaterCoils->WaterCoilNumericFields(CoilNum).FieldNames(3) = "Maximum Flow Rate"; + state.dataWaterCoils->WaterCoil(CoilNum).WaterInletNodeNum = 1; + state.dataWaterCoils->WaterCoil(CoilNum).WaterOutletNodeNum = 2; + state.dataWaterCoils->WaterCoil(CoilNum).AirInletNodeNum = 3; + state.dataWaterCoils->WaterCoil(CoilNum).AirOutletNodeNum = 4; + DataPlant::PlantLoop(1).LoopSide(1).Branch(1).Comp(1).NodeNumIn = state.dataWaterCoils->WaterCoil(CoilNum).WaterInletNodeNum; DataSizing::CurZoneEqNum = 0; DataSizing::CurSysNum = 1; @@ -391,74 +391,74 @@ TEST_F(AirloopUnitarySysTest, MultipleWaterCoolingCoilSizing) DataSizing::PlantSizData(1).ExitTemp = 5.7; DataSizing::PlantSizData(1).DeltaT = 5.0; DataSizing::FinalSysSizing(1).MassFlowAtCoolPeak = DataSizing::FinalSysSizing(1).DesMainVolFlow * DataEnvironment::StdRhoAir; - DataPlant::PlantLoop(1).LoopSide(1).Branch(1).Comp(1).TypeOf_Num = WaterCoils::WaterCoil(CoilNum).WaterCoilType_Num; - DataPlant::PlantLoop(1).LoopSide(1).Branch(1).Comp(1).Name = WaterCoils::WaterCoil(CoilNum).Name; + DataPlant::PlantLoop(1).LoopSide(1).Branch(1).Comp(1).TypeOf_Num = state.dataWaterCoils->WaterCoil(CoilNum).WaterCoilType_Num; + DataPlant::PlantLoop(1).LoopSide(1).Branch(1).Comp(1).Name = state.dataWaterCoils->WaterCoil(CoilNum).Name; DataSizing::DataWaterLoopNum = 1; FluidProperties::NumOfGlycols = 1; createCoilSelectionReportObj(); WaterCoils::SizeWaterCoil(state, CoilNum); - EXPECT_DOUBLE_EQ(0.159, WaterCoils::WaterCoil(CoilNum).DesAirVolFlowRate); - EXPECT_NEAR(6779.0, WaterCoils::WaterCoil(CoilNum).DesWaterCoolingCoilRate, 1.0); - EXPECT_EQ(20.0, WaterCoils::WaterCoil(CoilNum).DesInletAirTemp); // coil inlet does not include fan heat + EXPECT_DOUBLE_EQ(0.159, state.dataWaterCoils->WaterCoil(CoilNum).DesAirVolFlowRate); + EXPECT_NEAR(6779.0, state.dataWaterCoils->WaterCoil(CoilNum).DesWaterCoolingCoilRate, 1.0); + EXPECT_EQ(20.0, state.dataWaterCoils->WaterCoil(CoilNum).DesInletAirTemp); // coil inlet does not include fan heat // save coil capacity for comparison to UnitarySyste - Real64 coil1CoolingCoilRate = WaterCoils::WaterCoil(CoilNum).DesWaterCoolingCoilRate; + Real64 coil1CoolingCoilRate = state.dataWaterCoils->WaterCoil(CoilNum).DesWaterCoolingCoilRate; // save cooling coil air flow rate for use in fan heat calculation - Real64 coil1CoolingAirFlowRate = WaterCoils::WaterCoil(CoilNum).DesAirVolFlowRate; + Real64 coil1CoolingAirFlowRate = state.dataWaterCoils->WaterCoil(CoilNum).DesAirVolFlowRate; // reset coil sizing for next test - WaterCoils::WaterCoil(CoilNum).DesAirVolFlowRate = DataSizing::AutoSize; - WaterCoils::WaterCoil(CoilNum).DesInletAirTemp = DataSizing::AutoSize; - WaterCoils::WaterCoil(CoilNum).DesOutletAirTemp = DataSizing::AutoSize; - WaterCoils::WaterCoil(CoilNum).DesInletWaterTemp = DataSizing::AutoSize; - WaterCoils::WaterCoil(CoilNum).DesInletAirHumRat = DataSizing::AutoSize; - WaterCoils::WaterCoil(CoilNum).DesOutletAirHumRat = DataSizing::AutoSize; - WaterCoils::WaterCoil(CoilNum).MaxWaterVolFlowRate = DataSizing::AutoSize; + state.dataWaterCoils->WaterCoil(CoilNum).DesAirVolFlowRate = DataSizing::AutoSize; + state.dataWaterCoils->WaterCoil(CoilNum).DesInletAirTemp = DataSizing::AutoSize; + state.dataWaterCoils->WaterCoil(CoilNum).DesOutletAirTemp = DataSizing::AutoSize; + state.dataWaterCoils->WaterCoil(CoilNum).DesInletWaterTemp = DataSizing::AutoSize; + state.dataWaterCoils->WaterCoil(CoilNum).DesInletAirHumRat = DataSizing::AutoSize; + state.dataWaterCoils->WaterCoil(CoilNum).DesOutletAirHumRat = DataSizing::AutoSize; + state.dataWaterCoils->WaterCoil(CoilNum).MaxWaterVolFlowRate = DataSizing::AutoSize; // size heating coil CoilNum = 2; DataSizing::FinalSysSizing(1).MassFlowAtCoolPeak = DataSizing::FinalSysSizing(1).DesMainVolFlow * DataEnvironment::StdRhoAir; DataAirLoop::AirLoopControlInfo(1).UnitarySys = true; - WaterCoils::WaterCoil(CoilNum).WaterInletNodeNum = 5; - WaterCoils::WaterCoil(CoilNum).WaterOutletNodeNum = 6; - WaterCoils::WaterCoil(CoilNum).AirInletNodeNum = 7; - WaterCoils::WaterCoil(CoilNum).AirOutletNodeNum = 8; - WaterCoils::WaterCoil(CoilNum).Name = "Test Water Heating Coil"; - WaterCoils::WaterCoil(CoilNum).WaterLoopNum = 2; - WaterCoils::WaterCoil(CoilNum).WaterLoopSide = 1; - WaterCoils::WaterCoil(CoilNum).WaterLoopBranchNum = 1; - WaterCoils::WaterCoil(CoilNum).WaterLoopCompNum = 1; - WaterCoils::WaterCoil(CoilNum).WaterCoilType = WaterCoils::CoilType_Heating; - WaterCoils::WaterCoil(CoilNum).WaterCoilType_Num = WaterCoils::WaterCoil_SimpleHeating; - WaterCoils::WaterCoil(CoilNum).RequestingAutoSize = true; - WaterCoils::WaterCoil(CoilNum).DesAirVolFlowRate = DataSizing::AutoSize; - WaterCoils::WaterCoil(CoilNum).DesInletAirTemp = DataSizing::AutoSize; - WaterCoils::WaterCoil(CoilNum).DesOutletAirTemp = DataSizing::AutoSize; - WaterCoils::WaterCoil(CoilNum).DesInletWaterTemp = DataSizing::AutoSize; - WaterCoils::WaterCoil(CoilNum).DesInletAirHumRat = DataSizing::AutoSize; - WaterCoils::WaterCoil(CoilNum).DesOutletAirHumRat = DataSizing::AutoSize; - WaterCoils::WaterCoil(CoilNum).MaxWaterVolFlowRate = DataSizing::AutoSize; - DataPlant::PlantLoop(2).LoopSide(1).Branch(1).Comp(1).NodeNumIn = WaterCoils::WaterCoil(CoilNum).WaterInletNodeNum; - DataPlant::PlantLoop(2).LoopSide(1).Branch(1).Comp(1).TypeOf_Num = WaterCoils::WaterCoil(CoilNum).WaterCoilType_Num; - DataPlant::PlantLoop(2).LoopSide(1).Branch(1).Comp(1).Name = WaterCoils::WaterCoil(CoilNum).Name; + state.dataWaterCoils->WaterCoil(CoilNum).WaterInletNodeNum = 5; + state.dataWaterCoils->WaterCoil(CoilNum).WaterOutletNodeNum = 6; + state.dataWaterCoils->WaterCoil(CoilNum).AirInletNodeNum = 7; + state.dataWaterCoils->WaterCoil(CoilNum).AirOutletNodeNum = 8; + state.dataWaterCoils->WaterCoil(CoilNum).Name = "Test Water Heating Coil"; + state.dataWaterCoils->WaterCoil(CoilNum).WaterLoopNum = 2; + state.dataWaterCoils->WaterCoil(CoilNum).WaterLoopSide = 1; + state.dataWaterCoils->WaterCoil(CoilNum).WaterLoopBranchNum = 1; + state.dataWaterCoils->WaterCoil(CoilNum).WaterLoopCompNum = 1; + state.dataWaterCoils->WaterCoil(CoilNum).WaterCoilType = state.dataWaterCoils->CoilType_Heating; + state.dataWaterCoils->WaterCoil(CoilNum).WaterCoilType_Num = state.dataWaterCoils->WaterCoil_SimpleHeating; + state.dataWaterCoils->WaterCoil(CoilNum).RequestingAutoSize = true; + state.dataWaterCoils->WaterCoil(CoilNum).DesAirVolFlowRate = DataSizing::AutoSize; + state.dataWaterCoils->WaterCoil(CoilNum).DesInletAirTemp = DataSizing::AutoSize; + state.dataWaterCoils->WaterCoil(CoilNum).DesOutletAirTemp = DataSizing::AutoSize; + state.dataWaterCoils->WaterCoil(CoilNum).DesInletWaterTemp = DataSizing::AutoSize; + state.dataWaterCoils->WaterCoil(CoilNum).DesInletAirHumRat = DataSizing::AutoSize; + state.dataWaterCoils->WaterCoil(CoilNum).DesOutletAirHumRat = DataSizing::AutoSize; + state.dataWaterCoils->WaterCoil(CoilNum).MaxWaterVolFlowRate = DataSizing::AutoSize; + DataPlant::PlantLoop(2).LoopSide(1).Branch(1).Comp(1).NodeNumIn = state.dataWaterCoils->WaterCoil(CoilNum).WaterInletNodeNum; + DataPlant::PlantLoop(2).LoopSide(1).Branch(1).Comp(1).TypeOf_Num = state.dataWaterCoils->WaterCoil(CoilNum).WaterCoilType_Num; + DataPlant::PlantLoop(2).LoopSide(1).Branch(1).Comp(1).Name = state.dataWaterCoils->WaterCoil(CoilNum).Name; DataSizing::DataWaterLoopNum = 2; WaterCoils::SizeWaterCoil(state, CoilNum); // heating flow rate adjusted by FinalSysSizing(1).SysAirMinFlowRat = 0.3 - EXPECT_NEAR(0.159 * heatFlowRat, WaterCoils::WaterCoil(CoilNum).DesAirVolFlowRate, 0.00001); - EXPECT_NEAR(1154.0, WaterCoils::WaterCoil(CoilNum).DesWaterHeatingCoilRate, 1.0); - Real64 coil2HeatingCoilRate = WaterCoils::WaterCoil(CoilNum).DesWaterHeatingCoilRate; + EXPECT_NEAR(0.159 * heatFlowRat, state.dataWaterCoils->WaterCoil(CoilNum).DesAirVolFlowRate, 0.00001); + EXPECT_NEAR(1154.0, state.dataWaterCoils->WaterCoil(CoilNum).DesWaterHeatingCoilRate, 1.0); + Real64 coil2HeatingCoilRate = state.dataWaterCoils->WaterCoil(CoilNum).DesWaterHeatingCoilRate; // reset coil sizing for next test - WaterCoils::WaterCoil(CoilNum).DesAirVolFlowRate = DataSizing::AutoSize; - WaterCoils::WaterCoil(CoilNum).DesInletAirTemp = DataSizing::AutoSize; - WaterCoils::WaterCoil(CoilNum).DesOutletAirTemp = DataSizing::AutoSize; - WaterCoils::WaterCoil(CoilNum).DesInletWaterTemp = DataSizing::AutoSize; - WaterCoils::WaterCoil(CoilNum).DesInletAirHumRat = DataSizing::AutoSize; - WaterCoils::WaterCoil(CoilNum).DesOutletAirHumRat = DataSizing::AutoSize; - WaterCoils::WaterCoil(CoilNum).MaxWaterVolFlowRate = DataSizing::AutoSize; + state.dataWaterCoils->WaterCoil(CoilNum).DesAirVolFlowRate = DataSizing::AutoSize; + state.dataWaterCoils->WaterCoil(CoilNum).DesInletAirTemp = DataSizing::AutoSize; + state.dataWaterCoils->WaterCoil(CoilNum).DesOutletAirTemp = DataSizing::AutoSize; + state.dataWaterCoils->WaterCoil(CoilNum).DesInletWaterTemp = DataSizing::AutoSize; + state.dataWaterCoils->WaterCoil(CoilNum).DesInletAirHumRat = DataSizing::AutoSize; + state.dataWaterCoils->WaterCoil(CoilNum).DesOutletAirHumRat = DataSizing::AutoSize; + state.dataWaterCoils->WaterCoil(CoilNum).MaxWaterVolFlowRate = DataSizing::AutoSize; // resize cooling coil with fan on branch CoilNum = 1; @@ -476,17 +476,17 @@ TEST_F(AirloopUnitarySysTest, MultipleWaterCoolingCoilSizing) WaterCoils::SizeWaterCoil(state, CoilNum); EXPECT_NEAR(FanCoolLoad, 106.0, 1.0); // make sure there is enough fan heat to change results - EXPECT_NEAR(6779.0 + FanCoolLoad, WaterCoils::WaterCoil(CoilNum).DesWaterCoolingCoilRate, 1.0); - EXPECT_NEAR(20.541, WaterCoils::WaterCoil(CoilNum).DesInletAirTemp, 0.001); // coil inlet does include fan heat + EXPECT_NEAR(6779.0 + FanCoolLoad, state.dataWaterCoils->WaterCoil(CoilNum).DesWaterCoolingCoilRate, 1.0); + EXPECT_NEAR(20.541, state.dataWaterCoils->WaterCoil(CoilNum).DesInletAirTemp, 0.001); // coil inlet does include fan heat // reset coil sizing for next test - WaterCoils::WaterCoil(CoilNum).DesAirVolFlowRate = DataSizing::AutoSize; - WaterCoils::WaterCoil(CoilNum).DesInletAirTemp = DataSizing::AutoSize; - WaterCoils::WaterCoil(CoilNum).DesOutletAirTemp = DataSizing::AutoSize; - WaterCoils::WaterCoil(CoilNum).DesInletWaterTemp = DataSizing::AutoSize; - WaterCoils::WaterCoil(CoilNum).DesInletAirHumRat = DataSizing::AutoSize; - WaterCoils::WaterCoil(CoilNum).DesOutletAirHumRat = DataSizing::AutoSize; - WaterCoils::WaterCoil(CoilNum).MaxWaterVolFlowRate = DataSizing::AutoSize; + state.dataWaterCoils->WaterCoil(CoilNum).DesAirVolFlowRate = DataSizing::AutoSize; + state.dataWaterCoils->WaterCoil(CoilNum).DesInletAirTemp = DataSizing::AutoSize; + state.dataWaterCoils->WaterCoil(CoilNum).DesOutletAirTemp = DataSizing::AutoSize; + state.dataWaterCoils->WaterCoil(CoilNum).DesInletWaterTemp = DataSizing::AutoSize; + state.dataWaterCoils->WaterCoil(CoilNum).DesInletAirHumRat = DataSizing::AutoSize; + state.dataWaterCoils->WaterCoil(CoilNum).DesOutletAirHumRat = DataSizing::AutoSize; + state.dataWaterCoils->WaterCoil(CoilNum).MaxWaterVolFlowRate = DataSizing::AutoSize; // reset primary air system fan type and location as if is doesn't exist DataAirSystems::PrimaryAirSystem(1).supFanModelTypeEnum = DataAirSystems::fanModelTypeNotYetSet; DataAirSystems::PrimaryAirSystem(1).supFanLocation = DataAirSystems::fanPlacement::fanPlaceNotSet; @@ -508,10 +508,10 @@ TEST_F(AirloopUnitarySysTest, MultipleWaterCoolingCoilSizing) mySys->m_CoolingCoilName = "Test Water Cooling Coil"; mySys->m_HeatingCoilType_Num = DataHVACGlobals::Coil_HeatingWater; mySys->m_HeatingCoilName = "Test Water Heating Coil"; - WaterCoils::GetWaterCoilsInputFlag = false; // don't overwrite these coil data - WaterCoils::MySizeFlag = true; // need to size again for UnitarySystem - WaterCoils::WaterCoil(1).DesWaterCoolingCoilRate = 0.0; // reset these to be sure they get recalculated - WaterCoils::WaterCoil(2).DesWaterHeatingCoilRate = 0.0; + 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 + state.dataWaterCoils->WaterCoil(2).DesWaterHeatingCoilRate = 0.0; OutputReportPredefined::SetPredefinedTables(); DataGlobals::DoingSizing = true; @@ -519,14 +519,14 @@ TEST_F(AirloopUnitarySysTest, MultipleWaterCoolingCoilSizing) // Show coil sizes in UnitarySystem, cooling coil does not include fan heat // Same sizes as coil on branch without fan heat - EXPECT_NEAR(6672.0, WaterCoils::WaterCoil(1).DesWaterCoolingCoilRate, 1.0); - EXPECT_EQ(20.0, WaterCoils::WaterCoil(CoilNum).DesInletAirTemp); // coil inlet does not include fan heat + EXPECT_NEAR(6672.0, state.dataWaterCoils->WaterCoil(1).DesWaterCoolingCoilRate, 1.0); + EXPECT_EQ(20.0, state.dataWaterCoils->WaterCoil(CoilNum).DesInletAirTemp); // coil inlet does not include fan heat // heating coil in UnitarySystem sized at higher air flow rate, i.e., not using SysAirMinFlowRat - EXPECT_NEAR(3848.0, WaterCoils::WaterCoil(2).DesWaterHeatingCoilRate, 1.0); + EXPECT_NEAR(3848.0, state.dataWaterCoils->WaterCoil(2).DesWaterHeatingCoilRate, 1.0); // note size of heating coil on branch is smaller than heating coil in UnitarySystem minus 10 W EXPECT_LT(coil2HeatingCoilRate, 3838.0); // heating flow rate of coil in UnitarySystem NOT adjusted by FinalSysSizing(1).SysAirMinFlowRat = 0.3 - EXPECT_NEAR(0.159, WaterCoils::WaterCoil(CoilNum).DesAirVolFlowRate, 0.00001); + EXPECT_NEAR(0.159, state.dataWaterCoils->WaterCoil(CoilNum).DesAirVolFlowRate, 0.00001); // the water cooling coil sizes are only different by the air density used in capacity calculation // water coils use StdRhoAir and UnitarySystem coils use actual air density @@ -536,10 +536,10 @@ TEST_F(AirloopUnitarySysTest, MultipleWaterCoolingCoilSizing) // this is the ratio of UnitarySystem cooling coil size to coil-on-branch water cooling coil size Real64 rhoRatio = DataEnvironment::StdRhoAir / rhoair; - EXPECT_NEAR(coil1CoolingCoilRate, rhoRatio * WaterCoils::WaterCoil(1).DesWaterCoolingCoilRate, 1.0); + EXPECT_NEAR(coil1CoolingCoilRate, rhoRatio * state.dataWaterCoils->WaterCoil(1).DesWaterCoolingCoilRate, 1.0); EXPECT_NEAR(coil1CoolingCoilRate, rhoRatio * mySys->m_DesignCoolingCapacity, 1.0); // the heating coils are sized differently since SysAirMinFlowRat is not accounted for - EXPECT_LT(coil2HeatingCoilRate, WaterCoils::WaterCoil(2).DesWaterHeatingCoilRate); + EXPECT_LT(coil2HeatingCoilRate, state.dataWaterCoils->WaterCoil(2).DesWaterHeatingCoilRate); EXPECT_LT(coil2HeatingCoilRate, mySys->m_DesignHeatingCapacity); // add fan to UnitarySystem @@ -556,35 +556,35 @@ TEST_F(AirloopUnitarySysTest, MultipleWaterCoolingCoilSizing) // pretend this is first call and UnitarySystem doesn't know the coil index mySys->m_CoolingCoilIndex = 0; mySys->m_HeatingCoilIndex = 0; - WaterCoils::MySizeFlag = true; - WaterCoils::WaterCoil(1).DesAirVolFlowRate = DataSizing::AutoSize; - WaterCoils::WaterCoil(1).DesInletAirTemp = DataSizing::AutoSize; - WaterCoils::WaterCoil(1).DesOutletAirTemp = DataSizing::AutoSize; - WaterCoils::WaterCoil(1).DesInletWaterTemp = DataSizing::AutoSize; - WaterCoils::WaterCoil(1).DesInletAirHumRat = DataSizing::AutoSize; - WaterCoils::WaterCoil(1).DesOutletAirHumRat = DataSizing::AutoSize; - WaterCoils::WaterCoil(1).MaxWaterVolFlowRate = DataSizing::AutoSize; - WaterCoils::WaterCoil(1).MaxWaterVolFlowRate = DataSizing::AutoSize; - WaterCoils::WaterCoil(2).DesAirVolFlowRate = DataSizing::AutoSize; - WaterCoils::WaterCoil(2).DesInletAirTemp = DataSizing::AutoSize; - WaterCoils::WaterCoil(2).DesOutletAirTemp = DataSizing::AutoSize; - WaterCoils::WaterCoil(2).DesInletWaterTemp = DataSizing::AutoSize; - WaterCoils::WaterCoil(2).DesInletAirHumRat = DataSizing::AutoSize; - WaterCoils::WaterCoil(2).DesOutletAirHumRat = DataSizing::AutoSize; - WaterCoils::WaterCoil(2).MaxWaterVolFlowRate = DataSizing::AutoSize; - WaterCoils::WaterCoil(2).MaxWaterVolFlowRate = DataSizing::AutoSize; - WaterCoils::WaterCoil(1).DesWaterCoolingCoilRate = 0.0; // reset these to be sure they get recalculated - WaterCoils::WaterCoil(2).DesWaterHeatingCoilRate = 0.0; + state.dataWaterCoils->MySizeFlag = true; + state.dataWaterCoils->WaterCoil(1).DesAirVolFlowRate = DataSizing::AutoSize; + state.dataWaterCoils->WaterCoil(1).DesInletAirTemp = DataSizing::AutoSize; + state.dataWaterCoils->WaterCoil(1).DesOutletAirTemp = DataSizing::AutoSize; + state.dataWaterCoils->WaterCoil(1).DesInletWaterTemp = DataSizing::AutoSize; + state.dataWaterCoils->WaterCoil(1).DesInletAirHumRat = DataSizing::AutoSize; + state.dataWaterCoils->WaterCoil(1).DesOutletAirHumRat = DataSizing::AutoSize; + state.dataWaterCoils->WaterCoil(1).MaxWaterVolFlowRate = DataSizing::AutoSize; + state.dataWaterCoils->WaterCoil(1).MaxWaterVolFlowRate = DataSizing::AutoSize; + state.dataWaterCoils->WaterCoil(2).DesAirVolFlowRate = DataSizing::AutoSize; + state.dataWaterCoils->WaterCoil(2).DesInletAirTemp = DataSizing::AutoSize; + state.dataWaterCoils->WaterCoil(2).DesOutletAirTemp = DataSizing::AutoSize; + state.dataWaterCoils->WaterCoil(2).DesInletWaterTemp = DataSizing::AutoSize; + state.dataWaterCoils->WaterCoil(2).DesInletAirHumRat = DataSizing::AutoSize; + state.dataWaterCoils->WaterCoil(2).DesOutletAirHumRat = DataSizing::AutoSize; + state.dataWaterCoils->WaterCoil(2).MaxWaterVolFlowRate = DataSizing::AutoSize; + state.dataWaterCoils->WaterCoil(2).MaxWaterVolFlowRate = DataSizing::AutoSize; + state.dataWaterCoils->WaterCoil(1).DesWaterCoolingCoilRate = 0.0; // reset these to be sure they get recalculated + state.dataWaterCoils->WaterCoil(2).DesWaterHeatingCoilRate = 0.0; mySys->sizeSystem(state, FirstHVACIteration, AirLoopNum); // Show coil sizes in UnitarySystem, cooling coil now includes fan heat // Same sizes as coil on branch with fan heat - EXPECT_NEAR(6672.0 + FanCoolLoad, WaterCoils::WaterCoil(1).DesWaterCoolingCoilRate, 1.0); + EXPECT_NEAR(6672.0 + FanCoolLoad, state.dataWaterCoils->WaterCoil(1).DesWaterCoolingCoilRate, 1.0); EXPECT_NEAR(6672.0 + FanCoolLoad, mySys->m_DesignCoolingCapacity, 1.0); - EXPECT_NEAR(20.541, WaterCoils::WaterCoil(1).DesInletAirTemp, 0.001); // coil inlet does include fan heat + EXPECT_NEAR(20.541, state.dataWaterCoils->WaterCoil(1).DesInletAirTemp, 0.001); // coil inlet does include fan heat // the heating coils are sized differently since SysAirMinFlowRat is not accounted for - EXPECT_NEAR(3848.0, WaterCoils::WaterCoil(2).DesWaterHeatingCoilRate, 1.0); + EXPECT_NEAR(3848.0, state.dataWaterCoils->WaterCoil(2).DesWaterHeatingCoilRate, 1.0); } TEST_F(ZoneUnitarySysTest, Test_UnitarySystemModel_factory) @@ -4101,7 +4101,7 @@ TEST_F(EnergyPlusFixture, UnitarySystemModel_CalcUnitaryHeatingSystem) thisSys.m_MultiOrVarSpeedHeatCoil = true; thisSys.m_MultiOrVarSpeedCoolCoil = true; DataLoopNode::Node.allocate(10); - WaterCoils::WaterCoil.allocate(1); + state.dataWaterCoils->WaterCoil.allocate(1); thisSys.m_HeatMassFlowRate.resize(4); thisSys.m_CoolMassFlowRate.resize(4); @@ -4150,45 +4150,45 @@ TEST_F(EnergyPlusFixture, UnitarySystemModel_CalcUnitaryHeatingSystem) thisSys.m_HeatingCycRatio = 1.0; thisSys.m_HeatingSpeedNum = 3; - WaterCoils::CheckEquipName.allocate(1); - WaterCoils::NumWaterCoils = 1; - WaterCoils::GetWaterCoilsInputFlag = false; - WaterCoils::WaterCoil(1).SchedPtr = DataGlobals::ScheduleAlwaysOn; - WaterCoils::WaterCoil(1).Name = "Water Heating Coil"; - WaterCoils::WaterCoil(1).WaterCoilType = DataHVACGlobals::Coil_HeatingWater; - WaterCoils::WaterCoil(1).WaterCoilType_Num = WaterCoils::WaterCoil_SimpleHeating; - WaterCoils::WaterCoil(1).DesAirVolFlowRate = 1.0; - WaterCoils::WaterCoil(1).MaxWaterVolFlowRate = HotWaterMassFlowRate; - WaterCoils::WaterCoil(1).UACoil = 400.0; - WaterCoils::WaterCoil(1).InletAirTemp = 10.0; - WaterCoils::WaterCoil(1).InletAirEnthalpy = 18000.0; - WaterCoils::WaterCoil(1).InletAirHumRat = - Psychrometrics::PsyWFnTdbH(WaterCoils::WaterCoil(1).InletAirTemp, WaterCoils::WaterCoil(1).InletAirEnthalpy); - - WaterCoils::WaterCoil(1).AirInletNodeNum = 4; - WaterCoils::WaterCoil(1).AirOutletNodeNum = 5; - DataLoopNode::Node(WaterCoils::WaterCoil(1).AirInletNodeNum).Temp = 10.0; - DataLoopNode::Node(WaterCoils::WaterCoil(1).AirInletNodeNum).Enthalpy = 18000; - DataLoopNode::Node(WaterCoils::WaterCoil(1).AirInletNodeNum).HumRat = Psychrometrics::PsyWFnTdbH( - DataLoopNode::Node(WaterCoils::WaterCoil(1).AirInletNodeNum).Temp, DataLoopNode::Node(WaterCoils::WaterCoil(1).AirInletNodeNum).Enthalpy); - - DataLoopNode::Node(WaterCoils::WaterCoil(1).AirInletNodeNum).MassFlowRate = AirMassFlowRate; - DataLoopNode::Node(WaterCoils::WaterCoil(1).AirInletNodeNum).MassFlowRateMax = AirMassFlowRate; - - WaterCoils::WaterCoil(1).WaterLoopNum = 1; - WaterCoils::WaterCoil(1).WaterLoopSide = 1; - WaterCoils::WaterCoil(1).WaterLoopBranchNum = 1; - WaterCoils::WaterCoil(1).WaterLoopCompNum = 1; - WaterCoils::WaterCoil(1).WaterInletNodeNum = 6; - WaterCoils::WaterCoil(1).WaterOutletNodeNum = 7; - WaterCoils::WaterCoil(1).InletWaterTemp = 60.0; - WaterCoils::WaterCoil(1).InletWaterMassFlowRate = HotWaterMassFlowRate; - WaterCoils::WaterCoil(1).MaxWaterMassFlowRate = HotWaterMassFlowRate; - DataLoopNode::Node(WaterCoils::WaterCoil(1).WaterInletNodeNum).MassFlowRate = HotWaterMassFlowRate; - DataLoopNode::Node(WaterCoils::WaterCoil(1).WaterInletNodeNum).MassFlowRateMaxAvail = HotWaterMassFlowRate; - DataLoopNode::Node(WaterCoils::WaterCoil(1).WaterInletNodeNum).Temp = WaterCoils::WaterCoil(1).InletWaterTemp; - DataLoopNode::Node(WaterCoils::WaterCoil(1).WaterOutletNodeNum).MassFlowRate = HotWaterMassFlowRate; - DataLoopNode::Node(WaterCoils::WaterCoil(1).WaterOutletNodeNum).MassFlowRateMaxAvail = HotWaterMassFlowRate; + state.dataWaterCoils->CheckEquipName.allocate(1); + state.dataWaterCoils->NumWaterCoils = 1; + state.dataWaterCoils->GetWaterCoilsInputFlag = false; + state.dataWaterCoils->WaterCoil(1).SchedPtr = DataGlobals::ScheduleAlwaysOn; + state.dataWaterCoils->WaterCoil(1).Name = "Water Heating Coil"; + state.dataWaterCoils->WaterCoil(1).WaterCoilType = DataHVACGlobals::Coil_HeatingWater; + state.dataWaterCoils->WaterCoil(1).WaterCoilType_Num = state.dataWaterCoils->WaterCoil_SimpleHeating; + state.dataWaterCoils->WaterCoil(1).DesAirVolFlowRate = 1.0; + state.dataWaterCoils->WaterCoil(1).MaxWaterVolFlowRate = HotWaterMassFlowRate; + state.dataWaterCoils->WaterCoil(1).UACoil = 400.0; + state.dataWaterCoils->WaterCoil(1).InletAirTemp = 10.0; + state.dataWaterCoils->WaterCoil(1).InletAirEnthalpy = 18000.0; + state.dataWaterCoils->WaterCoil(1).InletAirHumRat = + Psychrometrics::PsyWFnTdbH(state.dataWaterCoils->WaterCoil(1).InletAirTemp, state.dataWaterCoils->WaterCoil(1).InletAirEnthalpy); + + state.dataWaterCoils->WaterCoil(1).AirInletNodeNum = 4; + state.dataWaterCoils->WaterCoil(1).AirOutletNodeNum = 5; + DataLoopNode::Node(state.dataWaterCoils->WaterCoil(1).AirInletNodeNum).Temp = 10.0; + DataLoopNode::Node(state.dataWaterCoils->WaterCoil(1).AirInletNodeNum).Enthalpy = 18000; + DataLoopNode::Node(state.dataWaterCoils->WaterCoil(1).AirInletNodeNum).HumRat = Psychrometrics::PsyWFnTdbH( + DataLoopNode::Node(state.dataWaterCoils->WaterCoil(1).AirInletNodeNum).Temp, DataLoopNode::Node(state.dataWaterCoils->WaterCoil(1).AirInletNodeNum).Enthalpy); + + DataLoopNode::Node(state.dataWaterCoils->WaterCoil(1).AirInletNodeNum).MassFlowRate = AirMassFlowRate; + DataLoopNode::Node(state.dataWaterCoils->WaterCoil(1).AirInletNodeNum).MassFlowRateMax = AirMassFlowRate; + + state.dataWaterCoils->WaterCoil(1).WaterLoopNum = 1; + state.dataWaterCoils->WaterCoil(1).WaterLoopSide = 1; + state.dataWaterCoils->WaterCoil(1).WaterLoopBranchNum = 1; + state.dataWaterCoils->WaterCoil(1).WaterLoopCompNum = 1; + state.dataWaterCoils->WaterCoil(1).WaterInletNodeNum = 6; + state.dataWaterCoils->WaterCoil(1).WaterOutletNodeNum = 7; + state.dataWaterCoils->WaterCoil(1).InletWaterTemp = 60.0; + state.dataWaterCoils->WaterCoil(1).InletWaterMassFlowRate = HotWaterMassFlowRate; + state.dataWaterCoils->WaterCoil(1).MaxWaterMassFlowRate = HotWaterMassFlowRate; + DataLoopNode::Node(state.dataWaterCoils->WaterCoil(1).WaterInletNodeNum).MassFlowRate = HotWaterMassFlowRate; + DataLoopNode::Node(state.dataWaterCoils->WaterCoil(1).WaterInletNodeNum).MassFlowRateMaxAvail = HotWaterMassFlowRate; + DataLoopNode::Node(state.dataWaterCoils->WaterCoil(1).WaterInletNodeNum).Temp = state.dataWaterCoils->WaterCoil(1).InletWaterTemp; + DataLoopNode::Node(state.dataWaterCoils->WaterCoil(1).WaterOutletNodeNum).MassFlowRate = HotWaterMassFlowRate; + DataLoopNode::Node(state.dataWaterCoils->WaterCoil(1).WaterOutletNodeNum).MassFlowRateMaxAvail = HotWaterMassFlowRate; for (int l = 1; l <= DataPlant::TotNumLoops; ++l) { auto &loop(DataPlant::PlantLoop(l)); @@ -4204,20 +4204,20 @@ TEST_F(EnergyPlusFixture, UnitarySystemModel_CalcUnitaryHeatingSystem) DataPlant::PlantLoop(1).FluidName = "FluidWaterLoop"; DataPlant::PlantLoop(1).FluidIndex = 1; DataPlant::PlantLoop(1).FluidName = "WATER"; - DataPlant::PlantLoop(1).LoopSide(1).Branch(1).Comp(1).Name = WaterCoils::WaterCoil(1).Name; - DataPlant::PlantLoop(1).LoopSide(1).Branch(1).Comp(1).TypeOf_Num = WaterCoils::WaterCoil_SimpleHeating; - DataPlant::PlantLoop(1).LoopSide(1).Branch(1).Comp(1).NodeNumIn = WaterCoils::WaterCoil(1).WaterInletNodeNum; + DataPlant::PlantLoop(1).LoopSide(1).Branch(1).Comp(1).Name = state.dataWaterCoils->WaterCoil(1).Name; + DataPlant::PlantLoop(1).LoopSide(1).Branch(1).Comp(1).TypeOf_Num = state.dataWaterCoils->WaterCoil_SimpleHeating; + DataPlant::PlantLoop(1).LoopSide(1).Branch(1).Comp(1).NodeNumIn = state.dataWaterCoils->WaterCoil(1).WaterInletNodeNum; thisSys.m_HeatingCoilIndex = 1; - thisSys.m_HeatingCoilName = WaterCoils::WaterCoil(1).Name; - thisSys.HeatCoilFluidInletNode = WaterCoils::WaterCoil(1).WaterInletNodeNum; - thisSys.HeatCoilFluidOutletNodeNum = WaterCoils::WaterCoil(1).WaterOutletNodeNum; + thisSys.m_HeatingCoilName = state.dataWaterCoils->WaterCoil(1).Name; + thisSys.HeatCoilFluidInletNode = state.dataWaterCoils->WaterCoil(1).WaterInletNodeNum; + thisSys.HeatCoilFluidOutletNodeNum = state.dataWaterCoils->WaterCoil(1).WaterOutletNodeNum; DataGlobals::DoingSizing = true; - WaterCoils::WaterCoil(1).TotWaterHeatingCoilRate = 0.0; + state.dataWaterCoils->WaterCoil(1).TotWaterHeatingCoilRate = 0.0; thisSys.calcUnitaryHeatingSystem(state, AirLoopNum, FirstHVACIteration, thisSys.m_HeatingCycRatio, CompOn, OnOffAirFlowRatio, HeatCoilLoad); - EXPECT_NEAR(15750.0, WaterCoils::WaterCoil(1).TotWaterHeatingCoilRate, 2.0); + EXPECT_NEAR(15750.0, state.dataWaterCoils->WaterCoil(1).TotWaterHeatingCoilRate, 2.0); } TEST_F(EnergyPlusFixture, UnitarySystemModel_CalcUnitaryCoolingSystem) @@ -4245,7 +4245,7 @@ TEST_F(EnergyPlusFixture, UnitarySystemModel_CalcUnitaryCoolingSystem) thisSys.m_MultiOrVarSpeedHeatCoil = true; thisSys.m_MultiOrVarSpeedCoolCoil = true; DataLoopNode::Node.allocate(10); - WaterCoils::WaterCoil.allocate(1); + state.dataWaterCoils->WaterCoil.allocate(1); thisSys.m_HeatMassFlowRate.resize(4); thisSys.m_CoolMassFlowRate.resize(4); @@ -4290,57 +4290,57 @@ TEST_F(EnergyPlusFixture, UnitarySystemModel_CalcUnitaryCoolingSystem) thisSys.m_CoolingCycRatio = 1.0; thisSys.m_CoolingSpeedNum = 3; - WaterCoils::CheckEquipName.allocate(1); - WaterCoils::NumWaterCoils = 1; - WaterCoils::GetWaterCoilsInputFlag = false; - WaterCoils::WaterCoil(1).SchedPtr = DataGlobals::ScheduleAlwaysOn; - WaterCoils::WaterCoil(1).Name = "Water Cooling Coil"; - WaterCoils::WaterCoil(1).WaterCoilType = WaterCoils::CoilType_Cooling; - WaterCoils::WaterCoil(1).WaterCoilType_Num = WaterCoils::WaterCoil_Cooling; - WaterCoils::WaterCoil(1).WaterCoilModel = WaterCoils::CoilModel_Cooling; - WaterCoils::WaterCoil(1).DesAirVolFlowRate = 1.0; - WaterCoils::WaterCoil(1).MaxWaterVolFlowRate = ColdWaterMassFlowRate; - WaterCoils::WaterCoil(1).CoolingCoilAnalysisMode = WaterCoils::SimpleAnalysis; - WaterCoils::WaterCoil(1).HeatExchType = WaterCoils::CrossFlow; - WaterCoils::WaterCoil(1).UACoilTotal = 4689.0; - WaterCoils::WaterCoil(1).UACoilExternal = 6110.0; - WaterCoils::WaterCoil(1).UACoilInternal = 20164.0; - WaterCoils::WaterCoil(1).TotCoilOutsideSurfArea = 50.0; - - WaterCoils::WaterCoil(1).MaxWaterVolFlowRate = 0.001; - WaterCoils::WaterCoil(1).DesInletWaterTemp = 6.67; - WaterCoils::WaterCoil(1).DesInletAirTemp = 30.0; - WaterCoils::WaterCoil(1).DesOutletAirTemp = 12.0; - WaterCoils::WaterCoil(1).DesInletAirHumRat = 0.013; - WaterCoils::WaterCoil(1).DesOutletAirHumRat = 0.008; - WaterCoils::WaterCoil(1).AirInletNodeNum = 4; - WaterCoils::WaterCoil(1).AirOutletNodeNum = 5; - WaterCoils::WaterCoil(1).InletAirTemp = 30.0; - WaterCoils::WaterCoil(1).InletAirEnthalpy = 53000; - WaterCoils::WaterCoil(1).InletAirHumRat = - Psychrometrics::PsyWFnTdbH(WaterCoils::WaterCoil(1).InletAirTemp, WaterCoils::WaterCoil(1).InletAirEnthalpy); - WaterCoils::WaterCoil(1).InletWaterTemp = 6.0; - WaterCoils::WaterCoil(1).InletAirMassFlowRate = AirMassFlowRate; - DataLoopNode::Node(WaterCoils::WaterCoil(1).AirInletNodeNum).MassFlowRate = AirMassFlowRate; - DataLoopNode::Node(WaterCoils::WaterCoil(1).AirInletNodeNum).MassFlowRateMax = AirMassFlowRate; - DataLoopNode::Node(WaterCoils::WaterCoil(1).AirInletNodeNum).Temp = 30.0; - DataLoopNode::Node(WaterCoils::WaterCoil(1).AirInletNodeNum).Enthalpy = 53000; - DataLoopNode::Node(WaterCoils::WaterCoil(1).AirInletNodeNum).HumRat = Psychrometrics::PsyWFnTdbH( - DataLoopNode::Node(WaterCoils::WaterCoil(1).AirInletNodeNum).Temp, DataLoopNode::Node(WaterCoils::WaterCoil(1).AirInletNodeNum).Enthalpy); - - WaterCoils::WaterCoil(1).WaterLoopNum = 1; - WaterCoils::WaterCoil(1).WaterLoopSide = 1; - WaterCoils::WaterCoil(1).WaterLoopBranchNum = 1; - WaterCoils::WaterCoil(1).WaterLoopCompNum = 1; - WaterCoils::WaterCoil(1).WaterInletNodeNum = 6; - WaterCoils::WaterCoil(1).WaterOutletNodeNum = 7; - WaterCoils::WaterCoil(1).InletWaterMassFlowRate = ColdWaterMassFlowRate; - WaterCoils::WaterCoil(1).MaxWaterMassFlowRate = ColdWaterMassFlowRate; - DataLoopNode::Node(WaterCoils::WaterCoil(1).WaterInletNodeNum).Temp = WaterCoils::WaterCoil(1).InletWaterTemp; - DataLoopNode::Node(WaterCoils::WaterCoil(1).WaterInletNodeNum).MassFlowRate = ColdWaterMassFlowRate; - DataLoopNode::Node(WaterCoils::WaterCoil(1).WaterInletNodeNum).MassFlowRateMaxAvail = HotWaterMassFlowRate; - DataLoopNode::Node(WaterCoils::WaterCoil(1).WaterOutletNodeNum).MassFlowRate = ColdWaterMassFlowRate; - DataLoopNode::Node(WaterCoils::WaterCoil(1).WaterOutletNodeNum).MassFlowRateMaxAvail = ColdWaterMassFlowRate; + state.dataWaterCoils->CheckEquipName.allocate(1); + state.dataWaterCoils->NumWaterCoils = 1; + state.dataWaterCoils->GetWaterCoilsInputFlag = false; + state.dataWaterCoils->WaterCoil(1).SchedPtr = DataGlobals::ScheduleAlwaysOn; + state.dataWaterCoils->WaterCoil(1).Name = "Water Cooling Coil"; + state.dataWaterCoils->WaterCoil(1).WaterCoilType = state.dataWaterCoils->CoilType_Cooling; + state.dataWaterCoils->WaterCoil(1).WaterCoilType_Num = state.dataWaterCoils->WaterCoil_Cooling; + state.dataWaterCoils->WaterCoil(1).WaterCoilModel = state.dataWaterCoils->CoilModel_Cooling; + state.dataWaterCoils->WaterCoil(1).DesAirVolFlowRate = 1.0; + state.dataWaterCoils->WaterCoil(1).MaxWaterVolFlowRate = ColdWaterMassFlowRate; + state.dataWaterCoils->WaterCoil(1).CoolingCoilAnalysisMode = state.dataWaterCoils->SimpleAnalysis; + state.dataWaterCoils->WaterCoil(1).HeatExchType = state.dataWaterCoils->CrossFlow; + state.dataWaterCoils->WaterCoil(1).UACoilTotal = 4689.0; + state.dataWaterCoils->WaterCoil(1).UACoilExternal = 6110.0; + state.dataWaterCoils->WaterCoil(1).UACoilInternal = 20164.0; + state.dataWaterCoils->WaterCoil(1).TotCoilOutsideSurfArea = 50.0; + + state.dataWaterCoils->WaterCoil(1).MaxWaterVolFlowRate = 0.001; + state.dataWaterCoils->WaterCoil(1).DesInletWaterTemp = 6.67; + state.dataWaterCoils->WaterCoil(1).DesInletAirTemp = 30.0; + state.dataWaterCoils->WaterCoil(1).DesOutletAirTemp = 12.0; + state.dataWaterCoils->WaterCoil(1).DesInletAirHumRat = 0.013; + state.dataWaterCoils->WaterCoil(1).DesOutletAirHumRat = 0.008; + state.dataWaterCoils->WaterCoil(1).AirInletNodeNum = 4; + state.dataWaterCoils->WaterCoil(1).AirOutletNodeNum = 5; + state.dataWaterCoils->WaterCoil(1).InletAirTemp = 30.0; + state.dataWaterCoils->WaterCoil(1).InletAirEnthalpy = 53000; + state.dataWaterCoils->WaterCoil(1).InletAirHumRat = + Psychrometrics::PsyWFnTdbH(state.dataWaterCoils->WaterCoil(1).InletAirTemp, state.dataWaterCoils->WaterCoil(1).InletAirEnthalpy); + state.dataWaterCoils->WaterCoil(1).InletWaterTemp = 6.0; + state.dataWaterCoils->WaterCoil(1).InletAirMassFlowRate = AirMassFlowRate; + DataLoopNode::Node(state.dataWaterCoils->WaterCoil(1).AirInletNodeNum).MassFlowRate = AirMassFlowRate; + DataLoopNode::Node(state.dataWaterCoils->WaterCoil(1).AirInletNodeNum).MassFlowRateMax = AirMassFlowRate; + DataLoopNode::Node(state.dataWaterCoils->WaterCoil(1).AirInletNodeNum).Temp = 30.0; + DataLoopNode::Node(state.dataWaterCoils->WaterCoil(1).AirInletNodeNum).Enthalpy = 53000; + DataLoopNode::Node(state.dataWaterCoils->WaterCoil(1).AirInletNodeNum).HumRat = Psychrometrics::PsyWFnTdbH( + DataLoopNode::Node(state.dataWaterCoils->WaterCoil(1).AirInletNodeNum).Temp, DataLoopNode::Node(state.dataWaterCoils->WaterCoil(1).AirInletNodeNum).Enthalpy); + + state.dataWaterCoils->WaterCoil(1).WaterLoopNum = 1; + state.dataWaterCoils->WaterCoil(1).WaterLoopSide = 1; + state.dataWaterCoils->WaterCoil(1).WaterLoopBranchNum = 1; + state.dataWaterCoils->WaterCoil(1).WaterLoopCompNum = 1; + state.dataWaterCoils->WaterCoil(1).WaterInletNodeNum = 6; + state.dataWaterCoils->WaterCoil(1).WaterOutletNodeNum = 7; + state.dataWaterCoils->WaterCoil(1).InletWaterMassFlowRate = ColdWaterMassFlowRate; + state.dataWaterCoils->WaterCoil(1).MaxWaterMassFlowRate = ColdWaterMassFlowRate; + DataLoopNode::Node(state.dataWaterCoils->WaterCoil(1).WaterInletNodeNum).Temp = state.dataWaterCoils->WaterCoil(1).InletWaterTemp; + DataLoopNode::Node(state.dataWaterCoils->WaterCoil(1).WaterInletNodeNum).MassFlowRate = ColdWaterMassFlowRate; + DataLoopNode::Node(state.dataWaterCoils->WaterCoil(1).WaterInletNodeNum).MassFlowRateMaxAvail = HotWaterMassFlowRate; + DataLoopNode::Node(state.dataWaterCoils->WaterCoil(1).WaterOutletNodeNum).MassFlowRate = ColdWaterMassFlowRate; + DataLoopNode::Node(state.dataWaterCoils->WaterCoil(1).WaterOutletNodeNum).MassFlowRateMaxAvail = ColdWaterMassFlowRate; for (int l = 1; l <= DataPlant::TotNumLoops; ++l) { auto &loop(DataPlant::PlantLoop(l)); @@ -4356,24 +4356,24 @@ TEST_F(EnergyPlusFixture, UnitarySystemModel_CalcUnitaryCoolingSystem) DataPlant::PlantLoop(1).FluidName = "FluidWaterLoop"; DataPlant::PlantLoop(1).FluidIndex = 1; DataPlant::PlantLoop(1).FluidName = "WATER"; - DataPlant::PlantLoop(1).LoopSide(1).Branch(1).Comp(1).Name = WaterCoils::WaterCoil(1).Name; - DataPlant::PlantLoop(1).LoopSide(1).Branch(1).Comp(1).TypeOf_Num = WaterCoils::WaterCoil_Cooling; - DataPlant::PlantLoop(1).LoopSide(1).Branch(1).Comp(1).NodeNumIn = WaterCoils::WaterCoil(1).WaterInletNodeNum; + DataPlant::PlantLoop(1).LoopSide(1).Branch(1).Comp(1).Name = state.dataWaterCoils->WaterCoil(1).Name; + DataPlant::PlantLoop(1).LoopSide(1).Branch(1).Comp(1).TypeOf_Num = state.dataWaterCoils->WaterCoil_Cooling; + DataPlant::PlantLoop(1).LoopSide(1).Branch(1).Comp(1).NodeNumIn = state.dataWaterCoils->WaterCoil(1).WaterInletNodeNum; thisSys.m_CoolingCoilIndex = 1; - thisSys.m_CoolingCoilName = WaterCoils::WaterCoil(1).Name; - thisSys.CoolCoilFluidInletNode = WaterCoils::WaterCoil(1).WaterInletNodeNum; - thisSys.CoolCoilFluidOutletNodeNum = WaterCoils::WaterCoil(1).WaterOutletNodeNum; + thisSys.m_CoolingCoilName = state.dataWaterCoils->WaterCoil(1).Name; + thisSys.CoolCoilFluidInletNode = state.dataWaterCoils->WaterCoil(1).WaterInletNodeNum; + thisSys.CoolCoilFluidOutletNodeNum = state.dataWaterCoils->WaterCoil(1).WaterOutletNodeNum; - WaterCoils::MyUAAndFlowCalcFlag.allocate(1); - WaterCoils::MyUAAndFlowCalcFlag(1) = true; + state.dataWaterCoils->MyUAAndFlowCalcFlag.allocate(1); + state.dataWaterCoils->MyUAAndFlowCalcFlag(1) = true; DataGlobals::DoingSizing = true; - WaterCoils::WaterCoil(1).TotWaterCoolingCoilRate = 0.0; + state.dataWaterCoils->WaterCoil(1).TotWaterCoolingCoilRate = 0.0; thisSys.calcUnitaryCoolingSystem(state, AirLoopNum, FirstHVACIteration, thisSys.m_CoolingCycRatio, CompOn, OnOffAirFlowRatio, CoilCoolHeatRat, false); - EXPECT_NEAR(27530.0, WaterCoils::WaterCoil(1).TotWaterCoolingCoilRate, 2.0); + EXPECT_NEAR(27530.0, state.dataWaterCoils->WaterCoil(1).TotWaterCoolingCoilRate, 2.0); } TEST_F(EnergyPlusFixture, UnitarySystemModel_GetInput) @@ -8313,7 +8313,7 @@ TEST_F(EnergyPlusFixture, UnitarySystemModel_ASHRAEModel_WaterCoils) Real64 saveSystemHeatWaterFlowRate = thisSys->MaxHeatCoilFluidFlow; // test that heating coil was operating prior to the next call to simulate EXPECT_GT(DataLoopNode::Node(thisSys->HeatCoilFluidInletNode).MassFlowRate, 0.0); - EXPECT_GT(WaterCoils::WaterCoil(thisSys->m_HeatingCoilIndex).TotWaterHeatingCoilRate, 0.0); + EXPECT_GT(state.dataWaterCoils->WaterCoil(thisSys->m_HeatingCoilIndex).TotWaterHeatingCoilRate, 0.0); EXPECT_LT(DataLoopNode::Node(thisSys->HeatCoilInletNodeNum).Temp, DataLoopNode::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 @@ -8333,7 +8333,7 @@ TEST_F(EnergyPlusFixture, UnitarySystemModel_ASHRAEModel_WaterCoils) // 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, DataLoopNode::Node(thisSys->HeatCoilFluidInletNode).MassFlowRate); // these show coil is off - EXPECT_EQ(0.0, WaterCoils::WaterCoil(thisSys->m_HeatingCoilIndex).TotWaterHeatingCoilRate); + EXPECT_EQ(0.0, state.dataWaterCoils->WaterCoil(thisSys->m_HeatingCoilIndex).TotWaterHeatingCoilRate); EXPECT_EQ(DataLoopNode::Node(thisSys->HeatCoilInletNodeNum).Temp, DataLoopNode::Node(thisSys->HeatCoilOutletNodeNum).Temp); // reset for next unit tests UnitarySystems::unitarySys[0].MaxHeatCoilFluidFlow = saveSystemHeatWaterFlowRate; @@ -8569,7 +8569,7 @@ TEST_F(EnergyPlusFixture, UnitarySystemModel_ASHRAEModel_WaterCoils) Real64 saveSystemCoolWaterFlowRate = thisSys->MaxCoolCoilFluidFlow; // test that cooling coil was operating prior to the next call to simulate EXPECT_GT(DataLoopNode::Node(thisSys->CoolCoilFluidInletNode).MassFlowRate, 0.0); - EXPECT_GT(WaterCoils::WaterCoil(thisSys->m_CoolingCoilIndex).TotWaterCoolingCoilRate, 0.0); + EXPECT_GT(state.dataWaterCoils->WaterCoil(thisSys->m_CoolingCoilIndex).TotWaterCoolingCoilRate, 0.0); EXPECT_GT(DataLoopNode::Node(thisSys->CoolCoilInletNodeNum).Temp, DataLoopNode::Node(thisSys->CoolCoilOutletNodeNum).Temp); thisSys->MaxCoolCoilFluidFlow = 0.0; thisSys->simulate(state, thisSys->Name, @@ -8587,7 +8587,7 @@ TEST_F(EnergyPlusFixture, UnitarySystemModel_ASHRAEModel_WaterCoils) // 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, DataLoopNode::Node(thisSys->CoolCoilFluidInletNode).MassFlowRate); // these show coil is off - EXPECT_EQ(0.0, WaterCoils::WaterCoil(thisSys->m_CoolingCoilIndex).TotWaterCoolingCoilRate); + EXPECT_EQ(0.0, state.dataWaterCoils->WaterCoil(thisSys->m_CoolingCoilIndex).TotWaterCoolingCoilRate); EXPECT_EQ(DataLoopNode::Node(thisSys->CoolCoilInletNodeNum).Temp, DataLoopNode::Node(thisSys->CoolCoilOutletNodeNum).Temp); // reset for next unit tests thisSys->MaxCoolCoilFluidFlow = saveSystemCoolWaterFlowRate; @@ -11939,15 +11939,15 @@ TEST_F(ZoneUnitarySysTest, UnitarySystemModel_FractionOfAutoSizedCoolingValueTes DataSizing::ZoneEqSizing(DataSizing::CurZoneEqNum).DesignSizeFromParent = true; // DataSizing::NumPltSizInput = 2; - DataPlant::PlantLoop(1).LoopSide(1).Branch(1).Comp(1).Name = WaterCoils::WaterCoil(1).Name; + DataPlant::PlantLoop(1).LoopSide(1).Branch(1).Comp(1).Name = state.dataWaterCoils->WaterCoil(1).Name; DataPlant::PlantLoop(1).LoopSide(1).Branch(1).Comp(1).TypeOf_Num = DataPlant::TypeOf_CoilWaterSimpleHeating; - DataPlant::PlantLoop(1).LoopSide(1).Branch(1).Comp(1).NodeNumIn = WaterCoils::WaterCoil(1).WaterInletNodeNum; - DataPlant::PlantLoop(1).LoopSide(1).Branch(1).Comp(1).NodeNumOut = WaterCoils::WaterCoil(1).WaterOutletNodeNum; + DataPlant::PlantLoop(1).LoopSide(1).Branch(1).Comp(1).NodeNumIn = state.dataWaterCoils->WaterCoil(1).WaterInletNodeNum; + DataPlant::PlantLoop(1).LoopSide(1).Branch(1).Comp(1).NodeNumOut = state.dataWaterCoils->WaterCoil(1).WaterOutletNodeNum; - DataPlant::PlantLoop(2).LoopSide(1).Branch(1).Comp(1).Name = WaterCoils::WaterCoil(2).Name; + DataPlant::PlantLoop(2).LoopSide(1).Branch(1).Comp(1).Name = state.dataWaterCoils->WaterCoil(2).Name; DataPlant::PlantLoop(2).LoopSide(1).Branch(1).Comp(1).TypeOf_Num = DataPlant::TypeOf_CoilWaterCooling; - DataPlant::PlantLoop(2).LoopSide(1).Branch(1).Comp(1).NodeNumIn = WaterCoils::WaterCoil(2).WaterInletNodeNum; - DataPlant::PlantLoop(2).LoopSide(1).Branch(1).Comp(1).NodeNumOut = WaterCoils::WaterCoil(2).WaterOutletNodeNum; + DataPlant::PlantLoop(2).LoopSide(1).Branch(1).Comp(1).NodeNumIn = state.dataWaterCoils->WaterCoil(2).WaterInletNodeNum; + DataPlant::PlantLoop(2).LoopSide(1).Branch(1).Comp(1).NodeNumOut = state.dataWaterCoils->WaterCoil(2).WaterOutletNodeNum; // check user specified values before overriding during sizing Real64 userspecifiedFractionOfAutoSizedCoolingFlowRateValue = thisSys->m_MaxNoCoolHeatAirVolFlow; @@ -12081,15 +12081,15 @@ TEST_F(ZoneUnitarySysTest, UnitarySystemModel_FlowPerCoolingCapacityTest) DataSizing::ZoneSizingRunDone = true; DataSizing::ZoneEqSizing(DataSizing::CurZoneEqNum).DesignSizeFromParent = true; - DataPlant::PlantLoop(1).LoopSide(1).Branch(1).Comp(1).Name = WaterCoils::WaterCoil(1).Name; + DataPlant::PlantLoop(1).LoopSide(1).Branch(1).Comp(1).Name = state.dataWaterCoils->WaterCoil(1).Name; DataPlant::PlantLoop(1).LoopSide(1).Branch(1).Comp(1).TypeOf_Num = DataPlant::TypeOf_CoilWaterSimpleHeating; - DataPlant::PlantLoop(1).LoopSide(1).Branch(1).Comp(1).NodeNumIn = WaterCoils::WaterCoil(1).WaterInletNodeNum; - DataPlant::PlantLoop(1).LoopSide(1).Branch(1).Comp(1).NodeNumOut = WaterCoils::WaterCoil(1).WaterOutletNodeNum; + DataPlant::PlantLoop(1).LoopSide(1).Branch(1).Comp(1).NodeNumIn = state.dataWaterCoils->WaterCoil(1).WaterInletNodeNum; + DataPlant::PlantLoop(1).LoopSide(1).Branch(1).Comp(1).NodeNumOut = state.dataWaterCoils->WaterCoil(1).WaterOutletNodeNum; - DataPlant::PlantLoop(2).LoopSide(1).Branch(1).Comp(1).Name = WaterCoils::WaterCoil(2).Name; + DataPlant::PlantLoop(2).LoopSide(1).Branch(1).Comp(1).Name = state.dataWaterCoils->WaterCoil(2).Name; DataPlant::PlantLoop(2).LoopSide(1).Branch(1).Comp(1).TypeOf_Num = DataPlant::TypeOf_CoilWaterCooling; - DataPlant::PlantLoop(2).LoopSide(1).Branch(1).Comp(1).NodeNumIn = WaterCoils::WaterCoil(2).WaterInletNodeNum; - DataPlant::PlantLoop(2).LoopSide(1).Branch(1).Comp(1).NodeNumOut = WaterCoils::WaterCoil(2).WaterOutletNodeNum; + DataPlant::PlantLoop(2).LoopSide(1).Branch(1).Comp(1).NodeNumIn = state.dataWaterCoils->WaterCoil(2).WaterInletNodeNum; + DataPlant::PlantLoop(2).LoopSide(1).Branch(1).Comp(1).NodeNumOut = state.dataWaterCoils->WaterCoil(2).WaterOutletNodeNum; // check user specified values before overriding during sizing Real64 userspecifiedFlowPerCoolingCapacityValue = thisSys->m_MaxNoCoolHeatAirVolFlow; diff --git a/tst/EnergyPlus/unit/WaterCoils.unit.cc b/tst/EnergyPlus/unit/WaterCoils.unit.cc index 501f8ee774e..e8f21f64198 100644 --- a/tst/EnergyPlus/unit/WaterCoils.unit.cc +++ b/tst/EnergyPlus/unit/WaterCoils.unit.cc @@ -111,10 +111,10 @@ class WaterCoilsTest : public EnergyPlusFixture CurZoneEqNum = 0; CurSysNum = 0; CurOASysNum = 0; - NumWaterCoils = 1; - WaterCoil.allocate(NumWaterCoils); - WaterCoilNumericFields.allocate(NumWaterCoils); - WaterCoilNumericFields(NumWaterCoils).FieldNames.allocate(17); // max N fields for water coil + state.dataWaterCoils->NumWaterCoils = 1; + state.dataWaterCoils->WaterCoil.allocate(state.dataWaterCoils->NumWaterCoils); + state.dataWaterCoils->WaterCoilNumericFields.allocate(state.dataWaterCoils->NumWaterCoils); + state.dataWaterCoils->WaterCoilNumericFields(state.dataWaterCoils->NumWaterCoils).FieldNames.allocate(17); // max N fields for water coil TotNumLoops = 1; PlantLoop.allocate(TotNumLoops); PlantSizData.allocate(1); @@ -141,9 +141,9 @@ class WaterCoilsTest : public EnergyPlusFixture { EnergyPlusFixture::TearDown(); // Remember to tear down the base fixture after cleaning up derived fixture! - NumWaterCoils = 0; - WaterCoil.clear(); - WaterCoilNumericFields.clear(); + state.dataWaterCoils->NumWaterCoils = 0; + state.dataWaterCoils->WaterCoil.clear(); + state.dataWaterCoils->WaterCoilNumericFields.clear(); PlantLoop.clear(); PlantSizData.clear(); ZoneEqSizing.clear(); @@ -200,21 +200,21 @@ TEST_F(WaterCoilsTest, WaterCoolingCoilSizing) // set up water coil int CoilNum = 1; - WaterCoil(CoilNum).Name = "Test Water Cooling Coil"; - WaterCoil(CoilNum).WaterLoopNum = 1; - WaterCoil(CoilNum).WaterCoilType = CoilType_Cooling; - WaterCoil(CoilNum).RequestingAutoSize = true; - WaterCoil(CoilNum).DesAirVolFlowRate = AutoSize; - WaterCoil(CoilNum).DesInletAirTemp = AutoSize; - WaterCoil(CoilNum).DesOutletAirTemp = AutoSize; - WaterCoil(CoilNum).DesInletWaterTemp = AutoSize; - WaterCoil(CoilNum).DesInletAirHumRat = AutoSize; - WaterCoil(CoilNum).DesOutletAirHumRat = AutoSize; - WaterCoil(CoilNum).MaxWaterVolFlowRate = AutoSize; - - WaterCoilNumericFields(CoilNum).FieldNames(3) = "Maximum Flow Rate"; - WaterCoil(CoilNum).WaterInletNodeNum = 1; - PlantLoop(1).LoopSide(1).Branch(1).Comp(1).NodeNumIn = WaterCoil(CoilNum).WaterInletNodeNum; + state.dataWaterCoils->WaterCoil(CoilNum).Name = "Test Water Cooling Coil"; + state.dataWaterCoils->WaterCoil(CoilNum).WaterLoopNum = 1; + state.dataWaterCoils->WaterCoil(CoilNum).WaterCoilType = state.dataWaterCoils->CoilType_Cooling; + state.dataWaterCoils->WaterCoil(CoilNum).RequestingAutoSize = true; + state.dataWaterCoils->WaterCoil(CoilNum).DesAirVolFlowRate = AutoSize; + state.dataWaterCoils->WaterCoil(CoilNum).DesInletAirTemp = AutoSize; + state.dataWaterCoils->WaterCoil(CoilNum).DesOutletAirTemp = AutoSize; + state.dataWaterCoils->WaterCoil(CoilNum).DesInletWaterTemp = AutoSize; + state.dataWaterCoils->WaterCoil(CoilNum).DesInletAirHumRat = AutoSize; + state.dataWaterCoils->WaterCoil(CoilNum).DesOutletAirHumRat = AutoSize; + state.dataWaterCoils->WaterCoil(CoilNum).MaxWaterVolFlowRate = AutoSize; + + state.dataWaterCoils->WaterCoilNumericFields(CoilNum).FieldNames(3) = "Maximum Flow Rate"; + state.dataWaterCoils->WaterCoil(CoilNum).WaterInletNodeNum = 1; + PlantLoop(1).LoopSide(1).Branch(1).Comp(1).NodeNumIn = state.dataWaterCoils->WaterCoil(CoilNum).WaterInletNodeNum; CurZoneEqNum = 0; CurSysNum = 1; @@ -229,7 +229,7 @@ TEST_F(WaterCoilsTest, WaterCoolingCoilSizing) createCoilSelectionReportObj(); SizeWaterCoil(state, CoilNum); - EXPECT_DOUBLE_EQ(0.00159, WaterCoil(CoilNum).DesAirVolFlowRate); + EXPECT_DOUBLE_EQ(0.00159, state.dataWaterCoils->WaterCoil(CoilNum).DesAirVolFlowRate); // Check that all Data* variables have been reset EXPECT_EQ(0, DataPltSizCoolNum); EXPECT_EQ(0, DataWaterLoopNum); @@ -249,18 +249,18 @@ TEST_F(WaterCoilsTest, WaterCoolingCoilSizing) FinalSysSizing(1).DesMainVolFlow = 0.00259; FinalSysSizing(1).MassFlowAtCoolPeak = FinalSysSizing(1).DesMainVolFlow * StdRhoAir; - WaterCoil(CoilNum).Name = "Test Water Cooling Coil 2"; - WaterCoil(CoilNum).DesAirVolFlowRate = AutoSize; - WaterCoil(CoilNum).DesInletAirTemp = AutoSize; - WaterCoil(CoilNum).DesOutletAirTemp = AutoSize; - WaterCoil(CoilNum).DesInletWaterTemp = AutoSize; - WaterCoil(CoilNum).DesInletAirHumRat = AutoSize; - WaterCoil(CoilNum).DesOutletAirHumRat = AutoSize; - WaterCoil(CoilNum).MaxWaterVolFlowRate = AutoSize; + state.dataWaterCoils->WaterCoil(CoilNum).Name = "Test Water Cooling Coil 2"; + state.dataWaterCoils->WaterCoil(CoilNum).DesAirVolFlowRate = AutoSize; + state.dataWaterCoils->WaterCoil(CoilNum).DesInletAirTemp = AutoSize; + state.dataWaterCoils->WaterCoil(CoilNum).DesOutletAirTemp = AutoSize; + state.dataWaterCoils->WaterCoil(CoilNum).DesInletWaterTemp = AutoSize; + state.dataWaterCoils->WaterCoil(CoilNum).DesInletAirHumRat = AutoSize; + state.dataWaterCoils->WaterCoil(CoilNum).DesOutletAirHumRat = AutoSize; + state.dataWaterCoils->WaterCoil(CoilNum).MaxWaterVolFlowRate = AutoSize; SizeWaterCoil(state, CoilNum); - EXPECT_DOUBLE_EQ(0.00259, WaterCoil(CoilNum).DesAirVolFlowRate); + EXPECT_DOUBLE_EQ(0.00259, state.dataWaterCoils->WaterCoil(CoilNum).DesAirVolFlowRate); EXPECT_EQ(0, DataPltSizCoolNum); EXPECT_EQ(0, DataWaterLoopNum); EXPECT_DOUBLE_EQ(0.0, DataConstantUsedForSizing); @@ -283,19 +283,19 @@ TEST_F(WaterCoilsTest, WaterCoolingCoilSizing) FinalSysSizing(1).MassFlowAtCoolPeak = FinalSysSizing(1).DesMainVolFlow * StdRhoAir; AirLoopControlInfo(1).UnitarySys = true; - WaterCoil(CoilNum).Name = "Test Water Heating Coil"; - WaterCoil(CoilNum).WaterCoilType = CoilType_Heating; - WaterCoil(CoilNum).DesAirVolFlowRate = AutoSize; - WaterCoil(CoilNum).DesInletAirTemp = AutoSize; - WaterCoil(CoilNum).DesOutletAirTemp = AutoSize; - WaterCoil(CoilNum).DesInletWaterTemp = AutoSize; - WaterCoil(CoilNum).DesInletAirHumRat = AutoSize; - WaterCoil(CoilNum).DesOutletAirHumRat = AutoSize; - WaterCoil(CoilNum).MaxWaterVolFlowRate = AutoSize; + state.dataWaterCoils->WaterCoil(CoilNum).Name = "Test Water Heating Coil"; + state.dataWaterCoils->WaterCoil(CoilNum).WaterCoilType = state.dataWaterCoils->CoilType_Heating; + state.dataWaterCoils->WaterCoil(CoilNum).DesAirVolFlowRate = AutoSize; + state.dataWaterCoils->WaterCoil(CoilNum).DesInletAirTemp = AutoSize; + state.dataWaterCoils->WaterCoil(CoilNum).DesOutletAirTemp = AutoSize; + state.dataWaterCoils->WaterCoil(CoilNum).DesInletWaterTemp = AutoSize; + state.dataWaterCoils->WaterCoil(CoilNum).DesInletAirHumRat = AutoSize; + state.dataWaterCoils->WaterCoil(CoilNum).DesOutletAirHumRat = AutoSize; + state.dataWaterCoils->WaterCoil(CoilNum).MaxWaterVolFlowRate = AutoSize; SizeWaterCoil(state, CoilNum); - EXPECT_DOUBLE_EQ(0.00359, WaterCoil(CoilNum).DesAirVolFlowRate); + EXPECT_DOUBLE_EQ(0.00359, state.dataWaterCoils->WaterCoil(CoilNum).DesAirVolFlowRate); EXPECT_EQ(0, DataPltSizCoolNum); EXPECT_EQ(0, DataWaterLoopNum); EXPECT_DOUBLE_EQ(0.0, DataConstantUsedForSizing); @@ -314,19 +314,19 @@ TEST_F(WaterCoilsTest, WaterCoolingCoilSizing) FinalSysSizing(1).DesMainVolFlow = 0.00459; FinalSysSizing(1).MassFlowAtCoolPeak = FinalSysSizing(1).DesMainVolFlow * StdRhoAir; - WaterCoil(CoilNum).Name = "Test Water Heating Coil 2"; - WaterCoil(CoilNum).WaterCoilType = CoilType_Heating; - WaterCoil(CoilNum).DesAirVolFlowRate = AutoSize; - WaterCoil(CoilNum).DesInletAirTemp = AutoSize; - WaterCoil(CoilNum).DesOutletAirTemp = AutoSize; - WaterCoil(CoilNum).DesInletWaterTemp = AutoSize; - WaterCoil(CoilNum).DesInletAirHumRat = AutoSize; - WaterCoil(CoilNum).DesOutletAirHumRat = AutoSize; - WaterCoil(CoilNum).MaxWaterVolFlowRate = AutoSize; + state.dataWaterCoils->WaterCoil(CoilNum).Name = "Test Water Heating Coil 2"; + state.dataWaterCoils->WaterCoil(CoilNum).WaterCoilType = state.dataWaterCoils->CoilType_Heating; + state.dataWaterCoils->WaterCoil(CoilNum).DesAirVolFlowRate = AutoSize; + state.dataWaterCoils->WaterCoil(CoilNum).DesInletAirTemp = AutoSize; + state.dataWaterCoils->WaterCoil(CoilNum).DesOutletAirTemp = AutoSize; + state.dataWaterCoils->WaterCoil(CoilNum).DesInletWaterTemp = AutoSize; + state.dataWaterCoils->WaterCoil(CoilNum).DesInletAirHumRat = AutoSize; + state.dataWaterCoils->WaterCoil(CoilNum).DesOutletAirHumRat = AutoSize; + state.dataWaterCoils->WaterCoil(CoilNum).MaxWaterVolFlowRate = AutoSize; SizeWaterCoil(state, CoilNum); - EXPECT_DOUBLE_EQ(0.00459, WaterCoil(CoilNum).DesAirVolFlowRate); + EXPECT_DOUBLE_EQ(0.00459, state.dataWaterCoils->WaterCoil(CoilNum).DesAirVolFlowRate); EXPECT_EQ(0, DataPltSizCoolNum); EXPECT_EQ(0, DataWaterLoopNum); EXPECT_DOUBLE_EQ(0.0, DataConstantUsedForSizing); @@ -360,26 +360,26 @@ TEST_F(WaterCoilsTest, WaterCoolingCoilSizing) ZoneEqSizing(1).HeatingAirFlow = true; ZoneEqSizing(1).HeatingAirVolFlow = 0.1; FinalZoneSizing(1).DesHeatMassFlow = StdRhoAir * ZoneEqSizing(1).HeatingAirVolFlow; - MySizeFlag.allocate(1); - MySizeFlag(CoilNum) = true; - MyUAAndFlowCalcFlag.allocate(1); - MyUAAndFlowCalcFlag(CoilNum) = true; - - WaterCoil(CoilNum).UACoil = AutoSize; - WaterCoil(CoilNum).DesTotWaterCoilLoad = AutoSize; - WaterCoil(CoilNum).DesAirVolFlowRate = AutoSize; - WaterCoil(CoilNum).DesInletAirTemp = AutoSize; - WaterCoil(CoilNum).DesOutletAirTemp = AutoSize; - WaterCoil(CoilNum).DesInletWaterTemp = AutoSize; - WaterCoil(CoilNum).DesInletAirHumRat = AutoSize; - WaterCoil(CoilNum).DesOutletAirHumRat = AutoSize; - WaterCoil(CoilNum).MaxWaterVolFlowRate = AutoSize; + state.dataWaterCoils->MySizeFlag.allocate(1); + state.dataWaterCoils->MySizeFlag(CoilNum) = true; + state.dataWaterCoils->MyUAAndFlowCalcFlag.allocate(1); + state.dataWaterCoils->MyUAAndFlowCalcFlag(CoilNum) = true; + + state.dataWaterCoils->WaterCoil(CoilNum).UACoil = AutoSize; + state.dataWaterCoils->WaterCoil(CoilNum).DesTotWaterCoilLoad = AutoSize; + state.dataWaterCoils->WaterCoil(CoilNum).DesAirVolFlowRate = AutoSize; + state.dataWaterCoils->WaterCoil(CoilNum).DesInletAirTemp = AutoSize; + state.dataWaterCoils->WaterCoil(CoilNum).DesOutletAirTemp = AutoSize; + state.dataWaterCoils->WaterCoil(CoilNum).DesInletWaterTemp = AutoSize; + state.dataWaterCoils->WaterCoil(CoilNum).DesInletAirHumRat = AutoSize; + state.dataWaterCoils->WaterCoil(CoilNum).DesOutletAirHumRat = AutoSize; + state.dataWaterCoils->WaterCoil(CoilNum).MaxWaterVolFlowRate = AutoSize; SizeWaterCoil(state, CoilNum); - EXPECT_NEAR(WaterCoil(CoilNum).InletAirTemp, 16.0, 0.0001); // a mixture of zone air (20 C) and 10% OA (-20 C) = 16 C - EXPECT_NEAR(WaterCoil(CoilNum).DesTotWaterCoilLoad, 1709.8638, 0.0001); - EXPECT_NEAR(WaterCoil(CoilNum).UACoil, 51.2456, 0.0001); - EXPECT_NEAR(WaterCoil(CoilNum).OutletAirTemp, 30.1302, 0.0001); // reasonable delta T above inlet air temp + EXPECT_NEAR(state.dataWaterCoils->WaterCoil(CoilNum).InletAirTemp, 16.0, 0.0001); // a mixture of zone air (20 C) and 10% OA (-20 C) = 16 C + EXPECT_NEAR(state.dataWaterCoils->WaterCoil(CoilNum).DesTotWaterCoilLoad, 1709.8638, 0.0001); + EXPECT_NEAR(state.dataWaterCoils->WaterCoil(CoilNum).UACoil, 51.2456, 0.0001); + EXPECT_NEAR(state.dataWaterCoils->WaterCoil(CoilNum).OutletAirTemp, 30.1302, 0.0001); // reasonable delta T above inlet air temp } TEST_F(WaterCoilsTest, TdbFnHRhPbTest) @@ -434,27 +434,27 @@ TEST_F(WaterCoilsTest, CoilHeatingWaterUASizing) // set up water coil int CoilNum = 1; - WaterCoil(CoilNum).Name = "Water Heating Coil"; - WaterCoil(CoilNum).WaterLoopNum = 1; - WaterCoil(CoilNum).WaterCoilType = CoilType_Heating; - WaterCoil(CoilNum).WaterCoilType_Num = WaterCoil_SimpleHeating; // Coil:Heating:Water - WaterCoil(CoilNum).WaterCoilModel = CoilType_Heating; - WaterCoil(CoilNum).SchedPtr = DataGlobals::ScheduleAlwaysOn; - - WaterCoil(CoilNum).RequestingAutoSize = true; - WaterCoil(CoilNum).DesAirVolFlowRate = AutoSize; - WaterCoil(CoilNum).UACoil = AutoSize; - WaterCoil(CoilNum).MaxWaterVolFlowRate = AutoSize; - WaterCoil(CoilNum).CoilPerfInpMeth = UAandFlow; - WaterCoil(CoilNum).DesInletAirTemp = AutoSize; - WaterCoil(CoilNum).DesOutletAirTemp = AutoSize; - WaterCoil(CoilNum).DesInletWaterTemp = AutoSize; - WaterCoil(CoilNum).DesInletAirHumRat = AutoSize; - WaterCoil(CoilNum).DesOutletAirHumRat = AutoSize; - - WaterCoilNumericFields(CoilNum).FieldNames(2) = "Maximum Water Flow Rate"; - WaterCoil(CoilNum).WaterInletNodeNum = 1; - PlantLoop(1).LoopSide(1).Branch(1).Comp(1).NodeNumIn = WaterCoil(CoilNum).WaterInletNodeNum; + state.dataWaterCoils->WaterCoil(CoilNum).Name = "Water Heating Coil"; + state.dataWaterCoils->WaterCoil(CoilNum).WaterLoopNum = 1; + state.dataWaterCoils->WaterCoil(CoilNum).WaterCoilType = state.dataWaterCoils->CoilType_Heating; + state.dataWaterCoils->WaterCoil(CoilNum).WaterCoilType_Num = state.dataWaterCoils->WaterCoil_SimpleHeating; // Coil:Heating:Water + state.dataWaterCoils->WaterCoil(CoilNum).WaterCoilModel = state.dataWaterCoils->CoilType_Heating; + state.dataWaterCoils->WaterCoil(CoilNum).SchedPtr = DataGlobals::ScheduleAlwaysOn; + + state.dataWaterCoils->WaterCoil(CoilNum).RequestingAutoSize = true; + state.dataWaterCoils->WaterCoil(CoilNum).DesAirVolFlowRate = AutoSize; + state.dataWaterCoils->WaterCoil(CoilNum).UACoil = AutoSize; + state.dataWaterCoils->WaterCoil(CoilNum).MaxWaterVolFlowRate = AutoSize; + state.dataWaterCoils->WaterCoil(CoilNum).CoilPerfInpMeth = state.dataWaterCoils->UAandFlow; + state.dataWaterCoils->WaterCoil(CoilNum).DesInletAirTemp = AutoSize; + state.dataWaterCoils->WaterCoil(CoilNum).DesOutletAirTemp = AutoSize; + state.dataWaterCoils->WaterCoil(CoilNum).DesInletWaterTemp = AutoSize; + state.dataWaterCoils->WaterCoil(CoilNum).DesInletAirHumRat = AutoSize; + state.dataWaterCoils->WaterCoil(CoilNum).DesOutletAirHumRat = AutoSize; + + state.dataWaterCoils->WaterCoilNumericFields(CoilNum).FieldNames(2) = "Maximum Water Flow Rate"; + state.dataWaterCoils->WaterCoil(CoilNum).WaterInletNodeNum = 1; + PlantLoop(1).LoopSide(1).Branch(1).Comp(1).NodeNumIn = state.dataWaterCoils->WaterCoil(CoilNum).WaterInletNodeNum; CurZoneEqNum = 0; CurSysNum = 1; @@ -462,27 +462,27 @@ TEST_F(WaterCoilsTest, CoilHeatingWaterUASizing) DataWaterLoopNum = 1; NumOfGlycols = 1; - MyUAAndFlowCalcFlag.allocate(1); - MyUAAndFlowCalcFlag(1) = true; + state.dataWaterCoils->MyUAAndFlowCalcFlag.allocate(1); + state.dataWaterCoils->MyUAAndFlowCalcFlag(1) = true; - MySizeFlag.allocate(1); - MySizeFlag(1) = true; + state.dataWaterCoils->MySizeFlag.allocate(1); + state.dataWaterCoils->MySizeFlag(1) = true; // run water coil sizing createCoilSelectionReportObj(); SizeWaterCoil(state, CoilNum); - EXPECT_DOUBLE_EQ(1.0, WaterCoil(CoilNum).DesAirVolFlowRate); + EXPECT_DOUBLE_EQ(1.0, state.dataWaterCoils->WaterCoil(CoilNum).DesAirVolFlowRate); Real64 CpAirStd = 0.0; Real64 DesMassFlow = 0.0; Real64 DesCoilHeatingLoad = 0.0; CpAirStd = PsyCpAirFnW(0.0); - DesMassFlow = WaterCoil(CoilNum).DesAirVolFlowRate * StdRhoAir; + DesMassFlow = state.dataWaterCoils->WaterCoil(CoilNum).DesAirVolFlowRate * StdRhoAir; DesCoilHeatingLoad = CpAirStd * DesMassFlow * (40.0 - 5.0); // check heating coil design load - EXPECT_DOUBLE_EQ(DesCoilHeatingLoad, WaterCoil(CoilNum).DesWaterHeatingCoilRate); + EXPECT_DOUBLE_EQ(DesCoilHeatingLoad, state.dataWaterCoils->WaterCoil(CoilNum).DesWaterHeatingCoilRate); Real64 Cp = 0; Real64 rho = 0; @@ -490,13 +490,13 @@ TEST_F(WaterCoilsTest, CoilHeatingWaterUASizing) Cp = GetSpecificHeatGlycol(PlantLoop(1).FluidName, DataGlobals::HWInitConvTemp, PlantLoop(1).FluidIndex, "Unit Test"); rho = GetDensityGlycol(PlantLoop(1).FluidName, DataGlobals::HWInitConvTemp, PlantLoop(1).FluidIndex, "Unit Test"); - DesWaterFlowRate = WaterCoil(CoilNum).DesWaterHeatingCoilRate / (10.0 * Cp * rho); + DesWaterFlowRate = state.dataWaterCoils->WaterCoil(CoilNum).DesWaterHeatingCoilRate / (10.0 * Cp * rho); // check heating coil design water flow rate - EXPECT_DOUBLE_EQ(DesWaterFlowRate, WaterCoil(CoilNum).MaxWaterVolFlowRate); + EXPECT_DOUBLE_EQ(DesWaterFlowRate, state.dataWaterCoils->WaterCoil(CoilNum).MaxWaterVolFlowRate); // check coil UA-value sizing - EXPECT_NEAR(1435.01, WaterCoil(CoilNum).UACoil, 0.01); + EXPECT_NEAR(1435.01, state.dataWaterCoils->WaterCoil(CoilNum).UACoil, 0.01); // test single zone VAV reheat coil sizing CurZoneEqNum = 1; @@ -504,20 +504,20 @@ TEST_F(WaterCoilsTest, CoilHeatingWaterUASizing) CurSysNum = 0; TermUnitSizing.allocate(1); TermUnitFinalZoneSizing.allocate(1); - TermUnitSizing(CurTermUnitSizingNum).AirVolFlow = WaterCoil(CoilNum).DesAirVolFlowRate / 3.0; // DesAirVolFlowRate = 1.0 - TermUnitSizing(CurTermUnitSizingNum).MaxHWVolFlow = WaterCoil(CoilNum).MaxWaterVolFlowRate / 3.0; + TermUnitSizing(CurTermUnitSizingNum).AirVolFlow = state.dataWaterCoils->WaterCoil(CoilNum).DesAirVolFlowRate / 3.0; // DesAirVolFlowRate = 1.0 + TermUnitSizing(CurTermUnitSizingNum).MaxHWVolFlow = state.dataWaterCoils->WaterCoil(CoilNum).MaxWaterVolFlowRate / 3.0; TermUnitSizing(CurTermUnitSizingNum).MinFlowFrac = 0.5; DataSizing::TermUnitSingDuct = true; - WaterCoil(CoilNum).DesAirVolFlowRate = AutoSize; - WaterCoil(CoilNum).UACoil = AutoSize; - WaterCoil(CoilNum).MaxWaterVolFlowRate = AutoSize; - WaterCoil(CoilNum).CoilPerfInpMeth = UAandFlow; - WaterCoil(CoilNum).DesInletAirTemp = AutoSize; - WaterCoil(CoilNum).DesOutletAirTemp = AutoSize; - WaterCoil(CoilNum).DesInletWaterTemp = AutoSize; - WaterCoil(CoilNum).DesInletAirHumRat = AutoSize; - WaterCoil(CoilNum).DesOutletAirHumRat = AutoSize; + state.dataWaterCoils->WaterCoil(CoilNum).DesAirVolFlowRate = AutoSize; + state.dataWaterCoils->WaterCoil(CoilNum).UACoil = AutoSize; + state.dataWaterCoils->WaterCoil(CoilNum).MaxWaterVolFlowRate = AutoSize; + state.dataWaterCoils->WaterCoil(CoilNum).CoilPerfInpMeth = state.dataWaterCoils->UAandFlow; + state.dataWaterCoils->WaterCoil(CoilNum).DesInletAirTemp = AutoSize; + state.dataWaterCoils->WaterCoil(CoilNum).DesOutletAirTemp = AutoSize; + state.dataWaterCoils->WaterCoil(CoilNum).DesInletWaterTemp = AutoSize; + state.dataWaterCoils->WaterCoil(CoilNum).DesInletAirHumRat = AutoSize; + state.dataWaterCoils->WaterCoil(CoilNum).DesOutletAirHumRat = AutoSize; SysSizingRunDone = false; ZoneSizingRunDone = true; @@ -538,12 +538,12 @@ TEST_F(WaterCoilsTest, CoilHeatingWaterUASizing) FinalZoneSizing(CurZoneEqNum).ZoneHumRatAtHeatPeak = 0.008; TermUnitFinalZoneSizing(CurTermUnitSizingNum) = FinalZoneSizing(CurZoneEqNum); - MySizeFlag(1) = true; + state.dataWaterCoils->MySizeFlag(1) = true; // run water coil sizing SizeWaterCoil(state, CoilNum); // check coil UA-value sizing - EXPECT_NEAR(577.686, WaterCoil(CoilNum).UACoil, 0.01); // smaller UA than result above at 1435.00 + EXPECT_NEAR(577.686, state.dataWaterCoils->WaterCoil(CoilNum).UACoil, 0.01); // smaller UA than result above at 1435.00 } TEST_F(WaterCoilsTest, CoilHeatingWaterLowAirFlowUASizing) @@ -586,27 +586,27 @@ TEST_F(WaterCoilsTest, CoilHeatingWaterLowAirFlowUASizing) // set up water coil int CoilNum = 1; - WaterCoil(CoilNum).Name = "Water Heating Coil"; - WaterCoil(CoilNum).WaterLoopNum = 1; - WaterCoil(CoilNum).WaterCoilType = CoilType_Heating; - WaterCoil(CoilNum).WaterCoilType_Num = WaterCoil_SimpleHeating; // Coil:Heating:Water - WaterCoil(CoilNum).WaterCoilModel = CoilType_Heating; - WaterCoil(CoilNum).SchedPtr = DataGlobals::ScheduleAlwaysOn; - - WaterCoil(CoilNum).RequestingAutoSize = true; - WaterCoil(CoilNum).DesAirVolFlowRate = AutoSize; - WaterCoil(CoilNum).UACoil = AutoSize; - WaterCoil(CoilNum).MaxWaterVolFlowRate = AutoSize; - WaterCoil(CoilNum).CoilPerfInpMeth = UAandFlow; - WaterCoil(CoilNum).DesInletAirTemp = AutoSize; - WaterCoil(CoilNum).DesOutletAirTemp = AutoSize; - WaterCoil(CoilNum).DesInletWaterTemp = AutoSize; - WaterCoil(CoilNum).DesInletAirHumRat = AutoSize; - WaterCoil(CoilNum).DesOutletAirHumRat = AutoSize; - - WaterCoilNumericFields(CoilNum).FieldNames(2) = "Maximum Water Flow Rate"; - WaterCoil(CoilNum).WaterInletNodeNum = 1; - PlantLoop(1).LoopSide(1).Branch(1).Comp(1).NodeNumIn = WaterCoil(CoilNum).WaterInletNodeNum; + state.dataWaterCoils->WaterCoil(CoilNum).Name = "Water Heating Coil"; + state.dataWaterCoils->WaterCoil(CoilNum).WaterLoopNum = 1; + state.dataWaterCoils->WaterCoil(CoilNum).WaterCoilType = state.dataWaterCoils->CoilType_Heating; + state.dataWaterCoils->WaterCoil(CoilNum).WaterCoilType_Num = state.dataWaterCoils->WaterCoil_SimpleHeating; // Coil:Heating:Water + state.dataWaterCoils->WaterCoil(CoilNum).WaterCoilModel = state.dataWaterCoils->CoilType_Heating; + state.dataWaterCoils->WaterCoil(CoilNum).SchedPtr = DataGlobals::ScheduleAlwaysOn; + + state.dataWaterCoils->WaterCoil(CoilNum).RequestingAutoSize = true; + state.dataWaterCoils->WaterCoil(CoilNum).DesAirVolFlowRate = AutoSize; + state.dataWaterCoils->WaterCoil(CoilNum).UACoil = AutoSize; + state.dataWaterCoils->WaterCoil(CoilNum).MaxWaterVolFlowRate = AutoSize; + state.dataWaterCoils->WaterCoil(CoilNum).CoilPerfInpMeth = state.dataWaterCoils->UAandFlow; + state.dataWaterCoils->WaterCoil(CoilNum).DesInletAirTemp = AutoSize; + state.dataWaterCoils->WaterCoil(CoilNum).DesOutletAirTemp = AutoSize; + state.dataWaterCoils->WaterCoil(CoilNum).DesInletWaterTemp = AutoSize; + state.dataWaterCoils->WaterCoil(CoilNum).DesInletAirHumRat = AutoSize; + state.dataWaterCoils->WaterCoil(CoilNum).DesOutletAirHumRat = AutoSize; + + state.dataWaterCoils->WaterCoilNumericFields(CoilNum).FieldNames(2) = "Maximum Water Flow Rate"; + state.dataWaterCoils->WaterCoil(CoilNum).WaterInletNodeNum = 1; + PlantLoop(1).LoopSide(1).Branch(1).Comp(1).NodeNumIn = state.dataWaterCoils->WaterCoil(CoilNum).WaterInletNodeNum; CurZoneEqNum = 0; CurSysNum = 1; @@ -614,27 +614,27 @@ TEST_F(WaterCoilsTest, CoilHeatingWaterLowAirFlowUASizing) DataWaterLoopNum = 1; NumOfGlycols = 1; - MyUAAndFlowCalcFlag.allocate(1); - MyUAAndFlowCalcFlag(1) = true; + state.dataWaterCoils->MyUAAndFlowCalcFlag.allocate(1); + state.dataWaterCoils->MyUAAndFlowCalcFlag(1) = true; - MySizeFlag.allocate(1); - MySizeFlag(1) = true; + state.dataWaterCoils->MySizeFlag.allocate(1); + state.dataWaterCoils->MySizeFlag(1) = true; // run water coil sizing createCoilSelectionReportObj(); SizeWaterCoil(state, CoilNum); - EXPECT_DOUBLE_EQ(1.0, WaterCoil(CoilNum).DesAirVolFlowRate); + EXPECT_DOUBLE_EQ(1.0, state.dataWaterCoils->WaterCoil(CoilNum).DesAirVolFlowRate); Real64 CpAirStd = 0.0; Real64 DesMassFlow = 0.0; Real64 DesCoilHeatingLoad = 0.0; CpAirStd = PsyCpAirFnW(0.0); - DesMassFlow = WaterCoil(CoilNum).DesAirVolFlowRate * StdRhoAir; + DesMassFlow = state.dataWaterCoils->WaterCoil(CoilNum).DesAirVolFlowRate * StdRhoAir; DesCoilHeatingLoad = CpAirStd * DesMassFlow * (40.0 - 5.0); // check heating coil design load - EXPECT_DOUBLE_EQ(DesCoilHeatingLoad, WaterCoil(CoilNum).DesWaterHeatingCoilRate); + EXPECT_DOUBLE_EQ(DesCoilHeatingLoad, state.dataWaterCoils->WaterCoil(CoilNum).DesWaterHeatingCoilRate); Real64 Cp = 0; Real64 rho = 0; @@ -642,13 +642,13 @@ TEST_F(WaterCoilsTest, CoilHeatingWaterLowAirFlowUASizing) Cp = GetSpecificHeatGlycol(PlantLoop(1).FluidName, DataGlobals::HWInitConvTemp, PlantLoop(1).FluidIndex, "Unit Test"); rho = GetDensityGlycol(PlantLoop(1).FluidName, DataGlobals::HWInitConvTemp, PlantLoop(1).FluidIndex, "Unit Test"); - DesWaterFlowRate = WaterCoil(CoilNum).DesWaterHeatingCoilRate / (10.0 * Cp * rho); + DesWaterFlowRate = state.dataWaterCoils->WaterCoil(CoilNum).DesWaterHeatingCoilRate / (10.0 * Cp * rho); // check heating coil design water flow rate - EXPECT_DOUBLE_EQ(DesWaterFlowRate, WaterCoil(CoilNum).MaxWaterVolFlowRate); + EXPECT_DOUBLE_EQ(DesWaterFlowRate, state.dataWaterCoils->WaterCoil(CoilNum).MaxWaterVolFlowRate); // check coil UA-value sizing - EXPECT_NEAR(1435.01, WaterCoil(CoilNum).UACoil, 0.01); + EXPECT_NEAR(1435.01, state.dataWaterCoils->WaterCoil(CoilNum).UACoil, 0.01); // test single zone VAV reheat coil sizing CurZoneEqNum = 1; @@ -657,20 +657,20 @@ TEST_F(WaterCoilsTest, CoilHeatingWaterLowAirFlowUASizing) TermUnitSizing.allocate(1); TermUnitFinalZoneSizing.allocate(1); TermUnitSizing(CurTermUnitSizingNum).AirVolFlow = - WaterCoil(CoilNum).DesAirVolFlowRate / 1500.0; // DesAirVolFlowRate = 1.0 so TU air flow = 0.00067 (lower than 0.001) - TermUnitSizing(CurTermUnitSizingNum).MaxHWVolFlow = WaterCoil(CoilNum).MaxWaterVolFlowRate / 1500.0; + state.dataWaterCoils->WaterCoil(CoilNum).DesAirVolFlowRate / 1500.0; // DesAirVolFlowRate = 1.0 so TU air flow = 0.00067 (lower than 0.001) + TermUnitSizing(CurTermUnitSizingNum).MaxHWVolFlow = state.dataWaterCoils->WaterCoil(CoilNum).MaxWaterVolFlowRate / 1500.0; TermUnitSizing(CurTermUnitSizingNum).MinFlowFrac = 0.5; DataSizing::TermUnitSingDuct = true; - WaterCoil(CoilNum).DesAirVolFlowRate = AutoSize; - WaterCoil(CoilNum).UACoil = AutoSize; - WaterCoil(CoilNum).MaxWaterVolFlowRate = AutoSize; - WaterCoil(CoilNum).CoilPerfInpMeth = UAandFlow; - WaterCoil(CoilNum).DesInletAirTemp = AutoSize; - WaterCoil(CoilNum).DesOutletAirTemp = AutoSize; - WaterCoil(CoilNum).DesInletWaterTemp = AutoSize; - WaterCoil(CoilNum).DesInletAirHumRat = AutoSize; - WaterCoil(CoilNum).DesOutletAirHumRat = AutoSize; + state.dataWaterCoils->WaterCoil(CoilNum).DesAirVolFlowRate = AutoSize; + state.dataWaterCoils->WaterCoil(CoilNum).UACoil = AutoSize; + state.dataWaterCoils->WaterCoil(CoilNum).MaxWaterVolFlowRate = AutoSize; + state.dataWaterCoils->WaterCoil(CoilNum).CoilPerfInpMeth = state.dataWaterCoils->UAandFlow; + state.dataWaterCoils->WaterCoil(CoilNum).DesInletAirTemp = AutoSize; + state.dataWaterCoils->WaterCoil(CoilNum).DesOutletAirTemp = AutoSize; + state.dataWaterCoils->WaterCoil(CoilNum).DesInletWaterTemp = AutoSize; + state.dataWaterCoils->WaterCoil(CoilNum).DesInletAirHumRat = AutoSize; + state.dataWaterCoils->WaterCoil(CoilNum).DesOutletAirHumRat = AutoSize; SysSizingRunDone = false; ZoneSizingRunDone = true; @@ -691,15 +691,15 @@ TEST_F(WaterCoilsTest, CoilHeatingWaterLowAirFlowUASizing) FinalZoneSizing(CurZoneEqNum).ZoneHumRatAtHeatPeak = 0.008; TermUnitFinalZoneSizing(CurTermUnitSizingNum) = FinalZoneSizing(CurZoneEqNum); - MySizeFlag(1) = true; + state.dataWaterCoils->MySizeFlag(1) = true; // run water coil sizing SizeWaterCoil(state, CoilNum); // water flow rate should be non-zero, and air flow rate being so small will get set to 0 during sizing - EXPECT_GT(WaterCoil(CoilNum).InletWaterMassFlowRate, 0.0); - EXPECT_EQ(0.0, WaterCoil(CoilNum).InletAirMassFlowRate); + EXPECT_GT(state.dataWaterCoils->WaterCoil(CoilNum).InletWaterMassFlowRate, 0.0); + EXPECT_EQ(0.0, state.dataWaterCoils->WaterCoil(CoilNum).InletAirMassFlowRate); // check coil UA-value sizing - EXPECT_NEAR(1.0, WaterCoil(CoilNum).UACoil, 0.0001); // TU air flow is too low to size, set to 0, so UA is set to 1.0 + EXPECT_NEAR(1.0, state.dataWaterCoils->WaterCoil(CoilNum).UACoil, 0.0001); // TU air flow is too low to size, set to 0, so UA is set to 1.0 } TEST_F(WaterCoilsTest, CoilHeatingWaterUASizingLowHwaterInletTemp) @@ -742,27 +742,27 @@ TEST_F(WaterCoilsTest, CoilHeatingWaterUASizingLowHwaterInletTemp) // set up water coil int CoilNum = 1; - WaterCoil(CoilNum).Name = "Water Heating Coil"; - WaterCoil(CoilNum).WaterLoopNum = 1; - WaterCoil(CoilNum).WaterCoilType = CoilType_Heating; - WaterCoil(CoilNum).WaterCoilType_Num = WaterCoil_SimpleHeating; // Coil:Heating:Water - WaterCoil(CoilNum).WaterCoilModel = CoilType_Heating; - WaterCoil(CoilNum).SchedPtr = DataGlobals::ScheduleAlwaysOn; - - WaterCoil(CoilNum).RequestingAutoSize = true; - WaterCoil(CoilNum).DesAirVolFlowRate = AutoSize; - WaterCoil(CoilNum).UACoil = AutoSize; - WaterCoil(CoilNum).MaxWaterVolFlowRate = AutoSize; - WaterCoil(CoilNum).CoilPerfInpMeth = UAandFlow; - WaterCoil(CoilNum).DesInletAirTemp = AutoSize; - WaterCoil(CoilNum).DesOutletAirTemp = AutoSize; - WaterCoil(CoilNum).DesInletWaterTemp = AutoSize; - WaterCoil(CoilNum).DesInletAirHumRat = AutoSize; - WaterCoil(CoilNum).DesOutletAirHumRat = AutoSize; - - WaterCoilNumericFields(CoilNum).FieldNames(2) = "Maximum Water Flow Rate"; - WaterCoil(CoilNum).WaterInletNodeNum = 1; - PlantLoop(1).LoopSide(1).Branch(1).Comp(1).NodeNumIn = WaterCoil(CoilNum).WaterInletNodeNum; + state.dataWaterCoils->WaterCoil(CoilNum).Name = "Water Heating Coil"; + state.dataWaterCoils->WaterCoil(CoilNum).WaterLoopNum = 1; + state.dataWaterCoils->WaterCoil(CoilNum).WaterCoilType = state.dataWaterCoils->CoilType_Heating; + state.dataWaterCoils->WaterCoil(CoilNum).WaterCoilType_Num = state.dataWaterCoils->WaterCoil_SimpleHeating; // Coil:Heating:Water + state.dataWaterCoils->WaterCoil(CoilNum).WaterCoilModel = state.dataWaterCoils->CoilType_Heating; + state.dataWaterCoils->WaterCoil(CoilNum).SchedPtr = DataGlobals::ScheduleAlwaysOn; + + state.dataWaterCoils->WaterCoil(CoilNum).RequestingAutoSize = true; + state.dataWaterCoils->WaterCoil(CoilNum).DesAirVolFlowRate = AutoSize; + state.dataWaterCoils->WaterCoil(CoilNum).UACoil = AutoSize; + state.dataWaterCoils->WaterCoil(CoilNum).MaxWaterVolFlowRate = AutoSize; + state.dataWaterCoils->WaterCoil(CoilNum).CoilPerfInpMeth = state.dataWaterCoils->UAandFlow; + state.dataWaterCoils->WaterCoil(CoilNum).DesInletAirTemp = AutoSize; + state.dataWaterCoils->WaterCoil(CoilNum).DesOutletAirTemp = AutoSize; + state.dataWaterCoils->WaterCoil(CoilNum).DesInletWaterTemp = AutoSize; + state.dataWaterCoils->WaterCoil(CoilNum).DesInletAirHumRat = AutoSize; + state.dataWaterCoils->WaterCoil(CoilNum).DesOutletAirHumRat = AutoSize; + + state.dataWaterCoils->WaterCoilNumericFields(CoilNum).FieldNames(2) = "Maximum Water Flow Rate"; + state.dataWaterCoils->WaterCoil(CoilNum).WaterInletNodeNum = 1; + PlantLoop(1).LoopSide(1).Branch(1).Comp(1).NodeNumIn = state.dataWaterCoils->WaterCoil(CoilNum).WaterInletNodeNum; CurZoneEqNum = 0; CurSysNum = 1; @@ -771,27 +771,27 @@ TEST_F(WaterCoilsTest, CoilHeatingWaterUASizingLowHwaterInletTemp) DataWaterLoopNum = 1; NumOfGlycols = 1; - MyUAAndFlowCalcFlag.allocate(1); - MyUAAndFlowCalcFlag(1) = true; + state.dataWaterCoils->MyUAAndFlowCalcFlag.allocate(1); + state.dataWaterCoils->MyUAAndFlowCalcFlag(1) = true; - MySizeFlag.allocate(1); - MySizeFlag(1) = true; + state.dataWaterCoils->MySizeFlag.allocate(1); + state.dataWaterCoils->MySizeFlag(1) = true; // run water coil sizing createCoilSelectionReportObj(); SizeWaterCoil(state, CoilNum); - EXPECT_DOUBLE_EQ(1.0, WaterCoil(CoilNum).DesAirVolFlowRate); + EXPECT_DOUBLE_EQ(1.0, state.dataWaterCoils->WaterCoil(CoilNum).DesAirVolFlowRate); Real64 CpAirStd = 0.0; Real64 DesMassFlow = 0.0; Real64 DesCoilHeatingLoad = 0.0; CpAirStd = PsyCpAirFnW(0.0); - DesMassFlow = WaterCoil(CoilNum).DesAirVolFlowRate * StdRhoAir; + DesMassFlow = state.dataWaterCoils->WaterCoil(CoilNum).DesAirVolFlowRate * StdRhoAir; DesCoilHeatingLoad = CpAirStd * DesMassFlow * (40.0 - 5.0); // check heating coil design load - EXPECT_DOUBLE_EQ(DesCoilHeatingLoad, WaterCoil(CoilNum).DesWaterHeatingCoilRate); + EXPECT_DOUBLE_EQ(DesCoilHeatingLoad, state.dataWaterCoils->WaterCoil(CoilNum).DesWaterHeatingCoilRate); Real64 Cp = 0; Real64 rho = 0; @@ -799,20 +799,20 @@ TEST_F(WaterCoilsTest, CoilHeatingWaterUASizingLowHwaterInletTemp) Cp = GetSpecificHeatGlycol(PlantLoop(1).FluidName, DataGlobals::HWInitConvTemp, PlantLoop(1).FluidIndex, "Unit Test"); rho = GetDensityGlycol(PlantLoop(1).FluidName, DataGlobals::HWInitConvTemp, PlantLoop(1).FluidIndex, "Unit Test"); - DesWaterFlowRate = WaterCoil(CoilNum).DesWaterHeatingCoilRate / (10.0 * Cp * rho); + DesWaterFlowRate = state.dataWaterCoils->WaterCoil(CoilNum).DesWaterHeatingCoilRate / (10.0 * Cp * rho); // check heating coil design water flow rate - EXPECT_DOUBLE_EQ(DesWaterFlowRate, WaterCoil(CoilNum).MaxWaterVolFlowRate); + EXPECT_DOUBLE_EQ(DesWaterFlowRate, state.dataWaterCoils->WaterCoil(CoilNum).MaxWaterVolFlowRate); // check coil UA-value sizing for low design loop exit temp - EXPECT_NEAR(2479.27, WaterCoil(CoilNum).UACoil, 0.01); + EXPECT_NEAR(2479.27, state.dataWaterCoils->WaterCoil(CoilNum).UACoil, 0.01); Real64 DesCoilInletWaterTempUsed = 0.0; Real64 DataFanOpMode = ContFanCycCoil; - Real64 UAMax = WaterCoil(CoilNum).DesWaterHeatingCoilRate; + Real64 UAMax = state.dataWaterCoils->WaterCoil(CoilNum).DesWaterHeatingCoilRate; // check if coil design inlet water temperature is increased above the plant loop exit temp - EstimateCoilInletWaterTemp(CoilNum, DataFanOpMode, 1.0, UAMax, DesCoilInletWaterTempUsed); + EstimateCoilInletWaterTemp(state, CoilNum, DataFanOpMode, 1.0, UAMax, DesCoilInletWaterTempUsed); EXPECT_GT(DesCoilInletWaterTempUsed, PlantSizData(1).ExitTemp); EXPECT_NEAR(48.73, DesCoilInletWaterTempUsed, 0.01); } @@ -822,7 +822,7 @@ TEST_F(WaterCoilsTest, CoilCoolingWaterSimpleSizing) InitializePsychRoutines(); OutBaroPress = 101325.0; StdRhoAir = PsyRhoAirFnPbTdbW(OutBaroPress, 20.0, 0.0); - ShowMessage("Begin Test: WaterCoilsTest, CoilCoolingWaterSimpleSizing"); + ShowMessage("Begin Test: state.dataWaterCoils->WaterCoilsTest, CoilCoolingWaterSimpleSizing"); // set up sizing flags SysSizingRunDone = true; @@ -858,27 +858,27 @@ TEST_F(WaterCoilsTest, CoilCoolingWaterSimpleSizing) // set up water coil int CoilNum = 1; - WaterCoil(CoilNum).Name = "Test Simple Water Cooling Coil"; - WaterCoil(CoilNum).WaterLoopNum = 1; - WaterCoil(CoilNum).WaterCoilType = CoilType_Cooling; - WaterCoil(CoilNum).WaterCoilType_Num = WaterCoil_Cooling; // Coil:Cooling:Water - WaterCoil(CoilNum).WaterCoilModel = CoilModel_Cooling; - - WaterCoil(CoilNum).RequestingAutoSize = true; - WaterCoil(CoilNum).DesAirVolFlowRate = AutoSize; - WaterCoil(CoilNum).DesInletAirTemp = AutoSize; - WaterCoil(CoilNum).DesOutletAirTemp = AutoSize; - WaterCoil(CoilNum).DesInletWaterTemp = AutoSize; - WaterCoil(CoilNum).DesInletAirHumRat = AutoSize; - WaterCoil(CoilNum).DesOutletAirHumRat = AutoSize; - WaterCoil(CoilNum).MaxWaterVolFlowRate = AutoSize; - - WaterCoil(CoilNum).DesignWaterDeltaTemp = 6.67; - WaterCoil(CoilNum).UseDesignWaterDeltaTemp = true; - - WaterCoilNumericFields(CoilNum).FieldNames(1) = "Design Water Flow Rate"; - WaterCoil(CoilNum).WaterInletNodeNum = 1; - PlantLoop(1).LoopSide(1).Branch(1).Comp(1).NodeNumIn = WaterCoil(CoilNum).WaterInletNodeNum; + state.dataWaterCoils->WaterCoil(CoilNum).Name = "Test Simple Water Cooling Coil"; + state.dataWaterCoils->WaterCoil(CoilNum).WaterLoopNum = 1; + state.dataWaterCoils->WaterCoil(CoilNum).WaterCoilType = state.dataWaterCoils->CoilType_Cooling; + state.dataWaterCoils->WaterCoil(CoilNum).WaterCoilType_Num = state.dataWaterCoils->WaterCoil_Cooling; // Coil:Cooling:Water + state.dataWaterCoils->WaterCoil(CoilNum).WaterCoilModel = state.dataWaterCoils->CoilModel_Cooling; + + state.dataWaterCoils->WaterCoil(CoilNum).RequestingAutoSize = true; + state.dataWaterCoils->WaterCoil(CoilNum).DesAirVolFlowRate = AutoSize; + state.dataWaterCoils->WaterCoil(CoilNum).DesInletAirTemp = AutoSize; + state.dataWaterCoils->WaterCoil(CoilNum).DesOutletAirTemp = AutoSize; + state.dataWaterCoils->WaterCoil(CoilNum).DesInletWaterTemp = AutoSize; + state.dataWaterCoils->WaterCoil(CoilNum).DesInletAirHumRat = AutoSize; + state.dataWaterCoils->WaterCoil(CoilNum).DesOutletAirHumRat = AutoSize; + state.dataWaterCoils->WaterCoil(CoilNum).MaxWaterVolFlowRate = AutoSize; + + state.dataWaterCoils->WaterCoil(CoilNum).DesignWaterDeltaTemp = 6.67; + state.dataWaterCoils->WaterCoil(CoilNum).UseDesignWaterDeltaTemp = true; + + state.dataWaterCoils->WaterCoilNumericFields(CoilNum).FieldNames(1) = "Design Water Flow Rate"; + state.dataWaterCoils->WaterCoil(CoilNum).WaterInletNodeNum = 1; + PlantLoop(1).LoopSide(1).Branch(1).Comp(1).NodeNumIn = state.dataWaterCoils->WaterCoil(CoilNum).WaterInletNodeNum; CurZoneEqNum = 0; CurSysNum = 1; @@ -893,7 +893,7 @@ TEST_F(WaterCoilsTest, CoilCoolingWaterSimpleSizing) // run water coil sizing createCoilSelectionReportObj(); SizeWaterCoil(state, CoilNum); - EXPECT_DOUBLE_EQ(1.0, WaterCoil(CoilNum).DesAirVolFlowRate); + EXPECT_DOUBLE_EQ(1.0, state.dataWaterCoils->WaterCoil(CoilNum).DesAirVolFlowRate); Real64 DesCoilCoolingLoad = 0.0; Real64 CoilInEnth = 0.0; @@ -901,10 +901,10 @@ TEST_F(WaterCoilsTest, CoilCoolingWaterSimpleSizing) CoilInEnth = PsyHFnTdbW(20.0, 0.01); CoilOutEnth = PsyHFnTdbW(10.0, 0.0085); - DesCoilCoolingLoad = WaterCoil(CoilNum).DesAirVolFlowRate * StdRhoAir * (CoilInEnth - CoilOutEnth); + DesCoilCoolingLoad = state.dataWaterCoils->WaterCoil(CoilNum).DesAirVolFlowRate * StdRhoAir * (CoilInEnth - CoilOutEnth); // check cooling coil design load - EXPECT_DOUBLE_EQ(DesCoilCoolingLoad, WaterCoil(CoilNum).DesWaterCoolingCoilRate); + EXPECT_DOUBLE_EQ(DesCoilCoolingLoad, state.dataWaterCoils->WaterCoil(CoilNum).DesWaterCoolingCoilRate); Real64 Cp = 0; Real64 rho = 0; @@ -912,10 +912,10 @@ TEST_F(WaterCoilsTest, CoilCoolingWaterSimpleSizing) Cp = GetSpecificHeatGlycol(PlantLoop(1).FluidName, DataGlobals::CWInitConvTemp, PlantLoop(1).FluidIndex, "Unit Test"); rho = GetDensityGlycol(PlantLoop(1).FluidName, DataGlobals::CWInitConvTemp, PlantLoop(1).FluidIndex, "Unit Test"); - DesWaterFlowRate = WaterCoil(CoilNum).DesWaterCoolingCoilRate / (WaterCoil(CoilNum).DesignWaterDeltaTemp * Cp * rho); + DesWaterFlowRate = state.dataWaterCoils->WaterCoil(CoilNum).DesWaterCoolingCoilRate / (state.dataWaterCoils->WaterCoil(CoilNum).DesignWaterDeltaTemp * Cp * rho); // check cooling coil design water flow rate - EXPECT_DOUBLE_EQ(DesWaterFlowRate, WaterCoil(CoilNum).MaxWaterVolFlowRate); + EXPECT_DOUBLE_EQ(DesWaterFlowRate, state.dataWaterCoils->WaterCoil(CoilNum).MaxWaterVolFlowRate); } TEST_F(WaterCoilsTest, CoilCoolingWaterDetailedSizing) @@ -923,7 +923,7 @@ TEST_F(WaterCoilsTest, CoilCoolingWaterDetailedSizing) InitializePsychRoutines(); OutBaroPress = 101325.0; StdRhoAir = PsyRhoAirFnPbTdbW(OutBaroPress, 20.0, 0.0); - ShowMessage("Begin Test: WaterCoilsTest, CoilCoolingWaterDetailedSizing"); + ShowMessage("Begin Test: state.dataWaterCoils->WaterCoilsTest, CoilCoolingWaterDetailedSizing"); // set up sizing flags SysSizingRunDone = true; @@ -959,43 +959,43 @@ TEST_F(WaterCoilsTest, CoilCoolingWaterDetailedSizing) // set up water coil int CoilNum = 1; - WaterCoil(CoilNum).Name = "Test Detailed Water Cooling Coil"; - WaterCoil(CoilNum).WaterLoopNum = 1; - WaterCoil(CoilNum).WaterCoilType = CoilType_Cooling; - WaterCoil(CoilNum).WaterCoilType_Num = WaterCoil_DetFlatFinCooling; // Coil:Cooling:Water:DetailedGeometry - WaterCoil(CoilNum).WaterCoilModel = CoilModel_Detailed; - - WaterCoil(CoilNum).TubeOutsideSurfArea = 6.23816; - WaterCoil(CoilNum).TotTubeInsideArea = 6.20007018; - WaterCoil(CoilNum).FinSurfArea = 101.7158224; - WaterCoil(CoilNum).MinAirFlowArea = 0.810606367; - WaterCoil(CoilNum).CoilDepth = 0.165097968; - WaterCoil(CoilNum).FinDiam = 0.43507152; - WaterCoil(CoilNum).FinThickness = 0.001499982; - WaterCoil(CoilNum).TubeInsideDiam = 0.014449958; - WaterCoil(CoilNum).TubeOutsideDiam = 0.015879775; - WaterCoil(CoilNum).TubeThermConductivity = 385.764854; - WaterCoil(CoilNum).FinThermConductivity = 203.882537; - WaterCoil(CoilNum).FinSpacing = 0.001814292; - WaterCoil(CoilNum).TubeDepthSpacing = 0.02589977; - WaterCoil(CoilNum).NumOfTubeRows = 6; - WaterCoil(CoilNum).NumOfTubesPerRow = 16; - WaterCoil(CoilNum).DesignWaterDeltaTemp = 6.67; - WaterCoil(CoilNum).UseDesignWaterDeltaTemp = true; - - WaterCoil(CoilNum).RequestingAutoSize = true; - WaterCoil(CoilNum).DesAirVolFlowRate = AutoSize; - WaterCoil(CoilNum).MaxWaterVolFlowRate = AutoSize; - WaterCoil(CoilNum).DesInletAirTemp = AutoSize; - WaterCoil(CoilNum).DesOutletAirTemp = AutoSize; - WaterCoil(CoilNum).DesInletWaterTemp = AutoSize; - WaterCoil(CoilNum).DesInletAirHumRat = AutoSize; - WaterCoil(CoilNum).DesOutletAirHumRat = AutoSize; - WaterCoil(CoilNum).MaxWaterVolFlowRate = AutoSize; - - WaterCoilNumericFields(CoilNum).FieldNames(1) = "Design Water Flow Rate"; - WaterCoil(CoilNum).WaterInletNodeNum = 1; - PlantLoop(1).LoopSide(1).Branch(1).Comp(1).NodeNumIn = WaterCoil(CoilNum).WaterInletNodeNum; + state.dataWaterCoils->WaterCoil(CoilNum).Name = "Test Detailed Water Cooling Coil"; + state.dataWaterCoils->WaterCoil(CoilNum).WaterLoopNum = 1; + state.dataWaterCoils->WaterCoil(CoilNum).WaterCoilType = state.dataWaterCoils->CoilType_Cooling; + state.dataWaterCoils->WaterCoil(CoilNum).WaterCoilType_Num = state.dataWaterCoils->WaterCoil_DetFlatFinCooling; // Coil:Cooling:Water:DetailedGeometry + state.dataWaterCoils->WaterCoil(CoilNum).WaterCoilModel = state.dataWaterCoils->CoilModel_Detailed; + + state.dataWaterCoils->WaterCoil(CoilNum).TubeOutsideSurfArea = 6.23816; + state.dataWaterCoils->WaterCoil(CoilNum).TotTubeInsideArea = 6.20007018; + state.dataWaterCoils->WaterCoil(CoilNum).FinSurfArea = 101.7158224; + state.dataWaterCoils->WaterCoil(CoilNum).MinAirFlowArea = 0.810606367; + state.dataWaterCoils->WaterCoil(CoilNum).CoilDepth = 0.165097968; + state.dataWaterCoils->WaterCoil(CoilNum).FinDiam = 0.43507152; + state.dataWaterCoils->WaterCoil(CoilNum).FinThickness = 0.001499982; + state.dataWaterCoils->WaterCoil(CoilNum).TubeInsideDiam = 0.014449958; + state.dataWaterCoils->WaterCoil(CoilNum).TubeOutsideDiam = 0.015879775; + state.dataWaterCoils->WaterCoil(CoilNum).TubeThermConductivity = 385.764854; + state.dataWaterCoils->WaterCoil(CoilNum).FinThermConductivity = 203.882537; + state.dataWaterCoils->WaterCoil(CoilNum).FinSpacing = 0.001814292; + state.dataWaterCoils->WaterCoil(CoilNum).TubeDepthSpacing = 0.02589977; + state.dataWaterCoils->WaterCoil(CoilNum).NumOfTubeRows = 6; + state.dataWaterCoils->WaterCoil(CoilNum).NumOfTubesPerRow = 16; + state.dataWaterCoils->WaterCoil(CoilNum).DesignWaterDeltaTemp = 6.67; + state.dataWaterCoils->WaterCoil(CoilNum).UseDesignWaterDeltaTemp = true; + + state.dataWaterCoils->WaterCoil(CoilNum).RequestingAutoSize = true; + state.dataWaterCoils->WaterCoil(CoilNum).DesAirVolFlowRate = AutoSize; + state.dataWaterCoils->WaterCoil(CoilNum).MaxWaterVolFlowRate = AutoSize; + state.dataWaterCoils->WaterCoil(CoilNum).DesInletAirTemp = AutoSize; + state.dataWaterCoils->WaterCoil(CoilNum).DesOutletAirTemp = AutoSize; + state.dataWaterCoils->WaterCoil(CoilNum).DesInletWaterTemp = AutoSize; + state.dataWaterCoils->WaterCoil(CoilNum).DesInletAirHumRat = AutoSize; + state.dataWaterCoils->WaterCoil(CoilNum).DesOutletAirHumRat = AutoSize; + state.dataWaterCoils->WaterCoil(CoilNum).MaxWaterVolFlowRate = AutoSize; + + state.dataWaterCoils->WaterCoilNumericFields(CoilNum).FieldNames(1) = "Design Water Flow Rate"; + state.dataWaterCoils->WaterCoil(CoilNum).WaterInletNodeNum = 1; + PlantLoop(1).LoopSide(1).Branch(1).Comp(1).NodeNumIn = state.dataWaterCoils->WaterCoil(CoilNum).WaterInletNodeNum; CurZoneEqNum = 0; CurSysNum = 1; @@ -1009,7 +1009,7 @@ TEST_F(WaterCoilsTest, CoilCoolingWaterDetailedSizing) // run water coil sizing createCoilSelectionReportObj(); SizeWaterCoil(state, CoilNum); - EXPECT_DOUBLE_EQ(1.0, WaterCoil(CoilNum).DesAirVolFlowRate); + EXPECT_DOUBLE_EQ(1.0, state.dataWaterCoils->WaterCoil(CoilNum).DesAirVolFlowRate); Real64 DesCoilCoolingLoad = 0.0; Real64 CoilInEnth = 0.0; @@ -1017,9 +1017,9 @@ TEST_F(WaterCoilsTest, CoilCoolingWaterDetailedSizing) CoilInEnth = PsyHFnTdbW(FinalSysSizing(1).MixTempAtCoolPeak, FinalSysSizing(1).MixHumRatAtCoolPeak); CoilOutEnth = PsyHFnTdbW(FinalSysSizing(1).CoolSupTemp, FinalSysSizing(1).CoolSupHumRat); - DesCoilCoolingLoad = WaterCoil(CoilNum).DesAirVolFlowRate * StdRhoAir * (CoilInEnth - CoilOutEnth); + DesCoilCoolingLoad = state.dataWaterCoils->WaterCoil(CoilNum).DesAirVolFlowRate * StdRhoAir * (CoilInEnth - CoilOutEnth); // check cooling coil design load - EXPECT_DOUBLE_EQ(DesCoilCoolingLoad, WaterCoil(CoilNum).DesWaterCoolingCoilRate); + EXPECT_DOUBLE_EQ(DesCoilCoolingLoad, state.dataWaterCoils->WaterCoil(CoilNum).DesWaterCoolingCoilRate); Real64 Cp = 0; Real64 rho = 0; @@ -1027,16 +1027,16 @@ TEST_F(WaterCoilsTest, CoilCoolingWaterDetailedSizing) Cp = GetSpecificHeatGlycol(PlantLoop(1).FluidName, DataGlobals::CWInitConvTemp, PlantLoop(1).FluidIndex, "Unit Test"); rho = GetDensityGlycol(PlantLoop(1).FluidName, DataGlobals::CWInitConvTemp, PlantLoop(1).FluidIndex, "Unit Test"); - DesWaterFlowRate = WaterCoil(CoilNum).DesWaterCoolingCoilRate / (6.67 * Cp * rho); + DesWaterFlowRate = state.dataWaterCoils->WaterCoil(CoilNum).DesWaterCoolingCoilRate / (6.67 * Cp * rho); // check cooling coil design water flow rate - EXPECT_DOUBLE_EQ(DesWaterFlowRate, WaterCoil(CoilNum).MaxWaterVolFlowRate); + EXPECT_DOUBLE_EQ(DesWaterFlowRate, state.dataWaterCoils->WaterCoil(CoilNum).MaxWaterVolFlowRate); } TEST_F(WaterCoilsTest, CoilHeatingWaterSimpleSizing) { InitializePsychRoutines(); OutBaroPress = 101325.0; StdRhoAir = PsyRhoAirFnPbTdbW(OutBaroPress, 20.0, 0.0); - ShowMessage("Begin Test: WaterCoilsTest, CoilHeatingWaterSimpleSizing"); + ShowMessage("Begin Test: state.dataWaterCoils->WaterCoilsTest, CoilHeatingWaterSimpleSizing"); // set up sizing flags SysSizingRunDone = true; @@ -1071,26 +1071,26 @@ TEST_F(WaterCoilsTest, CoilHeatingWaterSimpleSizing) // set up water coil int CoilNum = 1; - WaterCoil(CoilNum).Name = "Test Simple Water Heating Coil"; - WaterCoil(CoilNum).WaterLoopNum = 1; - WaterCoil(CoilNum).WaterCoilType = CoilType_Heating; - WaterCoil(CoilNum).WaterCoilType_Num = WaterCoil_SimpleHeating; // Coil:Heating:Water - WaterCoil(CoilNum).WaterCoilModel = CoilType_Heating; - WaterCoil(CoilNum).RequestingAutoSize = true; - WaterCoil(CoilNum).DesAirVolFlowRate = AutoSize; - WaterCoil(CoilNum).DesInletAirTemp = AutoSize; - WaterCoil(CoilNum).DesOutletAirTemp = AutoSize; - WaterCoil(CoilNum).DesInletWaterTemp = AutoSize; - WaterCoil(CoilNum).DesInletAirHumRat = AutoSize; - WaterCoil(CoilNum).DesOutletAirHumRat = AutoSize; - WaterCoil(CoilNum).MaxWaterVolFlowRate = AutoSize; - - WaterCoil(CoilNum).DesignWaterDeltaTemp = 11.0; - WaterCoil(CoilNum).UseDesignWaterDeltaTemp = true; - - WaterCoilNumericFields(CoilNum).FieldNames(2) = "Maximum Water Flow Rate"; - WaterCoil(CoilNum).WaterInletNodeNum = 1; - PlantLoop(1).LoopSide(1).Branch(1).Comp(1).NodeNumIn = WaterCoil(CoilNum).WaterInletNodeNum; + state.dataWaterCoils->WaterCoil(CoilNum).Name = "Test Simple Water Heating Coil"; + state.dataWaterCoils->WaterCoil(CoilNum).WaterLoopNum = 1; + state.dataWaterCoils->WaterCoil(CoilNum).WaterCoilType = state.dataWaterCoils->CoilType_Heating; + state.dataWaterCoils->WaterCoil(CoilNum).WaterCoilType_Num = state.dataWaterCoils->WaterCoil_SimpleHeating; // Coil:Heating:Water + state.dataWaterCoils->WaterCoil(CoilNum).WaterCoilModel = state.dataWaterCoils->CoilType_Heating; + state.dataWaterCoils->WaterCoil(CoilNum).RequestingAutoSize = true; + state.dataWaterCoils->WaterCoil(CoilNum).DesAirVolFlowRate = AutoSize; + state.dataWaterCoils->WaterCoil(CoilNum).DesInletAirTemp = AutoSize; + state.dataWaterCoils->WaterCoil(CoilNum).DesOutletAirTemp = AutoSize; + state.dataWaterCoils->WaterCoil(CoilNum).DesInletWaterTemp = AutoSize; + state.dataWaterCoils->WaterCoil(CoilNum).DesInletAirHumRat = AutoSize; + state.dataWaterCoils->WaterCoil(CoilNum).DesOutletAirHumRat = AutoSize; + state.dataWaterCoils->WaterCoil(CoilNum).MaxWaterVolFlowRate = AutoSize; + + state.dataWaterCoils->WaterCoil(CoilNum).DesignWaterDeltaTemp = 11.0; + state.dataWaterCoils->WaterCoil(CoilNum).UseDesignWaterDeltaTemp = true; + + state.dataWaterCoils->WaterCoilNumericFields(CoilNum).FieldNames(2) = "Maximum Water Flow Rate"; + state.dataWaterCoils->WaterCoil(CoilNum).WaterInletNodeNum = 1; + PlantLoop(1).LoopSide(1).Branch(1).Comp(1).NodeNumIn = state.dataWaterCoils->WaterCoil(CoilNum).WaterInletNodeNum; CurZoneEqNum = 0; CurSysNum = 1; @@ -1105,7 +1105,7 @@ TEST_F(WaterCoilsTest, CoilHeatingWaterSimpleSizing) // run water coil sizing createCoilSelectionReportObj(); SizeWaterCoil(state, CoilNum); - EXPECT_DOUBLE_EQ(1.0, WaterCoil(CoilNum).DesAirVolFlowRate); + EXPECT_DOUBLE_EQ(1.0, state.dataWaterCoils->WaterCoil(CoilNum).DesAirVolFlowRate); Real64 CpAirStd = 0.0; Real64 DesMassFlow = 0.0; @@ -1116,7 +1116,7 @@ TEST_F(WaterCoilsTest, CoilHeatingWaterSimpleSizing) DesCoilHeatingLoad = CpAirStd * DesMassFlow * (40.0 - 5.0); // check heating coil design load - EXPECT_DOUBLE_EQ(DesCoilHeatingLoad, WaterCoil(CoilNum).DesWaterHeatingCoilRate); + EXPECT_DOUBLE_EQ(DesCoilHeatingLoad, state.dataWaterCoils->WaterCoil(CoilNum).DesWaterHeatingCoilRate); Real64 Cp = 0; Real64 rho = 0; @@ -1124,10 +1124,10 @@ TEST_F(WaterCoilsTest, CoilHeatingWaterSimpleSizing) Cp = GetSpecificHeatGlycol(PlantLoop(1).FluidName, DataGlobals::HWInitConvTemp, PlantLoop(1).FluidIndex, "Unit Test"); rho = GetDensityGlycol(PlantLoop(1).FluidName, DataGlobals::HWInitConvTemp, PlantLoop(1).FluidIndex, "Unit Test"); - DesWaterFlowRate = WaterCoil(CoilNum).DesWaterHeatingCoilRate / (11.0 * Cp * rho); + DesWaterFlowRate = state.dataWaterCoils->WaterCoil(CoilNum).DesWaterHeatingCoilRate / (11.0 * Cp * rho); // check heating coil design water flow rate - EXPECT_DOUBLE_EQ(DesWaterFlowRate, WaterCoil(CoilNum).MaxWaterVolFlowRate); + EXPECT_DOUBLE_EQ(DesWaterFlowRate, state.dataWaterCoils->WaterCoil(CoilNum).MaxWaterVolFlowRate); } TEST_F(WaterCoilsTest, HotWaterHeatingCoilAutoSizeTempTest) { @@ -1169,27 +1169,27 @@ TEST_F(WaterCoilsTest, HotWaterHeatingCoilAutoSizeTempTest) // set up water coil int CoilNum = 1; - WaterCoil(CoilNum).Name = "Water Heating Coil"; - WaterCoil(CoilNum).WaterLoopNum = 1; - WaterCoil(CoilNum).WaterCoilType_Num = WaterCoil_SimpleHeating; // Coil:Heating:Water - WaterCoil(CoilNum).WaterCoilModel = CoilType_Heating; - WaterCoil(CoilNum).WaterCoilType = CoilType_Heating; - WaterCoil(CoilNum).SchedPtr = DataGlobals::ScheduleAlwaysOn; - - WaterCoil(CoilNum).RequestingAutoSize = true; - WaterCoil(CoilNum).DesAirVolFlowRate = AutoSize; - WaterCoil(CoilNum).UACoil = AutoSize; - WaterCoil(CoilNum).MaxWaterVolFlowRate = AutoSize; - WaterCoil(CoilNum).CoilPerfInpMeth = UAandFlow; - WaterCoil(CoilNum).DesInletAirTemp = AutoSize; - WaterCoil(CoilNum).DesOutletAirTemp = AutoSize; - WaterCoil(CoilNum).DesInletWaterTemp = AutoSize; - WaterCoil(CoilNum).DesInletAirHumRat = AutoSize; - WaterCoil(CoilNum).DesOutletAirHumRat = AutoSize; - - WaterCoilNumericFields(CoilNum).FieldNames(2) = "Maximum Water Flow Rate"; - WaterCoil(CoilNum).WaterInletNodeNum = 1; - PlantLoop(1).LoopSide(1).Branch(1).Comp(1).NodeNumIn = WaterCoil(CoilNum).WaterInletNodeNum; + state.dataWaterCoils->WaterCoil(CoilNum).Name = "Water Heating Coil"; + state.dataWaterCoils->WaterCoil(CoilNum).WaterLoopNum = 1; + state.dataWaterCoils->WaterCoil(CoilNum).WaterCoilType_Num = state.dataWaterCoils->WaterCoil_SimpleHeating; // Coil:Heating:Water + state.dataWaterCoils->WaterCoil(CoilNum).WaterCoilModel = state.dataWaterCoils->CoilType_Heating; + state.dataWaterCoils->WaterCoil(CoilNum).WaterCoilType = state.dataWaterCoils->CoilType_Heating; + state.dataWaterCoils->WaterCoil(CoilNum).SchedPtr = DataGlobals::ScheduleAlwaysOn; + + state.dataWaterCoils->WaterCoil(CoilNum).RequestingAutoSize = true; + state.dataWaterCoils->WaterCoil(CoilNum).DesAirVolFlowRate = AutoSize; + state.dataWaterCoils->WaterCoil(CoilNum).UACoil = AutoSize; + state.dataWaterCoils->WaterCoil(CoilNum).MaxWaterVolFlowRate = AutoSize; + state.dataWaterCoils->WaterCoil(CoilNum).CoilPerfInpMeth = state.dataWaterCoils->UAandFlow; + state.dataWaterCoils->WaterCoil(CoilNum).DesInletAirTemp = AutoSize; + state.dataWaterCoils->WaterCoil(CoilNum).DesOutletAirTemp = AutoSize; + state.dataWaterCoils->WaterCoil(CoilNum).DesInletWaterTemp = AutoSize; + state.dataWaterCoils->WaterCoil(CoilNum).DesInletAirHumRat = AutoSize; + state.dataWaterCoils->WaterCoil(CoilNum).DesOutletAirHumRat = AutoSize; + + state.dataWaterCoils->WaterCoilNumericFields(CoilNum).FieldNames(2) = "Maximum Water Flow Rate"; + state.dataWaterCoils->WaterCoil(CoilNum).WaterInletNodeNum = 1; + PlantLoop(1).LoopSide(1).Branch(1).Comp(1).NodeNumIn = state.dataWaterCoils->WaterCoil(CoilNum).WaterInletNodeNum; CurZoneEqNum = 0; CurSysNum = 1; @@ -1198,26 +1198,26 @@ TEST_F(WaterCoilsTest, HotWaterHeatingCoilAutoSizeTempTest) DataWaterLoopNum = 1; NumOfGlycols = 1; - MyUAAndFlowCalcFlag.allocate(1); - MyUAAndFlowCalcFlag(1) = true; + state.dataWaterCoils->MyUAAndFlowCalcFlag.allocate(1); + state.dataWaterCoils->MyUAAndFlowCalcFlag(1) = true; - MySizeFlag.allocate(1); - MySizeFlag(1) = true; + state.dataWaterCoils->MySizeFlag.allocate(1); + state.dataWaterCoils->MySizeFlag(1) = true; // run water coil sizing SizeWaterCoil(state, CoilNum); - EXPECT_DOUBLE_EQ(1.0, WaterCoil(CoilNum).DesAirVolFlowRate); + EXPECT_DOUBLE_EQ(1.0, state.dataWaterCoils->WaterCoil(CoilNum).DesAirVolFlowRate); Real64 CpAirStd(0.0); Real64 DesMassFlow(0.0); Real64 DesCoilHeatingLoad(0.0); CpAirStd = PsyCpAirFnW(0.0); - DesMassFlow = WaterCoil(CoilNum).DesAirVolFlowRate * StdRhoAir; + DesMassFlow = state.dataWaterCoils->WaterCoil(CoilNum).DesAirVolFlowRate * StdRhoAir; DesCoilHeatingLoad = DesMassFlow * CpAirStd * (40.0 - 5.0); // check heating coil design load - EXPECT_DOUBLE_EQ(DesCoilHeatingLoad, WaterCoil(CoilNum).DesWaterHeatingCoilRate); + EXPECT_DOUBLE_EQ(DesCoilHeatingLoad, state.dataWaterCoils->WaterCoil(CoilNum).DesWaterHeatingCoilRate); Real64 Cp(0.0); Real64 rho(0.0); @@ -1229,5 +1229,5 @@ TEST_F(WaterCoilsTest, HotWaterHeatingCoilAutoSizeTempTest) DesWaterFlowRate = DesCoilHeatingLoad / (PlantSizData(1).DeltaT * Cp * rho); // check heating coil design water flow rate calculated here and sizing results are identical - EXPECT_DOUBLE_EQ(DesWaterFlowRate, WaterCoil(CoilNum).MaxWaterVolFlowRate); + EXPECT_DOUBLE_EQ(DesWaterFlowRate, state.dataWaterCoils->WaterCoil(CoilNum).MaxWaterVolFlowRate); }