Line data Source code
1 : // EnergyPlus, Copyright (c) 1996-2025, The Board of Trustees of the University of Illinois,
2 : // The Regents of the University of California, through Lawrence Berkeley National Laboratory
3 : // (subject to receipt of any required approvals from the U.S. Dept. of Energy), Oak Ridge
4 : // National Laboratory, managed by UT-Battelle, Alliance for Sustainable Energy, LLC, and other
5 : // contributors. All rights reserved.
6 : //
7 : // NOTICE: This Software was developed under funding from the U.S. Department of Energy and the
8 : // U.S. Government consequently retains certain rights. As such, the U.S. Government has been
9 : // granted for itself and others acting on its behalf a paid-up, nonexclusive, irrevocable,
10 : // worldwide license in the Software to reproduce, distribute copies to the public, prepare
11 : // derivative works, and perform publicly and display publicly, and to permit others to do so.
12 : //
13 : // Redistribution and use in source and binary forms, with or without modification, are permitted
14 : // provided that the following conditions are met:
15 : //
16 : // (1) Redistributions of source code must retain the above copyright notice, this list of
17 : // conditions and the following disclaimer.
18 : //
19 : // (2) Redistributions in binary form must reproduce the above copyright notice, this list of
20 : // conditions and the following disclaimer in the documentation and/or other materials
21 : // provided with the distribution.
22 : //
23 : // (3) Neither the name of the University of California, Lawrence Berkeley National Laboratory,
24 : // the University of Illinois, U.S. Dept. of Energy nor the names of its contributors may be
25 : // used to endorse or promote products derived from this software without specific prior
26 : // written permission.
27 : //
28 : // (4) Use of EnergyPlus(TM) Name. If Licensee (i) distributes the software in stand-alone form
29 : // without changes from the version obtained under this License, or (ii) Licensee makes a
30 : // reference solely to the software portion of its product, Licensee must refer to the
31 : // software as "EnergyPlus version X" software, where "X" is the version number Licensee
32 : // obtained under this License and may not use a different name for the software. Except as
33 : // specifically required in this Section (4), Licensee shall not use in a company name, a
34 : // product name, in advertising, publicity, or other promotional activities any name, trade
35 : // name, trademark, logo, or other designation of "EnergyPlus", "E+", "e+" or confusingly
36 : // similar designation, without the U.S. Department of Energy's prior written consent.
37 : //
38 : // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR
39 : // IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY
40 : // AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
41 : // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
42 : // CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
43 : // SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
44 : // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
45 : // OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
46 : // POSSIBILITY OF SUCH DAMAGE.
47 :
48 : // C++ Headers
49 :
50 : // ObjexxFCL Headers
51 : #include <ObjexxFCL/Array.functions.hh>
52 :
53 : // EnergyPlus Headers
54 : #include <EnergyPlus/Autosizing/Base.hh>
55 : #include <EnergyPlus/BranchNodeConnections.hh>
56 : #include <EnergyPlus/CurveManager.hh>
57 : #include <EnergyPlus/DXCoils.hh>
58 : #include <EnergyPlus/Data/EnergyPlusData.hh>
59 : #include <EnergyPlus/DataAirSystems.hh>
60 : #include <EnergyPlus/DataContaminantBalance.hh>
61 : #include <EnergyPlus/DataEnvironment.hh>
62 : #include <EnergyPlus/DataHVACGlobals.hh>
63 : #include <EnergyPlus/DataHeatBalance.hh>
64 : #include <EnergyPlus/DataSizing.hh>
65 : #include <EnergyPlus/DataWater.hh>
66 : #include <EnergyPlus/EMSManager.hh>
67 : #include <EnergyPlus/Fans.hh>
68 : #include <EnergyPlus/FluidProperties.hh>
69 : #include <EnergyPlus/General.hh>
70 : #include <EnergyPlus/GeneralRoutines.hh>
71 : #include <EnergyPlus/GlobalNames.hh>
72 : #include <EnergyPlus/InputProcessing/InputProcessor.hh>
73 : #include <EnergyPlus/NodeInputManager.hh>
74 : #include <EnergyPlus/OutAirNodeManager.hh>
75 : #include <EnergyPlus/OutputProcessor.hh>
76 : #include <EnergyPlus/OutputReportPredefined.hh>
77 : #include <EnergyPlus/PlantUtilities.hh>
78 : #include <EnergyPlus/Psychrometrics.hh>
79 : #include <EnergyPlus/ReportCoilSelection.hh>
80 : #include <EnergyPlus/ScheduleManager.hh>
81 : #include <EnergyPlus/UnitarySystem.hh>
82 : #include <EnergyPlus/VariableSpeedCoils.hh>
83 : #include <EnergyPlus/WaterManager.hh>
84 :
85 : namespace EnergyPlus {
86 :
87 : namespace VariableSpeedCoils {
88 :
89 : Real64 constexpr RatedInletAirTemp = 26.6667; // 26.6667C or 80F
90 : Real64 constexpr RatedInletWetBulbTemp = 19.4444; // 19.44 or 67F, cooling mode
91 : Real64 constexpr RatedInletAirHumRat = 0.0111847; // Humidity ratio corresponding to 80F dry bulb/67F wet bulb
92 : Real64 constexpr RatedInletWaterTemp = 29.4444; // 85 F cooling mode
93 : Real64 constexpr RatedAmbAirTemp = 35.0; // 95 F cooling mode
94 : Real64 constexpr RatedInletAirTempHeat = 21.1111; // 21.11C or 70F, heating mode
95 : Real64 constexpr RatedInletWaterTempHeat = 21.1111; // 21.11C or 70F, heating mode
96 : Real64 constexpr RatedAmbAirTempHeat = 8.3333; // 8.33 or 47F, heating mode
97 : Real64 constexpr RatedAmbAirWBHeat = 6.1111; // 8.33 or 43F, heating mode, rated wet bulb temperature
98 : // Water Systems
99 : int constexpr CondensateDiscarded = 1001; // default mode where water is "lost"
100 : int constexpr CondensateToTank = 1002; // collect coil condensate from air and store in water storage tank
101 :
102 : int constexpr WaterSupplyFromMains = 101;
103 : int constexpr WaterSupplyFromTank = 102;
104 :
105 : // Defrost strategy (heat pump only)
106 : int constexpr ReverseCycle = 1; // uses reverse cycle defrost strategy
107 : int constexpr Resistive = 2; // uses electric resistance heater for defrost
108 : // Defrost control (heat pump only)
109 : int constexpr Timed = 1; // defrost cycle is timed
110 : int constexpr OnDemand = 2; // defrost cycle occurs only when required
111 :
112 67677 : void SimVariableSpeedCoils(EnergyPlusData &state,
113 : std::string_view CompName, // Coil Name
114 : int &CompIndex, // Index for Component name
115 : HVAC::FanOp const fanOp, // Continuous fan OR cycling compressor
116 : HVAC::CompressorOp const compressorOp, // compressor on/off. 0 = off; 1= on
117 : Real64 const PartLoadFrac,
118 : int const SpeedNum, // compressor speed number
119 : Real64 const SpeedRatio, // compressor speed ratio
120 : Real64 const SensLoad, // Sensible demand load [W]
121 : Real64 const LatentLoad, // Latent demand load [W]
122 : const Real64 OnOffAirFlowRatio // ratio of comp on to comp off air flow rate
123 : )
124 : {
125 :
126 : // AUTHOR Bo Shen, ORNL
127 : // DATE WRITTEN March 2012
128 : // MODIFIED Bo Shen, 12/2014, add variable-speed HPWH
129 :
130 : // PURPOSE OF THIS SUBROUTINE:
131 : // This subroutine manages variable-speed Water to Air Heat Pump component simulation.
132 :
133 : // SUBROUTINE LOCAL VARIABLE DECLARATIONS:
134 : int DXCoilNum; // The WatertoAirHP that you are currently loading input into
135 : int SpeedCal; // variable for error proof speed input
136 :
137 : // Obtains and Allocates WatertoAirHP related parameters from input file
138 67677 : if (state.dataVariableSpeedCoils->GetCoilsInputFlag) { // First time subroutine has been entered
139 0 : GetVarSpeedCoilInput(state);
140 0 : state.dataVariableSpeedCoils->GetCoilsInputFlag = false;
141 : }
142 :
143 67677 : if (CompIndex == 0) {
144 3 : DXCoilNum = Util::FindItemInList(CompName, state.dataVariableSpeedCoils->VarSpeedCoil);
145 3 : if (DXCoilNum == 0) {
146 0 : ShowFatalError(state, format("WaterToAirHPVSWEquationFit not found={}", CompName));
147 : }
148 3 : CompIndex = DXCoilNum;
149 : } else {
150 67674 : DXCoilNum = CompIndex;
151 67674 : if (DXCoilNum > state.dataVariableSpeedCoils->NumVarSpeedCoils || DXCoilNum < 1) {
152 0 : ShowFatalError(state,
153 0 : format("SimVariableSpeedCoils: Invalid CompIndex passed={}, Number of Water to Air HPs={}, WaterToAir HP name={}",
154 : DXCoilNum,
155 0 : state.dataVariableSpeedCoils->NumVarSpeedCoils,
156 : CompName));
157 : }
158 67674 : if (!CompName.empty() && CompName != state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name) {
159 0 : ShowFatalError(
160 : state,
161 0 : format("SimVariableSpeedCoils: Invalid CompIndex passed={}, WaterToAir HP name={}, stored WaterToAir HP Name for that index={}",
162 : DXCoilNum,
163 : CompName,
164 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name));
165 : }
166 : }
167 :
168 : // ERROR PROOF
169 67677 : if (SpeedNum < 1) {
170 37143 : SpeedCal = 1;
171 : } else {
172 30534 : SpeedCal = SpeedNum;
173 : }
174 :
175 101717 : if ((state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).VSCoilType == HVAC::Coil_CoolingWaterToAirHPVSEquationFit) ||
176 34040 : (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).VSCoilType == HVAC::Coil_CoolingAirToAirVariableSpeed)) {
177 : // Cooling mode
178 34010 : InitVarSpeedCoil(state, DXCoilNum, SensLoad, LatentLoad, fanOp, OnOffAirFlowRatio, SpeedRatio, SpeedCal);
179 34010 : CalcVarSpeedCoilCooling(
180 : state, DXCoilNum, fanOp, SensLoad, LatentLoad, compressorOp, PartLoadFrac, OnOffAirFlowRatio, SpeedRatio, SpeedCal);
181 34010 : UpdateVarSpeedCoil(state, DXCoilNum);
182 33698 : } else if ((state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).VSCoilType == HVAC::Coil_HeatingWaterToAirHPVSEquationFit) ||
183 31 : (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).VSCoilType == HVAC::Coil_HeatingAirToAirVariableSpeed)) {
184 : // Heating mode
185 33667 : InitVarSpeedCoil(state, DXCoilNum, SensLoad, LatentLoad, fanOp, OnOffAirFlowRatio, SpeedRatio, SpeedCal);
186 33667 : CalcVarSpeedCoilHeating(state, DXCoilNum, fanOp, SensLoad, compressorOp, PartLoadFrac, OnOffAirFlowRatio, SpeedRatio, SpeedCal);
187 33667 : UpdateVarSpeedCoil(state, DXCoilNum);
188 0 : } else if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).VSCoilType == HVAC::CoilDX_HeatPumpWaterHeaterVariableSpeed) {
189 : // Heating mode
190 0 : InitVarSpeedCoil(state, DXCoilNum, SensLoad, LatentLoad, fanOp, OnOffAirFlowRatio, SpeedRatio, SpeedCal);
191 0 : CalcVarSpeedHPWH(state, DXCoilNum, PartLoadFrac, SpeedRatio, SpeedNum, fanOp);
192 0 : UpdateVarSpeedCoil(state, DXCoilNum);
193 : } else {
194 0 : ShowFatalError(state, "SimVariableSpeedCoils: WatertoAir heatpump not in either HEATING or COOLING mode");
195 : }
196 :
197 : // two additional output variables
198 67677 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).SpeedNumReport = SpeedCal;
199 67677 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).SpeedRatioReport = SpeedRatio;
200 67677 : }
201 :
202 49 : void GetVarSpeedCoilInput(EnergyPlusData &state)
203 : {
204 :
205 : // SUBROUTINE INFORMATION:
206 : // AUTHOR Bo Shen
207 : // DATE WRITTEN March, 2012
208 : // MODIFIED Bo Shen, 12/2014, add variable-speed HPWH
209 :
210 : // PURPOSE OF THIS SUBROUTINE:
211 : // Obtains input data for HPs and stores it in HP data structures
212 :
213 : // METHODOLOGY EMPLOYED:
214 : // Uses "Get" routines to read in data.
215 :
216 : // SUBROUTINE PARAMETER DEFINITIONS:
217 : static constexpr std::string_view RoutineName("GetVarSpeedCoilInput: "); // include trailing blank space
218 : static constexpr std::string_view routineName = "GetVarSpeedCoilInput";
219 :
220 : // SUBROUTINE LOCAL VARIABLE DECLARATIONS:
221 : int NumAlphas; // Number of variables in String format
222 : int NumNums; // Number of variables in Numeric format
223 : int NumParams; // Total number of input fields
224 49 : int MaxNums(0); // Maximum number of numeric input fields
225 49 : int MaxAlphas(0); // Maximum number of alpha input fields
226 : int IOStat;
227 : int AlfaFieldIncre; // increment number of Alfa field
228 49 : bool ErrorsFound(false); // If errors detected in input
229 : Real64 CurveVal; // Used to verify modifier curves equal 1 at rated conditions
230 : Real64 WHInletAirTemp; // Used to pass proper inlet air temp to HPWH DX coil performance curves
231 : Real64 WHInletWaterTemp; // Used to pass proper inlet water temp to HPWH DX coil performance curves
232 49 : std::string CurrentModuleObject; // for ease in getting objects
233 49 : Array1D_string AlphArray; // Alpha input items for object
234 49 : Array1D_string cAlphaFields; // Alpha field names
235 49 : Array1D_string cNumericFields; // Numeric field names
236 49 : Array1D<Real64> NumArray; // Numeric input items for object
237 49 : Array1D_bool lAlphaBlanks; // Logical array, alpha field input BLANK = .TRUE.
238 49 : Array1D_bool lNumericBlanks; // Logical array, numeric field input BLANK = .TRUE.
239 :
240 : int NumCool =
241 49 : state.dataInputProcessing->inputProcessor->getNumObjectsFound(state, "COIL:COOLING:WATERTOAIRHEATPUMP:VARIABLESPEEDEQUATIONFIT");
242 : int NumHeat =
243 49 : state.dataInputProcessing->inputProcessor->getNumObjectsFound(state, "COIL:HEATING:WATERTOAIRHEATPUMP:VARIABLESPEEDEQUATIONFIT");
244 49 : int NumCoolAS = state.dataInputProcessing->inputProcessor->getNumObjectsFound(state, "COIL:COOLING:DX:VARIABLESPEED");
245 49 : int NumHeatAS = state.dataInputProcessing->inputProcessor->getNumObjectsFound(state, "COIL:HEATING:DX:VARIABLESPEED");
246 : int NumHPWHAirToWater =
247 49 : state.dataInputProcessing->inputProcessor->getNumObjectsFound(state, "COIL:WATERHEATING:AIRTOWATERHEATPUMP:VARIABLESPEED");
248 49 : state.dataVariableSpeedCoils->NumVarSpeedCoils = NumCool + NumHeat + NumCoolAS + NumHeatAS + NumHPWHAirToWater;
249 49 : int DXCoilNum = 0;
250 :
251 49 : if (state.dataVariableSpeedCoils->NumVarSpeedCoils <= 0) {
252 0 : ShowSevereError(state, "No Equipment found in GetVarSpeedCoilInput");
253 0 : ErrorsFound = true;
254 : }
255 :
256 : // Allocate Arrays
257 49 : if (state.dataVariableSpeedCoils->NumVarSpeedCoils > 0) {
258 49 : state.dataVariableSpeedCoils->VarSpeedCoil.allocate(state.dataVariableSpeedCoils->NumVarSpeedCoils);
259 49 : state.dataHeatBal->HeatReclaimVS_Coil.allocate(state.dataVariableSpeedCoils->NumVarSpeedCoils);
260 : }
261 :
262 49 : state.dataInputProcessing->inputProcessor->getObjectDefMaxArgs(
263 : state, "COIL:COOLING:WATERTOAIRHEATPUMP:VARIABLESPEEDEQUATIONFIT", NumParams, NumAlphas, NumNums);
264 49 : MaxNums = max(MaxNums, NumNums);
265 49 : MaxAlphas = max(MaxAlphas, NumAlphas);
266 49 : state.dataInputProcessing->inputProcessor->getObjectDefMaxArgs(
267 : state, "COIL:HEATING:WATERTOAIRHEATPUMP:VARIABLESPEEDEQUATIONFIT", NumParams, NumAlphas, NumNums);
268 49 : MaxNums = max(MaxNums, NumNums);
269 49 : MaxAlphas = max(MaxAlphas, NumAlphas);
270 :
271 49 : state.dataInputProcessing->inputProcessor->getObjectDefMaxArgs(state, "COIL:COOLING:DX:VARIABLESPEED", NumParams, NumAlphas, NumNums);
272 49 : MaxNums = max(MaxNums, NumNums);
273 49 : MaxAlphas = max(MaxAlphas, NumAlphas);
274 49 : state.dataInputProcessing->inputProcessor->getObjectDefMaxArgs(state, "COIL:HEATING:DX:VARIABLESPEED", NumParams, NumAlphas, NumNums);
275 49 : MaxNums = max(MaxNums, NumNums);
276 49 : MaxAlphas = max(MaxAlphas, NumAlphas);
277 :
278 : // variable speed air-source HPWH
279 49 : state.dataInputProcessing->inputProcessor->getObjectDefMaxArgs(
280 : state, "COIL:WATERHEATING:AIRTOWATERHEATPUMP:VARIABLESPEED", NumParams, NumAlphas, NumNums);
281 49 : MaxNums = max(MaxNums, NumNums);
282 49 : MaxAlphas = max(MaxAlphas, NumAlphas);
283 :
284 49 : AlphArray.allocate(MaxAlphas);
285 49 : cAlphaFields.allocate(MaxAlphas);
286 49 : lAlphaBlanks.dimension(MaxAlphas, true);
287 49 : cNumericFields.allocate(MaxNums);
288 49 : lNumericBlanks.dimension(MaxNums, true);
289 49 : NumArray.dimension(MaxNums, 0.0);
290 :
291 : // Get the data for cooling coil, WATER SOURCE
292 49 : CurrentModuleObject = "Coil:Cooling:WaterToAirHeatPump:VariableSpeedEquationFit"; // for reporting
293 :
294 54 : for (int CoilCounter = 1; CoilCounter <= NumCool; ++CoilCounter) {
295 :
296 5 : ++DXCoilNum;
297 5 : AlfaFieldIncre = 1;
298 :
299 5 : state.dataInputProcessing->inputProcessor->getObjectItem(state,
300 : CurrentModuleObject,
301 : CoilCounter,
302 : AlphArray,
303 : NumAlphas,
304 : NumArray,
305 : NumNums,
306 : IOStat,
307 : lNumericBlanks,
308 : lAlphaBlanks,
309 : cAlphaFields,
310 : cNumericFields);
311 :
312 : // ErrorsFound will be set to True if problem was found, left untouched otherwise
313 5 : GlobalNames::VerifyUniqueCoilName(state, CurrentModuleObject, AlphArray(1), ErrorsFound, CurrentModuleObject + " Name");
314 :
315 5 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).bIsDesuperheater = false;
316 5 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name = AlphArray(1);
317 5 : state.dataHeatBal->HeatReclaimVS_Coil(DXCoilNum).Name = state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name;
318 5 : state.dataHeatBal->HeatReclaimVS_Coil(DXCoilNum).SourceType = CurrentModuleObject;
319 5 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).CoolHeatType = "COOLING";
320 5 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).VSCoilType = HVAC::Coil_CoolingWaterToAirHPVSEquationFit;
321 5 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).VarSpeedCoilType =
322 10 : HVAC::cAllCoilTypes(state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).VSCoilType);
323 5 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).NumOfSpeeds = int(NumArray(1));
324 5 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).NormSpedLevel = int(NumArray(2));
325 5 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).RatedCapCoolTotal = NumArray(3);
326 5 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).RatedAirVolFlowRate = NumArray(4);
327 5 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).RatedWaterVolFlowRate = NumArray(5);
328 5 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Twet_Rated = NumArray(6);
329 5 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Gamma_Rated = NumArray(7);
330 5 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MaxONOFFCyclesperHour = NumArray(8);
331 5 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).LatentCapacityTimeConstant = NumArray(9);
332 5 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).FanDelayTime = NumArray(10);
333 5 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).HOTGASREHEATFLG = int(NumArray(11));
334 5 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).CondenserType = DataHeatBalance::RefrigCondenserType::Water;
335 :
336 5 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).WaterInletNodeNum =
337 10 : GetOnlySingleNode(state,
338 5 : AlphArray(2),
339 : ErrorsFound,
340 : DataLoopNode::ConnectionObjectType::CoilCoolingWaterToAirHeatPumpVariableSpeedEquationFit,
341 5 : AlphArray(1),
342 : DataLoopNode::NodeFluidType::Water,
343 : DataLoopNode::ConnectionType::Inlet,
344 : NodeInputManager::CompFluidStream::Secondary,
345 : DataLoopNode::ObjectIsNotParent);
346 5 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).WaterOutletNodeNum =
347 10 : GetOnlySingleNode(state,
348 5 : AlphArray(3),
349 : ErrorsFound,
350 : DataLoopNode::ConnectionObjectType::CoilCoolingWaterToAirHeatPumpVariableSpeedEquationFit,
351 5 : AlphArray(1),
352 : DataLoopNode::NodeFluidType::Water,
353 : DataLoopNode::ConnectionType::Outlet,
354 : NodeInputManager::CompFluidStream::Secondary,
355 : DataLoopNode::ObjectIsNotParent);
356 5 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).AirInletNodeNum =
357 10 : GetOnlySingleNode(state,
358 5 : AlphArray(4),
359 : ErrorsFound,
360 : DataLoopNode::ConnectionObjectType::CoilCoolingWaterToAirHeatPumpVariableSpeedEquationFit,
361 5 : AlphArray(1),
362 : DataLoopNode::NodeFluidType::Air,
363 : DataLoopNode::ConnectionType::Inlet,
364 : NodeInputManager::CompFluidStream::Primary,
365 : DataLoopNode::ObjectIsNotParent);
366 5 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).AirOutletNodeNum =
367 15 : GetOnlySingleNode(state,
368 5 : AlphArray(5),
369 : ErrorsFound,
370 : DataLoopNode::ConnectionObjectType::CoilCoolingWaterToAirHeatPumpVariableSpeedEquationFit,
371 5 : AlphArray(1),
372 : DataLoopNode::NodeFluidType::Air,
373 : DataLoopNode::ConnectionType::Outlet,
374 : NodeInputManager::CompFluidStream::Primary,
375 : DataLoopNode::ObjectIsNotParent);
376 :
377 10 : BranchNodeConnections::TestCompSet(state, CurrentModuleObject, AlphArray(1), AlphArray(2), AlphArray(3), "Water Nodes");
378 5 : BranchNodeConnections::TestCompSet(state, CurrentModuleObject, AlphArray(1), AlphArray(4), AlphArray(5), "Air Nodes");
379 :
380 : // If (VarSpeedCoil(DXCoilNum)%NumOfSpeeds .LT. 2) Then
381 5 : if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).NumOfSpeeds < 1) {
382 0 : ShowSevereError(
383 : state,
384 0 : format("{}{}=\"{}\", invalid", RoutineName, CurrentModuleObject, state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name));
385 0 : ShowContinueError(state, format("...{} must be >= 1. entered number is {:.0T}", cNumericFields(1), NumArray(1)));
386 0 : ErrorsFound = true;
387 : }
388 :
389 5 : if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).NormSpedLevel >
390 5 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).NumOfSpeeds) {
391 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).NormSpedLevel =
392 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).NumOfSpeeds;
393 : }
394 :
395 5 : if ((state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).NormSpedLevel >
396 10 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).NumOfSpeeds) ||
397 5 : (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).NormSpedLevel <= 0)) {
398 0 : ShowSevereError(
399 : state,
400 0 : format("{}{}=\"{}\", invalid", RoutineName, CurrentModuleObject, state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name));
401 0 : ShowContinueError(state, format("...{} must be valid speed level entered number is {:.0T}", cNumericFields(2), NumArray(2)));
402 0 : ErrorsFound = true;
403 : }
404 :
405 : // part load curve
406 5 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).PLFFPLR = Curve::GetCurveIndex(state, AlphArray(6)); // convert curve name to number
407 5 : if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).PLFFPLR == 0) {
408 0 : if (lAlphaBlanks(6)) {
409 0 : ShowSevereError(
410 : state,
411 0 : format("{}{}=\"{}\", missing", RoutineName, CurrentModuleObject, state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name));
412 0 : ShowContinueError(state, format("...required {} is blank.", cAlphaFields(6)));
413 : } else {
414 0 : ShowSevereError(
415 : state,
416 0 : format("{}{}=\"{}\", invalid", RoutineName, CurrentModuleObject, state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name));
417 0 : ShowContinueError(state, format("...not found {}=\"{}\".", cAlphaFields(6), AlphArray(6)));
418 : }
419 0 : ErrorsFound = true;
420 : } else {
421 5 : CurveVal = Curve::CurveValue(state, state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).PLFFPLR, 1.0);
422 5 : if (CurveVal > 1.10 || CurveVal < 0.90) {
423 0 : ShowWarningError(state,
424 0 : format("{}{}=\"{}\", curve values",
425 : RoutineName,
426 : CurrentModuleObject,
427 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name));
428 0 : ShowContinueError(state, format("...{} output is not equal to 1.0 (+ or - 10%) at rated conditions.", cAlphaFields(6)));
429 0 : ShowContinueError(state, format("...Curve output at rated conditions = {:.3T}", CurveVal));
430 : }
431 : }
432 :
433 45 : for (int I = 1; I <= state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).NumOfSpeeds; ++I) {
434 40 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedTotCap(I) = NumArray(12 + (I - 1) * 6);
435 40 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedSHR(I) = NumArray(13 + (I - 1) * 6);
436 40 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedCOP(I) = NumArray(14 + (I - 1) * 6);
437 40 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedAirVolFlowRate(I) = NumArray(15 + (I - 1) * 6);
438 40 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedWaterVolFlowRate(I) = NumArray(16 + (I - 1) * 6);
439 40 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSWasteHeatFrac(I) = NumArray(17 + (I - 1) * 6);
440 :
441 40 : AlfaFieldIncre = 7 + (I - 1) * 7;
442 40 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSCCapFTemp(I) =
443 40 : Curve::GetCurveIndex(state, AlphArray(AlfaFieldIncre)); // convert curve name to number
444 40 : if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSCCapFTemp(I) == 0) {
445 0 : if (lAlphaBlanks(AlfaFieldIncre)) {
446 0 : ShowSevereError(state,
447 0 : format("{}{}=\"{}\", missing",
448 : RoutineName,
449 : CurrentModuleObject,
450 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name));
451 0 : ShowContinueError(state, format("...required {} is blank.", cAlphaFields(AlfaFieldIncre)));
452 : } else {
453 0 : ShowSevereError(state,
454 0 : format("{}{}=\"{}\", invalid",
455 : RoutineName,
456 : CurrentModuleObject,
457 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name));
458 0 : ShowContinueError(state, format("...not found {}=\"{}\".", cAlphaFields(AlfaFieldIncre), AlphArray(AlfaFieldIncre)));
459 : }
460 0 : ErrorsFound = true;
461 : } else {
462 : // Verify Curve Object, only legal type is BiQuadratic
463 120 : ErrorsFound |= Curve::CheckCurveDims(state,
464 40 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSCCapFTemp(I), // Curve index
465 : {2}, // Valid dimensions
466 : RoutineName, // Routine name
467 : CurrentModuleObject, // Object Type
468 40 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name, // Object Name
469 40 : cAlphaFields(AlfaFieldIncre)); // Field Name
470 :
471 40 : if (!ErrorsFound) {
472 80 : CurveVal = Curve::CurveValue(
473 40 : state, state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSCCapFTemp(I), RatedInletWetBulbTemp, RatedInletWaterTemp);
474 40 : if (CurveVal > 1.10 || CurveVal < 0.90) {
475 0 : ShowWarningError(state,
476 0 : format("{}{}=\"{}\", curve values",
477 : RoutineName,
478 : CurrentModuleObject,
479 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name));
480 0 : ShowContinueError(
481 0 : state, format("...{} output is not equal to 1.0 (+ or - 10%) at rated conditions.", cAlphaFields(AlfaFieldIncre)));
482 0 : ShowContinueError(state, format("...Curve output at rated conditions = {:.3T}", CurveVal));
483 : }
484 : }
485 : }
486 :
487 40 : AlfaFieldIncre = 8 + (I - 1) * 7;
488 40 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSCCapAirFFlow(I) =
489 40 : Curve::GetCurveIndex(state, AlphArray(AlfaFieldIncre)); // convert curve name to number
490 40 : if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSCCapAirFFlow(I) == 0) {
491 0 : if (lAlphaBlanks(AlfaFieldIncre)) {
492 0 : ShowSevereError(state,
493 0 : format("{}{}=\"{}\", missing",
494 : RoutineName,
495 : CurrentModuleObject,
496 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name));
497 0 : ShowContinueError(state, format("...required {} is blank.", cAlphaFields(AlfaFieldIncre)));
498 : } else {
499 0 : ShowSevereError(state,
500 0 : format("{}{}=\"{}\", invalid",
501 : RoutineName,
502 : CurrentModuleObject,
503 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name));
504 0 : ShowContinueError(state, format("...not found {}=\"{}\".", cAlphaFields(AlfaFieldIncre), AlphArray(AlfaFieldIncre)));
505 : }
506 0 : ErrorsFound = true;
507 : } else {
508 : // Verify Curve Object, only legal type is Quadratic
509 120 : ErrorsFound |= Curve::CheckCurveDims(state,
510 40 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSCCapAirFFlow(I), // Curve index
511 : {1}, // Valid dimensions
512 : RoutineName, // Routine name
513 : CurrentModuleObject, // Object Type
514 40 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name, // Object Name
515 40 : cAlphaFields(AlfaFieldIncre)); // Field Name
516 :
517 40 : if (!ErrorsFound) {
518 40 : CurveVal = Curve::CurveValue(state, state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSCCapAirFFlow(I), 1.0);
519 40 : if (CurveVal > 1.10 || CurveVal < 0.90) {
520 0 : ShowWarningError(state,
521 0 : format("{}{}=\"{}\", curve values",
522 : RoutineName,
523 : CurrentModuleObject,
524 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name));
525 0 : ShowContinueError(
526 0 : state, format("...{} output is not equal to 1.0 (+ or - 10%) at rated conditions.", cAlphaFields(AlfaFieldIncre)));
527 0 : ShowContinueError(state, format("...Curve output at rated conditions = {:.3T}", CurveVal));
528 : }
529 : }
530 : }
531 :
532 40 : AlfaFieldIncre = 9 + (I - 1) * 7;
533 40 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSCCapWaterFFlow(I) =
534 40 : Curve::GetCurveIndex(state, AlphArray(AlfaFieldIncre)); // convert curve name to number
535 40 : if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSCCapWaterFFlow(I) == 0) {
536 0 : if (lAlphaBlanks(AlfaFieldIncre)) {
537 0 : ShowSevereError(state,
538 0 : format("{}{}=\"{}\", missing",
539 : RoutineName,
540 : CurrentModuleObject,
541 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name));
542 0 : ShowContinueError(state, format("...required {} is blank.", cAlphaFields(AlfaFieldIncre)));
543 : } else {
544 0 : ShowSevereError(state,
545 0 : format("{}{}=\"{}\", invalid",
546 : RoutineName,
547 : CurrentModuleObject,
548 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name));
549 0 : ShowContinueError(state, format("...not found {}=\"{}\".", cAlphaFields(AlfaFieldIncre), AlphArray(AlfaFieldIncre)));
550 : }
551 0 : ErrorsFound = true;
552 : } else {
553 : // Verify Curve Object, only legal type is Quadratic
554 120 : ErrorsFound |= Curve::CheckCurveDims(state,
555 40 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSCCapWaterFFlow(I), // Curve index
556 : {1}, // Valid dimensions
557 : RoutineName, // Routine name
558 : CurrentModuleObject, // Object Type
559 40 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name, // Object Name
560 40 : cAlphaFields(AlfaFieldIncre)); // Field Name
561 :
562 40 : if (!ErrorsFound) {
563 40 : CurveVal = Curve::CurveValue(state, state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSCCapWaterFFlow(I), 1.0);
564 40 : if (CurveVal > 1.10 || CurveVal < 0.90) {
565 0 : ShowWarningError(state,
566 0 : format("{}{}=\"{}\", curve values",
567 : RoutineName,
568 : CurrentModuleObject,
569 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name));
570 0 : ShowContinueError(
571 0 : state, format("...{} output is not equal to 1.0 (+ or - 10%) at rated conditions.", cAlphaFields(AlfaFieldIncre)));
572 0 : ShowContinueError(state, format("...Curve output at rated conditions = {:.3T}", CurveVal));
573 : }
574 : }
575 : }
576 :
577 40 : AlfaFieldIncre = 10 + (I - 1) * 7;
578 40 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSEIRFTemp(I) =
579 40 : Curve::GetCurveIndex(state, AlphArray(AlfaFieldIncre)); // convert curve name to number
580 40 : if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSEIRFTemp(I) == 0) {
581 0 : if (lAlphaBlanks(AlfaFieldIncre)) {
582 0 : ShowSevereError(state,
583 0 : format("{}{}=\"{}\", missing",
584 : RoutineName,
585 : CurrentModuleObject,
586 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name));
587 0 : ShowContinueError(state, format("...required {} is blank.", cAlphaFields(AlfaFieldIncre)));
588 : } else {
589 0 : ShowSevereError(state,
590 0 : format("{}{}=\"{}\", invalid",
591 : RoutineName,
592 : CurrentModuleObject,
593 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name));
594 0 : ShowContinueError(state, format("...not found {}=\"{}\".", cAlphaFields(AlfaFieldIncre), AlphArray(AlfaFieldIncre)));
595 : }
596 0 : ErrorsFound = true;
597 : } else {
598 : // Verify Curve Object, only legal type is BiQuadratic
599 120 : ErrorsFound |= Curve::CheckCurveDims(state,
600 40 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSEIRFTemp(I), // Curve index
601 : {2}, // Valid dimensions
602 : RoutineName, // Routine name
603 : CurrentModuleObject, // Object Type
604 40 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name, // Object Name
605 40 : cAlphaFields(AlfaFieldIncre)); // Field Name
606 :
607 40 : if (!ErrorsFound) {
608 80 : CurveVal = Curve::CurveValue(
609 40 : state, state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSEIRFTemp(I), RatedInletWetBulbTemp, RatedInletWaterTemp);
610 40 : if (CurveVal > 1.10 || CurveVal < 0.90) {
611 0 : ShowWarningError(state,
612 0 : format("{}{}=\"{}\", curve values",
613 : RoutineName,
614 : CurrentModuleObject,
615 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name));
616 0 : ShowContinueError(
617 0 : state, format("...{} output is not equal to 1.0 (+ or - 10%) at rated conditions.", cAlphaFields(AlfaFieldIncre)));
618 0 : ShowContinueError(state, format("...Curve output at rated conditions = {:.3T}", CurveVal));
619 : }
620 : }
621 : }
622 :
623 40 : AlfaFieldIncre = 11 + (I - 1) * 7;
624 40 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSEIRAirFFlow(I) =
625 40 : Curve::GetCurveIndex(state, AlphArray(AlfaFieldIncre)); // convert curve name to number
626 40 : if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSEIRAirFFlow(I) == 0) {
627 0 : if (lAlphaBlanks(AlfaFieldIncre)) {
628 0 : ShowSevereError(state,
629 0 : format("{}{}=\"{}\", missing",
630 : RoutineName,
631 : CurrentModuleObject,
632 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name));
633 0 : ShowContinueError(state, format("...required {} is blank.", cAlphaFields(AlfaFieldIncre)));
634 : } else {
635 0 : ShowSevereError(state,
636 0 : format("{}{}=\"{}\", invalid",
637 : RoutineName,
638 : CurrentModuleObject,
639 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name));
640 0 : ShowContinueError(state, format("...not found {}=\"{}\".", cAlphaFields(AlfaFieldIncre), AlphArray(AlfaFieldIncre)));
641 : }
642 0 : ErrorsFound = true;
643 : } else {
644 : // Verify Curve Object, only legal type is Quadratic
645 120 : ErrorsFound |= Curve::CheckCurveDims(state,
646 40 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSEIRAirFFlow(I), // Curve index
647 : {1}, // Valid dimensions
648 : RoutineName, // Routine name
649 : CurrentModuleObject, // Object Type
650 40 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name, // Object Name
651 40 : cAlphaFields(AlfaFieldIncre)); // Field Name
652 :
653 40 : if (!ErrorsFound) {
654 40 : CurveVal = Curve::CurveValue(state, state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSEIRAirFFlow(I), 1.0);
655 40 : if (CurveVal > 1.10 || CurveVal < 0.90) {
656 0 : ShowWarningError(state,
657 0 : format("{}{}=\"{}\", curve values",
658 : RoutineName,
659 : CurrentModuleObject,
660 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name));
661 0 : ShowContinueError(
662 0 : state, format("...{} output is not equal to 1.0 (+ or - 10%) at rated conditions.", cAlphaFields(AlfaFieldIncre)));
663 0 : ShowContinueError(state, format("...Curve output at rated conditions = {:.3T}", CurveVal));
664 : }
665 : }
666 : }
667 :
668 40 : AlfaFieldIncre = 12 + (I - 1) * 7;
669 40 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSEIRWaterFFlow(I) =
670 40 : Curve::GetCurveIndex(state, AlphArray(AlfaFieldIncre)); // convert curve name to number
671 40 : if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSEIRWaterFFlow(I) == 0) {
672 0 : if (lAlphaBlanks(AlfaFieldIncre)) {
673 0 : ShowSevereError(state,
674 0 : format("{}{}=\"{}\", missing",
675 : RoutineName,
676 : CurrentModuleObject,
677 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name));
678 0 : ShowContinueError(state, format("...required {} is blank.", cAlphaFields(AlfaFieldIncre)));
679 : } else {
680 0 : ShowSevereError(state,
681 0 : format("{}{}=\"{}\", invalid",
682 : RoutineName,
683 : CurrentModuleObject,
684 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name));
685 0 : ShowContinueError(state, format("...not found {}=\"{}\".", cAlphaFields(AlfaFieldIncre), AlphArray(AlfaFieldIncre)));
686 : }
687 0 : ErrorsFound = true;
688 : } else {
689 : // Verify Curve Object, only legal type is Quadratic
690 120 : ErrorsFound |= Curve::CheckCurveDims(state,
691 40 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSEIRWaterFFlow(I), // Curve index
692 : {1}, // Valid dimensions
693 : RoutineName, // Routine name
694 : CurrentModuleObject, // Object Type
695 40 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name, // Object Name
696 40 : cAlphaFields(AlfaFieldIncre)); // Field Name
697 :
698 40 : if (!ErrorsFound) {
699 40 : CurveVal = Curve::CurveValue(state, state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSEIRWaterFFlow(I), 1.0);
700 40 : if (CurveVal > 1.10 || CurveVal < 0.90) {
701 0 : ShowWarningError(state,
702 0 : format("{}{}=\"{}\", curve values",
703 : RoutineName,
704 : CurrentModuleObject,
705 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name));
706 0 : ShowContinueError(
707 0 : state, format("...{} output is not equal to 1.0 (+ or - 10%) at rated conditions.", cAlphaFields(AlfaFieldIncre)));
708 0 : ShowContinueError(state, format("...Curve output at rated conditions = {:.3T}", CurveVal));
709 : }
710 : }
711 : }
712 :
713 40 : AlfaFieldIncre = 13 + (I - 1) * 7;
714 : // Read waste heat modifier curve name
715 40 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSWasteHeat(I) =
716 40 : Curve::GetCurveIndex(state, AlphArray(AlfaFieldIncre)); // convert curve name to number
717 40 : if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSWasteHeat(I) == 0) {
718 0 : if (lAlphaBlanks(AlfaFieldIncre)) {
719 0 : ShowSevereError(state,
720 0 : format("{}{}=\"{}\", missing",
721 : RoutineName,
722 : CurrentModuleObject,
723 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name));
724 0 : ShowContinueError(state, format("...required {} is blank.", cAlphaFields(AlfaFieldIncre)));
725 : } else {
726 0 : ShowSevereError(state,
727 0 : format("{}{}=\"{}\", invalid",
728 : RoutineName,
729 : CurrentModuleObject,
730 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name));
731 0 : ShowContinueError(state, format("...not found {}=\"{}\".", cAlphaFields(AlfaFieldIncre), AlphArray(AlfaFieldIncre)));
732 : }
733 0 : ErrorsFound = true;
734 : } else {
735 : // Verify Curve Object, only legal types are BiQuadratic
736 120 : ErrorsFound |= Curve::CheckCurveDims(state,
737 40 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSWasteHeat(I), // Curve index
738 : {2}, // Valid dimensions
739 : RoutineName, // Routine name
740 : CurrentModuleObject, // Object Type
741 40 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name, // Object Name
742 40 : cAlphaFields(AlfaFieldIncre)); // Field Name
743 :
744 40 : if (!ErrorsFound) {
745 80 : CurveVal = Curve::CurveValue(
746 40 : state, state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSWasteHeat(I), RatedInletWaterTemp, RatedInletAirTemp);
747 40 : if (CurveVal > 1.10 || CurveVal < 0.90) {
748 0 : ShowWarningError(state,
749 0 : format("{}{}=\"{}\", curve values",
750 : RoutineName,
751 : CurrentModuleObject,
752 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name));
753 0 : ShowContinueError(
754 0 : state, format("...{} output is not equal to 1.0 (+ or - 10%) at rated conditions.", cAlphaFields(AlfaFieldIncre)));
755 0 : ShowContinueError(state, format("...Curve output at rated conditions = {:.3T}", CurveVal));
756 : }
757 : }
758 : }
759 : }
760 :
761 45 : for (int I = 1; I <= state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).NumOfSpeeds; ++I) {
762 40 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedPercentTotCap(I) =
763 40 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedTotCap(I) /
764 80 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedTotCap(
765 40 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).NumOfSpeeds);
766 40 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedAirVolFlowPerRatedTotCap(I) =
767 40 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedAirVolFlowRate(I) /
768 40 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedTotCap(I);
769 40 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedWaterVolFlowPerRatedTotCap(I) =
770 40 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedWaterVolFlowRate(I) /
771 40 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedTotCap(I);
772 : }
773 :
774 : // CurrentModuleObject = "Coil:Cooling:WaterToAirHeatPump:VariableSpeedEquationFit"
775 10 : SetupOutputVariable(state,
776 : "Cooling Coil Electricity Energy",
777 : Constant::Units::J,
778 5 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Energy,
779 : OutputProcessor::TimeStepType::System,
780 : OutputProcessor::StoreType::Sum,
781 5 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name,
782 : Constant::eResource::Electricity,
783 : OutputProcessor::Group::HVAC,
784 : OutputProcessor::EndUseCat::Cooling);
785 10 : SetupOutputVariable(state,
786 : "Cooling Coil Total Cooling Energy",
787 : Constant::Units::J,
788 5 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).EnergyLoadTotal,
789 : OutputProcessor::TimeStepType::System,
790 : OutputProcessor::StoreType::Sum,
791 5 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name,
792 : Constant::eResource::EnergyTransfer,
793 : OutputProcessor::Group::HVAC,
794 : OutputProcessor::EndUseCat::CoolingCoils);
795 10 : SetupOutputVariable(state,
796 : "Cooling Coil Sensible Cooling Energy",
797 : Constant::Units::J,
798 5 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).EnergySensible,
799 : OutputProcessor::TimeStepType::System,
800 : OutputProcessor::StoreType::Sum,
801 5 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name);
802 10 : SetupOutputVariable(state,
803 : "Cooling Coil Latent Cooling Energy",
804 : Constant::Units::J,
805 5 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).EnergyLatent,
806 : OutputProcessor::TimeStepType::System,
807 : OutputProcessor::StoreType::Sum,
808 5 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name);
809 10 : SetupOutputVariable(state,
810 : "Cooling Coil Source Side Heat Transfer Energy",
811 : Constant::Units::J,
812 5 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).EnergySource,
813 : OutputProcessor::TimeStepType::System,
814 : OutputProcessor::StoreType::Sum,
815 5 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name,
816 : Constant::eResource::PlantLoopCoolingDemand,
817 : OutputProcessor::Group::HVAC,
818 : OutputProcessor::EndUseCat::CoolingCoils);
819 :
820 5 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).RatedCapCoolSens =
821 : DataSizing::AutoSize; // always auto-sized, to be determined in the sizing calculation
822 : }
823 :
824 : //-------------------------AIR SOURCE, COOLING---BEGIN
825 : // Get the data for cooling coil, AIR SOURCE
826 49 : CurrentModuleObject = "Coil:Cooling:DX:VariableSpeed"; // for reporting
827 :
828 87 : for (int CoilCounter = 1; CoilCounter <= NumCoolAS; ++CoilCounter) {
829 :
830 38 : ++DXCoilNum;
831 38 : AlfaFieldIncre = 1;
832 :
833 38 : state.dataInputProcessing->inputProcessor->getObjectItem(state,
834 : CurrentModuleObject,
835 : CoilCounter,
836 : AlphArray,
837 : NumAlphas,
838 : NumArray,
839 : NumNums,
840 : IOStat,
841 : lNumericBlanks,
842 : lAlphaBlanks,
843 : cAlphaFields,
844 : cNumericFields);
845 :
846 38 : ErrorObjectHeader eoh{routineName, CurrentModuleObject, AlphArray(1)};
847 :
848 : // ErrorsFound will be set to True if problem was found, left untouched otherwise
849 38 : GlobalNames::VerifyUniqueCoilName(state, CurrentModuleObject, AlphArray(1), ErrorsFound, CurrentModuleObject + " Name");
850 :
851 38 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).bIsDesuperheater = false;
852 38 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name = AlphArray(1);
853 : // Initialize DataHeatBalance heat reclaim variable name for use by heat reclaim coils
854 38 : state.dataHeatBal->HeatReclaimVS_Coil(DXCoilNum).Name = state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name;
855 38 : state.dataHeatBal->HeatReclaimVS_Coil(DXCoilNum).SourceType = CurrentModuleObject;
856 38 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).CoolHeatType = "COOLING";
857 38 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).VSCoilType = HVAC::Coil_CoolingAirToAirVariableSpeed;
858 38 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).VarSpeedCoilType = HVAC::cAllCoilTypes(HVAC::Coil_CoolingAirToAirVariableSpeed);
859 38 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).NumOfSpeeds = int(NumArray(1));
860 38 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).NormSpedLevel = int(NumArray(2));
861 38 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).RatedCapCoolTotal = NumArray(3);
862 38 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).RatedAirVolFlowRate = NumArray(4);
863 38 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Twet_Rated = NumArray(5);
864 38 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Gamma_Rated = NumArray(6);
865 38 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MaxONOFFCyclesperHour = NumArray(7);
866 38 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).LatentCapacityTimeConstant = NumArray(8);
867 38 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).FanDelayTime = NumArray(9);
868 :
869 38 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).AirInletNodeNum =
870 76 : GetOnlySingleNode(state,
871 38 : AlphArray(2),
872 : ErrorsFound,
873 : DataLoopNode::ConnectionObjectType::CoilCoolingDXVariableSpeed,
874 38 : AlphArray(1),
875 : DataLoopNode::NodeFluidType::Air,
876 : DataLoopNode::ConnectionType::Inlet,
877 : NodeInputManager::CompFluidStream::Primary,
878 : DataLoopNode::ObjectIsNotParent);
879 38 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).AirOutletNodeNum =
880 114 : GetOnlySingleNode(state,
881 38 : AlphArray(3),
882 : ErrorsFound,
883 : DataLoopNode::ConnectionObjectType::CoilCoolingDXVariableSpeed,
884 38 : AlphArray(1),
885 : DataLoopNode::NodeFluidType::Air,
886 : DataLoopNode::ConnectionType::Outlet,
887 : NodeInputManager::CompFluidStream::Primary,
888 : DataLoopNode::ObjectIsNotParent);
889 :
890 38 : BranchNodeConnections::TestCompSet(state, CurrentModuleObject, AlphArray(1), AlphArray(2), AlphArray(3), "Air Nodes");
891 :
892 38 : if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).NumOfSpeeds < 1) {
893 0 : ShowSevereError(
894 : state,
895 0 : format("{}{}=\"{}\", invalid", RoutineName, CurrentModuleObject, state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name));
896 0 : ShowContinueError(state, format("...{} must be >= 1. entered number is {:.0T}", cNumericFields(1), NumArray(1)));
897 0 : ErrorsFound = true;
898 : }
899 :
900 38 : if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).NormSpedLevel >
901 38 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).NumOfSpeeds) {
902 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).NormSpedLevel =
903 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).NumOfSpeeds;
904 : }
905 :
906 38 : if ((state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).NormSpedLevel >
907 76 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).NumOfSpeeds) ||
908 38 : (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).NormSpedLevel <= 0)) {
909 0 : ShowSevereError(
910 : state,
911 0 : format("{}{}=\"{}\", invalid", RoutineName, CurrentModuleObject, state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name));
912 0 : ShowContinueError(state, format("...{} must be valid speed level entered number is {:.0T}", cNumericFields(2), NumArray(2)));
913 0 : ErrorsFound = true;
914 : }
915 :
916 : // part load curve
917 38 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).PLFFPLR = Curve::GetCurveIndex(state, AlphArray(4)); // convert curve name to number
918 38 : if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).PLFFPLR == 0) {
919 0 : if (lAlphaBlanks(4)) {
920 0 : ShowSevereError(
921 : state,
922 0 : format("{}{}=\"{}\", missing", RoutineName, CurrentModuleObject, state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name));
923 0 : ShowContinueError(state, format("...required {} is blank.", cAlphaFields(6)));
924 : } else {
925 0 : ShowSevereError(
926 : state,
927 0 : format("{}{}=\"{}\", invalid", RoutineName, CurrentModuleObject, state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name));
928 0 : ShowContinueError(state, format("...not found {}=\"{}\".", cAlphaFields(4), AlphArray(4)));
929 : }
930 0 : ErrorsFound = true;
931 : } else {
932 38 : CurveVal = Curve::CurveValue(state, state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).PLFFPLR, 1.0);
933 38 : if (CurveVal > 1.10 || CurveVal < 0.90) {
934 0 : ShowWarningError(state,
935 0 : format("{}{}=\"{}\", curve values",
936 : RoutineName,
937 : CurrentModuleObject,
938 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name));
939 0 : ShowContinueError(state, format("...{} output is not equal to 1.0 (+ or - 10%) at rated conditions.", cAlphaFields(4)));
940 0 : ShowContinueError(state, format("...Curve output at rated conditions = {:.3T}", CurveVal));
941 : }
942 : }
943 :
944 : // outdoor condenser node
945 38 : if (lAlphaBlanks(5)) {
946 34 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).CondenserInletNodeNum = 0;
947 : } else {
948 4 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).CondenserInletNodeNum =
949 8 : GetOnlySingleNode(state,
950 4 : AlphArray(5),
951 : ErrorsFound,
952 : DataLoopNode::ConnectionObjectType::CoilCoolingDXVariableSpeed,
953 4 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name,
954 : DataLoopNode::NodeFluidType::Air,
955 : DataLoopNode::ConnectionType::OutsideAirReference,
956 : NodeInputManager::CompFluidStream::Primary,
957 : DataLoopNode::ObjectIsNotParent);
958 :
959 4 : if (!OutAirNodeManager::CheckOutAirNodeNumber(state, state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).CondenserInletNodeNum)) {
960 4 : ShowWarningError(state,
961 4 : format("{}{}=\"{}\", may be invalid",
962 : RoutineName,
963 : CurrentModuleObject,
964 2 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name));
965 4 : ShowContinueError(state,
966 4 : format("{}=\"{}\", node does not appear in an OutdoorAir:NodeList or as an OutdoorAir:Node.",
967 : cAlphaFields(10),
968 : AlphArray(5)));
969 6 : ShowContinueError(
970 : state, "This node needs to be included in an air system or the coil model will not be valid, and the simulation continues");
971 : }
972 : }
973 :
974 38 : if ((Util::SameString(AlphArray(6), "AirCooled")) || lAlphaBlanks(6)) {
975 37 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).CondenserType = DataHeatBalance::RefrigCondenserType::Air;
976 1 : } else if (Util::SameString(AlphArray(6), "EvaporativelyCooled")) {
977 1 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).CondenserType = DataHeatBalance::RefrigCondenserType::Evap;
978 1 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).ReportEvapCondVars = true;
979 : } else {
980 0 : ShowSevereError(
981 : state,
982 0 : format("{}{}=\"{}\", invalid", RoutineName, CurrentModuleObject, state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name));
983 0 : ShowContinueError(state, format("...{}=\"{}\":", cAlphaFields(6), AlphArray(6)));
984 0 : ShowContinueError(state, "...must be AirCooled or EvaporativelyCooled.");
985 0 : ErrorsFound = true;
986 : }
987 :
988 38 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).EvapCondPumpElecNomPower = NumArray(10);
989 :
990 38 : if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).EvapCondPumpElecNomPower != DataSizing::AutoSize) {
991 37 : if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).EvapCondPumpElecNomPower < 0.0) {
992 0 : ShowSevereError(
993 : state,
994 0 : format("{}{}=\"{}\", invalid", RoutineName, CurrentModuleObject, state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name));
995 0 : ShowContinueError(state, format("...{} cannot be < 0.0.", cNumericFields(10)));
996 0 : ShowContinueError(state, format("...entered value=[{:.2T}].", NumArray(10)));
997 0 : ErrorsFound = true;
998 : }
999 : }
1000 :
1001 : // Set crankcase heater capacity
1002 38 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).CrankcaseHeaterCapacity = NumArray(11);
1003 38 : if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).CrankcaseHeaterCapacity < 0.0) {
1004 0 : ShowSevereError(
1005 : state,
1006 0 : format("{}{}=\"{}\", invalid", RoutineName, CurrentModuleObject, state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name));
1007 0 : ShowContinueError(state, format("...{} cannot be < 0.0.", cNumericFields(11)));
1008 0 : ShowContinueError(state, format("...entered value=[{:.2T}].", NumArray(11)));
1009 0 : ErrorsFound = true;
1010 : }
1011 :
1012 : // Set crankcase heater cutout temperature
1013 38 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MaxOATCrankcaseHeater = NumArray(12);
1014 :
1015 : // Set crankcase heater cutout temperature
1016 38 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MinOATCompressor = NumArray(13);
1017 :
1018 : // A7; \field Crankcase Heater Capacity Function of Outdoor Temperature Curve Name
1019 38 : if (!lAlphaBlanks(7)) {
1020 2 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).CrankcaseHeaterCapacityCurveIndex = Curve::GetCurveIndex(state, AlphArray(7));
1021 2 : if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).CrankcaseHeaterCapacityCurveIndex == 0) { // can't find the curve
1022 0 : ShowSevereError(state,
1023 0 : format("{} = {}: {} not found = {}",
1024 : CurrentModuleObject,
1025 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name,
1026 : cAlphaFields(7),
1027 : AlphArray(7)));
1028 0 : ErrorsFound = true;
1029 : } else {
1030 2 : ErrorsFound |=
1031 8 : Curve::CheckCurveDims(state,
1032 2 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).CrankcaseHeaterCapacityCurveIndex, // Curve index
1033 : {1}, // Valid dimensions
1034 : RoutineName, // Routine name
1035 : CurrentModuleObject, // Object Type
1036 2 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name, // Object Name
1037 2 : cAlphaFields(7)); // Field Name
1038 : }
1039 : }
1040 :
1041 : // Get Water System tank connections
1042 : // A8, \field Name of Water Storage Tank for Supply
1043 38 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).EvapWaterSupplyName = AlphArray(8);
1044 38 : if (lAlphaBlanks(8)) {
1045 38 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).EvapWaterSupplyMode = WaterSupplyFromMains;
1046 : } else {
1047 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).EvapWaterSupplyMode = WaterSupplyFromTank;
1048 0 : WaterManager::SetupTankDemandComponent(state,
1049 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name,
1050 : CurrentModuleObject,
1051 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).EvapWaterSupplyName,
1052 : ErrorsFound,
1053 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).EvapWaterSupTankID,
1054 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).EvapWaterTankDemandARRID);
1055 : }
1056 :
1057 : // A9; \field Name of Water Storage Tank for Condensate Collection
1058 38 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).CondensateCollectName = AlphArray(9);
1059 38 : if (lAlphaBlanks(9)) {
1060 38 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).CondensateCollectMode = CondensateDiscarded;
1061 : } else {
1062 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).CondensateCollectMode = CondensateToTank;
1063 0 : WaterManager::SetupTankSupplyComponent(state,
1064 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name,
1065 : CurrentModuleObject,
1066 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).CondensateCollectName,
1067 : ErrorsFound,
1068 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).CondensateTankID,
1069 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).CondensateTankSupplyARRID);
1070 : }
1071 :
1072 : // Basin heater power as a function of temperature must be greater than or equal to 0
1073 38 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).BasinHeaterPowerFTempDiff = NumArray(14);
1074 38 : if (NumArray(14) < 0.0) {
1075 0 : ShowSevereError(
1076 : state,
1077 0 : format("{}{}=\"{}\", invalid", RoutineName, CurrentModuleObject, state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name));
1078 0 : ShowContinueError(state, format("...{} must be >= 0.0.", cNumericFields(14)));
1079 0 : ShowContinueError(state, format("...entered value=[{:.2T}].", NumArray(14)));
1080 0 : ErrorsFound = true;
1081 : }
1082 :
1083 38 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).BasinHeaterSetPointTemp = NumArray(15);
1084 38 : if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).BasinHeaterPowerFTempDiff > 0.0) {
1085 0 : if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).BasinHeaterSetPointTemp < 2.0) {
1086 0 : ShowWarningError(state,
1087 0 : format("{}{}=\"{}\", freeze possible",
1088 : RoutineName,
1089 : CurrentModuleObject,
1090 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name));
1091 0 : ShowContinueError(state, format("...{} is < 2 {{C}}. Freezing could occur.", cNumericFields(15)));
1092 0 : ShowContinueError(state, format("...entered value=[{:.2T}].", NumArray(15)));
1093 : }
1094 : }
1095 :
1096 38 : if (lAlphaBlanks(10)) {
1097 : // Should this be ScheduleAlwaysOff?
1098 0 : } else if ((state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).basinHeaterSched = Sched::GetSchedule(state, AlphArray(10))) ==
1099 : nullptr) {
1100 0 : ShowWarningItemNotFound(
1101 0 : state, eoh, cAlphaFields(10), AlphArray(10), "Basin heater will be available to operate throughout the simulation.");
1102 : }
1103 :
1104 234 : for (int I = 1; I <= state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).NumOfSpeeds; ++I) {
1105 196 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedTotCap(I) = NumArray(16 + (I - 1) * 8);
1106 196 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedSHR(I) = NumArray(17 + (I - 1) * 8);
1107 196 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedCOP(I) = NumArray(18 + (I - 1) * 8);
1108 196 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedAirVolFlowRate(I) = NumArray(19 + (I - 1) * 8);
1109 196 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedEvaporatorFanPowerPerVolumeFlowRate2017(I) = NumArray(20 + (I - 1) * 8);
1110 196 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedEvaporatorFanPowerPerVolumeFlowRate2023(I) = NumArray(21 + (I - 1) * 8);
1111 196 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).EvapCondAirFlow(I) = NumArray(22 + (I - 1) * 8);
1112 196 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).EvapCondEffect(I) = NumArray(23 + (I - 1) * 8);
1113 392 : if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).EvapCondEffect(I) < 0.0 ||
1114 196 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).EvapCondEffect(I) > 1.0) {
1115 0 : ShowSevereError(
1116 : state,
1117 0 : format("{}{}=\"{}\", invalid", RoutineName, CurrentModuleObject, state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name));
1118 0 : ShowContinueError(state, format("...{} cannot be < 0.0 or > 1.0.", cNumericFields(23 + (I - 1) * 8)));
1119 0 : ShowContinueError(state, format("...entered value=[{:.2T}].", NumArray(23 + (I - 1) * 8)));
1120 0 : ErrorsFound = true;
1121 : }
1122 :
1123 196 : AlfaFieldIncre = 11 + (I - 1) * 4;
1124 196 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSCCapFTemp(I) =
1125 196 : Curve::GetCurveIndex(state, AlphArray(AlfaFieldIncre)); // convert curve name to number
1126 196 : if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSCCapFTemp(I) == 0) {
1127 0 : if (lAlphaBlanks(AlfaFieldIncre)) {
1128 0 : ShowSevereError(state,
1129 0 : format("{}{}=\"{}\", missing",
1130 : RoutineName,
1131 : CurrentModuleObject,
1132 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name));
1133 0 : ShowContinueError(state, format("...required {} is blank.", cAlphaFields(AlfaFieldIncre)));
1134 : } else {
1135 0 : ShowSevereError(state,
1136 0 : format("{}{}=\"{}\", invalid",
1137 : RoutineName,
1138 : CurrentModuleObject,
1139 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name));
1140 0 : ShowContinueError(state, format("...not found {}=\"{}\".", cAlphaFields(AlfaFieldIncre), AlphArray(AlfaFieldIncre)));
1141 : }
1142 0 : ErrorsFound = true;
1143 : } else {
1144 : // Verify Curve Object, only legal type is BiQuadratic
1145 588 : ErrorsFound |= Curve::CheckCurveDims(state,
1146 196 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSCCapFTemp(I), // Curve index
1147 : {2}, // Valid dimensions
1148 : RoutineName, // Routine name
1149 : CurrentModuleObject, // Object Type
1150 196 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name, // Object Name
1151 196 : cAlphaFields(AlfaFieldIncre)); // Field Name
1152 :
1153 196 : if (!ErrorsFound) {
1154 392 : CurveVal = Curve::CurveValue(
1155 196 : state, state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSCCapFTemp(I), RatedInletWetBulbTemp, RatedAmbAirTemp);
1156 196 : if (CurveVal > 1.10 || CurveVal < 0.90) {
1157 4 : ShowWarningError(state,
1158 4 : format("{}{}=\"{}\", curve values",
1159 : RoutineName,
1160 : CurrentModuleObject,
1161 2 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name));
1162 4 : ShowContinueError(
1163 4 : state, format("...{} output is not equal to 1.0 (+ or - 10%) at rated conditions.", cAlphaFields(AlfaFieldIncre)));
1164 2 : ShowContinueError(state, format("...Curve output at rated conditions = {:.3T}", CurveVal));
1165 : }
1166 : }
1167 : }
1168 :
1169 196 : AlfaFieldIncre = 12 + (I - 1) * 4;
1170 196 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSCCapAirFFlow(I) =
1171 196 : Curve::GetCurveIndex(state, AlphArray(AlfaFieldIncre)); // convert curve name to number
1172 196 : if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSCCapAirFFlow(I) == 0) {
1173 0 : if (lAlphaBlanks(AlfaFieldIncre)) {
1174 0 : ShowSevereError(state,
1175 0 : format("{}{}=\"{}\", missing",
1176 : RoutineName,
1177 : CurrentModuleObject,
1178 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name));
1179 0 : ShowContinueError(state, format("...required {} is blank.", cAlphaFields(AlfaFieldIncre)));
1180 : } else {
1181 0 : ShowSevereError(state,
1182 0 : format("{}{}=\"{}\", invalid",
1183 : RoutineName,
1184 : CurrentModuleObject,
1185 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name));
1186 0 : ShowContinueError(state, format("...not found {}=\"{}\".", cAlphaFields(AlfaFieldIncre), AlphArray(AlfaFieldIncre)));
1187 : }
1188 0 : ErrorsFound = true;
1189 : } else {
1190 : // Verify Curve Object, only legal type is Quadratic
1191 588 : ErrorsFound |= Curve::CheckCurveDims(state,
1192 196 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSCCapAirFFlow(I), // Curve index
1193 : {1}, // Valid dimensions
1194 : RoutineName, // Routine name
1195 : CurrentModuleObject, // Object Type
1196 196 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name, // Object Name
1197 196 : cAlphaFields(AlfaFieldIncre)); // Field Name
1198 :
1199 196 : if (!ErrorsFound) {
1200 196 : CurveVal = Curve::CurveValue(state, state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSCCapAirFFlow(I), 1.0);
1201 196 : if (CurveVal > 1.10 || CurveVal < 0.90) {
1202 0 : ShowWarningError(state,
1203 0 : format("{}{}=\"{}\", curve values",
1204 : RoutineName,
1205 : CurrentModuleObject,
1206 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name));
1207 0 : ShowContinueError(
1208 0 : state, format("...{} output is not equal to 1.0 (+ or - 10%) at rated conditions.", cAlphaFields(AlfaFieldIncre)));
1209 0 : ShowContinueError(state, format("...Curve output at rated conditions = {:.3T}", CurveVal));
1210 : }
1211 : }
1212 : }
1213 :
1214 196 : AlfaFieldIncre = 13 + (I - 1) * 4;
1215 196 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSEIRFTemp(I) =
1216 196 : Curve::GetCurveIndex(state, AlphArray(AlfaFieldIncre)); // convert curve name to number
1217 196 : if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSEIRFTemp(I) == 0) {
1218 0 : if (lAlphaBlanks(AlfaFieldIncre)) {
1219 0 : ShowSevereError(state,
1220 0 : format("{}{}=\"{}\", missing",
1221 : RoutineName,
1222 : CurrentModuleObject,
1223 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name));
1224 0 : ShowContinueError(state, format("...required {} is blank.", cAlphaFields(AlfaFieldIncre)));
1225 : } else {
1226 0 : ShowSevereError(state,
1227 0 : format("{}{}=\"{}\", invalid",
1228 : RoutineName,
1229 : CurrentModuleObject,
1230 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name));
1231 0 : ShowContinueError(state, format("...not found {}=\"{}\".", cAlphaFields(AlfaFieldIncre), AlphArray(AlfaFieldIncre)));
1232 : }
1233 0 : ErrorsFound = true;
1234 : } else {
1235 : // Verify Curve Object, only legal type is BiQuadratic
1236 588 : ErrorsFound |= Curve::CheckCurveDims(state,
1237 196 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSEIRFTemp(I), // Curve index
1238 : {2}, // Valid dimensions
1239 : RoutineName, // Routine name
1240 : CurrentModuleObject, // Object Type
1241 196 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name, // Object Name
1242 196 : cAlphaFields(AlfaFieldIncre)); // Field Name
1243 :
1244 196 : if (!ErrorsFound) {
1245 392 : CurveVal = Curve::CurveValue(
1246 196 : state, state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSEIRFTemp(I), RatedInletWetBulbTemp, RatedAmbAirTemp);
1247 196 : if (CurveVal > 1.10 || CurveVal < 0.90) {
1248 4 : ShowWarningError(state,
1249 4 : format("{}{}=\"{}\", curve values",
1250 : RoutineName,
1251 : CurrentModuleObject,
1252 2 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name));
1253 4 : ShowContinueError(
1254 4 : state, format("...{} output is not equal to 1.0 (+ or - 10%) at rated conditions.", cAlphaFields(AlfaFieldIncre)));
1255 2 : ShowContinueError(state, format("...Curve output at rated conditions = {:.3T}", CurveVal));
1256 : }
1257 : }
1258 : }
1259 :
1260 196 : AlfaFieldIncre = 14 + (I - 1) * 4;
1261 196 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSEIRAirFFlow(I) =
1262 196 : Curve::GetCurveIndex(state, AlphArray(AlfaFieldIncre)); // convert curve name to number
1263 196 : if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSEIRAirFFlow(I) == 0) {
1264 0 : if (lAlphaBlanks(AlfaFieldIncre)) {
1265 0 : ShowSevereError(state,
1266 0 : format("{}{}=\"{}\", missing",
1267 : RoutineName,
1268 : CurrentModuleObject,
1269 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name));
1270 0 : ShowContinueError(state, format("...required {} is blank.", cAlphaFields(AlfaFieldIncre)));
1271 : } else {
1272 0 : ShowSevereError(state,
1273 0 : format("{}{}=\"{}\", invalid",
1274 : RoutineName,
1275 : CurrentModuleObject,
1276 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name));
1277 0 : ShowContinueError(state, format("...not found {}=\"{}\".", cAlphaFields(AlfaFieldIncre), AlphArray(AlfaFieldIncre)));
1278 : }
1279 0 : ErrorsFound = true;
1280 : } else {
1281 : // Verify Curve Object, only legal type is Quadratic
1282 588 : ErrorsFound |= Curve::CheckCurveDims(state,
1283 196 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSEIRAirFFlow(I), // Curve index
1284 : {1}, // Valid dimensions
1285 : RoutineName, // Routine name
1286 : CurrentModuleObject, // Object Type
1287 196 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name, // Object Name
1288 196 : cAlphaFields(AlfaFieldIncre)); // Field Name
1289 :
1290 196 : if (!ErrorsFound) {
1291 196 : CurveVal = Curve::CurveValue(state, state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSEIRAirFFlow(I), 1.0);
1292 196 : if (CurveVal > 1.10 || CurveVal < 0.90) {
1293 0 : ShowWarningError(state,
1294 0 : format("{}{}=\"{}\", curve values",
1295 : RoutineName,
1296 : CurrentModuleObject,
1297 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name));
1298 0 : ShowContinueError(
1299 0 : state, format("...{} output is not equal to 1.0 (+ or - 10%) at rated conditions.", cAlphaFields(AlfaFieldIncre)));
1300 0 : ShowContinueError(state, format("...Curve output at rated conditions = {:.3T}", CurveVal));
1301 : }
1302 : }
1303 : }
1304 : }
1305 :
1306 234 : for (int I = 1; I <= state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).NumOfSpeeds; ++I) {
1307 196 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedPercentTotCap(I) =
1308 196 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedTotCap(I) /
1309 392 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedTotCap(
1310 196 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).NumOfSpeeds);
1311 196 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedAirVolFlowPerRatedTotCap(I) =
1312 196 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedAirVolFlowRate(I) /
1313 196 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedTotCap(I);
1314 196 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedEvapCondVolFlowPerRatedTotCap(I) =
1315 196 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).EvapCondAirFlow(I) /
1316 196 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedTotCap(I);
1317 : }
1318 :
1319 : // CurrentModuleObject = "Coil:Cooling:DX:VariableSpeed"
1320 76 : SetupOutputVariable(state,
1321 : "Cooling Coil Electricity Energy",
1322 : Constant::Units::J,
1323 38 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Energy,
1324 : OutputProcessor::TimeStepType::System,
1325 : OutputProcessor::StoreType::Sum,
1326 38 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name,
1327 : Constant::eResource::Electricity,
1328 : OutputProcessor::Group::HVAC,
1329 : OutputProcessor::EndUseCat::Cooling);
1330 76 : SetupOutputVariable(state,
1331 : "Cooling Coil Total Cooling Energy",
1332 : Constant::Units::J,
1333 38 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).EnergyLoadTotal,
1334 : OutputProcessor::TimeStepType::System,
1335 : OutputProcessor::StoreType::Sum,
1336 38 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name,
1337 : Constant::eResource::EnergyTransfer,
1338 : OutputProcessor::Group::HVAC,
1339 : OutputProcessor::EndUseCat::CoolingCoils);
1340 76 : SetupOutputVariable(state,
1341 : "Cooling Coil Sensible Cooling Energy",
1342 : Constant::Units::J,
1343 38 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).EnergySensible,
1344 : OutputProcessor::TimeStepType::System,
1345 : OutputProcessor::StoreType::Sum,
1346 38 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name);
1347 76 : SetupOutputVariable(state,
1348 : "Cooling Coil Latent Cooling Energy",
1349 : Constant::Units::J,
1350 38 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).EnergyLatent,
1351 : OutputProcessor::TimeStepType::System,
1352 : OutputProcessor::StoreType::Sum,
1353 38 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name);
1354 76 : SetupOutputVariable(state,
1355 : "Cooling Coil Source Side Heat Transfer Energy",
1356 : Constant::Units::J,
1357 38 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).EnergySource,
1358 : OutputProcessor::TimeStepType::System,
1359 : OutputProcessor::StoreType::Sum,
1360 38 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name);
1361 :
1362 38 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).RatedCapCoolSens =
1363 : DataSizing::AutoSize; // always auto-sized, to be determined in the sizing calculation
1364 : }
1365 :
1366 : //-------------------------AIR SOURCE COOLING---END
1367 :
1368 : // Get the data for heating coil, WATER SOURCE
1369 49 : CurrentModuleObject = "Coil:Heating:WaterToAirHeatPump:VariableSpeedEquationFit";
1370 :
1371 53 : for (int CoilCounter = 1; CoilCounter <= NumHeat; ++CoilCounter) {
1372 :
1373 4 : ++DXCoilNum;
1374 :
1375 4 : state.dataInputProcessing->inputProcessor->getObjectItem(state,
1376 : CurrentModuleObject,
1377 : CoilCounter,
1378 : AlphArray,
1379 : NumAlphas,
1380 : NumArray,
1381 : NumNums,
1382 : IOStat,
1383 : lNumericBlanks,
1384 : lAlphaBlanks,
1385 : cAlphaFields,
1386 : cNumericFields);
1387 : // ErrorsFound will be set to True if problem was found, left untouched otherwise
1388 4 : GlobalNames::VerifyUniqueCoilName(state, CurrentModuleObject, AlphArray(1), ErrorsFound, CurrentModuleObject + " Name");
1389 :
1390 4 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).bIsDesuperheater = false;
1391 4 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name = AlphArray(1);
1392 4 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).CoolHeatType = "HEATING";
1393 4 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).VSCoilType = HVAC::Coil_HeatingWaterToAirHPVSEquationFit; // fix coil type
1394 :
1395 4 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).VarSpeedCoilType =
1396 8 : HVAC::cAllCoilTypes(state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).VSCoilType);
1397 4 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).NumOfSpeeds = int(NumArray(1));
1398 4 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).NormSpedLevel = int(NumArray(2));
1399 4 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).RatedCapHeat = NumArray(3);
1400 4 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).RatedAirVolFlowRate = NumArray(4);
1401 4 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).RatedWaterVolFlowRate = NumArray(5);
1402 4 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).CondenserType = DataHeatBalance::RefrigCondenserType::Water;
1403 :
1404 : // Previously set by parent objects, but not user-definable
1405 4 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MaxONOFFCyclesperHour = 4;
1406 4 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).LatentCapacityTimeConstant = 0.;
1407 4 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).FanDelayTime = 0.;
1408 :
1409 4 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).WaterInletNodeNum =
1410 8 : GetOnlySingleNode(state,
1411 4 : AlphArray(2),
1412 : ErrorsFound,
1413 : DataLoopNode::ConnectionObjectType::CoilHeatingWaterToAirHeatPumpVariableSpeedEquationFit,
1414 4 : AlphArray(1),
1415 : DataLoopNode::NodeFluidType::Water,
1416 : DataLoopNode::ConnectionType::Inlet,
1417 : NodeInputManager::CompFluidStream::Secondary,
1418 : DataLoopNode::ObjectIsNotParent);
1419 4 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).WaterOutletNodeNum =
1420 8 : GetOnlySingleNode(state,
1421 4 : AlphArray(3),
1422 : ErrorsFound,
1423 : DataLoopNode::ConnectionObjectType::CoilHeatingWaterToAirHeatPumpVariableSpeedEquationFit,
1424 4 : AlphArray(1),
1425 : DataLoopNode::NodeFluidType::Water,
1426 : DataLoopNode::ConnectionType::Outlet,
1427 : NodeInputManager::CompFluidStream::Secondary,
1428 : DataLoopNode::ObjectIsNotParent);
1429 4 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).AirInletNodeNum =
1430 8 : GetOnlySingleNode(state,
1431 4 : AlphArray(4),
1432 : ErrorsFound,
1433 : DataLoopNode::ConnectionObjectType::CoilHeatingWaterToAirHeatPumpVariableSpeedEquationFit,
1434 4 : AlphArray(1),
1435 : DataLoopNode::NodeFluidType::Air,
1436 : DataLoopNode::ConnectionType::Inlet,
1437 : NodeInputManager::CompFluidStream::Primary,
1438 : DataLoopNode::ObjectIsNotParent);
1439 4 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).AirOutletNodeNum =
1440 12 : GetOnlySingleNode(state,
1441 4 : AlphArray(5),
1442 : ErrorsFound,
1443 : DataLoopNode::ConnectionObjectType::CoilHeatingWaterToAirHeatPumpVariableSpeedEquationFit,
1444 4 : AlphArray(1),
1445 : DataLoopNode::NodeFluidType::Air,
1446 : DataLoopNode::ConnectionType::Outlet,
1447 : NodeInputManager::CompFluidStream::Primary,
1448 : DataLoopNode::ObjectIsNotParent);
1449 :
1450 8 : BranchNodeConnections::TestCompSet(state, CurrentModuleObject, AlphArray(1), AlphArray(2), AlphArray(3), "Water Nodes");
1451 4 : BranchNodeConnections::TestCompSet(state, CurrentModuleObject, AlphArray(1), AlphArray(4), AlphArray(5), "Air Nodes");
1452 :
1453 : // If (VarSpeedCoil(DXCoilNum)%NumOfSpeeds .LT. 2) Then
1454 4 : if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).NumOfSpeeds < 1) {
1455 0 : ShowSevereError(
1456 : state,
1457 0 : format("{}{}=\"{}\", invalid", RoutineName, CurrentModuleObject, state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name));
1458 0 : ShowContinueError(state, format("...{} must be >= 1. entered number is {:.0T}", cNumericFields(1), NumArray(1)));
1459 0 : ErrorsFound = true;
1460 : }
1461 :
1462 4 : if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).NormSpedLevel >
1463 4 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).NumOfSpeeds) {
1464 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).NormSpedLevel =
1465 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).NumOfSpeeds;
1466 : }
1467 :
1468 4 : if ((state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).NormSpedLevel >
1469 8 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).NumOfSpeeds) ||
1470 4 : (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).NormSpedLevel <= 0)) {
1471 0 : ShowSevereError(
1472 : state,
1473 0 : format("{}{}=\"{}\", invalid", RoutineName, CurrentModuleObject, state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name));
1474 0 : ShowContinueError(state, format("...{} must be valid speed level entered number is {:.0T}", cNumericFields(2), NumArray(2)));
1475 0 : ErrorsFound = true;
1476 : }
1477 :
1478 : // part load curve
1479 4 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).PLFFPLR = Curve::GetCurveIndex(state, AlphArray(6)); // convert curve name to number
1480 4 : if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).PLFFPLR == 0) {
1481 0 : if (lAlphaBlanks(6)) {
1482 0 : ShowSevereError(
1483 : state,
1484 0 : format("{}{}=\"{}\", missing", RoutineName, CurrentModuleObject, state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name));
1485 0 : ShowContinueError(state, format("...required {} is blank.", cAlphaFields(6)));
1486 : } else {
1487 0 : ShowSevereError(
1488 : state,
1489 0 : format("{}{}=\"{}\", invalid", RoutineName, CurrentModuleObject, state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name));
1490 0 : ShowContinueError(state, format("...not found {}=\"{}\".", cAlphaFields(6), AlphArray(6)));
1491 : }
1492 0 : ErrorsFound = true;
1493 : } else {
1494 4 : CurveVal = Curve::CurveValue(state, state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).PLFFPLR, 1.0);
1495 4 : if (CurveVal > 1.10 || CurveVal < 0.90) {
1496 0 : ShowWarningError(state,
1497 0 : format("{}{}=\"{}\", curve values",
1498 : RoutineName,
1499 : CurrentModuleObject,
1500 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name));
1501 0 : ShowContinueError(state, format("...{} output is not equal to 1.0 (+ or - 10%) at rated conditions.", cAlphaFields(6)));
1502 0 : ShowContinueError(state, format("...Curve output at rated conditions = {:.3T}", CurveVal));
1503 : }
1504 : }
1505 :
1506 42 : for (int I = 1; I <= state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).NumOfSpeeds; ++I) {
1507 38 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedTotCap(I) = NumArray(6 + (I - 1) * 5);
1508 38 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedCOP(I) = NumArray(7 + (I - 1) * 5);
1509 38 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedAirVolFlowRate(I) = NumArray(8 + (I - 1) * 5);
1510 38 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedWaterVolFlowRate(I) = NumArray(9 + (I - 1) * 5);
1511 38 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSWasteHeatFrac(I) = NumArray(10 + (I - 1) * 5);
1512 :
1513 38 : AlfaFieldIncre = 7 + (I - 1) * 7;
1514 38 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSCCapFTemp(I) =
1515 38 : Curve::GetCurveIndex(state, AlphArray(AlfaFieldIncre)); // convert curve name to number
1516 38 : if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSCCapFTemp(I) == 0) {
1517 0 : if (lAlphaBlanks(AlfaFieldIncre)) {
1518 0 : ShowSevereError(state,
1519 0 : format("{}{}=\"{}\", missing",
1520 : RoutineName,
1521 : CurrentModuleObject,
1522 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name));
1523 0 : ShowContinueError(state, format("...required {} is blank.", cAlphaFields(AlfaFieldIncre)));
1524 : } else {
1525 0 : ShowSevereError(state,
1526 0 : format("{}{}=\"{}\", invalid",
1527 : RoutineName,
1528 : CurrentModuleObject,
1529 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name));
1530 0 : ShowContinueError(state, format("...not found {}=\"{}\".", cAlphaFields(AlfaFieldIncre), AlphArray(AlfaFieldIncre)));
1531 : }
1532 0 : ErrorsFound = true;
1533 : } else {
1534 : // Verify Curve Object, only legal type is BiQuadratic
1535 114 : ErrorsFound |= Curve::CheckCurveDims(state,
1536 38 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSCCapFTemp(I), // Curve index
1537 : {2}, // Valid dimensions
1538 : RoutineName, // Routine name
1539 : CurrentModuleObject, // Object Type
1540 38 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name, // Object Name
1541 38 : cAlphaFields(AlfaFieldIncre)); // Field Name
1542 :
1543 38 : if (!ErrorsFound) {
1544 76 : CurveVal = Curve::CurveValue(state,
1545 38 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSCCapFTemp(I),
1546 : RatedInletAirTempHeat,
1547 : RatedInletWaterTempHeat);
1548 38 : if (CurveVal > 1.10 || CurveVal < 0.90) {
1549 0 : ShowWarningError(state,
1550 0 : format("{}{}=\"{}\", curve values",
1551 : RoutineName,
1552 : CurrentModuleObject,
1553 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name));
1554 0 : ShowContinueError(
1555 0 : state, format("...{} output is not equal to 1.0 (+ or - 10%) at rated conditions.", cAlphaFields(AlfaFieldIncre)));
1556 0 : ShowContinueError(state, format("...Curve output at rated conditions = {:.3T}", CurveVal));
1557 : }
1558 : }
1559 : }
1560 :
1561 38 : AlfaFieldIncre = 8 + (I - 1) * 7;
1562 38 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSCCapAirFFlow(I) =
1563 38 : Curve::GetCurveIndex(state, AlphArray(AlfaFieldIncre)); // convert curve name to number
1564 38 : if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSCCapAirFFlow(I) == 0) {
1565 0 : if (lAlphaBlanks(AlfaFieldIncre)) {
1566 0 : ShowSevereError(state,
1567 0 : format("{}{}=\"{}\", missing",
1568 : RoutineName,
1569 : CurrentModuleObject,
1570 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name));
1571 0 : ShowContinueError(state, format("...required {} is blank.", cAlphaFields(AlfaFieldIncre)));
1572 : } else {
1573 0 : ShowSevereError(state,
1574 0 : format("{}{}=\"{}\", invalid",
1575 : RoutineName,
1576 : CurrentModuleObject,
1577 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name));
1578 0 : ShowContinueError(state, format("...not found {}=\"{}\".", cAlphaFields(AlfaFieldIncre), AlphArray(AlfaFieldIncre)));
1579 : }
1580 0 : ErrorsFound = true;
1581 : } else {
1582 : // Verify Curve Object, only legal type is Quadratic
1583 114 : ErrorsFound |= Curve::CheckCurveDims(state,
1584 38 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSCCapAirFFlow(I), // Curve index
1585 : {1}, // Valid dimensions
1586 : RoutineName, // Routine name
1587 : CurrentModuleObject, // Object Type
1588 38 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name, // Object Name
1589 38 : cAlphaFields(AlfaFieldIncre)); // Field Name
1590 :
1591 38 : if (!ErrorsFound) {
1592 38 : CurveVal = Curve::CurveValue(state, state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSCCapAirFFlow(I), 1.0);
1593 38 : if (CurveVal > 1.10 || CurveVal < 0.90) {
1594 0 : ShowWarningError(state,
1595 0 : format("{}{}=\"{}\", curve values",
1596 : RoutineName,
1597 : CurrentModuleObject,
1598 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name));
1599 0 : ShowContinueError(
1600 0 : state, format("...{} output is not equal to 1.0 (+ or - 10%) at rated conditions.", cAlphaFields(AlfaFieldIncre)));
1601 0 : ShowContinueError(state, format("...Curve output at rated conditions = {:.3T}", CurveVal));
1602 : }
1603 : }
1604 : }
1605 :
1606 38 : AlfaFieldIncre = 9 + (I - 1) * 7;
1607 38 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSCCapWaterFFlow(I) =
1608 38 : Curve::GetCurveIndex(state, AlphArray(AlfaFieldIncre)); // convert curve name to number
1609 38 : if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSCCapWaterFFlow(I) == 0) {
1610 0 : if (lAlphaBlanks(AlfaFieldIncre)) {
1611 0 : ShowSevereError(state,
1612 0 : format("{}{}=\"{}\", missing",
1613 : RoutineName,
1614 : CurrentModuleObject,
1615 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name));
1616 0 : ShowContinueError(state, format("...required {} is blank.", cAlphaFields(AlfaFieldIncre)));
1617 : } else {
1618 0 : ShowSevereError(state,
1619 0 : format("{}{}=\"{}\", invalid",
1620 : RoutineName,
1621 : CurrentModuleObject,
1622 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name));
1623 0 : ShowContinueError(state, format("...not found {}=\"{}\".", cAlphaFields(AlfaFieldIncre), AlphArray(AlfaFieldIncre)));
1624 : }
1625 0 : ErrorsFound = true;
1626 : } else {
1627 : // Verify Curve Object, only legal type is Quadratic
1628 114 : ErrorsFound |= Curve::CheckCurveDims(state,
1629 38 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSCCapWaterFFlow(I), // Curve index
1630 : {1}, // Valid dimensions
1631 : RoutineName, // Routine name
1632 : CurrentModuleObject, // Object Type
1633 38 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name, // Object Name
1634 38 : cAlphaFields(AlfaFieldIncre)); // Field Name
1635 :
1636 38 : if (!ErrorsFound) {
1637 38 : CurveVal = Curve::CurveValue(state, state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSCCapWaterFFlow(I), 1.0);
1638 38 : if (CurveVal > 1.10 || CurveVal < 0.90) {
1639 0 : ShowWarningError(state,
1640 0 : format("{}{}=\"{}\", curve values",
1641 : RoutineName,
1642 : CurrentModuleObject,
1643 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name));
1644 0 : ShowContinueError(
1645 0 : state, format("...{} output is not equal to 1.0 (+ or - 10%) at rated conditions.", cAlphaFields(AlfaFieldIncre)));
1646 0 : ShowContinueError(state, format("...Curve output at rated conditions = {:.3T}", CurveVal));
1647 : }
1648 : }
1649 : }
1650 :
1651 38 : AlfaFieldIncre = 10 + (I - 1) * 7;
1652 38 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSEIRFTemp(I) =
1653 38 : Curve::GetCurveIndex(state, AlphArray(AlfaFieldIncre)); // convert curve name to number
1654 38 : if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSEIRFTemp(I) == 0) {
1655 0 : if (lAlphaBlanks(AlfaFieldIncre)) {
1656 0 : ShowSevereError(state,
1657 0 : format("{}{}=\"{}\", missing",
1658 : RoutineName,
1659 : CurrentModuleObject,
1660 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name));
1661 0 : ShowContinueError(state, format("...required {} is blank.", cAlphaFields(AlfaFieldIncre)));
1662 : } else {
1663 0 : ShowSevereError(state,
1664 0 : format("{}{}=\"{}\", invalid",
1665 : RoutineName,
1666 : CurrentModuleObject,
1667 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name));
1668 0 : ShowContinueError(state, format("...not found {}=\"{}\".", cAlphaFields(AlfaFieldIncre), AlphArray(AlfaFieldIncre)));
1669 : }
1670 0 : ErrorsFound = true;
1671 : } else {
1672 : // Verify Curve Object, only legal type is BiQuadratic
1673 114 : ErrorsFound |= Curve::CheckCurveDims(state,
1674 38 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSEIRFTemp(I), // Curve index
1675 : {2}, // Valid dimensions
1676 : RoutineName, // Routine name
1677 : CurrentModuleObject, // Object Type
1678 38 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name, // Object Name
1679 38 : cAlphaFields(AlfaFieldIncre)); // Field Name
1680 :
1681 38 : if (!ErrorsFound) {
1682 76 : CurveVal = Curve::CurveValue(state,
1683 38 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSEIRFTemp(I),
1684 : RatedInletAirTempHeat,
1685 : RatedInletWaterTempHeat);
1686 38 : if (CurveVal > 1.10 || CurveVal < 0.90) {
1687 0 : ShowWarningError(state,
1688 0 : format("{}{}=\"{}\", curve values",
1689 : RoutineName,
1690 : CurrentModuleObject,
1691 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name));
1692 0 : ShowContinueError(
1693 0 : state, format("...{} output is not equal to 1.0 (+ or - 10%) at rated conditions.", cAlphaFields(AlfaFieldIncre)));
1694 0 : ShowContinueError(state, format("...Curve output at rated conditions = {:.3T}", CurveVal));
1695 : }
1696 : }
1697 : }
1698 :
1699 38 : AlfaFieldIncre = 11 + (I - 1) * 7;
1700 38 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSEIRAirFFlow(I) =
1701 38 : Curve::GetCurveIndex(state, AlphArray(AlfaFieldIncre)); // convert curve name to number
1702 38 : if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSEIRAirFFlow(I) == 0) {
1703 0 : if (lAlphaBlanks(AlfaFieldIncre)) {
1704 0 : ShowSevereError(state,
1705 0 : format("{}{}=\"{}\", missing",
1706 : RoutineName,
1707 : CurrentModuleObject,
1708 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name));
1709 0 : ShowContinueError(state, format("...required {} is blank.", cAlphaFields(AlfaFieldIncre)));
1710 : } else {
1711 0 : ShowSevereError(state,
1712 0 : format("{}{}=\"{}\", invalid",
1713 : RoutineName,
1714 : CurrentModuleObject,
1715 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name));
1716 0 : ShowContinueError(state, format("...not found {}=\"{}\".", cAlphaFields(AlfaFieldIncre), AlphArray(AlfaFieldIncre)));
1717 : }
1718 0 : ErrorsFound = true;
1719 : } else {
1720 : // Verify Curve Object, only legal type is Quadratic
1721 114 : ErrorsFound |= Curve::CheckCurveDims(state,
1722 38 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSEIRAirFFlow(I), // Curve index
1723 : {1}, // Valid dimensions
1724 : RoutineName, // Routine name
1725 : CurrentModuleObject, // Object Type
1726 38 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name, // Object Name
1727 38 : cAlphaFields(AlfaFieldIncre)); // Field Name
1728 :
1729 38 : if (!ErrorsFound) {
1730 38 : CurveVal = Curve::CurveValue(state, state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSEIRAirFFlow(I), 1.0);
1731 38 : if (CurveVal > 1.10 || CurveVal < 0.90) {
1732 0 : ShowWarningError(state,
1733 0 : format("{}{}=\"{}\", curve values",
1734 : RoutineName,
1735 : CurrentModuleObject,
1736 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name));
1737 0 : ShowContinueError(
1738 0 : state, format("...{} output is not equal to 1.0 (+ or - 10%) at rated conditions.", cAlphaFields(AlfaFieldIncre)));
1739 0 : ShowContinueError(state, format("...Curve output at rated conditions = {:.3T}", CurveVal));
1740 : }
1741 : }
1742 : }
1743 :
1744 38 : AlfaFieldIncre = 12 + (I - 1) * 7;
1745 38 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSEIRWaterFFlow(I) =
1746 38 : Curve::GetCurveIndex(state, AlphArray(AlfaFieldIncre)); // convert curve name to number
1747 38 : if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSEIRWaterFFlow(I) == 0) {
1748 0 : if (lAlphaBlanks(AlfaFieldIncre)) {
1749 0 : ShowSevereError(state,
1750 0 : format("{}{}=\"{}\", missing",
1751 : RoutineName,
1752 : CurrentModuleObject,
1753 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name));
1754 0 : ShowContinueError(state, format("...required {} is blank.", cAlphaFields(AlfaFieldIncre)));
1755 : } else {
1756 0 : ShowSevereError(state,
1757 0 : format("{}{}=\"{}\", invalid",
1758 : RoutineName,
1759 : CurrentModuleObject,
1760 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name));
1761 0 : ShowContinueError(state, format("...not found {}=\"{}\".", cAlphaFields(AlfaFieldIncre), AlphArray(AlfaFieldIncre)));
1762 : }
1763 0 : ErrorsFound = true;
1764 : } else {
1765 : // Verify Curve Object, only legal type is Quadratic
1766 114 : ErrorsFound |= Curve::CheckCurveDims(state,
1767 38 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSEIRWaterFFlow(I), // Curve index
1768 : {1}, // Valid dimensions
1769 : RoutineName, // Routine name
1770 : CurrentModuleObject, // Object Type
1771 38 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name, // Object Name
1772 38 : cAlphaFields(AlfaFieldIncre)); // Field Name
1773 :
1774 38 : if (!ErrorsFound) {
1775 38 : CurveVal = Curve::CurveValue(state, state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSEIRWaterFFlow(I), 1.0);
1776 38 : if (CurveVal > 1.10 || CurveVal < 0.90) {
1777 0 : ShowWarningError(state,
1778 0 : format("{}{}=\"{}\", curve values",
1779 : RoutineName,
1780 : CurrentModuleObject,
1781 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name));
1782 0 : ShowContinueError(
1783 0 : state, format("...{} output is not equal to 1.0 (+ or - 10%) at rated conditions.", cAlphaFields(AlfaFieldIncre)));
1784 0 : ShowContinueError(state, format("...Curve output at rated conditions = {:.3T}", CurveVal));
1785 : }
1786 : }
1787 : }
1788 :
1789 38 : AlfaFieldIncre = 13 + (I - 1) * 7;
1790 : // Read waste heat modifier curve name
1791 38 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSWasteHeat(I) =
1792 38 : Curve::GetCurveIndex(state, AlphArray(AlfaFieldIncre)); // convert curve name to number
1793 38 : if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSWasteHeat(I) == 0) {
1794 0 : if (lAlphaBlanks(AlfaFieldIncre)) {
1795 0 : ShowSevereError(state,
1796 0 : format("{}{}=\"{}\", missing",
1797 : RoutineName,
1798 : CurrentModuleObject,
1799 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name));
1800 0 : ShowContinueError(state, format("...required {} is blank.", cAlphaFields(AlfaFieldIncre)));
1801 : } else {
1802 0 : ShowSevereError(state,
1803 0 : format("{}{}=\"{}\", invalid",
1804 : RoutineName,
1805 : CurrentModuleObject,
1806 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name));
1807 0 : ShowContinueError(state, format("...not found {}=\"{}\".", cAlphaFields(AlfaFieldIncre), AlphArray(AlfaFieldIncre)));
1808 : }
1809 0 : ErrorsFound = true;
1810 : } else {
1811 : // Verify Curve Object, only legal types are BiQuadratic
1812 114 : ErrorsFound |= Curve::CheckCurveDims(state,
1813 38 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSWasteHeat(I), // Curve index
1814 : {2}, // Valid dimensions
1815 : RoutineName, // Routine name
1816 : CurrentModuleObject, // Object Type
1817 38 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name, // Object Name
1818 38 : cAlphaFields(AlfaFieldIncre)); // Field Name
1819 :
1820 38 : if (!ErrorsFound) {
1821 76 : CurveVal = Curve::CurveValue(state,
1822 38 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSWasteHeat(I),
1823 : RatedInletAirTempHeat,
1824 : RatedInletWaterTempHeat);
1825 38 : if (CurveVal > 1.10 || CurveVal < 0.90) {
1826 0 : ShowWarningError(state,
1827 0 : format("{}{}=\"{}\", curve values",
1828 : RoutineName,
1829 : CurrentModuleObject,
1830 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name));
1831 0 : ShowContinueError(
1832 0 : state, format("...{} output is not equal to 1.0 (+ or - 10%) at rated conditions.", cAlphaFields(AlfaFieldIncre)));
1833 0 : ShowContinueError(state, format("...Curve output at rated conditions = {:.3T}", CurveVal));
1834 : }
1835 : }
1836 : }
1837 : }
1838 :
1839 42 : for (int I = 1; I <= state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).NumOfSpeeds; ++I) {
1840 38 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedPercentTotCap(I) =
1841 38 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedTotCap(I) /
1842 76 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedTotCap(
1843 38 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).NumOfSpeeds);
1844 38 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedAirVolFlowPerRatedTotCap(I) =
1845 38 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedAirVolFlowRate(I) /
1846 38 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedTotCap(I);
1847 38 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedWaterVolFlowPerRatedTotCap(I) =
1848 38 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedWaterVolFlowRate(I) /
1849 38 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedTotCap(I);
1850 : }
1851 :
1852 : // CurrentModuleObject = "Coil:Heating:WaterToAirHeatPump:VariableSpeedEquationFit"
1853 8 : SetupOutputVariable(state,
1854 : "Heating Coil Electricity Energy",
1855 : Constant::Units::J,
1856 4 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Energy,
1857 : OutputProcessor::TimeStepType::System,
1858 : OutputProcessor::StoreType::Sum,
1859 4 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name,
1860 : Constant::eResource::Electricity,
1861 : OutputProcessor::Group::HVAC,
1862 : OutputProcessor::EndUseCat::Heating);
1863 8 : SetupOutputVariable(state,
1864 : "Heating Coil Heating Energy",
1865 : Constant::Units::J,
1866 4 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).EnergyLoadTotal,
1867 : OutputProcessor::TimeStepType::System,
1868 : OutputProcessor::StoreType::Sum,
1869 4 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name,
1870 : Constant::eResource::EnergyTransfer,
1871 : OutputProcessor::Group::HVAC,
1872 : OutputProcessor::EndUseCat::HeatingCoils);
1873 8 : SetupOutputVariable(state,
1874 : "Heating Coil Source Side Heat Transfer Energy",
1875 : Constant::Units::J,
1876 4 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).EnergySource,
1877 : OutputProcessor::TimeStepType::System,
1878 : OutputProcessor::StoreType::Sum,
1879 4 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name,
1880 : Constant::eResource::PlantLoopHeatingDemand,
1881 : OutputProcessor::Group::HVAC,
1882 : OutputProcessor::EndUseCat::HeatingCoils);
1883 :
1884 : // create predefined report entries
1885 8 : OutputReportPredefined::PreDefTableEntry(
1886 4 : state, state.dataOutRptPredefined->pdchHeatCoilType, state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name, CurrentModuleObject);
1887 8 : OutputReportPredefined::PreDefTableEntry(state,
1888 4 : state.dataOutRptPredefined->pdchHeatCoilNomCap,
1889 4 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name,
1890 4 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).RatedCapHeat);
1891 8 : OutputReportPredefined::PreDefTableEntry(state,
1892 4 : state.dataOutRptPredefined->pdchHeatCoilNomEff,
1893 4 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name,
1894 8 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedCOP(
1895 4 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).NormSpedLevel));
1896 : }
1897 :
1898 : //-------------------------AIR SOURCE, HEATING---BEGIN
1899 : // Get the data for heating coil, AIR SOURCE
1900 49 : CurrentModuleObject = "COIL:HEATING:DX:VARIABLESPEED";
1901 :
1902 62 : for (int CoilCounter = 1; CoilCounter <= NumHeatAS; ++CoilCounter) {
1903 :
1904 13 : ++DXCoilNum;
1905 :
1906 13 : state.dataInputProcessing->inputProcessor->getObjectItem(state,
1907 : CurrentModuleObject,
1908 : CoilCounter,
1909 : AlphArray,
1910 : NumAlphas,
1911 : NumArray,
1912 : NumNums,
1913 : IOStat,
1914 : lNumericBlanks,
1915 : lAlphaBlanks,
1916 : cAlphaFields,
1917 : cNumericFields);
1918 : // ErrorsFound will be set to True if problem was found, left untouched otherwise
1919 13 : GlobalNames::VerifyUniqueCoilName(state, CurrentModuleObject, AlphArray(1), ErrorsFound, CurrentModuleObject + " Name");
1920 :
1921 13 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).bIsDesuperheater = false;
1922 13 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name = AlphArray(1);
1923 13 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).CoolHeatType = "HEATING";
1924 13 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).VSCoilType = HVAC::Coil_HeatingAirToAirVariableSpeed;
1925 13 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).VarSpeedCoilType = HVAC::cAllCoilTypes(HVAC::Coil_HeatingAirToAirVariableSpeed);
1926 13 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).NumOfSpeeds = int(NumArray(1));
1927 13 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).NormSpedLevel = int(NumArray(2));
1928 13 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).RatedCapHeat = NumArray(3);
1929 13 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).RatedAirVolFlowRate = NumArray(4);
1930 :
1931 : // Previously set by parent objects, but not user-definable
1932 13 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MaxONOFFCyclesperHour = 4;
1933 13 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).LatentCapacityTimeConstant = 0.;
1934 13 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).FanDelayTime = 0.;
1935 :
1936 13 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).AirInletNodeNum =
1937 26 : GetOnlySingleNode(state,
1938 13 : AlphArray(2),
1939 : ErrorsFound,
1940 : DataLoopNode::ConnectionObjectType::CoilHeatingDXVariableSpeed,
1941 13 : AlphArray(1),
1942 : DataLoopNode::NodeFluidType::Air,
1943 : DataLoopNode::ConnectionType::Inlet,
1944 : NodeInputManager::CompFluidStream::Primary,
1945 : DataLoopNode::ObjectIsNotParent);
1946 13 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).AirOutletNodeNum =
1947 39 : GetOnlySingleNode(state,
1948 13 : AlphArray(3),
1949 : ErrorsFound,
1950 : DataLoopNode::ConnectionObjectType::CoilHeatingDXVariableSpeed,
1951 13 : AlphArray(1),
1952 : DataLoopNode::NodeFluidType::Air,
1953 : DataLoopNode::ConnectionType::Outlet,
1954 : NodeInputManager::CompFluidStream::Primary,
1955 : DataLoopNode::ObjectIsNotParent);
1956 :
1957 13 : BranchNodeConnections::TestCompSet(state, CurrentModuleObject, AlphArray(1), AlphArray(2), AlphArray(3), "Air Nodes");
1958 :
1959 13 : if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).NumOfSpeeds < 1) {
1960 0 : ShowSevereError(
1961 : state,
1962 0 : format("{}{}=\"{}\", invalid", RoutineName, CurrentModuleObject, state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name));
1963 0 : ShowContinueError(state, format("...{} must be >= 1. entered number is {:.0T}", cNumericFields(1), NumArray(1)));
1964 0 : ErrorsFound = true;
1965 : }
1966 :
1967 13 : if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).NormSpedLevel >
1968 13 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).NumOfSpeeds) {
1969 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).NormSpedLevel =
1970 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).NumOfSpeeds;
1971 : }
1972 :
1973 13 : if ((state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).NormSpedLevel >
1974 26 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).NumOfSpeeds) ||
1975 13 : (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).NormSpedLevel <= 0)) {
1976 0 : ShowSevereError(
1977 : state,
1978 0 : format("{}{}=\"{}\", invalid", RoutineName, CurrentModuleObject, state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name));
1979 0 : ShowContinueError(state, format("...{} must be valid speed level entered number is {:.0T}", cNumericFields(2), NumArray(2)));
1980 0 : ErrorsFound = true;
1981 : }
1982 :
1983 : // part load curve
1984 13 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).PLFFPLR = Curve::GetCurveIndex(state, AlphArray(4)); // convert curve name to number
1985 13 : if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).PLFFPLR == 0) {
1986 0 : if (lAlphaBlanks(4)) {
1987 0 : ShowSevereError(
1988 : state,
1989 0 : format("{}{}=\"{}\", missing", RoutineName, CurrentModuleObject, state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name));
1990 0 : ShowContinueError(state, format("...required {} is blank.", cAlphaFields(4)));
1991 : } else {
1992 0 : ShowSevereError(
1993 : state,
1994 0 : format("{}{}=\"{}\", invalid", RoutineName, CurrentModuleObject, state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name));
1995 0 : ShowContinueError(state, format("...not found {}=\"{}\".", cAlphaFields(4), AlphArray(4)));
1996 : }
1997 0 : ErrorsFound = true;
1998 : } else {
1999 13 : CurveVal = Curve::CurveValue(state, state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).PLFFPLR, 1.0);
2000 13 : if (CurveVal > 1.10 || CurveVal < 0.90) {
2001 4 : ShowWarningError(state,
2002 4 : format("{}{}=\"{}\", curve values",
2003 : RoutineName,
2004 : CurrentModuleObject,
2005 2 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name));
2006 2 : ShowContinueError(state, format("...{} output is not equal to 1.0 (+ or - 10%) at rated conditions.", cAlphaFields(4)));
2007 2 : ShowContinueError(state, format("...Curve output at rated conditions = {:.3T}", CurveVal));
2008 : }
2009 : }
2010 :
2011 13 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).DefrostEIRFT =
2012 13 : Curve::GetCurveIndex(state, AlphArray(5)); // convert curve name to number
2013 :
2014 13 : if (!lAlphaBlanks(6)) {
2015 2 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).CrankcaseHeaterCapacityCurveIndex = Curve::GetCurveIndex(state, AlphArray(6));
2016 :
2017 2 : if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).CrankcaseHeaterCapacityCurveIndex == 0) { // can't find the curve
2018 0 : ShowSevereError(state,
2019 0 : format("{} = {}: {} not found = {}",
2020 : CurrentModuleObject,
2021 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name,
2022 : cAlphaFields(6),
2023 : AlphArray(6)));
2024 0 : ErrorsFound = true;
2025 : } else {
2026 2 : ErrorsFound |=
2027 8 : Curve::CheckCurveDims(state,
2028 2 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).CrankcaseHeaterCapacityCurveIndex, // Curve index
2029 : {1}, // Valid dimensions
2030 : RoutineName, // Routine name
2031 : CurrentModuleObject, // Object Type
2032 2 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name, // Object Name
2033 2 : cAlphaFields(6)); // Field Name
2034 : }
2035 : }
2036 :
2037 13 : if (Util::SameString(AlphArray(7), "ReverseCycle")) {
2038 0 : if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).DefrostEIRFT == 0) {
2039 0 : if (lAlphaBlanks(5)) {
2040 0 : ShowSevereError(state,
2041 0 : format("{}{}=\"{}\", missing",
2042 : RoutineName,
2043 : CurrentModuleObject,
2044 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name));
2045 0 : ShowContinueError(state, format("...required {} is blank.", cAlphaFields(5)));
2046 0 : ShowContinueError(state, format("...field is required because {} is \"ReverseCycle\".", cAlphaFields(7)));
2047 : } else {
2048 0 : ShowSevereError(state,
2049 0 : format("{}{}=\"{}\", invalid",
2050 : RoutineName,
2051 : CurrentModuleObject,
2052 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name));
2053 0 : ShowContinueError(state, format("...not found {}=\"{}\".", cAlphaFields(5), AlphArray(5)));
2054 : }
2055 0 : ErrorsFound = true;
2056 : } else {
2057 : // Verify Curve Object, only legal type is BiQuadratic
2058 0 : ErrorsFound |= Curve::CheckCurveDims(state,
2059 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).DefrostEIRFT, // Curve index
2060 : {2}, // Valid dimensions
2061 : RoutineName, // Routine name
2062 : CurrentModuleObject, // Object Type
2063 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name, // Object Name
2064 0 : cAlphaFields(AlfaFieldIncre)); // Field Name
2065 : }
2066 : }
2067 :
2068 13 : if (Util::SameString(AlphArray(7), "ReverseCycle")) state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).DefrostStrategy = ReverseCycle;
2069 13 : if (Util::SameString(AlphArray(7), "Resistive")) state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).DefrostStrategy = Resistive;
2070 13 : if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).DefrostStrategy == 0) {
2071 0 : ShowSevereError(
2072 : state,
2073 0 : format("{}{}=\"{}\", invalid", RoutineName, CurrentModuleObject, state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name));
2074 0 : ShowContinueError(state, format("...illegal {}=\"{}\".", cAlphaFields(7), AlphArray(7)));
2075 0 : ShowContinueError(state, "...valid values for this field are ReverseCycle or Resistive.");
2076 0 : ErrorsFound = true;
2077 : }
2078 :
2079 13 : if (Util::SameString(AlphArray(8), "Timed")) state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).DefrostControl = Timed;
2080 13 : if (Util::SameString(AlphArray(8), "OnDemand")) state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).DefrostControl = OnDemand;
2081 13 : if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).DefrostControl == 0) {
2082 0 : ShowSevereError(
2083 : state,
2084 0 : format("{}{}=\"{}\", invalid", RoutineName, CurrentModuleObject, state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name));
2085 0 : ShowContinueError(state, format("...illegal {}=\"{}\".", cAlphaFields(8), AlphArray(8)));
2086 0 : ShowContinueError(state, "...valid values for this field are Timed or OnDemand.");
2087 0 : ErrorsFound = true;
2088 : }
2089 :
2090 : // Set minimum OAT for heat pump compressor operation
2091 13 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MinOATCompressor = NumArray(5);
2092 :
2093 : // reserved for HSPF calculation
2094 13 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).OATempCompressorOn = NumArray(6);
2095 :
2096 : // Set maximum outdoor temp for defrost to occur
2097 13 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MaxOATDefrost = NumArray(7);
2098 :
2099 : // Set crankcase heater capacity
2100 13 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).CrankcaseHeaterCapacity = NumArray(8);
2101 13 : if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).CrankcaseHeaterCapacity < 0.0) {
2102 0 : ShowSevereError(
2103 : state,
2104 0 : format("{}{}=\"{}\", invalid", RoutineName, CurrentModuleObject, state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name));
2105 0 : ShowContinueError(state, format("...{} cannot be < 0.0.", cNumericFields(9)));
2106 0 : ShowContinueError(state, format("...entered value=[{:.2T}].", NumArray(9)));
2107 0 : ErrorsFound = true;
2108 : }
2109 :
2110 : // Set crankcase heater cutout temperature
2111 13 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MaxOATCrankcaseHeater = NumArray(9);
2112 :
2113 : // Set defrost time period
2114 13 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).DefrostTime = NumArray(10);
2115 13 : if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).DefrostTime == 0.0 &&
2116 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).DefrostControl == 1) {
2117 0 : ShowWarningError(
2118 0 : state, format("{}{}=\"{}\", ", RoutineName, CurrentModuleObject, state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name));
2119 0 : ShowContinueError(state, format("...{} = 0.0 for defrost control = TIMED.", cNumericFields(5)));
2120 : }
2121 :
2122 : // Set defrost capacity (for resistive defrost)
2123 13 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).DefrostCapacity = NumArray(11);
2124 13 : if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).DefrostCapacity == 0.0 &&
2125 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).DefrostStrategy == 2) {
2126 0 : ShowWarningError(
2127 0 : state, format("{}{}=\"{}\", ", RoutineName, CurrentModuleObject, state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name));
2128 0 : ShowContinueError(state, format("...{} = 0.0 for defrost strategy = RESISTIVE.", cNumericFields(6)));
2129 : }
2130 :
2131 133 : for (int I = 1; I <= state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).NumOfSpeeds; ++I) {
2132 120 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedTotCap(I) = NumArray(12 + (I - 1) * 5);
2133 120 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedCOP(I) = NumArray(13 + (I - 1) * 5);
2134 120 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedAirVolFlowRate(I) = NumArray(14 + (I - 1) * 5);
2135 120 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedEvaporatorFanPowerPerVolumeFlowRate2017(I) = NumArray(15 + (I - 1) * 5);
2136 120 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedEvaporatorFanPowerPerVolumeFlowRate2023(I) = NumArray(16 + (I - 1) * 5);
2137 :
2138 120 : if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedTotCap(I) < 1.e-10) {
2139 0 : ShowSevereError(state,
2140 0 : format("{}{}=\"{}\", invalid value",
2141 : RoutineName,
2142 : CurrentModuleObject,
2143 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name));
2144 0 : ShowContinueError(state,
2145 0 : format("...too small {}=[{:.2R}].",
2146 0 : cNumericFields(12 + (I - 1) * 3),
2147 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedTotCap(I)));
2148 0 : ErrorsFound = true;
2149 : }
2150 :
2151 120 : AlfaFieldIncre = 9 + (I - 1) * 4;
2152 120 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSCCapFTemp(I) =
2153 120 : Curve::GetCurveIndex(state, AlphArray(AlfaFieldIncre)); // convert curve name to number
2154 120 : if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSCCapFTemp(I) == 0) {
2155 0 : if (lAlphaBlanks(AlfaFieldIncre)) {
2156 0 : ShowSevereError(state,
2157 0 : format("{}{}=\"{}\", missing",
2158 : RoutineName,
2159 : CurrentModuleObject,
2160 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name));
2161 0 : ShowContinueError(state, format("...required {} is blank.", cAlphaFields(AlfaFieldIncre)));
2162 : } else {
2163 0 : ShowSevereError(state,
2164 0 : format("{}{}=\"{}\", invalid",
2165 : RoutineName,
2166 : CurrentModuleObject,
2167 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name));
2168 0 : ShowContinueError(state, format("...not found {}=\"{}\".", cAlphaFields(AlfaFieldIncre), AlphArray(AlfaFieldIncre)));
2169 : }
2170 0 : ErrorsFound = true;
2171 : } else {
2172 : // Verify Curve Object, only legal type is BiQuadratic
2173 360 : ErrorsFound |= Curve::CheckCurveDims(state,
2174 120 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSCCapFTemp(I), // Curve index
2175 : {2}, // Valid dimensions
2176 : RoutineName, // Routine name
2177 : CurrentModuleObject, // Object Type
2178 120 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name, // Object Name
2179 120 : cAlphaFields(AlfaFieldIncre)); // Field Name
2180 :
2181 120 : if (!ErrorsFound) {
2182 240 : CurveVal = Curve::CurveValue(
2183 120 : state, state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSCCapFTemp(I), RatedInletAirTempHeat, RatedAmbAirTempHeat);
2184 120 : if (CurveVal > 1.10 || CurveVal < 0.90) {
2185 60 : ShowWarningError(state,
2186 60 : format("{}{}=\"{}\", curve values",
2187 : RoutineName,
2188 : CurrentModuleObject,
2189 30 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name));
2190 60 : ShowContinueError(
2191 60 : state, format("...{} output is not equal to 1.0 (+ or - 10%) at rated conditions.", cAlphaFields(AlfaFieldIncre)));
2192 30 : ShowContinueError(state, format("...Curve output at rated conditions = {:.3T}", CurveVal));
2193 : }
2194 : }
2195 : }
2196 :
2197 120 : AlfaFieldIncre = 10 + (I - 1) * 4;
2198 120 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSCCapAirFFlow(I) =
2199 120 : Curve::GetCurveIndex(state, AlphArray(AlfaFieldIncre)); // convert curve name to number
2200 120 : if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSCCapAirFFlow(I) == 0) {
2201 0 : if (lAlphaBlanks(AlfaFieldIncre)) {
2202 0 : ShowSevereError(state,
2203 0 : format("{}{}=\"{}\", missing",
2204 : RoutineName,
2205 : CurrentModuleObject,
2206 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name));
2207 0 : ShowContinueError(state, format("...required {} is blank.", cAlphaFields(AlfaFieldIncre)));
2208 : } else {
2209 0 : ShowSevereError(state,
2210 0 : format("{}{}=\"{}\", invalid",
2211 : RoutineName,
2212 : CurrentModuleObject,
2213 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name));
2214 0 : ShowContinueError(state, format("...not found {}=\"{}\".", cAlphaFields(AlfaFieldIncre), AlphArray(AlfaFieldIncre)));
2215 : }
2216 0 : ErrorsFound = true;
2217 : } else {
2218 : // Verify Curve Object, only legal type is Quadratic
2219 360 : ErrorsFound |= Curve::CheckCurveDims(state,
2220 120 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSCCapAirFFlow(I), // Curve index
2221 : {1}, // Valid dimensions
2222 : RoutineName, // Routine name
2223 : CurrentModuleObject, // Object Type
2224 120 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name, // Object Name
2225 120 : cAlphaFields(AlfaFieldIncre)); // Field Name
2226 :
2227 120 : if (!ErrorsFound) {
2228 120 : CurveVal = Curve::CurveValue(state, state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSCCapAirFFlow(I), 1.0);
2229 120 : if (CurveVal > 1.10 || CurveVal < 0.90) {
2230 0 : ShowWarningError(state,
2231 0 : format("{}{}=\"{}\", curve values",
2232 : RoutineName,
2233 : CurrentModuleObject,
2234 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name));
2235 0 : ShowContinueError(
2236 0 : state, format("...{} output is not equal to 1.0 (+ or - 10%) at rated conditions.", cAlphaFields(AlfaFieldIncre)));
2237 0 : ShowContinueError(state, format("...Curve output at rated conditions = {:.3T}", CurveVal));
2238 : }
2239 : }
2240 : }
2241 :
2242 120 : AlfaFieldIncre = 11 + (I - 1) * 4;
2243 120 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSEIRFTemp(I) =
2244 120 : Curve::GetCurveIndex(state, AlphArray(AlfaFieldIncre)); // convert curve name to number
2245 120 : if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSEIRFTemp(I) == 0) {
2246 0 : if (lAlphaBlanks(AlfaFieldIncre)) {
2247 0 : ShowSevereError(state,
2248 0 : format("{}{}=\"{}\", missing",
2249 : RoutineName,
2250 : CurrentModuleObject,
2251 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name));
2252 0 : ShowContinueError(state, format("...required {} is blank.", cAlphaFields(AlfaFieldIncre)));
2253 : } else {
2254 0 : ShowSevereError(state,
2255 0 : format("{}{}=\"{}\", invalid",
2256 : RoutineName,
2257 : CurrentModuleObject,
2258 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name));
2259 0 : ShowContinueError(state, format("...not found {}=\"{}\".", cAlphaFields(AlfaFieldIncre), AlphArray(AlfaFieldIncre)));
2260 : }
2261 0 : ErrorsFound = true;
2262 : } else {
2263 : // Verify Curve Object, only legal type is BiQuadratic
2264 360 : ErrorsFound |= Curve::CheckCurveDims(state,
2265 120 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSEIRFTemp(I), // Curve index
2266 : {2}, // Valid dimensions
2267 : RoutineName, // Routine name
2268 : CurrentModuleObject, // Object Type
2269 120 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name, // Object Name
2270 120 : cAlphaFields(AlfaFieldIncre)); // Field Name
2271 :
2272 120 : if (!ErrorsFound) {
2273 240 : CurveVal = Curve::CurveValue(
2274 120 : state, state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSEIRFTemp(I), RatedInletAirTempHeat, RatedAmbAirTempHeat);
2275 120 : if (CurveVal > 1.10 || CurveVal < 0.90) {
2276 60 : ShowWarningError(state,
2277 60 : format("{}{}=\"{}\", curve values",
2278 : RoutineName,
2279 : CurrentModuleObject,
2280 30 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name));
2281 60 : ShowContinueError(
2282 60 : state, format("...{} output is not equal to 1.0 (+ or - 10%) at rated conditions.", cAlphaFields(AlfaFieldIncre)));
2283 30 : ShowContinueError(state, format("...Curve output at rated conditions = {:.3T}", CurveVal));
2284 : }
2285 : }
2286 : }
2287 :
2288 120 : AlfaFieldIncre = 12 + (I - 1) * 4;
2289 120 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSEIRAirFFlow(I) =
2290 120 : Curve::GetCurveIndex(state, AlphArray(AlfaFieldIncre)); // convert curve name to number
2291 120 : if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSEIRAirFFlow(I) == 0) {
2292 0 : if (lAlphaBlanks(AlfaFieldIncre)) {
2293 0 : ShowSevereError(state,
2294 0 : format("{}{}=\"{}\", missing",
2295 : RoutineName,
2296 : CurrentModuleObject,
2297 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name));
2298 0 : ShowContinueError(state, format("...required {} is blank.", cAlphaFields(AlfaFieldIncre)));
2299 : } else {
2300 0 : ShowSevereError(state,
2301 0 : format("{}{}=\"{}\", invalid",
2302 : RoutineName,
2303 : CurrentModuleObject,
2304 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name));
2305 0 : ShowContinueError(state, format("...not found {}=\"{}\".", cAlphaFields(AlfaFieldIncre), AlphArray(AlfaFieldIncre)));
2306 : }
2307 0 : ErrorsFound = true;
2308 : } else {
2309 : // Verify Curve Object, only legal type is Quadratic
2310 360 : ErrorsFound |= Curve::CheckCurveDims(state,
2311 120 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSEIRAirFFlow(I), // Curve index
2312 : {1}, // Valid dimensions
2313 : RoutineName, // Routine name
2314 : CurrentModuleObject, // Object Type
2315 120 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name, // Object Name
2316 120 : cAlphaFields(AlfaFieldIncre)); // Field Name
2317 :
2318 120 : if (!ErrorsFound) {
2319 120 : CurveVal = Curve::CurveValue(state, state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSEIRAirFFlow(I), 1.0);
2320 120 : if (CurveVal > 1.10 || CurveVal < 0.90) {
2321 0 : ShowWarningError(state,
2322 0 : format("{}{}=\"{}\", curve values",
2323 : RoutineName,
2324 : CurrentModuleObject,
2325 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name));
2326 0 : ShowContinueError(
2327 0 : state, format("...{} output is not equal to 1.0 (+ or - 10%) at rated conditions.", cAlphaFields(AlfaFieldIncre)));
2328 0 : ShowContinueError(state, format("...Curve output at rated conditions = {:.3T}", CurveVal));
2329 : }
2330 : }
2331 : }
2332 : }
2333 :
2334 13 : if (ErrorsFound) continue;
2335 :
2336 133 : for (int I = 1; I <= state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).NumOfSpeeds; ++I) {
2337 120 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedPercentTotCap(I) =
2338 120 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedTotCap(I) /
2339 240 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedTotCap(
2340 120 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).NumOfSpeeds);
2341 120 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedAirVolFlowPerRatedTotCap(I) =
2342 120 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedAirVolFlowRate(I) /
2343 120 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedTotCap(I);
2344 : }
2345 :
2346 : // CurrentModuleObject = "Coil:Heating:DX:Variablespeed "
2347 26 : SetupOutputVariable(state,
2348 : "Heating Coil Electricity Energy",
2349 : Constant::Units::J,
2350 13 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Energy,
2351 : OutputProcessor::TimeStepType::System,
2352 : OutputProcessor::StoreType::Sum,
2353 13 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name,
2354 : Constant::eResource::Electricity,
2355 : OutputProcessor::Group::HVAC,
2356 : OutputProcessor::EndUseCat::Heating);
2357 26 : SetupOutputVariable(state,
2358 : "Heating Coil Heating Energy",
2359 : Constant::Units::J,
2360 13 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).EnergyLoadTotal,
2361 : OutputProcessor::TimeStepType::System,
2362 : OutputProcessor::StoreType::Sum,
2363 13 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name,
2364 : Constant::eResource::EnergyTransfer,
2365 : OutputProcessor::Group::HVAC,
2366 : OutputProcessor::EndUseCat::HeatingCoils);
2367 26 : SetupOutputVariable(state,
2368 : "Heating Coil Source Side Heat Transfer Energy",
2369 : Constant::Units::J,
2370 13 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).EnergySource,
2371 : OutputProcessor::TimeStepType::System,
2372 : OutputProcessor::StoreType::Sum,
2373 13 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name);
2374 :
2375 : // create predefined report entries
2376 26 : OutputReportPredefined::PreDefTableEntry(
2377 13 : state, state.dataOutRptPredefined->pdchHeatCoilType, state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name, CurrentModuleObject);
2378 26 : OutputReportPredefined::PreDefTableEntry(state,
2379 13 : state.dataOutRptPredefined->pdchHeatCoilNomCap,
2380 13 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name,
2381 13 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).RatedCapHeat);
2382 26 : OutputReportPredefined::PreDefTableEntry(state,
2383 13 : state.dataOutRptPredefined->pdchHeatCoilNomEff,
2384 13 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name,
2385 26 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedCOP(
2386 13 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).NormSpedLevel));
2387 : }
2388 :
2389 : //-------------------------AIR SOURCE HEATING---END
2390 :
2391 : //------------------------VARIABLE-SPEED AIR SOURCE HPWH---BEGIN
2392 49 : CurrentModuleObject = "COIL:WATERHEATING:AIRTOWATERHEATPUMP:VARIABLESPEED"; // for reporting
2393 :
2394 56 : for (int CoilCounter = 1; CoilCounter <= NumHPWHAirToWater; ++CoilCounter) {
2395 :
2396 7 : ++DXCoilNum;
2397 :
2398 7 : state.dataInputProcessing->inputProcessor->getObjectItem(state,
2399 : CurrentModuleObject,
2400 : CoilCounter,
2401 : AlphArray,
2402 : NumAlphas,
2403 : NumArray,
2404 : NumNums,
2405 : IOStat,
2406 : lNumericBlanks,
2407 : lAlphaBlanks,
2408 : cAlphaFields,
2409 : cNumericFields);
2410 : // ErrorsFound will be set to True if problem was found, left untouched otherwise
2411 7 : GlobalNames::VerifyUniqueCoilName(state, CurrentModuleObject, AlphArray(1), ErrorsFound, CurrentModuleObject + " Name");
2412 :
2413 7 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).bIsDesuperheater = false;
2414 7 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).CondenserType = DataHeatBalance::RefrigCondenserType::WaterHeater;
2415 7 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).CoolHeatType = "WATERHEATING";
2416 7 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).VSCoilType = HVAC::CoilDX_HeatPumpWaterHeaterVariableSpeed;
2417 7 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).VarSpeedCoilType =
2418 14 : HVAC::cAllCoilTypes(HVAC::CoilDX_HeatPumpWaterHeaterVariableSpeed);
2419 :
2420 7 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name = AlphArray(1);
2421 7 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).NumOfSpeeds = int(NumArray(1));
2422 7 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).NormSpedLevel = int(NumArray(2));
2423 :
2424 7 : if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).NumOfSpeeds < 1) {
2425 0 : ShowSevereError(
2426 : state,
2427 0 : format("{}{}=\"{}\", invalid", RoutineName, CurrentModuleObject, state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name));
2428 0 : ShowContinueError(state, format("...{} must be >= 1. entered number is {:.0T}", cNumericFields(1), NumArray(1)));
2429 0 : ErrorsFound = true;
2430 : }
2431 :
2432 7 : if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).NormSpedLevel >
2433 7 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).NumOfSpeeds) {
2434 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).NormSpedLevel =
2435 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).NumOfSpeeds;
2436 : }
2437 :
2438 7 : if ((state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).NormSpedLevel >
2439 14 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).NumOfSpeeds) ||
2440 7 : (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).NormSpedLevel <= 0)) {
2441 0 : ShowSevereError(
2442 : state,
2443 0 : format("{}{}=\"{}\", invalid", RoutineName, CurrentModuleObject, state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name));
2444 0 : ShowContinueError(state, format("...{} must be valid speed level entered number is {:.0T}", cNumericFields(2), NumArray(2)));
2445 0 : ErrorsFound = true;
2446 : }
2447 :
2448 7 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).RatedCapWH = NumArray(3);
2449 7 : if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).RatedCapWH <= 0.0) {
2450 0 : ShowSevereError(
2451 : state,
2452 0 : format("{}{}=\"{}\", invalid", RoutineName, CurrentModuleObject, state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name));
2453 0 : ShowContinueError(state, format("...{} must be > 0.0, entered value=[{:.2T}].", cNumericFields(3), NumArray(3)));
2454 0 : ErrorsFound = true;
2455 : }
2456 :
2457 7 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).WHRatedInletDBTemp = NumArray(4);
2458 7 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).WHRatedInletWBTemp = NumArray(5);
2459 7 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).WHRatedInletWaterTemp = NumArray(6);
2460 :
2461 7 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).RatedAirVolFlowRate = NumArray(7);
2462 7 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).RatedWaterVolFlowRate = NumArray(8);
2463 :
2464 7 : if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).RatedAirVolFlowRate != Constant::AutoCalculate) {
2465 5 : if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).RatedAirVolFlowRate <= 0.0) {
2466 0 : ShowSevereError(
2467 : state,
2468 0 : format("{}{}=\"{}\", invalid", RoutineName, CurrentModuleObject, state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name));
2469 0 : ShowContinueError(state, format("...{} must be > 0.0. entered value=[{:.3T}].", cNumericFields(7), NumArray(7)));
2470 0 : ErrorsFound = true;
2471 : }
2472 : }
2473 :
2474 7 : if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).RatedWaterVolFlowRate != Constant::AutoCalculate) {
2475 5 : if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).RatedWaterVolFlowRate <= 0.0) {
2476 0 : ShowSevereError(
2477 : state,
2478 0 : format("{}{}=\"{}\", invalid", RoutineName, CurrentModuleObject, state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name));
2479 0 : ShowContinueError(state, format("...{} must be > 0.0 entered value=[{:.3T}].", cNumericFields(8), NumArray(8)));
2480 0 : ErrorsFound = true;
2481 : }
2482 : }
2483 :
2484 7 : if (Util::SameString(AlphArray(2), "Yes") || Util::SameString(AlphArray(2), "No")) {
2485 : // initialized to TRUE on allocate
2486 7 : if (Util::SameString(AlphArray(2), "No"))
2487 7 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).FanPowerIncludedInCOP = false;
2488 : else
2489 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).FanPowerIncludedInCOP = true;
2490 : } else {
2491 0 : ShowSevereError(
2492 : state,
2493 0 : format("{}{}=\"{}\", invalid", RoutineName, CurrentModuleObject, state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name));
2494 0 : ShowContinueError(state, format(",,,invalid choice for {}. Entered choice = {}", cAlphaFields(2), AlphArray(2)));
2495 0 : ShowContinueError(state, "Valid choices are Yes or No.");
2496 0 : ErrorsFound = true;
2497 : }
2498 :
2499 7 : if (Util::SameString(AlphArray(3), "Yes") || Util::SameString(AlphArray(3), "No")) {
2500 : // initialized to FALSE on allocate
2501 7 : if (Util::SameString(AlphArray(3), "Yes"))
2502 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).CondPumpPowerInCOP = true;
2503 : else
2504 7 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).CondPumpPowerInCOP = false;
2505 : } else {
2506 0 : ShowSevereError(
2507 : state,
2508 0 : format("{}{}=\"{}\", invalid", RoutineName, CurrentModuleObject, state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name));
2509 0 : ShowContinueError(state, format(",,,invalid choice for {}. Entered choice = {}", cAlphaFields(3), AlphArray(3)));
2510 0 : ShowContinueError(state, "Valid choices are Yes or No.");
2511 0 : ErrorsFound = true;
2512 : }
2513 :
2514 7 : if (Util::SameString(AlphArray(4), "Yes") || Util::SameString(AlphArray(4), "No")) {
2515 : // initialized to FALSE on allocate
2516 7 : if (Util::SameString(AlphArray(4), "Yes"))
2517 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).CondPumpHeatInCapacity = true;
2518 : else
2519 7 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).CondPumpHeatInCapacity = false;
2520 : } else {
2521 0 : ShowSevereError(
2522 : state,
2523 0 : format("{}{}=\"{}\", invalid", RoutineName, CurrentModuleObject, state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name));
2524 0 : ShowContinueError(state, format(",,,invalid choice for {}. Entered choice = {}", cAlphaFields(4), AlphArray(4)));
2525 0 : ShowContinueError(state, "Valid choices are Yes or No.");
2526 0 : ErrorsFound = true;
2527 : }
2528 :
2529 7 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).HPWHCondPumpFracToWater = NumArray(9);
2530 14 : if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).HPWHCondPumpFracToWater <= 0.0 ||
2531 7 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).HPWHCondPumpFracToWater > 1.0) {
2532 0 : ShowSevereError(
2533 : state,
2534 0 : format("{}{}=\"{}\", invalid", RoutineName, CurrentModuleObject, state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name));
2535 0 : ShowContinueError(state, format("...{} must be >= 0 and <= 1. entered value=[{:.3T}].", cNumericFields(10), NumArray(9)));
2536 0 : ErrorsFound = true;
2537 : }
2538 :
2539 7 : if (!state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).CondPumpHeatInCapacity) {
2540 7 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).HPWHCondPumpFracToWater = 0.0;
2541 : }
2542 :
2543 : // Air nodes
2544 7 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).AirInletNodeNum =
2545 14 : GetOnlySingleNode(state,
2546 7 : AlphArray(5),
2547 : ErrorsFound,
2548 : DataLoopNode::ConnectionObjectType::CoilWaterHeatingAirToWaterHeatPumpVariableSpeed,
2549 7 : AlphArray(1),
2550 : DataLoopNode::NodeFluidType::Air,
2551 : DataLoopNode::ConnectionType::Inlet,
2552 : NodeInputManager::CompFluidStream::Primary,
2553 : DataLoopNode::ObjectIsNotParent);
2554 :
2555 7 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).AirOutletNodeNum =
2556 21 : GetOnlySingleNode(state,
2557 7 : AlphArray(6),
2558 : ErrorsFound,
2559 : DataLoopNode::ConnectionObjectType::CoilWaterHeatingAirToWaterHeatPumpVariableSpeed,
2560 7 : AlphArray(1),
2561 : DataLoopNode::NodeFluidType::Air,
2562 : DataLoopNode::ConnectionType::Outlet,
2563 : NodeInputManager::CompFluidStream::Primary,
2564 : DataLoopNode::ObjectIsNotParent);
2565 :
2566 7 : BranchNodeConnections::TestCompSet(state, CurrentModuleObject, AlphArray(1), AlphArray(5), AlphArray(6), "Air Nodes");
2567 :
2568 : // Check if the air inlet node is OA node, to justify whether the coil is placed in zone or not
2569 7 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).IsDXCoilInZone =
2570 7 : !OutAirNodeManager::CheckOutAirNodeNumber(state, state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).AirInletNodeNum);
2571 :
2572 : // Water nodes
2573 7 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).WaterInletNodeNum =
2574 14 : GetOnlySingleNode(state,
2575 7 : AlphArray(7),
2576 : ErrorsFound,
2577 : DataLoopNode::ConnectionObjectType::CoilWaterHeatingAirToWaterHeatPumpVariableSpeed,
2578 7 : AlphArray(1),
2579 : DataLoopNode::NodeFluidType::Water,
2580 : DataLoopNode::ConnectionType::Inlet,
2581 : NodeInputManager::CompFluidStream::Secondary,
2582 : DataLoopNode::ObjectIsNotParent);
2583 :
2584 7 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).WaterOutletNodeNum =
2585 21 : GetOnlySingleNode(state,
2586 7 : AlphArray(8),
2587 : ErrorsFound,
2588 : DataLoopNode::ConnectionObjectType::CoilWaterHeatingAirToWaterHeatPumpVariableSpeed,
2589 7 : AlphArray(1),
2590 : DataLoopNode::NodeFluidType::Water,
2591 : DataLoopNode::ConnectionType::Outlet,
2592 : NodeInputManager::CompFluidStream::Secondary,
2593 : DataLoopNode::ObjectIsNotParent);
2594 :
2595 7 : BranchNodeConnections::TestCompSet(state, CurrentModuleObject, AlphArray(1), AlphArray(7), AlphArray(8), "Water Nodes");
2596 :
2597 7 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).CrankcaseHeaterCapacity = NumArray(10);
2598 7 : if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).CrankcaseHeaterCapacity < 0.0) {
2599 0 : ShowSevereError(
2600 : state,
2601 0 : format("{}{}=\"{}\", invalid", RoutineName, CurrentModuleObject, state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name));
2602 0 : ShowContinueError(state, format("...{} must be >= 0.0 entered value=[{:.1T}].", cNumericFields(10), NumArray(10)));
2603 0 : ErrorsFound = true;
2604 : }
2605 :
2606 7 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MaxOATCrankcaseHeater = NumArray(11);
2607 7 : if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MaxOATCrankcaseHeater < 0.0) {
2608 0 : ShowSevereError(
2609 : state,
2610 0 : format("{}{}=\"{}\", invalid", RoutineName, CurrentModuleObject, state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name));
2611 0 : ShowContinueError(state, format("...{} must be >= 0 {{C}}. entered value=[{:.1T}].", cNumericFields(11), NumArray(11)));
2612 0 : ErrorsFound = true;
2613 : }
2614 :
2615 7 : if (!lAlphaBlanks(9)) {
2616 2 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).CrankcaseHeaterCapacityCurveIndex = Curve::GetCurveIndex(state, AlphArray(9));
2617 2 : if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).CrankcaseHeaterCapacityCurveIndex == 0) { // can't find the curve
2618 0 : ShowSevereError(state,
2619 0 : format("{} = {}: {} not found = {}",
2620 : CurrentModuleObject,
2621 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name,
2622 : cAlphaFields(9),
2623 : AlphArray(9)));
2624 0 : ErrorsFound = true;
2625 : } else {
2626 2 : ErrorsFound |=
2627 8 : Curve::CheckCurveDims(state,
2628 2 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).CrankcaseHeaterCapacityCurveIndex, // Curve index
2629 : {1}, // Valid dimensions
2630 : RoutineName, // Routine name
2631 : CurrentModuleObject, // Object Type
2632 2 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name, // Object Name
2633 2 : cAlphaFields(9)); // Field Name
2634 : }
2635 : }
2636 :
2637 7 : if (Util::SameString(AlphArray(10), "DryBulbTemperature")) {
2638 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).InletAirTemperatureType = HVAC::OATType::DryBulb;
2639 7 : } else if (Util::SameString(AlphArray(10), "WetBulbTemperature")) {
2640 7 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).InletAirTemperatureType = HVAC::OATType::WetBulb;
2641 : } else {
2642 : // wrong temperature type selection
2643 0 : ShowSevereError(
2644 : state,
2645 0 : format("{}{}=\"{}\", invalid", RoutineName, CurrentModuleObject, state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name));
2646 0 : ShowContinueError(state, format("...{} must be DryBulbTemperature or WetBulbTemperature.", cAlphaFields(10)));
2647 0 : ShowContinueError(state, format("...entered value=\"{}\".", AlphArray(10)));
2648 0 : ErrorsFound = true;
2649 : }
2650 :
2651 : // set rated inlet air temperature for curve object verification
2652 7 : if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).InletAirTemperatureType == HVAC::OATType::WetBulb) {
2653 7 : WHInletAirTemp = state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).WHRatedInletWBTemp;
2654 : } else {
2655 0 : WHInletAirTemp = state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).WHRatedInletDBTemp;
2656 : }
2657 : // set rated water temperature for curve object verification
2658 7 : WHInletWaterTemp = state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).WHRatedInletWaterTemp;
2659 :
2660 : // part load curve
2661 7 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).PLFFPLR =
2662 7 : Curve::GetCurveIndex(state, AlphArray(11)); // convert curve name to number
2663 7 : if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).PLFFPLR == 0) {
2664 0 : if (lAlphaBlanks(11)) {
2665 0 : ShowSevereError(
2666 : state,
2667 0 : format("{}{}=\"{}\", missing", RoutineName, CurrentModuleObject, state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name));
2668 0 : ShowContinueError(state, format("...required {} is blank.", cAlphaFields(11)));
2669 : } else {
2670 0 : ShowSevereError(
2671 : state,
2672 0 : format("{}{}=\"{}\", invalid", RoutineName, CurrentModuleObject, state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name));
2673 0 : ShowContinueError(state, format("...not found {}=\"{}\".", cAlphaFields(11), AlphArray(11)));
2674 : }
2675 0 : ErrorsFound = true;
2676 : } else {
2677 7 : CurveVal = Curve::CurveValue(state, state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).PLFFPLR, 1.0);
2678 7 : if (CurveVal > 1.10 || CurveVal < 0.90) {
2679 4 : ShowWarningError(state,
2680 4 : format("{}{}=\"{}\", curve values",
2681 : RoutineName,
2682 : CurrentModuleObject,
2683 2 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name));
2684 2 : ShowContinueError(state, format("...{} output is not equal to 1.0 (+ or - 10%) at rated conditions.", cAlphaFields(11)));
2685 2 : ShowContinueError(state, format("...Curve output at rated conditions = {:.3T}", CurveVal));
2686 : }
2687 : }
2688 :
2689 77 : for (int I = 1; I <= state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).NumOfSpeeds; ++I) {
2690 70 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedTotCap(I) = NumArray(12 + (I - 1) * 6);
2691 70 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedCOP(I) = NumArray(13 + (I - 1) * 6);
2692 70 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedSHR(I) = NumArray(14 + (I - 1) * 6);
2693 70 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedAirVolFlowRate(I) = NumArray(15 + (I - 1) * 6);
2694 70 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedWaterVolFlowRate(I) = NumArray(16 + (I - 1) * 6);
2695 70 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSWHPumpPower(I) = NumArray(17 + (I - 1) * 6);
2696 :
2697 70 : AlfaFieldIncre = 12 + (I - 1) * 6;
2698 70 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSCCapFTemp(I) =
2699 70 : Curve::GetCurveIndex(state, AlphArray(AlfaFieldIncre)); // convert curve name to number
2700 70 : if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSCCapFTemp(I) == 0) {
2701 0 : if (lAlphaBlanks(AlfaFieldIncre)) {
2702 0 : ShowSevereError(state,
2703 0 : format("{}{}=\"{}\", missing",
2704 : RoutineName,
2705 : CurrentModuleObject,
2706 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name));
2707 0 : ShowContinueError(state, format("...required {} is blank.", cAlphaFields(AlfaFieldIncre)));
2708 : } else {
2709 0 : ShowSevereError(state,
2710 0 : format("{}{}=\"{}\", invalid",
2711 : RoutineName,
2712 : CurrentModuleObject,
2713 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name));
2714 0 : ShowContinueError(state, format("...not found {}=\"{}\".", cAlphaFields(AlfaFieldIncre), AlphArray(AlfaFieldIncre)));
2715 : }
2716 0 : ErrorsFound = true;
2717 : } else {
2718 : // Verify Curve Object, only legal type is BiQuadratic
2719 210 : ErrorsFound |= Curve::CheckCurveDims(state,
2720 70 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSCCapFTemp(I), // Curve index
2721 : {2}, // Valid dimensions
2722 : RoutineName, // Routine name
2723 : CurrentModuleObject, // Object Type
2724 70 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name, // Object Name
2725 70 : cAlphaFields(AlfaFieldIncre)); // Field Name
2726 :
2727 70 : if (!ErrorsFound) {
2728 140 : CurveVal = Curve::CurveValue(
2729 70 : state, state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSCCapFTemp(I), WHInletAirTemp, WHInletWaterTemp);
2730 70 : if (CurveVal > 1.10 || CurveVal < 0.90) {
2731 40 : ShowWarningError(state,
2732 40 : format("{}{}=\"{}\", curve values",
2733 : RoutineName,
2734 : CurrentModuleObject,
2735 20 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name));
2736 40 : ShowContinueError(
2737 40 : state, format("...{} output is not equal to 1.0 (+ or - 10%) at rated conditions.", cAlphaFields(AlfaFieldIncre)));
2738 20 : ShowContinueError(state, format("...Curve output at rated conditions = {:.3T}", CurveVal));
2739 : }
2740 : }
2741 : }
2742 :
2743 70 : AlfaFieldIncre = 13 + (I - 1) * 6;
2744 70 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSCCapAirFFlow(I) =
2745 70 : Curve::GetCurveIndex(state, AlphArray(AlfaFieldIncre)); // convert curve name to number
2746 70 : if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSCCapAirFFlow(I) == 0) {
2747 0 : if (lAlphaBlanks(AlfaFieldIncre)) {
2748 0 : ShowSevereError(state,
2749 0 : format("{}{}=\"{}\", missing",
2750 : RoutineName,
2751 : CurrentModuleObject,
2752 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name));
2753 0 : ShowContinueError(state, format("...required {} is blank.", cAlphaFields(AlfaFieldIncre)));
2754 : } else {
2755 0 : ShowSevereError(state,
2756 0 : format("{}{}=\"{}\", invalid",
2757 : RoutineName,
2758 : CurrentModuleObject,
2759 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name));
2760 0 : ShowContinueError(state, format("...not found {}=\"{}\".", cAlphaFields(AlfaFieldIncre), AlphArray(AlfaFieldIncre)));
2761 : }
2762 0 : ErrorsFound = true;
2763 : } else {
2764 : // Verify Curve Object, only legal type is Quadratic
2765 210 : ErrorsFound |= Curve::CheckCurveDims(state,
2766 70 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSCCapAirFFlow(I), // Curve index
2767 : {1}, // Valid dimensions
2768 : RoutineName, // Routine name
2769 : CurrentModuleObject, // Object Type
2770 70 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name, // Object Name
2771 70 : cAlphaFields(AlfaFieldIncre)); // Field Name
2772 :
2773 70 : if (!ErrorsFound) {
2774 70 : CurveVal = Curve::CurveValue(state, state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSCCapAirFFlow(I), 1.0);
2775 70 : if (CurveVal > 1.10 || CurveVal < 0.90) {
2776 0 : ShowWarningError(state,
2777 0 : format("{}{}=\"{}\", curve values",
2778 : RoutineName,
2779 : CurrentModuleObject,
2780 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name));
2781 0 : ShowContinueError(
2782 0 : state, format("...{} output is not equal to 1.0 (+ or - 10%) at rated conditions.", cAlphaFields(AlfaFieldIncre)));
2783 0 : ShowContinueError(state, format("...Curve output at rated conditions = {:.3T}", CurveVal));
2784 : }
2785 : }
2786 : }
2787 :
2788 70 : AlfaFieldIncre = 14 + (I - 1) * 6;
2789 70 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSCCapWaterFFlow(I) =
2790 70 : Curve::GetCurveIndex(state, AlphArray(AlfaFieldIncre)); // convert curve name to number
2791 70 : if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSCCapWaterFFlow(I) == 0) {
2792 0 : if (lAlphaBlanks(AlfaFieldIncre)) {
2793 0 : ShowSevereError(state,
2794 0 : format("{}{}=\"{}\", missing",
2795 : RoutineName,
2796 : CurrentModuleObject,
2797 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name));
2798 0 : ShowContinueError(state, format("...required {} is blank.", cAlphaFields(AlfaFieldIncre)));
2799 : } else {
2800 0 : ShowSevereError(state,
2801 0 : format("{}{}=\"{}\", invalid",
2802 : RoutineName,
2803 : CurrentModuleObject,
2804 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name));
2805 0 : ShowContinueError(state, format("...not found {}=\"{}\".", cAlphaFields(AlfaFieldIncre), AlphArray(AlfaFieldIncre)));
2806 : }
2807 0 : ErrorsFound = true;
2808 : } else {
2809 : // Verify Curve Object, only legal type is Quadratic
2810 210 : ErrorsFound |= Curve::CheckCurveDims(state,
2811 70 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSCCapWaterFFlow(I), // Curve index
2812 : {1}, // Valid dimensions
2813 : RoutineName, // Routine name
2814 : CurrentModuleObject, // Object Type
2815 70 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name, // Object Name
2816 70 : cAlphaFields(AlfaFieldIncre)); // Field Name
2817 :
2818 70 : if (!ErrorsFound) {
2819 70 : CurveVal = Curve::CurveValue(state, state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSCCapWaterFFlow(I), 1.0);
2820 70 : if (CurveVal > 1.10 || CurveVal < 0.90) {
2821 0 : ShowWarningError(state,
2822 0 : format("{}{}=\"{}\", curve values",
2823 : RoutineName,
2824 : CurrentModuleObject,
2825 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name));
2826 0 : ShowContinueError(
2827 0 : state, format("...{} output is not equal to 1.0 (+ or - 10%) at rated conditions.", cAlphaFields(AlfaFieldIncre)));
2828 0 : ShowContinueError(state, format("...Curve output at rated conditions = {:.3T}", CurveVal));
2829 : }
2830 : }
2831 : }
2832 :
2833 70 : AlfaFieldIncre = 15 + (I - 1) * 6;
2834 70 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSEIRFTemp(I) =
2835 70 : Curve::GetCurveIndex(state, AlphArray(AlfaFieldIncre)); // convert curve name to number
2836 70 : if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSEIRFTemp(I) == 0) {
2837 0 : if (lAlphaBlanks(AlfaFieldIncre)) {
2838 0 : ShowSevereError(state,
2839 0 : format("{}{}=\"{}\", missing",
2840 : RoutineName,
2841 : CurrentModuleObject,
2842 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name));
2843 0 : ShowContinueError(state, format("...required {} is blank.", cAlphaFields(AlfaFieldIncre)));
2844 : } else {
2845 0 : ShowSevereError(state,
2846 0 : format("{}{}=\"{}\", invalid",
2847 : RoutineName,
2848 : CurrentModuleObject,
2849 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name));
2850 0 : ShowContinueError(state, format("...not found {}=\"{}\".", cAlphaFields(AlfaFieldIncre), AlphArray(AlfaFieldIncre)));
2851 : }
2852 0 : ErrorsFound = true;
2853 : } else {
2854 : // Verify Curve Object, only legal type is BiQuadratic
2855 210 : ErrorsFound |= Curve::CheckCurveDims(state,
2856 70 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSEIRFTemp(I), // Curve index
2857 : {2}, // Valid dimensions
2858 : RoutineName, // Routine name
2859 : CurrentModuleObject, // Object Type
2860 70 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name, // Object Name
2861 70 : cAlphaFields(AlfaFieldIncre)); // Field Name
2862 :
2863 70 : if (!ErrorsFound) {
2864 140 : CurveVal = Curve::CurveValue(
2865 70 : state, state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSEIRFTemp(I), WHInletAirTemp, WHInletWaterTemp);
2866 70 : if (CurveVal > 1.10 || CurveVal < 0.90) {
2867 40 : ShowWarningError(state,
2868 40 : format("{}{}=\"{}\", curve values",
2869 : RoutineName,
2870 : CurrentModuleObject,
2871 20 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name));
2872 40 : ShowContinueError(
2873 40 : state, format("...{} output is not equal to 1.0 (+ or - 10%) at rated conditions.", cAlphaFields(AlfaFieldIncre)));
2874 20 : ShowContinueError(state, format("...Curve output at rated conditions = {:.3T}", CurveVal));
2875 : }
2876 : }
2877 : }
2878 :
2879 70 : AlfaFieldIncre = 16 + (I - 1) * 6;
2880 70 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSEIRAirFFlow(I) =
2881 70 : Curve::GetCurveIndex(state, AlphArray(AlfaFieldIncre)); // convert curve name to number
2882 70 : if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSEIRAirFFlow(I) == 0) {
2883 0 : if (lAlphaBlanks(AlfaFieldIncre)) {
2884 0 : ShowSevereError(state,
2885 0 : format("{}{}=\"{}\", missing",
2886 : RoutineName,
2887 : CurrentModuleObject,
2888 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name));
2889 0 : ShowContinueError(state, format("...required {} is blank.", cAlphaFields(AlfaFieldIncre)));
2890 : } else {
2891 0 : ShowSevereError(state,
2892 0 : format("{}{}=\"{}\", invalid",
2893 : RoutineName,
2894 : CurrentModuleObject,
2895 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name));
2896 0 : ShowContinueError(state, format("...not found {}=\"{}\".", cAlphaFields(AlfaFieldIncre), AlphArray(AlfaFieldIncre)));
2897 : }
2898 0 : ErrorsFound = true;
2899 : } else {
2900 : // Verify Curve Object, only legal type is Quadratic
2901 210 : ErrorsFound |= Curve::CheckCurveDims(state,
2902 70 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSEIRAirFFlow(I), // Curve index
2903 : {1}, // Valid dimensions
2904 : RoutineName, // Routine name
2905 : CurrentModuleObject, // Object Type
2906 70 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name, // Object Name
2907 70 : cAlphaFields(AlfaFieldIncre)); // Field Name
2908 :
2909 70 : if (!ErrorsFound) {
2910 70 : CurveVal = Curve::CurveValue(state, state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSEIRAirFFlow(I), 1.0);
2911 70 : if (CurveVal > 1.10 || CurveVal < 0.90) {
2912 0 : ShowWarningError(state,
2913 0 : format("{}{}=\"{}\", curve values",
2914 : RoutineName,
2915 : CurrentModuleObject,
2916 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name));
2917 0 : ShowContinueError(
2918 0 : state, format("...{} output is not equal to 1.0 (+ or - 10%) at rated conditions.", cAlphaFields(AlfaFieldIncre)));
2919 0 : ShowContinueError(state, format("...Curve output at rated conditions = {:.3T}", CurveVal));
2920 : }
2921 : }
2922 : }
2923 :
2924 70 : AlfaFieldIncre = 17 + (I - 1) * 6;
2925 70 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSEIRWaterFFlow(I) =
2926 70 : Curve::GetCurveIndex(state, AlphArray(AlfaFieldIncre)); // convert curve name to number
2927 70 : if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSEIRWaterFFlow(I) == 0) {
2928 0 : if (lAlphaBlanks(AlfaFieldIncre)) {
2929 0 : ShowSevereError(state,
2930 0 : format("{}{}=\"{}\", missing",
2931 : RoutineName,
2932 : CurrentModuleObject,
2933 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name));
2934 0 : ShowContinueError(state, format("...required {} is blank.", cAlphaFields(AlfaFieldIncre)));
2935 : } else {
2936 0 : ShowSevereError(state,
2937 0 : format("{}{}=\"{}\", invalid",
2938 : RoutineName,
2939 : CurrentModuleObject,
2940 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name));
2941 0 : ShowContinueError(state, format("...not found {}=\"{}\".", cAlphaFields(AlfaFieldIncre), AlphArray(AlfaFieldIncre)));
2942 : }
2943 0 : ErrorsFound = true;
2944 : } else {
2945 : // Verify Curve Object, only legal type is Quadratic
2946 210 : ErrorsFound |= Curve::CheckCurveDims(state,
2947 70 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSEIRWaterFFlow(I), // Curve index
2948 : {1}, // Valid dimensions
2949 : RoutineName, // Routine name
2950 : CurrentModuleObject, // Object Type
2951 70 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name, // Object Name
2952 70 : cAlphaFields(AlfaFieldIncre)); // Field Name
2953 :
2954 70 : if (!ErrorsFound) {
2955 70 : CurveVal = Curve::CurveValue(state, state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSEIRWaterFFlow(I), 1.0);
2956 70 : if (CurveVal > 1.10 || CurveVal < 0.90) {
2957 0 : ShowWarningError(state,
2958 0 : format("{}{}=\"{}\", curve values",
2959 : RoutineName,
2960 : CurrentModuleObject,
2961 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name));
2962 0 : ShowContinueError(
2963 0 : state, format("...{} output is not equal to 1.0 (+ or - 10%) at rated conditions.", cAlphaFields(AlfaFieldIncre)));
2964 0 : ShowContinueError(state, format("...Curve output at rated conditions = {:.3T}", CurveVal));
2965 : }
2966 : }
2967 : }
2968 : }
2969 :
2970 : // get scale values
2971 77 : for (int I = 1; I <= state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).NumOfSpeeds; ++I) {
2972 70 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedPercentTotCap(I) =
2973 70 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedTotCap(I) /
2974 140 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedTotCap(
2975 70 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).NumOfSpeeds);
2976 70 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedAirVolFlowPerRatedTotCap(I) =
2977 70 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedAirVolFlowRate(I) /
2978 70 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedTotCap(I);
2979 70 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedWaterVolFlowPerRatedTotCap(I) =
2980 70 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedWaterVolFlowRate(I) /
2981 70 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedTotCap(I);
2982 70 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSWHPumpPowerPerRatedTotCap(I) =
2983 70 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSWHPumpPower(I) /
2984 70 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedTotCap(I);
2985 : }
2986 :
2987 : // CurrentModuleObject = "Coil:Waterheating:Airtowaterheatpump:Variablespeed"
2988 14 : SetupOutputVariable(state,
2989 : "Cooling Coil Electricity Energy",
2990 : Constant::Units::J,
2991 7 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Energy,
2992 : OutputProcessor::TimeStepType::System,
2993 : OutputProcessor::StoreType::Sum,
2994 7 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name,
2995 : Constant::eResource::Electricity,
2996 : OutputProcessor::Group::HVAC,
2997 : OutputProcessor::EndUseCat::Heating);
2998 14 : SetupOutputVariable(state,
2999 : "Cooling Coil Sensible Cooling Energy",
3000 : Constant::Units::J,
3001 7 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).EnergySensible,
3002 : OutputProcessor::TimeStepType::System,
3003 : OutputProcessor::StoreType::Sum,
3004 7 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name);
3005 14 : SetupOutputVariable(state,
3006 : "Cooling Coil Latent Cooling Energy",
3007 : Constant::Units::J,
3008 7 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).EnergyLatent,
3009 : OutputProcessor::TimeStepType::System,
3010 : OutputProcessor::StoreType::Sum,
3011 7 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name);
3012 14 : SetupOutputVariable(state,
3013 : "Cooling Coil Water Side Heat Transfer Energy",
3014 : Constant::Units::J,
3015 7 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).EnergySource,
3016 : OutputProcessor::TimeStepType::System,
3017 : OutputProcessor::StoreType::Sum,
3018 7 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name,
3019 : Constant::eResource::PlantLoopHeatingDemand,
3020 : OutputProcessor::Group::HVAC,
3021 : OutputProcessor::EndUseCat::HeatingCoils);
3022 :
3023 7 : if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).IsDXCoilInZone) {
3024 14 : SetupOutputVariable(state,
3025 : "Cooling Coil Cooling Energy",
3026 : Constant::Units::J,
3027 7 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).EnergyLoadTotal,
3028 : OutputProcessor::TimeStepType::System,
3029 : OutputProcessor::StoreType::Sum,
3030 7 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name,
3031 : Constant::eResource::EnergyTransfer,
3032 : OutputProcessor::Group::HVAC,
3033 : OutputProcessor::EndUseCat::CoolingCoils);
3034 : } else {
3035 0 : SetupOutputVariable(state,
3036 : "Cooling Coil Cooling Energy",
3037 : Constant::Units::J,
3038 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).EnergyLoadTotal,
3039 : OutputProcessor::TimeStepType::System,
3040 : OutputProcessor::StoreType::Sum,
3041 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name);
3042 : }
3043 :
3044 7 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).RatedCapCoolSens =
3045 : DataSizing::AutoSize; // always auto-sized, to be determined in the sizing calculation
3046 : }
3047 : //---------------------------VARIABLE-SPEED AIR SOURCE HPWH END --------------
3048 :
3049 49 : AlphArray.deallocate();
3050 49 : cAlphaFields.deallocate();
3051 49 : lAlphaBlanks.deallocate();
3052 49 : cNumericFields.deallocate();
3053 49 : lNumericBlanks.deallocate();
3054 49 : NumArray.deallocate();
3055 :
3056 49 : if (ErrorsFound) {
3057 0 : ShowFatalError(state, format("{}Errors found getting input. Program terminates.", RoutineName));
3058 : }
3059 :
3060 116 : for (DXCoilNum = 1; DXCoilNum <= state.dataVariableSpeedCoils->NumVarSpeedCoils; ++DXCoilNum) {
3061 96 : if ((state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).VSCoilType == HVAC::Coil_CoolingAirToAirVariableSpeed) ||
3062 29 : (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).VSCoilType == HVAC::Coil_HeatingAirToAirVariableSpeed)) {
3063 : // Setup Report variables for the Heat Pump
3064 :
3065 : // cooling and heating coils separately
3066 51 : if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).VSCoilType == HVAC::Coil_CoolingAirToAirVariableSpeed) {
3067 : // air source cooling coils
3068 76 : SetupOutputVariable(state,
3069 : "Cooling Coil Air Mass Flow Rate",
3070 : Constant::Units::kg_s,
3071 38 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).AirMassFlowRate,
3072 : OutputProcessor::TimeStepType::System,
3073 : OutputProcessor::StoreType::Average,
3074 38 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name);
3075 76 : SetupOutputVariable(state,
3076 : "Cooling Coil Air Inlet Temperature",
3077 : Constant::Units::C,
3078 38 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).InletAirDBTemp,
3079 : OutputProcessor::TimeStepType::System,
3080 : OutputProcessor::StoreType::Average,
3081 38 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name);
3082 76 : SetupOutputVariable(state,
3083 : "Cooling Coil Air Inlet Humidity Ratio",
3084 : Constant::Units::kgWater_kgDryAir,
3085 38 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).InletAirHumRat,
3086 : OutputProcessor::TimeStepType::System,
3087 : OutputProcessor::StoreType::Average,
3088 38 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name);
3089 76 : SetupOutputVariable(state,
3090 : "Cooling Coil Latent Cooling Rate",
3091 : Constant::Units::W,
3092 38 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).QLatent,
3093 : OutputProcessor::TimeStepType::System,
3094 : OutputProcessor::StoreType::Average,
3095 38 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name);
3096 76 : SetupOutputVariable(state,
3097 : "Cooling Coil Air Outlet Temperature",
3098 : Constant::Units::C,
3099 38 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).OutletAirDBTemp,
3100 : OutputProcessor::TimeStepType::System,
3101 : OutputProcessor::StoreType::Average,
3102 38 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name);
3103 76 : SetupOutputVariable(state,
3104 : "Cooling Coil Air Outlet Humidity Ratio",
3105 : Constant::Units::kgWater_kgDryAir,
3106 38 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).OutletAirHumRat,
3107 : OutputProcessor::TimeStepType::System,
3108 : OutputProcessor::StoreType::Average,
3109 38 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name);
3110 76 : SetupOutputVariable(state,
3111 : "Cooling Coil Sensible Cooling Rate",
3112 : Constant::Units::W,
3113 38 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).QSensible,
3114 : OutputProcessor::TimeStepType::System,
3115 : OutputProcessor::StoreType::Average,
3116 38 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name);
3117 76 : SetupOutputVariable(state,
3118 : "Cooling Coil Total Cooling Rate",
3119 : Constant::Units::W,
3120 38 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).QLoadTotal,
3121 : OutputProcessor::TimeStepType::System,
3122 : OutputProcessor::StoreType::Average,
3123 38 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name);
3124 76 : SetupOutputVariable(state,
3125 : "Cooling Coil Part Load Ratio",
3126 : Constant::Units::None,
3127 38 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).PartLoadRatio,
3128 : OutputProcessor::TimeStepType::System,
3129 : OutputProcessor::StoreType::Average,
3130 38 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name);
3131 76 : SetupOutputVariable(state,
3132 : "Cooling Coil Electricity Rate",
3133 : Constant::Units::W,
3134 38 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Power,
3135 : OutputProcessor::TimeStepType::System,
3136 : OutputProcessor::StoreType::Average,
3137 38 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name);
3138 76 : SetupOutputVariable(state,
3139 : "Cooling Coil Runtime Fraction",
3140 : Constant::Units::None,
3141 38 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).RunFrac,
3142 : OutputProcessor::TimeStepType::System,
3143 : OutputProcessor::StoreType::Average,
3144 38 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name);
3145 76 : SetupOutputVariable(state,
3146 : "Cooling Coil Source Side Heat Transfer Rate",
3147 : Constant::Units::W,
3148 38 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).QSource,
3149 : OutputProcessor::TimeStepType::System,
3150 : OutputProcessor::StoreType::Average,
3151 38 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name);
3152 76 : SetupOutputVariable(state,
3153 : "Cooling Coil Upper Speed Level",
3154 : Constant::Units::None,
3155 38 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).SpeedNumReport,
3156 : OutputProcessor::TimeStepType::System,
3157 : OutputProcessor::StoreType::Average,
3158 38 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name);
3159 76 : SetupOutputVariable(state,
3160 : "Cooling Coil Neighboring Speed Levels Ratio",
3161 : Constant::Units::None,
3162 38 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).SpeedRatioReport,
3163 : OutputProcessor::TimeStepType::System,
3164 : OutputProcessor::StoreType::Average,
3165 38 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name);
3166 :
3167 38 : if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).CondensateCollectMode == CondensateToTank) {
3168 0 : SetupOutputVariable(state,
3169 : "Cooling Coil Condensate Volume Flow Rate",
3170 : Constant::Units::m3_s,
3171 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).CondensateVdot,
3172 : OutputProcessor::TimeStepType::System,
3173 : OutputProcessor::StoreType::Average,
3174 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name);
3175 0 : SetupOutputVariable(state,
3176 : "Cooling Coil Condensate Volume",
3177 : Constant::Units::m3,
3178 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).CondensateVol,
3179 : OutputProcessor::TimeStepType::System,
3180 : OutputProcessor::StoreType::Sum,
3181 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name,
3182 : Constant::eResource::OnSiteWater,
3183 : OutputProcessor::Group::HVAC,
3184 : OutputProcessor::EndUseCat::Condensate);
3185 : }
3186 :
3187 38 : if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).ReportEvapCondVars) {
3188 2 : SetupOutputVariable(state,
3189 : "Cooling Coil Condenser Inlet Temperature",
3190 : Constant::Units::C,
3191 1 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).CondInletTemp,
3192 : OutputProcessor::TimeStepType::System,
3193 : OutputProcessor::StoreType::Average,
3194 1 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name);
3195 2 : SetupOutputVariable(state,
3196 : "Cooling Coil Evaporative Condenser Water Volume",
3197 : Constant::Units::m3,
3198 1 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).EvapWaterConsump,
3199 : OutputProcessor::TimeStepType::System,
3200 : OutputProcessor::StoreType::Sum,
3201 1 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name,
3202 : Constant::eResource::Water,
3203 : OutputProcessor::Group::HVAC,
3204 : OutputProcessor::EndUseCat::Cooling);
3205 2 : SetupOutputVariable(state,
3206 : "Cooling Coil Evaporative Condenser Mains Water Volume",
3207 : Constant::Units::m3,
3208 1 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).EvapWaterConsump,
3209 : OutputProcessor::TimeStepType::System,
3210 : OutputProcessor::StoreType::Sum,
3211 1 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name,
3212 : Constant::eResource::MainsWater,
3213 : OutputProcessor::Group::HVAC,
3214 : OutputProcessor::EndUseCat::Cooling);
3215 2 : SetupOutputVariable(state,
3216 : "Cooling Coil Evaporative Condenser Pump Electricity Rate",
3217 : Constant::Units::W,
3218 1 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).EvapCondPumpElecPower,
3219 : OutputProcessor::TimeStepType::System,
3220 : OutputProcessor::StoreType::Average,
3221 1 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name);
3222 2 : SetupOutputVariable(state,
3223 : "Cooling Coil Evaporative Condenser Pump Electricity Energy",
3224 : Constant::Units::J,
3225 1 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).EvapCondPumpElecConsumption,
3226 : OutputProcessor::TimeStepType::System,
3227 : OutputProcessor::StoreType::Sum,
3228 1 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name,
3229 : Constant::eResource::Electricity,
3230 : OutputProcessor::Group::HVAC,
3231 : OutputProcessor::EndUseCat::Cooling);
3232 1 : if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).BasinHeaterPowerFTempDiff > 0.0) {
3233 0 : SetupOutputVariable(state,
3234 : "Cooling Coil Basin Heater Electricity Rate",
3235 : Constant::Units::W,
3236 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).BasinHeaterPower,
3237 : OutputProcessor::TimeStepType::System,
3238 : OutputProcessor::StoreType::Average,
3239 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name);
3240 0 : SetupOutputVariable(state,
3241 : "Cooling Coil Basin Heater Electricity Energy",
3242 : Constant::Units::J,
3243 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).BasinHeaterConsumption,
3244 : OutputProcessor::TimeStepType::System,
3245 : OutputProcessor::StoreType::Sum,
3246 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name,
3247 : Constant::eResource::Electricity,
3248 : OutputProcessor::Group::HVAC,
3249 : OutputProcessor::EndUseCat::Cooling);
3250 : }
3251 : }
3252 :
3253 76 : SetupOutputVariable(state,
3254 : "Cooling Coil Crankcase Heater Electricity Rate",
3255 : Constant::Units::W,
3256 38 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).CrankcaseHeaterPower,
3257 : OutputProcessor::TimeStepType::System,
3258 : OutputProcessor::StoreType::Average,
3259 38 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name);
3260 76 : SetupOutputVariable(state,
3261 : "Cooling Coil Crankcase Heater Electricity Energy",
3262 : Constant::Units::J,
3263 38 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).CrankcaseHeaterConsumption,
3264 : OutputProcessor::TimeStepType::System,
3265 : OutputProcessor::StoreType::Sum,
3266 38 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name,
3267 : Constant::eResource::Electricity,
3268 : OutputProcessor::Group::HVAC,
3269 : OutputProcessor::EndUseCat::Cooling);
3270 : } else {
3271 : // air source heating coils
3272 26 : SetupOutputVariable(state,
3273 : "Heating Coil Air Mass Flow Rate",
3274 : Constant::Units::kg_s,
3275 13 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).AirMassFlowRate,
3276 : OutputProcessor::TimeStepType::System,
3277 : OutputProcessor::StoreType::Average,
3278 13 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name);
3279 26 : SetupOutputVariable(state,
3280 : "Heating Coil Air Inlet Temperature",
3281 : Constant::Units::C,
3282 13 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).InletAirDBTemp,
3283 : OutputProcessor::TimeStepType::System,
3284 : OutputProcessor::StoreType::Average,
3285 13 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name);
3286 26 : SetupOutputVariable(state,
3287 : "Heating Coil Air Inlet Humidity Ratio",
3288 : Constant::Units::kgWater_kgDryAir,
3289 13 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).InletAirHumRat,
3290 : OutputProcessor::TimeStepType::System,
3291 : OutputProcessor::StoreType::Average,
3292 13 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name);
3293 26 : SetupOutputVariable(state,
3294 : "Heating Coil Air Outlet Temperature",
3295 : Constant::Units::C,
3296 13 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).OutletAirDBTemp,
3297 : OutputProcessor::TimeStepType::System,
3298 : OutputProcessor::StoreType::Average,
3299 13 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name);
3300 26 : SetupOutputVariable(state,
3301 : "Heating Coil Air Outlet Humidity Ratio",
3302 : Constant::Units::kgWater_kgDryAir,
3303 13 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).OutletAirHumRat,
3304 : OutputProcessor::TimeStepType::System,
3305 : OutputProcessor::StoreType::Average,
3306 13 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name);
3307 26 : SetupOutputVariable(state,
3308 : "Heating Coil Sensible Heating Rate",
3309 : Constant::Units::W,
3310 13 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).QSensible,
3311 : OutputProcessor::TimeStepType::System,
3312 : OutputProcessor::StoreType::Average,
3313 13 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name);
3314 26 : SetupOutputVariable(state,
3315 : "Heating Coil Heating Rate",
3316 : Constant::Units::W,
3317 13 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).QLoadTotal,
3318 : OutputProcessor::TimeStepType::System,
3319 : OutputProcessor::StoreType::Average,
3320 13 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name);
3321 26 : SetupOutputVariable(state,
3322 : "Heating Coil Part Load Ratio",
3323 : Constant::Units::None,
3324 13 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).PartLoadRatio,
3325 : OutputProcessor::TimeStepType::System,
3326 : OutputProcessor::StoreType::Average,
3327 13 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name);
3328 26 : SetupOutputVariable(state,
3329 : "Heating Coil Electricity Rate",
3330 : Constant::Units::W,
3331 13 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Power,
3332 : OutputProcessor::TimeStepType::System,
3333 : OutputProcessor::StoreType::Average,
3334 13 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name);
3335 26 : SetupOutputVariable(state,
3336 : "Heating Coil Runtime Fraction",
3337 : Constant::Units::None,
3338 13 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).RunFrac,
3339 : OutputProcessor::TimeStepType::System,
3340 : OutputProcessor::StoreType::Average,
3341 13 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name);
3342 :
3343 26 : SetupOutputVariable(state,
3344 : "Heating Coil Source Side Heat Transfer Rate",
3345 : Constant::Units::W,
3346 13 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).QSource,
3347 : OutputProcessor::TimeStepType::System,
3348 : OutputProcessor::StoreType::Average,
3349 13 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name);
3350 26 : SetupOutputVariable(state,
3351 : "Heating Coil Upper Speed Level",
3352 : Constant::Units::None,
3353 13 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).SpeedNumReport,
3354 : OutputProcessor::TimeStepType::System,
3355 : OutputProcessor::StoreType::Average,
3356 13 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name);
3357 26 : SetupOutputVariable(state,
3358 : "Heating Coil Neighboring Speed Levels Ratio",
3359 : Constant::Units::None,
3360 13 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).SpeedRatioReport,
3361 : OutputProcessor::TimeStepType::System,
3362 : OutputProcessor::StoreType::Average,
3363 13 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name);
3364 :
3365 26 : SetupOutputVariable(state,
3366 : "Heating Coil Defrost Electricity Rate",
3367 : Constant::Units::W,
3368 13 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).DefrostPower,
3369 : OutputProcessor::TimeStepType::System,
3370 : OutputProcessor::StoreType::Average,
3371 13 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name);
3372 26 : SetupOutputVariable(state,
3373 : "Heating Coil Defrost Electricity Energy",
3374 : Constant::Units::J,
3375 13 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).DefrostConsumption,
3376 : OutputProcessor::TimeStepType::System,
3377 : OutputProcessor::StoreType::Sum,
3378 13 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name,
3379 : Constant::eResource::Electricity,
3380 : OutputProcessor::Group::HVAC,
3381 : OutputProcessor::EndUseCat::Heating);
3382 26 : SetupOutputVariable(state,
3383 : "Heating Coil Crankcase Heater Electricity Rate",
3384 : Constant::Units::W,
3385 13 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).CrankcaseHeaterPower,
3386 : OutputProcessor::TimeStepType::System,
3387 : OutputProcessor::StoreType::Average,
3388 13 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name);
3389 26 : SetupOutputVariable(state,
3390 : "Heating Coil Crankcase Heater Electricity Energy",
3391 : Constant::Units::J,
3392 13 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).CrankcaseHeaterConsumption,
3393 : OutputProcessor::TimeStepType::System,
3394 : OutputProcessor::StoreType::Sum,
3395 13 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name,
3396 : Constant::eResource::Electricity,
3397 : OutputProcessor::Group::HVAC,
3398 : OutputProcessor::EndUseCat::Heating);
3399 :
3400 13 : if (state.dataGlobal->AnyEnergyManagementSystemInModel) {
3401 0 : SetupEMSActuator(state,
3402 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).VarSpeedCoilType,
3403 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name,
3404 : "Frost Heating Capacity Multiplier",
3405 : "[]",
3406 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).FrostHeatingCapacityMultiplierEMSOverrideOn,
3407 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).FrostHeatingCapacityMultiplierEMSOverrideValue);
3408 :
3409 0 : SetupEMSActuator(state,
3410 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).VarSpeedCoilType,
3411 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name,
3412 : "Frost Heating Input Power Multiplier",
3413 : "[]",
3414 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).FrostHeatingInputPowerMultiplierEMSOverrideOn,
3415 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).FrostHeatingInputPowerMultiplierEMSOverrideValue);
3416 : }
3417 : }
3418 : } else {
3419 :
3420 16 : if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).VSCoilType ==
3421 : HVAC::Coil_CoolingWaterToAirHPVSEquationFit) { // fix coil type
3422 : // cooling WAHP coil
3423 : // Setup Report variables for water source Heat Pump
3424 10 : SetupOutputVariable(state,
3425 : "Cooling Coil Electricity Rate",
3426 : Constant::Units::W,
3427 5 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Power,
3428 : OutputProcessor::TimeStepType::System,
3429 : OutputProcessor::StoreType::Average,
3430 5 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name);
3431 10 : SetupOutputVariable(state,
3432 : "Cooling Coil Total Cooling Rate",
3433 : Constant::Units::W,
3434 5 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).QLoadTotal,
3435 : OutputProcessor::TimeStepType::System,
3436 : OutputProcessor::StoreType::Average,
3437 5 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name);
3438 10 : SetupOutputVariable(state,
3439 : "Cooling Coil Sensible Cooling Rate",
3440 : Constant::Units::W,
3441 5 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).QSensible,
3442 : OutputProcessor::TimeStepType::System,
3443 : OutputProcessor::StoreType::Average,
3444 5 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name);
3445 10 : SetupOutputVariable(state,
3446 : "Cooling Coil Latent Cooling Rate",
3447 : Constant::Units::W,
3448 5 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).QLatent,
3449 : OutputProcessor::TimeStepType::System,
3450 : OutputProcessor::StoreType::Average,
3451 5 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name);
3452 10 : SetupOutputVariable(state,
3453 : "Cooling Coil Source Side Heat Transfer Rate",
3454 : Constant::Units::W,
3455 5 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).QSource,
3456 : OutputProcessor::TimeStepType::System,
3457 : OutputProcessor::StoreType::Average,
3458 5 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name);
3459 10 : SetupOutputVariable(state,
3460 : "Cooling Coil Part Load Ratio",
3461 : Constant::Units::None,
3462 5 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).PartLoadRatio,
3463 : OutputProcessor::TimeStepType::System,
3464 : OutputProcessor::StoreType::Average,
3465 5 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name);
3466 10 : SetupOutputVariable(state,
3467 : "Cooling Coil Runtime Fraction",
3468 : Constant::Units::None,
3469 5 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).RunFrac,
3470 : OutputProcessor::TimeStepType::System,
3471 : OutputProcessor::StoreType::Average,
3472 5 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name);
3473 :
3474 10 : SetupOutputVariable(state,
3475 : "Cooling Coil Air Mass Flow Rate",
3476 : Constant::Units::kg_s,
3477 5 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).AirMassFlowRate,
3478 : OutputProcessor::TimeStepType::System,
3479 : OutputProcessor::StoreType::Average,
3480 5 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name);
3481 10 : SetupOutputVariable(state,
3482 : "Cooling Coil Air Inlet Temperature",
3483 : Constant::Units::C,
3484 5 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).InletAirDBTemp,
3485 : OutputProcessor::TimeStepType::System,
3486 : OutputProcessor::StoreType::Average,
3487 5 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name);
3488 10 : SetupOutputVariable(state,
3489 : "Cooling Coil Air Inlet Humidity Ratio",
3490 : Constant::Units::kgWater_kgDryAir,
3491 5 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).InletAirHumRat,
3492 : OutputProcessor::TimeStepType::System,
3493 : OutputProcessor::StoreType::Average,
3494 5 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name);
3495 10 : SetupOutputVariable(state,
3496 : "Cooling Coil Air Outlet Temperature",
3497 : Constant::Units::C,
3498 5 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).OutletAirDBTemp,
3499 : OutputProcessor::TimeStepType::System,
3500 : OutputProcessor::StoreType::Average,
3501 5 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name);
3502 10 : SetupOutputVariable(state,
3503 : "Cooling Coil Air Outlet Humidity Ratio",
3504 : Constant::Units::kgWater_kgDryAir,
3505 5 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).OutletAirHumRat,
3506 : OutputProcessor::TimeStepType::System,
3507 : OutputProcessor::StoreType::Average,
3508 5 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name);
3509 10 : SetupOutputVariable(state,
3510 : "Cooling Coil Source Side Mass Flow Rate",
3511 : Constant::Units::kg_s,
3512 5 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).WaterMassFlowRate,
3513 : OutputProcessor::TimeStepType::System,
3514 : OutputProcessor::StoreType::Average,
3515 5 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name);
3516 10 : SetupOutputVariable(state,
3517 : "Cooling Coil Source Side Inlet Temperature",
3518 : Constant::Units::C,
3519 5 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).InletWaterTemp,
3520 : OutputProcessor::TimeStepType::System,
3521 : OutputProcessor::StoreType::Average,
3522 5 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name);
3523 10 : SetupOutputVariable(state,
3524 : "Cooling Coil Source Side Outlet Temperature",
3525 : Constant::Units::C,
3526 5 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).OutletWaterTemp,
3527 : OutputProcessor::TimeStepType::System,
3528 : OutputProcessor::StoreType::Average,
3529 5 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name);
3530 :
3531 10 : SetupOutputVariable(state,
3532 : "Cooling Coil Upper Speed Level",
3533 : Constant::Units::None,
3534 5 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).SpeedNumReport,
3535 : OutputProcessor::TimeStepType::System,
3536 : OutputProcessor::StoreType::Average,
3537 5 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name);
3538 10 : SetupOutputVariable(state,
3539 : "Cooling Coil Neighboring Speed Levels Ratio",
3540 : Constant::Units::None,
3541 5 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).SpeedRatioReport,
3542 : OutputProcessor::TimeStepType::System,
3543 : OutputProcessor::StoreType::Average,
3544 5 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name);
3545 10 : SetupOutputVariable(state,
3546 : "Cooling Coil Recoverable Heat Transfer Rate",
3547 : Constant::Units::W,
3548 5 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).QWasteHeat,
3549 : OutputProcessor::TimeStepType::System,
3550 : OutputProcessor::StoreType::Average,
3551 5 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name);
3552 11 : } else if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).VSCoilType ==
3553 : HVAC::Coil_HeatingWaterToAirHPVSEquationFit) { // fix coil type
3554 : // heating WAHP coil
3555 : // Setup Report variables for water source Heat Pump
3556 8 : SetupOutputVariable(state,
3557 : "Heating Coil Electricity Rate",
3558 : Constant::Units::W,
3559 4 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Power,
3560 : OutputProcessor::TimeStepType::System,
3561 : OutputProcessor::StoreType::Average,
3562 4 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name);
3563 8 : SetupOutputVariable(state,
3564 : "Heating Coil Heating Rate",
3565 : Constant::Units::W,
3566 4 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).QLoadTotal,
3567 : OutputProcessor::TimeStepType::System,
3568 : OutputProcessor::StoreType::Average,
3569 4 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name);
3570 8 : SetupOutputVariable(state,
3571 : "Heating Coil Sensible Heating Rate",
3572 : Constant::Units::W,
3573 4 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).QSensible,
3574 : OutputProcessor::TimeStepType::System,
3575 : OutputProcessor::StoreType::Average,
3576 4 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name);
3577 :
3578 8 : SetupOutputVariable(state,
3579 : "Heating Coil Source Side Heat Transfer Rate",
3580 : Constant::Units::W,
3581 4 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).QSource,
3582 : OutputProcessor::TimeStepType::System,
3583 : OutputProcessor::StoreType::Average,
3584 4 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name);
3585 8 : SetupOutputVariable(state,
3586 : "Heating Coil Part Load Ratio",
3587 : Constant::Units::None,
3588 4 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).PartLoadRatio,
3589 : OutputProcessor::TimeStepType::System,
3590 : OutputProcessor::StoreType::Average,
3591 4 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name);
3592 8 : SetupOutputVariable(state,
3593 : "Heating Coil Runtime Fraction",
3594 : Constant::Units::None,
3595 4 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).RunFrac,
3596 : OutputProcessor::TimeStepType::System,
3597 : OutputProcessor::StoreType::Average,
3598 4 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name);
3599 :
3600 8 : SetupOutputVariable(state,
3601 : "Heating Coil Air Mass Flow Rate",
3602 : Constant::Units::kg_s,
3603 4 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).AirMassFlowRate,
3604 : OutputProcessor::TimeStepType::System,
3605 : OutputProcessor::StoreType::Average,
3606 4 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name);
3607 8 : SetupOutputVariable(state,
3608 : "Heating Coil Air Inlet Temperature",
3609 : Constant::Units::C,
3610 4 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).InletAirDBTemp,
3611 : OutputProcessor::TimeStepType::System,
3612 : OutputProcessor::StoreType::Average,
3613 4 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name);
3614 8 : SetupOutputVariable(state,
3615 : "Heating Coil Air Inlet Humidity Ratio",
3616 : Constant::Units::kgWater_kgDryAir,
3617 4 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).InletAirHumRat,
3618 : OutputProcessor::TimeStepType::System,
3619 : OutputProcessor::StoreType::Average,
3620 4 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name);
3621 8 : SetupOutputVariable(state,
3622 : "Heating Coil Air Outlet Temperature",
3623 : Constant::Units::C,
3624 4 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).OutletAirDBTemp,
3625 : OutputProcessor::TimeStepType::System,
3626 : OutputProcessor::StoreType::Average,
3627 4 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name);
3628 8 : SetupOutputVariable(state,
3629 : "Heating Coil Air Outlet Humidity Ratio",
3630 : Constant::Units::kgWater_kgDryAir,
3631 4 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).OutletAirHumRat,
3632 : OutputProcessor::TimeStepType::System,
3633 : OutputProcessor::StoreType::Average,
3634 4 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name);
3635 8 : SetupOutputVariable(state,
3636 : "Heating Coil Source Side Mass Flow Rate",
3637 : Constant::Units::kg_s,
3638 4 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).WaterMassFlowRate,
3639 : OutputProcessor::TimeStepType::System,
3640 : OutputProcessor::StoreType::Average,
3641 4 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name);
3642 8 : SetupOutputVariable(state,
3643 : "Heating Coil Source Side Inlet Temperature",
3644 : Constant::Units::C,
3645 4 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).InletWaterTemp,
3646 : OutputProcessor::TimeStepType::System,
3647 : OutputProcessor::StoreType::Average,
3648 4 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name);
3649 8 : SetupOutputVariable(state,
3650 : "Heating Coil Source Side Outlet Temperature",
3651 : Constant::Units::C,
3652 4 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).OutletWaterTemp,
3653 : OutputProcessor::TimeStepType::System,
3654 : OutputProcessor::StoreType::Average,
3655 4 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name);
3656 :
3657 8 : SetupOutputVariable(state,
3658 : "Heating Coil Upper Speed Level",
3659 : Constant::Units::None,
3660 4 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).SpeedNumReport,
3661 : OutputProcessor::TimeStepType::System,
3662 : OutputProcessor::StoreType::Average,
3663 4 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name);
3664 8 : SetupOutputVariable(state,
3665 : "Heating Coil Neighboring Speed Levels Ratio",
3666 : Constant::Units::None,
3667 4 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).SpeedRatioReport,
3668 : OutputProcessor::TimeStepType::System,
3669 : OutputProcessor::StoreType::Average,
3670 4 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name);
3671 8 : SetupOutputVariable(state,
3672 : "Heating Coil Recoverable Heat Transfer Rate",
3673 : Constant::Units::W,
3674 4 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).QWasteHeat,
3675 : OutputProcessor::TimeStepType::System,
3676 : OutputProcessor::StoreType::Average,
3677 4 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name);
3678 7 : } else if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).VSCoilType == HVAC::CoilDX_HeatPumpWaterHeaterVariableSpeed) {
3679 : // air source water heating coil
3680 14 : SetupOutputVariable(state,
3681 : "Cooling Coil Water Heating Electricity Rate",
3682 : Constant::Units::W,
3683 7 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Power,
3684 : OutputProcessor::TimeStepType::System,
3685 : OutputProcessor::StoreType::Average,
3686 7 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name);
3687 14 : SetupOutputVariable(state,
3688 : "Cooling Coil Total Cooling Rate",
3689 : Constant::Units::W,
3690 7 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).QLoadTotal,
3691 : OutputProcessor::TimeStepType::System,
3692 : OutputProcessor::StoreType::Average,
3693 7 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name);
3694 14 : SetupOutputVariable(state,
3695 : "Cooling Coil Sensible Cooling Rate",
3696 : Constant::Units::W,
3697 7 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).QSensible,
3698 : OutputProcessor::TimeStepType::System,
3699 : OutputProcessor::StoreType::Average,
3700 7 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name);
3701 14 : SetupOutputVariable(state,
3702 : "Cooling Coil Latent Cooling Rate",
3703 : Constant::Units::W,
3704 7 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).QLatent,
3705 : OutputProcessor::TimeStepType::System,
3706 : OutputProcessor::StoreType::Average,
3707 7 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name);
3708 14 : SetupOutputVariable(state,
3709 : "Cooling Coil Total Water Heating Rate",
3710 : Constant::Units::W,
3711 7 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).TotalHeatingEnergyRate,
3712 : OutputProcessor::TimeStepType::System,
3713 : OutputProcessor::StoreType::Average,
3714 7 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name);
3715 14 : SetupOutputVariable(state,
3716 : "Cooling Coil Part Load Ratio",
3717 : Constant::Units::None,
3718 7 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).PartLoadRatio,
3719 : OutputProcessor::TimeStepType::System,
3720 : OutputProcessor::StoreType::Average,
3721 7 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name);
3722 14 : SetupOutputVariable(state,
3723 : "Cooling Coil Runtime Fraction",
3724 : Constant::Units::None,
3725 7 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).RunFrac,
3726 : OutputProcessor::TimeStepType::System,
3727 : OutputProcessor::StoreType::Average,
3728 7 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name);
3729 :
3730 14 : SetupOutputVariable(state,
3731 : "Cooling Coil Air Mass Flow Rate",
3732 : Constant::Units::kg_s,
3733 7 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).AirMassFlowRate,
3734 : OutputProcessor::TimeStepType::System,
3735 : OutputProcessor::StoreType::Average,
3736 7 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name);
3737 14 : SetupOutputVariable(state,
3738 : "Cooling Coil Air Inlet Temperature",
3739 : Constant::Units::C,
3740 7 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).InletAirDBTemp,
3741 : OutputProcessor::TimeStepType::System,
3742 : OutputProcessor::StoreType::Average,
3743 7 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name);
3744 14 : SetupOutputVariable(state,
3745 : "Cooling Coil Air Inlet Humidity Ratio",
3746 : Constant::Units::kgWater_kgDryAir,
3747 7 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).InletAirHumRat,
3748 : OutputProcessor::TimeStepType::System,
3749 : OutputProcessor::StoreType::Average,
3750 7 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name);
3751 14 : SetupOutputVariable(state,
3752 : "Cooling Coil Air Outlet Temperature",
3753 : Constant::Units::C,
3754 7 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).OutletAirDBTemp,
3755 : OutputProcessor::TimeStepType::System,
3756 : OutputProcessor::StoreType::Average,
3757 7 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name);
3758 14 : SetupOutputVariable(state,
3759 : "Cooling Coil Air Outlet Humidity Ratio",
3760 : Constant::Units::kgWater_kgDryAir,
3761 7 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).OutletAirHumRat,
3762 : OutputProcessor::TimeStepType::System,
3763 : OutputProcessor::StoreType::Average,
3764 7 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name);
3765 14 : SetupOutputVariable(state,
3766 : "Cooling Coil Water Mass Flow Rate",
3767 : Constant::Units::kg_s,
3768 7 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).WaterMassFlowRate,
3769 : OutputProcessor::TimeStepType::System,
3770 : OutputProcessor::StoreType::Average,
3771 7 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name);
3772 14 : SetupOutputVariable(state,
3773 : "Cooling Coil Water Inlet Temperature",
3774 : Constant::Units::C,
3775 7 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).InletWaterTemp,
3776 : OutputProcessor::TimeStepType::System,
3777 : OutputProcessor::StoreType::Average,
3778 7 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name);
3779 14 : SetupOutputVariable(state,
3780 : "Cooling Coil Water Outlet Temperature",
3781 : Constant::Units::C,
3782 7 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).OutletWaterTemp,
3783 : OutputProcessor::TimeStepType::System,
3784 : OutputProcessor::StoreType::Average,
3785 7 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name);
3786 :
3787 14 : SetupOutputVariable(state,
3788 : "Cooling Coil Crankcase Heater Electricity Rate",
3789 : Constant::Units::W,
3790 7 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).CrankcaseHeaterPower,
3791 : OutputProcessor::TimeStepType::System,
3792 : OutputProcessor::StoreType::Average,
3793 7 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name);
3794 14 : SetupOutputVariable(state,
3795 : "Cooling Coil Crankcase Heater Electricity Energy",
3796 : Constant::Units::J,
3797 7 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).CrankcaseHeaterConsumption,
3798 : OutputProcessor::TimeStepType::System,
3799 : OutputProcessor::StoreType::Sum,
3800 7 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name,
3801 : Constant::eResource::Electricity,
3802 : OutputProcessor::Group::HVAC,
3803 : OutputProcessor::EndUseCat::Heating);
3804 :
3805 14 : SetupOutputVariable(state,
3806 : "Cooling Coil Upper Speed Level",
3807 : Constant::Units::None,
3808 7 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).SpeedNumReport,
3809 : OutputProcessor::TimeStepType::System,
3810 : OutputProcessor::StoreType::Average,
3811 7 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name);
3812 14 : SetupOutputVariable(state,
3813 : "Cooling Coil Neighboring Speed Levels Ratio",
3814 : Constant::Units::None,
3815 7 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).SpeedRatioReport,
3816 : OutputProcessor::TimeStepType::System,
3817 : OutputProcessor::StoreType::Average,
3818 7 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name);
3819 :
3820 14 : SetupOutputVariable(state,
3821 : "Cooling Coil Water Heating Pump Electricity Rate",
3822 : Constant::Units::W,
3823 7 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).HPWHCondPumpElecNomPower,
3824 : OutputProcessor::TimeStepType::System,
3825 : OutputProcessor::StoreType::Average,
3826 7 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name);
3827 14 : SetupOutputVariable(state,
3828 : "Cooling Coil Water Heating Pump Electricity Energy",
3829 : Constant::Units::J,
3830 7 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).EvapCondPumpElecConsumption,
3831 : OutputProcessor::TimeStepType::System,
3832 : OutputProcessor::StoreType::Sum,
3833 7 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name,
3834 : Constant::eResource::Electricity,
3835 : OutputProcessor::Group::HVAC,
3836 : OutputProcessor::EndUseCat::Heating);
3837 : }
3838 : }
3839 : }
3840 :
3841 49 : if (ErrorsFound) {
3842 0 : ShowFatalError(
3843 0 : state, format("{}Errors found in getting {} input. Preceding condition(s) causes termination.", RoutineName, CurrentModuleObject));
3844 : }
3845 49 : }
3846 :
3847 : // Beginning Initialization Section of the Module
3848 : //******************************************************************************
3849 :
3850 67679 : void InitVarSpeedCoil(EnergyPlusData &state,
3851 : int const DXCoilNum, // Current DXCoilNum under simulation
3852 : Real64 const SensLoad, // Control zone sensible load[W]
3853 : Real64 const LatentLoad, // Control zone latent load[W]
3854 : HVAC::FanOp const fanOp, // fan operating mode
3855 : [[maybe_unused]] Real64 const OnOffAirFlowRatio, // ratio of compressor on flow to average flow over time step
3856 : Real64 const SpeedRatio, // compressor speed ratio
3857 : int const SpeedNum // compressor speed number
3858 : )
3859 : {
3860 :
3861 : // SUBROUTINE INFORMATION:
3862 : // AUTHOR Bo Shen, based on MODULE WaterToAirHeatPumpSimple:InitSimpleWatertoAirHP
3863 : // DATE WRITTEN March, 2012
3864 : // MODIFIED Bo Shen, 12/2014, add variable-speed HPWH
3865 :
3866 : // PURPOSE OF THIS SUBROUTINE:
3867 : // This subroutine is for initializations of the variable speed Water to Air HP Components.
3868 :
3869 : // METHODOLOGY EMPLOYED:
3870 : // Uses the status flags to trigger initializations.
3871 :
3872 : // SUBROUTINE PARAMETER DEFINITIONS:
3873 : static constexpr std::string_view RoutineNameSimpleWatertoAirHP("InitSimpleWatertoAirHP");
3874 :
3875 : // SUBROUTINE LOCAL VARIABLE DECLARATIONS:
3876 : int WaterInletNode; // Node Number of the Water inlet
3877 : Real64 rho; // local fluid density
3878 : Real64 Cp; // local fluid specific heat
3879 : int SpeedCal; // calculated speed level
3880 : bool ErrorsFound; // TRUE when errors found, air loop initialization error
3881 : Real64 RatedVolFlowPerRatedTotCap; // Rated Air Volume Flow Rate divided by Rated Total Capacity [m3/s-W)
3882 : Real64 RatedHeatPumpIndoorAirTemp; // Indoor dry-bulb temperature to heat pump evaporator at rated conditions [C]
3883 : Real64 RatedHeatPumpIndoorHumRat; // Inlet humidity ratio to heat pump evaporator at rated conditions [kg/kg]
3884 : Real64 WaterFlowScale; // water flow scaling factor match rated flow rate
3885 :
3886 : // SUBROUTINE PARAMETER DEFINITIONS:
3887 : static constexpr std::string_view RoutineName = "InitVarSpeedCoil";
3888 67679 : int AirInletNode = state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).AirInletNodeNum;
3889 :
3890 67679 : if (state.dataVariableSpeedCoils->MyOneTimeFlag) {
3891 : // initialize the environment and sizing flags
3892 16 : state.dataVariableSpeedCoils->MySizeFlag.allocate(state.dataVariableSpeedCoils->NumVarSpeedCoils);
3893 16 : state.dataVariableSpeedCoils->MyEnvrnFlag.allocate(state.dataVariableSpeedCoils->NumVarSpeedCoils);
3894 16 : state.dataVariableSpeedCoils->MyPlantScanFlag.allocate(state.dataVariableSpeedCoils->NumVarSpeedCoils);
3895 16 : state.dataVariableSpeedCoils->MySizeFlag = true;
3896 16 : state.dataVariableSpeedCoils->MyEnvrnFlag = true;
3897 16 : state.dataVariableSpeedCoils->MyPlantScanFlag = true;
3898 16 : state.dataVariableSpeedCoils->MyOneTimeFlag = false;
3899 : }
3900 :
3901 67679 : state.dataHVACGlobal->DXCT = HVAC::DXCoilType::Regular; // hard-code to non-DOAS sizing routine for cfm/ton until .ISHundredPercentDOASDXCoil
3902 : // member from DXcoils.cc is added to VarSpeedCoil object
3903 :
3904 : // variable-speed heat pump water heating, begin
3905 67679 : if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).VSCoilType == HVAC::CoilDX_HeatPumpWaterHeaterVariableSpeed &&
3906 0 : state.dataVariableSpeedCoils->MySizeFlag(DXCoilNum)) {
3907 :
3908 0 : ErrorsFound = false;
3909 0 : SizeVarSpeedCoil(state, DXCoilNum, ErrorsFound);
3910 0 : if (ErrorsFound) {
3911 0 : ShowFatalError(state, format("{}: Failed to size variable speed coil.", RoutineName));
3912 : }
3913 :
3914 : // get rated coil bypass factor excluding fan heat
3915 :
3916 0 : state.dataVariableSpeedCoils->MySizeFlag(DXCoilNum) = false;
3917 : }
3918 : // variable-speed heat pump water heating, end
3919 :
3920 : // water source
3921 101721 : if ((state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).VSCoilType == HVAC::Coil_CoolingWaterToAirHPVSEquationFit) ||
3922 34042 : (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).VSCoilType == HVAC::Coil_HeatingWaterToAirHPVSEquationFit)) { // fix coil type
3923 67273 : if (state.dataVariableSpeedCoils->MyPlantScanFlag(DXCoilNum) && allocated(state.dataPlnt->PlantLoop)) {
3924 : // switch from coil type numbers in DataHVACGlobals, to coil type numbers in plant.
3925 3 : DataPlant::PlantEquipmentType CoilVSWAHPType(DataPlant::PlantEquipmentType::Invalid);
3926 3 : if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).VSCoilType == HVAC::Coil_CoolingWaterToAirHPVSEquationFit) {
3927 2 : CoilVSWAHPType = DataPlant::PlantEquipmentType::CoilVSWAHPCoolingEquationFit;
3928 1 : } else if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).VSCoilType == HVAC::Coil_HeatingWaterToAirHPVSEquationFit) {
3929 1 : CoilVSWAHPType = DataPlant::PlantEquipmentType::CoilVSWAHPHeatingEquationFit;
3930 : }
3931 3 : ErrorsFound = false;
3932 6 : PlantUtilities::ScanPlantLoopsForObject(state,
3933 3 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name,
3934 : CoilVSWAHPType,
3935 3 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).plantLoc,
3936 : ErrorsFound,
3937 : _,
3938 : _,
3939 : _,
3940 : _,
3941 : _);
3942 3 : if (ErrorsFound) {
3943 0 : ShowFatalError(state, "InitVarSpeedCoil: Program terminated for previous conditions.");
3944 : }
3945 3 : state.dataVariableSpeedCoils->MyPlantScanFlag(DXCoilNum) = false;
3946 : }
3947 : } else {
3948 406 : state.dataVariableSpeedCoils->MyPlantScanFlag(DXCoilNum) = false;
3949 : }
3950 :
3951 67697 : if (!state.dataGlobal->SysSizingCalc && state.dataVariableSpeedCoils->MySizeFlag(DXCoilNum) &&
3952 18 : !state.dataVariableSpeedCoils->MyPlantScanFlag(DXCoilNum)) {
3953 : // for each furnace, do the sizing once.
3954 18 : ErrorsFound = false;
3955 18 : SizeVarSpeedCoil(state, DXCoilNum, ErrorsFound);
3956 18 : if (ErrorsFound) {
3957 0 : ShowFatalError(state, format("{}: Failed to size variable speed coil.", RoutineName));
3958 : }
3959 :
3960 18 : state.dataVariableSpeedCoils->MySizeFlag(DXCoilNum) = false;
3961 :
3962 : // Multispeed Cooling
3963 34 : if ((state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).VSCoilType == HVAC::Coil_CoolingWaterToAirHPVSEquationFit) ||
3964 16 : (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).VSCoilType == HVAC::Coil_CoolingAirToAirVariableSpeed)) {
3965 86 : for (int Mode = 1; Mode <= state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).NumOfSpeeds; ++Mode) {
3966 74 : if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).RatedCapCoolTotal <= 0.0) break;
3967 : // Check for zero capacity or zero max flow rate
3968 73 : if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedTotCap(Mode) <= 0.0) {
3969 0 : ShowSevereError(state,
3970 0 : format("Sizing: {} {} has zero rated total capacity at speed {}",
3971 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).VarSpeedCoilType,
3972 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name,
3973 : Mode));
3974 0 : ErrorsFound = true;
3975 : }
3976 73 : if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedAirVolFlowRate(Mode) <= 0.0) {
3977 0 : ShowSevereError(state,
3978 0 : format("Sizing: {} {} has zero rated air flow rate at speed {}",
3979 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).VarSpeedCoilType,
3980 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name,
3981 : Mode));
3982 0 : ErrorsFound = true;
3983 : }
3984 73 : if (ErrorsFound) {
3985 0 : ShowFatalError(state, "Preceding condition causes termination.");
3986 : }
3987 : // Check for valid range of (Rated Air Volume Flow Rate / Rated Total Capacity)
3988 73 : RatedVolFlowPerRatedTotCap = state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedAirVolFlowRate(Mode) /
3989 73 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedTotCap(Mode);
3990 : }
3991 : // call coil model with everything set at rating point
3992 13 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).InletAirDBTemp = RatedInletAirTemp;
3993 13 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).InletAirHumRat =
3994 13 : Psychrometrics::PsyWFnTdbTwbPb(state, RatedInletAirTemp, RatedInletWetBulbTemp, DataEnvironment::StdPressureSeaLevel);
3995 13 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).InletAirEnthalpy =
3996 13 : Psychrometrics::PsyHFnTdbW(RatedInletAirTemp, state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).InletAirHumRat);
3997 13 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).InletAirPressure = DataEnvironment::StdPressureSeaLevel;
3998 :
3999 13 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).AirMassFlowRate =
4000 13 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).RatedAirVolFlowRate *
4001 26 : Psychrometrics::PsyRhoAirFnPbTdbW(state,
4002 : DataEnvironment::StdPressureSeaLevel,
4003 : RatedInletAirTemp,
4004 13 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).InletAirHumRat);
4005 : // store environment data fill back in after rating point calc is over
4006 13 : Real64 holdOutDryBulbTemp = state.dataEnvrn->OutDryBulbTemp;
4007 13 : Real64 holdOutHumRat = state.dataEnvrn->OutHumRat;
4008 13 : Real64 holdOutWetBulb = state.dataEnvrn->OutWetBulbTemp;
4009 13 : Real64 holdOutBaroPress = state.dataEnvrn->OutBaroPress;
4010 13 : Real64 ratedOutdoorAirWetBulb = 23.9; // from I/O ref. more precise value?
4011 :
4012 13 : state.dataEnvrn->OutDryBulbTemp = RatedAmbAirTemp;
4013 13 : state.dataEnvrn->OutWetBulbTemp = ratedOutdoorAirWetBulb;
4014 13 : state.dataEnvrn->OutBaroPress = DataEnvironment::StdPressureSeaLevel; // assume rating is for sea level.
4015 26 : state.dataEnvrn->OutHumRat =
4016 13 : Psychrometrics::PsyWFnTdbTwbPb(state, RatedAmbAirTemp, ratedOutdoorAirWetBulb, DataEnvironment::StdPressureSeaLevel, RoutineName);
4017 13 : if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).CondenserInletNodeNum > 0) {
4018 0 : state.dataLoopNodes->Node(state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).CondenserInletNodeNum).Temp = RatedAmbAirTemp;
4019 0 : state.dataLoopNodes->Node(state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).CondenserInletNodeNum).HumRat =
4020 0 : state.dataEnvrn->OutHumRat;
4021 0 : state.dataLoopNodes->Node(state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).CondenserInletNodeNum).Press =
4022 : DataEnvironment::StdPressureSeaLevel;
4023 0 : state.dataLoopNodes->Node(state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).CondenserInletNodeNum).OutAirWetBulb =
4024 : ratedOutdoorAirWetBulb;
4025 : }
4026 13 : if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).VSCoilType ==
4027 : HVAC::Coil_CoolingWaterToAirHPVSEquationFit) { // need to set water info for WSHP
4028 2 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).WaterMassFlowRate =
4029 4 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedWaterMassFlowRate(
4030 2 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).NumOfSpeeds);
4031 2 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).InletWaterTemp = RatedInletWaterTemp; // 85 F cooling mode
4032 2 : Real64 CpSource = state.dataPlnt->PlantLoop(state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).plantLoc.loopNum)
4033 2 : .glycol->getSpecificHeat(state, state.dataVariableSpeedCoils->SourceSideInletTemp, RoutineName);
4034 2 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).InletWaterEnthalpy =
4035 2 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).InletWaterTemp * CpSource;
4036 : }
4037 :
4038 : // calculate coil model at rating point
4039 13 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).RunFrac = 1.0;
4040 13 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).DesignAirMassFlowRate =
4041 26 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedAirMassFlowRate(
4042 13 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).NumOfSpeeds);
4043 13 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).DesignAirVolFlowRate =
4044 26 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedAirVolFlowRate(
4045 13 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).NumOfSpeeds);
4046 13 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).DesignWaterMassFlowRate =
4047 26 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedWaterMassFlowRate(
4048 13 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).NumOfSpeeds);
4049 13 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).DesignWaterVolFlowRate =
4050 26 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedWaterVolFlowRate(
4051 13 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).NumOfSpeeds);
4052 :
4053 13 : CalcVarSpeedCoilCooling(state,
4054 : DXCoilNum,
4055 : HVAC::FanOp::Continuous,
4056 : SensLoad,
4057 : LatentLoad,
4058 : HVAC::CompressorOp::On,
4059 : 1.0,
4060 : 1.0,
4061 : 1.0,
4062 13 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).NumOfSpeeds);
4063 : // coil outlets
4064 13 : Real64 RatedOutletWetBulb(0.0);
4065 39 : RatedOutletWetBulb = Psychrometrics::PsyTwbFnTdbWPb(state,
4066 13 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).OutletAirDBTemp,
4067 13 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).OutletAirHumRat,
4068 : DataEnvironment::StdPressureSeaLevel,
4069 : RoutineName);
4070 13 : state.dataRptCoilSelection->coilSelectionReportObj->setRatedCoilConditions(
4071 : state,
4072 13 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name,
4073 13 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).VarSpeedCoilType,
4074 13 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).QLoadTotal, // this is the report variable
4075 13 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).QSensible, // this is the report variable
4076 13 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).AirMassFlowRate,
4077 13 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).InletAirDBTemp,
4078 13 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).InletAirHumRat,
4079 : RatedInletWetBulbTemp,
4080 13 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).OutletAirDBTemp,
4081 13 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).OutletAirHumRat,
4082 : RatedOutletWetBulb,
4083 : RatedAmbAirTemp,
4084 : ratedOutdoorAirWetBulb,
4085 26 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedCBF(
4086 13 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).NumOfSpeeds),
4087 : -999.0); // coil effectiveness not define for DX
4088 :
4089 : // now replace the outdoor air conditions set above for one time rating point calc
4090 13 : state.dataEnvrn->OutDryBulbTemp = holdOutDryBulbTemp;
4091 13 : state.dataEnvrn->OutHumRat = holdOutHumRat;
4092 13 : state.dataEnvrn->OutWetBulbTemp = holdOutWetBulb;
4093 13 : state.dataEnvrn->OutBaroPress = holdOutBaroPress;
4094 : }
4095 :
4096 : // Multispeed Heating
4097 35 : if ((state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).VSCoilType == HVAC::Coil_HeatingWaterToAirHPVSEquationFit) ||
4098 17 : (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).VSCoilType == HVAC::Coil_HeatingAirToAirVariableSpeed)) {
4099 5 : RatedHeatPumpIndoorAirTemp = 21.11; // 21.11C or 70F
4100 5 : RatedHeatPumpIndoorHumRat = 0.00881; // Humidity ratio corresponding to 70F dry bulb/60F wet bulb
4101 50 : for (int Mode = 1; Mode <= state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).NumOfSpeeds; ++Mode) {
4102 :
4103 45 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedAirMassFlowRate(Mode) =
4104 45 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedAirVolFlowRate(Mode) *
4105 45 : Psychrometrics::PsyRhoAirFnPbTdbW(
4106 45 : state, state.dataEnvrn->OutBaroPress, RatedHeatPumpIndoorAirTemp, RatedHeatPumpIndoorHumRat, RoutineName);
4107 : // Check for valid range of (Rated Air Volume Flow Rate / Rated Total Capacity)
4108 45 : RatedVolFlowPerRatedTotCap = state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedAirVolFlowRate(Mode) /
4109 45 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedTotCap(Mode);
4110 : }
4111 : // call coil model with everthing set at rating point
4112 5 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).InletAirDBTemp = RatedInletAirTempHeat;
4113 5 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).InletAirHumRat =
4114 5 : Psychrometrics::PsyWFnTdbTwbPb(state, RatedInletAirTempHeat, RatedInletWetBulbTemp, DataEnvironment::StdPressureSeaLevel);
4115 5 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).InletAirEnthalpy =
4116 5 : Psychrometrics::PsyHFnTdbW(RatedInletAirTempHeat, state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).InletAirHumRat);
4117 5 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).InletAirPressure = DataEnvironment::StdPressureSeaLevel;
4118 :
4119 5 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).AirMassFlowRate =
4120 5 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).RatedAirVolFlowRate *
4121 10 : Psychrometrics::PsyRhoAirFnPbTdbW(state,
4122 : DataEnvironment::StdPressureSeaLevel,
4123 : RatedInletAirTempHeat,
4124 5 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).InletAirHumRat);
4125 : // store environment data fill back in after rating point calc is over
4126 5 : Real64 holdOutDryBulbTemp = state.dataEnvrn->OutDryBulbTemp;
4127 5 : Real64 holdOutHumRat = state.dataEnvrn->OutHumRat;
4128 5 : Real64 holdOutWetBulb = state.dataEnvrn->OutWetBulbTemp;
4129 5 : Real64 holdOutBaroPress = state.dataEnvrn->OutBaroPress;
4130 :
4131 5 : state.dataEnvrn->OutDryBulbTemp = RatedAmbAirTempHeat;
4132 5 : state.dataEnvrn->OutWetBulbTemp = RatedAmbAirWBHeat;
4133 5 : state.dataEnvrn->OutBaroPress = DataEnvironment::StdPressureSeaLevel; // assume rating is for sea level.
4134 10 : state.dataEnvrn->OutHumRat =
4135 5 : Psychrometrics::PsyWFnTdbTwbPb(state, RatedAmbAirTempHeat, RatedAmbAirWBHeat, DataEnvironment::StdPressureSeaLevel, RoutineName);
4136 5 : if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).CondenserInletNodeNum > 0) {
4137 0 : state.dataLoopNodes->Node(state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).CondenserInletNodeNum).Temp = RatedAmbAirTempHeat;
4138 0 : state.dataLoopNodes->Node(state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).CondenserInletNodeNum).HumRat =
4139 0 : state.dataEnvrn->OutHumRat;
4140 0 : state.dataLoopNodes->Node(state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).CondenserInletNodeNum).Press =
4141 : DataEnvironment::StdPressureSeaLevel;
4142 0 : state.dataLoopNodes->Node(state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).CondenserInletNodeNum).OutAirWetBulb =
4143 : RatedAmbAirWBHeat;
4144 : }
4145 :
4146 5 : if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).VSCoilType ==
4147 : HVAC::Coil_HeatingWaterToAirHPVSEquationFit) { // need to set water info for WSHP
4148 1 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).WaterMassFlowRate =
4149 2 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedWaterMassFlowRate(
4150 1 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).NumOfSpeeds);
4151 1 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).InletWaterTemp = RatedInletWaterTempHeat; // 21.11C or 70F, heating mode
4152 1 : Real64 CpSource = state.dataPlnt->PlantLoop(state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).plantLoc.loopNum)
4153 1 : .glycol->getSpecificHeat(state, state.dataVariableSpeedCoils->SourceSideInletTemp, RoutineName);
4154 1 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).InletWaterEnthalpy =
4155 1 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).InletWaterTemp * CpSource;
4156 : }
4157 :
4158 : // calculate coil model at rating point
4159 5 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).RunFrac = 1.0;
4160 5 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).DesignAirMassFlowRate =
4161 10 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedAirMassFlowRate(
4162 5 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).NumOfSpeeds);
4163 5 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).DesignAirVolFlowRate =
4164 10 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedAirVolFlowRate(
4165 5 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).NumOfSpeeds);
4166 5 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).DesignWaterMassFlowRate =
4167 10 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedWaterMassFlowRate(
4168 5 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).NumOfSpeeds);
4169 5 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).DesignWaterVolFlowRate =
4170 10 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedWaterVolFlowRate(
4171 5 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).NumOfSpeeds);
4172 5 : CalcVarSpeedCoilHeating(state,
4173 : DXCoilNum,
4174 : HVAC::FanOp::Continuous,
4175 : SensLoad,
4176 : HVAC::CompressorOp::On,
4177 : 1.0,
4178 : 1.0,
4179 : 1.0,
4180 5 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).NumOfSpeeds);
4181 : // coil outlets
4182 5 : Real64 RatedOutletWetBulb(0.0);
4183 15 : RatedOutletWetBulb = Psychrometrics::PsyTwbFnTdbWPb(state,
4184 5 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).OutletAirDBTemp,
4185 5 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).OutletAirHumRat,
4186 : DataEnvironment::StdPressureSeaLevel,
4187 : RoutineName);
4188 5 : state.dataRptCoilSelection->coilSelectionReportObj->setRatedCoilConditions(
4189 : state,
4190 5 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name,
4191 5 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).VarSpeedCoilType,
4192 5 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).QLoadTotal, // this is the report variable
4193 5 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).QSensible, // this is the report variable
4194 5 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).AirMassFlowRate,
4195 5 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).InletAirDBTemp,
4196 5 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).InletAirHumRat,
4197 : RatedInletWetBulbTemp,
4198 5 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).OutletAirDBTemp,
4199 5 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).OutletAirHumRat,
4200 : RatedOutletWetBulb,
4201 : RatedAmbAirTempHeat,
4202 : RatedAmbAirWBHeat,
4203 10 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedCBF(
4204 5 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).NumOfSpeeds),
4205 : -999.0); // coil effectiveness not define for DX
4206 :
4207 : // now replace the outdoor air conditions set above for one time rating point calc
4208 5 : state.dataEnvrn->OutDryBulbTemp = holdOutDryBulbTemp;
4209 5 : state.dataEnvrn->OutHumRat = holdOutHumRat;
4210 5 : state.dataEnvrn->OutWetBulbTemp = holdOutWetBulb;
4211 5 : state.dataEnvrn->OutBaroPress = holdOutBaroPress;
4212 : }
4213 :
4214 : // store fan info for coil
4215 18 : if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).SupplyFanIndex > 0) {
4216 5 : state.dataRptCoilSelection->coilSelectionReportObj->setCoilSupplyFanInfo(
4217 : state,
4218 5 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name,
4219 5 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).VarSpeedCoilType,
4220 5 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).SupplyFanName,
4221 5 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).supplyFanType,
4222 5 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).SupplyFanIndex);
4223 : }
4224 : }
4225 :
4226 67679 : if (SpeedNum > state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).NumOfSpeeds) {
4227 0 : SpeedCal = state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).NumOfSpeeds;
4228 67679 : } else if (SpeedNum < 1) {
4229 0 : SpeedCal = 1;
4230 : } else {
4231 67679 : SpeedCal = SpeedNum;
4232 : }
4233 67679 : if ((SpeedNum <= 1) || (SpeedNum > state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).NumOfSpeeds)) {
4234 42668 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).DesignAirMassFlowRate =
4235 42668 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedAirMassFlowRate(SpeedCal);
4236 42668 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).DesignAirVolFlowRate =
4237 42668 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedAirVolFlowRate(SpeedCal);
4238 42668 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).DesignWaterMassFlowRate =
4239 42668 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedWaterMassFlowRate(SpeedCal);
4240 42668 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).DesignWaterVolFlowRate =
4241 42668 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedWaterVolFlowRate(SpeedCal);
4242 : } else {
4243 25011 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).DesignAirMassFlowRate =
4244 25011 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedAirMassFlowRate(SpeedCal) * SpeedRatio +
4245 25011 : (1.0 - SpeedRatio) * state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedAirMassFlowRate(SpeedCal - 1);
4246 25011 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).DesignAirVolFlowRate =
4247 25011 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedAirVolFlowRate(SpeedCal) * SpeedRatio +
4248 25011 : (1.0 - SpeedRatio) * state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedAirVolFlowRate(SpeedCal - 1);
4249 25011 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).DesignWaterMassFlowRate =
4250 25011 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedWaterMassFlowRate(SpeedCal) * SpeedRatio +
4251 25011 : (1.0 - SpeedRatio) * state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedWaterMassFlowRate(SpeedCal - 1);
4252 25011 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).DesignWaterVolFlowRate =
4253 25011 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedWaterVolFlowRate(SpeedCal) * SpeedRatio +
4254 25011 : (1.0 - SpeedRatio) * state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedWaterVolFlowRate(SpeedCal - 1);
4255 : }
4256 :
4257 : // Do the Begin Environment initializations
4258 67696 : if (state.dataGlobal->BeginEnvrnFlag && state.dataVariableSpeedCoils->MyEnvrnFlag(DXCoilNum) &&
4259 17 : !state.dataVariableSpeedCoils->MyPlantScanFlag(DXCoilNum)) {
4260 : // Do the initializations to start simulation
4261 :
4262 : // Initialize all report variables to a known state at beginning of simulation
4263 17 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).AirVolFlowRate = 0.0;
4264 17 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).InletAirDBTemp = 0.0;
4265 17 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).InletAirHumRat = 0.0;
4266 17 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).OutletAirDBTemp = 0.0;
4267 17 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).OutletAirHumRat = 0.0;
4268 17 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).WaterVolFlowRate = 0.0;
4269 17 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).WaterMassFlowRate = 0.0;
4270 17 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).InletWaterTemp = 0.0;
4271 17 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).InletWaterEnthalpy = 0.0;
4272 17 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).OutletWaterEnthalpy = 0.0;
4273 17 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).OutletWaterTemp = 0.0;
4274 17 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Power = 0.0;
4275 17 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).QLoadTotal = 0.0;
4276 17 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).QSensible = 0.0;
4277 17 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).QLatent = 0.0;
4278 17 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).QSource = 0.0;
4279 17 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Energy = 0.0;
4280 17 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).EnergyLoadTotal = 0.0;
4281 17 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).EnergySensible = 0.0;
4282 17 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).EnergyLatent = 0.0;
4283 17 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).EnergySource = 0.0;
4284 17 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).COP = 0.0;
4285 17 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).RunFrac = 0.0;
4286 17 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).PartLoadRatio = 0.0;
4287 :
4288 30 : if ((state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).VSCoilType == HVAC::Coil_HeatingWaterToAirHPVSEquationFit) ||
4289 13 : (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).VSCoilType == HVAC::Coil_CoolingWaterToAirHPVSEquationFit)) {
4290 8 : WaterInletNode = state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).WaterInletNodeNum;
4291 :
4292 8 : rho = state.dataPlnt->PlantLoop(state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).plantLoc.loopNum)
4293 8 : .glycol->getDensity(state, Constant::CWInitConvTemp, RoutineNameSimpleWatertoAirHP);
4294 8 : Cp = state.dataPlnt->PlantLoop(state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).plantLoc.loopNum)
4295 8 : .glycol->getSpecificHeat(state, Constant::CWInitConvTemp, RoutineNameSimpleWatertoAirHP);
4296 :
4297 : // VarSpeedCoil(DXCoilNum)%DesignWaterMassFlowRate= &
4298 : // rho * VarSpeedCoil(DXCoilNum)%RatedWaterVolFlowRate
4299 :
4300 24 : PlantUtilities::InitComponentNodes(state,
4301 : 0.0,
4302 16 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedWaterMassFlowRate(
4303 8 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).NumOfSpeeds),
4304 8 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).WaterInletNodeNum,
4305 8 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).WaterOutletNodeNum);
4306 :
4307 8 : state.dataLoopNodes->Node(WaterInletNode).Temp = 5.0;
4308 8 : state.dataLoopNodes->Node(WaterInletNode).Enthalpy = Cp * state.dataLoopNodes->Node(WaterInletNode).Temp;
4309 8 : state.dataLoopNodes->Node(WaterInletNode).Quality = 0.0;
4310 8 : state.dataLoopNodes->Node(WaterInletNode).Press = 0.0;
4311 8 : state.dataLoopNodes->Node(WaterInletNode).HumRat = 0.0;
4312 :
4313 8 : state.dataLoopNodes->Node(state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).WaterOutletNodeNum).Temp = 5.0;
4314 8 : state.dataLoopNodes->Node(state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).WaterOutletNodeNum).Enthalpy =
4315 8 : Cp * state.dataLoopNodes->Node(WaterInletNode).Temp;
4316 8 : state.dataLoopNodes->Node(state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).WaterOutletNodeNum).Quality = 0.0;
4317 8 : state.dataLoopNodes->Node(state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).WaterOutletNodeNum).Press = 0.0;
4318 8 : state.dataLoopNodes->Node(state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).WaterOutletNodeNum).HumRat = 0.0;
4319 : }
4320 :
4321 17 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).SimFlag = true;
4322 17 : state.dataHeatBal->HeatReclaimVS_Coil(DXCoilNum).AvailCapacity = 0.0;
4323 :
4324 17 : state.dataVariableSpeedCoils->MyEnvrnFlag(DXCoilNum) = false;
4325 :
4326 : } // End If for the Begin Environment initializations
4327 :
4328 67679 : if (!state.dataGlobal->BeginEnvrnFlag) {
4329 66993 : state.dataVariableSpeedCoils->MyEnvrnFlag(DXCoilNum) = true;
4330 : }
4331 :
4332 : // Do the following initializations (every time step): This should be the info from
4333 : // the previous components outlets or the node data in this section.
4334 : // First set the conditions for the air into the heat pump model
4335 :
4336 : // Set water and air inlet nodes
4337 :
4338 67679 : WaterInletNode = state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).WaterInletNodeNum;
4339 :
4340 67679 : if ((SensLoad != 0.0 || LatentLoad != 0.0) && (state.dataLoopNodes->Node(AirInletNode).MassFlowRate > 0.0)) {
4341 28182 : if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedWaterMassFlowRate(
4342 28182 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).NormSpedLevel) > 0.0) {
4343 27877 : WaterFlowScale = state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).RatedWaterMassFlowRate /
4344 27877 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedWaterMassFlowRate(
4345 27877 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).NormSpedLevel);
4346 27877 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).WaterMassFlowRate =
4347 27877 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).DesignWaterMassFlowRate * WaterFlowScale;
4348 : } else {
4349 305 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).WaterMassFlowRate = 0.0;
4350 : }
4351 :
4352 28182 : if (fanOp == HVAC::FanOp::Continuous) {
4353 : // continuous fan, cycling compressor
4354 92 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).AirMassFlowRate = state.dataLoopNodes->Node(AirInletNode).MassFlowRate;
4355 : // VarSpeedCoil(DXCoilNum)%AirMassFlowRate = VarSpeedCoil(DXCoilNum)%DesignAirVolFlowRate* &
4356 : // PsyRhoAirFnPbTdbW(state, OutBaroPress,Node(AirInletNode)%Temp,Node(AirInletNode)%HumRat)
4357 : // If air flow is less than 25% rated flow. Then set air flow to the 25% of rated conditions
4358 92 : if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).AirMassFlowRate <
4359 92 : 0.25 * state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).DesignAirVolFlowRate *
4360 184 : Psychrometrics::PsyRhoAirFnPbTdbW(state,
4361 92 : state.dataEnvrn->OutBaroPress,
4362 92 : state.dataLoopNodes->Node(AirInletNode).Temp,
4363 92 : state.dataLoopNodes->Node(AirInletNode).HumRat)) {
4364 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).AirMassFlowRate =
4365 0 : 0.25 * state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).DesignAirVolFlowRate *
4366 0 : Psychrometrics::PsyRhoAirFnPbTdbW(state,
4367 0 : state.dataEnvrn->OutBaroPress,
4368 0 : state.dataLoopNodes->Node(AirInletNode).Temp,
4369 0 : state.dataLoopNodes->Node(AirInletNode).HumRat);
4370 : }
4371 : } else { // CYCLIC FAN, NOT CORRECTION, WILL BE PROCESSED IN THE FOLLOWING SUBROUTINES
4372 28090 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).AirMassFlowRate = state.dataLoopNodes->Node(AirInletNode).MassFlowRate;
4373 : }
4374 :
4375 : } else { // heat pump is off
4376 39497 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).WaterMassFlowRate = 0.0;
4377 39497 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).AirMassFlowRate = 0.0;
4378 : }
4379 :
4380 101722 : if ((state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).VSCoilType == HVAC::Coil_HeatingWaterToAirHPVSEquationFit) ||
4381 34043 : (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).VSCoilType == HVAC::Coil_CoolingWaterToAirHPVSEquationFit)) {
4382 201819 : PlantUtilities::SetComponentFlowRate(state,
4383 67273 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).WaterMassFlowRate,
4384 67273 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).WaterInletNodeNum,
4385 67273 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).WaterOutletNodeNum,
4386 67273 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).plantLoc);
4387 :
4388 67273 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).InletWaterTemp = state.dataLoopNodes->Node(WaterInletNode).Temp;
4389 67273 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).InletWaterEnthalpy = state.dataLoopNodes->Node(WaterInletNode).Enthalpy;
4390 : } else {
4391 406 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).InletWaterTemp = 0.0;
4392 406 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).InletWaterEnthalpy = 0.0;
4393 : }
4394 :
4395 67679 : if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).VSCoilType == HVAC::CoilDX_HeatPumpWaterHeaterVariableSpeed) {
4396 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).InletWaterTemp = state.dataLoopNodes->Node(WaterInletNode).Temp;
4397 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).InletWaterEnthalpy = state.dataLoopNodes->Node(WaterInletNode).Enthalpy;
4398 : };
4399 :
4400 67679 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).InletAirDBTemp = state.dataLoopNodes->Node(AirInletNode).Temp;
4401 67679 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).InletAirHumRat = state.dataLoopNodes->Node(AirInletNode).HumRat;
4402 67679 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).InletAirEnthalpy = state.dataLoopNodes->Node(AirInletNode).Enthalpy;
4403 :
4404 67679 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).InletAirPressure = state.dataEnvrn->OutBaroPress; // temporary
4405 : // Outlet variables
4406 67679 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Power = 0.0;
4407 67679 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).QLoadTotal = 0.0;
4408 67679 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).QSensible = 0.0;
4409 67679 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).QLatent = 0.0;
4410 67679 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).QSource = 0.0;
4411 67679 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).QWasteHeat = 0.0;
4412 67679 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Energy = 0.0;
4413 67679 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).EnergyLoadTotal = 0.0;
4414 67679 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).EnergySensible = 0.0;
4415 67679 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).EnergyLatent = 0.0;
4416 67679 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).EnergySource = 0.0;
4417 67679 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).COP = 0.0;
4418 :
4419 67679 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).OutletAirDBTemp = 0.0;
4420 67679 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).OutletWaterTemp = 0.0;
4421 67679 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).OutletAirHumRat = 0.0;
4422 67679 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).OutletAirEnthalpy = 0.0;
4423 67679 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).OutletWaterEnthalpy = 0.0;
4424 :
4425 : // bug fix, must set zeros to the variables below, otherwise can't pass switch DD test
4426 67679 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).CrankcaseHeaterConsumption = 0.0;
4427 67679 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).EvapWaterConsump = 0.0;
4428 67679 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).BasinHeaterConsumption = 0.0;
4429 67679 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).EvapCondPumpElecConsumption = 0.0;
4430 67679 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).CrankcaseHeaterPower = 0.0;
4431 67679 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).DefrostPower = 0.0;
4432 67679 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).DefrostConsumption = 0.0;
4433 67679 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).CondensateVdot = 0.0;
4434 67679 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).CondensateVol = 0.0;
4435 67679 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).QWasteHeat = 0.0;
4436 :
4437 : // clear zeros to HPWH variables
4438 67679 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).ElecWaterHeatingPower =
4439 : 0.0; // Total electric power consumed by compressor and condenser pump [W]
4440 67679 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).ElecWaterHeatingConsumption =
4441 : 0.0; // Total electric consumption by compressor and condenser pump [J]
4442 67679 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).TotalHeatingEnergy = 0.0; // total water heating energy
4443 67679 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).TotalHeatingEnergyRate = 0.0; // total WH energy rate
4444 67679 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).HPWHCondPumpElecNomPower = 0.0; // power power
4445 :
4446 67679 : state.dataVariableSpeedCoils->VSHPWHHeatingCapacity = 0.0; // Used by Heat Pump:Water Heater object as total water heating capacity [W]
4447 67679 : state.dataVariableSpeedCoils->VSHPWHHeatingCOP = 0.0; // Used by Heat Pump:Water Heater object as water heating COP [W/W]
4448 67679 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).OutletWaterTemp = state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).InletWaterTemp;
4449 67679 : state.dataHeatBal->HeatReclaimVS_Coil(DXCoilNum).AvailCapacity = 0.0;
4450 67679 : }
4451 :
4452 18 : void SizeVarSpeedCoil(EnergyPlusData &state, int const DXCoilNum, bool &ErrorsFound)
4453 : {
4454 :
4455 : // SUBROUTINE INFORMATION:
4456 : // AUTHOR Bo Shen, based on WaterToAirHeatPumpSimple:SizeHVACWaterToAir
4457 : // DATE WRITTEN March, 2012
4458 : // MODIFIED August 2013 Daeho Kang, add component sizing table entries
4459 : // MODIFIED Bo Shen, 12/2014, add variable-speed HPWH
4460 :
4461 : // PURPOSE OF THIS SUBROUTINE:
4462 : // This subroutine is for sizing WSHP Components for which nominal capacities
4463 : // and flow rates have not been specified in the input
4464 :
4465 : // METHODOLOGY EMPLOYED:
4466 : // Obtains heating capacities and flow rates from the zone or system sizing arrays.
4467 : // NOTE: For WSHP's we are sizing the heating capacity to be
4468 : // equal to the cooling capacity. Thus the cooling and
4469 : // and heating capacities of a DX heat pump system will be identical. In real life the ARI
4470 : // heating and cooling capacities are close but not identical.
4471 :
4472 : // SUBROUTINE PARAMETER DEFINITIONS:
4473 : static constexpr std::string_view RoutineName("SizeVarSpeedCoil");
4474 : static constexpr std::string_view RoutineNameAlt("SizeHVACWaterToAir");
4475 :
4476 18 : auto &varSpeedCoil = state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum);
4477 :
4478 : // SUBROUTINE LOCAL VARIABLE DECLARATIONS:
4479 18 : Real64 rhoair = state.dataEnvrn->StdRhoAir;
4480 18 : Real64 MixTemp = -999.0;
4481 18 : Real64 MixHumRat = -999.0;
4482 18 : Real64 MixEnth = -999.0;
4483 18 : Real64 MixWetBulb = -999.0;
4484 18 : Real64 SupTemp = -999.0;
4485 18 : Real64 SupHumRat = -999.0;
4486 18 : Real64 SupEnth = -999.0;
4487 18 : Real64 OutTemp = -999.0;
4488 18 : Real64 OutAirFrac = -999.0;
4489 18 : Real64 VolFlowRate = -999.0;
4490 18 : Real64 CoolCapAtPeak = -999.0;
4491 18 : Real64 TotCapTempModFac = -999.0;
4492 : int TimeStepNumAtMax;
4493 : int DDNum;
4494 : bool RatedCapCoolTotalAutoSized;
4495 : bool RatedCapCoolSensAutoSized;
4496 : Real64 SystemCapacity;
4497 : Real64 rho;
4498 : Real64 cp;
4499 : int Mode; // speed level
4500 : Real64 rhoW; // water density
4501 : Real64 SHR; // sensible heat transfer ratio
4502 : Real64 RatedAirMassFlowRate; // rated air mass flow rate
4503 : Real64 CBFRated; // bypass factor at the rated condition, considering difference in flow rates
4504 : Real64 RatedInletEnth; // rated inlet air enthalpy
4505 : Real64 QLoadTotal1; // placeholder for calculating SHR
4506 : Real64 QLoadTotal2; // placeholder for calculating SHR
4507 : Real64 QLoadTotal; // placeholder for calculating SHR
4508 : Real64 AirMassFlowRatio; // air mass flow ratio
4509 : Real64 WaterMassFlowRatio; // water mass flow rate
4510 : Real64 RatedSourceTempCool; // rated source temperature, space cooling mode
4511 18 : std::string CurrentObjSubfix; // Object subfix type for printing
4512 : bool HardSizeNoDesRun; // Indicator to hardsize withouth sizing runs
4513 : bool SizingDesRunThisAirSys; // true if a particular air system had a Sizing:System object and system sizing done
4514 : bool SizingDesRunThisZone; // true if a particular zone had a Sizing:Zone object and zone sizing was done
4515 : Real64 HPInletAirHumRat; // Rated inlet air humidity ratio for heat pump water heater [kgWater/kgDryAir]
4516 : Real64 HPWHCoolCapacity; // estimate cooling capacity in HPWH
4517 :
4518 18 : int UpperSpeed = varSpeedCoil.NumOfSpeeds;
4519 18 : int NormSpeed = varSpeedCoil.NormSpedLevel;
4520 18 : int PltSizNum = 0;
4521 18 : bool RatedAirFlowAutoSized = false;
4522 18 : bool RatedWaterFlowAutoSized = false;
4523 18 : bool RatedCapHeatAutoSized = false;
4524 18 : bool IsAutoSize = false;
4525 :
4526 18 : if (state.dataSize->SysSizingRunDone || state.dataSize->ZoneSizingRunDone) {
4527 10 : HardSizeNoDesRun = false;
4528 : } else {
4529 8 : HardSizeNoDesRun = true;
4530 : }
4531 18 : if (state.dataSize->CurSysNum > 0) {
4532 1 : CheckThisAirSystemForSizing(state, state.dataSize->CurSysNum, SizingDesRunThisAirSys);
4533 : } else {
4534 17 : SizingDesRunThisAirSys = false;
4535 : }
4536 18 : if (state.dataSize->CurZoneEqNum > 0) {
4537 12 : CheckThisZoneForSizing(state, state.dataSize->CurZoneEqNum, SizingDesRunThisZone);
4538 : } else {
4539 6 : SizingDesRunThisZone = false;
4540 : }
4541 18 : bool HardSizeNoDesRunAirFlow = false;
4542 18 : Real64 RatedAirVolFlowRateDes = 0.0;
4543 18 : Real64 RatedAirVolFlowRateUser = 0.0;
4544 18 : Real64 RatedCapCoolTotalDes = 0.0;
4545 18 : Real64 RatedCapCoolTotalUser = 0.0;
4546 18 : Real64 RatedCapHeatDes = 0.0;
4547 18 : Real64 RatedCapHeatUser = 0.0;
4548 18 : Real64 RatedWaterVolFlowRateDes = 0.0;
4549 18 : Real64 RatedWaterVolFlowRateUser = 0.0;
4550 18 : Real64 RatedCapCoolSensDes = 0.0;
4551 18 : Real64 EvapCondPumpElecNomPowerDes = 0.0;
4552 18 : Real64 EvapCondPumpElecNomPowerUser = 0.0;
4553 18 : Real64 DefrostCapacityDes = 0.0;
4554 18 : Real64 DefrostCapacityUser = 0.0;
4555 :
4556 18 : if (varSpeedCoil.VSCoilType == HVAC::Coil_CoolingWaterToAirHPVSEquationFit ||
4557 16 : varSpeedCoil.VSCoilType == HVAC::Coil_HeatingWaterToAirHPVSEquationFit) {
4558 3 : CurrentObjSubfix = ":WATERTOAIRHEATPUMP:VARIABLESPEEDEQUATIONFIT";
4559 15 : } else if (varSpeedCoil.VSCoilType == HVAC::CoilDX_HeatPumpWaterHeaterVariableSpeed) {
4560 0 : CurrentObjSubfix = ":WATERHEATING:AIRTOWATERHEATPUMP:VARIABLESPEED";
4561 : } else {
4562 15 : CurrentObjSubfix = ":DX:VARIABLESPEED";
4563 : }
4564 :
4565 18 : if (varSpeedCoil.VSCoilType == HVAC::CoilDX_HeatPumpWaterHeaterVariableSpeed) {
4566 0 : if (varSpeedCoil.RatedAirVolFlowRate == Constant::AutoCalculate) {
4567 0 : varSpeedCoil.RatedAirVolFlowRate =
4568 0 : varSpeedCoil.RatedCapWH * varSpeedCoil.MSRatedAirVolFlowRate(NormSpeed) / varSpeedCoil.MSRatedTotCap(NormSpeed); // 0.00005035;
4569 0 : varSpeedCoil.AirVolFlowAutoSized = true;
4570 : }
4571 0 : state.dataRptCoilSelection->coilSelectionReportObj->setCoilAirFlow(
4572 0 : state, varSpeedCoil.Name, varSpeedCoil.VarSpeedCoilType, varSpeedCoil.RatedAirVolFlowRate, varSpeedCoil.AirVolFlowAutoSized);
4573 :
4574 0 : if (varSpeedCoil.RatedWaterVolFlowRate == Constant::AutoCalculate) {
4575 0 : varSpeedCoil.RatedHPWHCondWaterFlow = varSpeedCoil.RatedCapWH * varSpeedCoil.MSRatedWaterVolFlowRate(NormSpeed) /
4576 0 : varSpeedCoil.MSRatedTotCap(NormSpeed); // 0.00000004487;
4577 0 : varSpeedCoil.RatedWaterVolFlowRate = varSpeedCoil.RatedHPWHCondWaterFlow;
4578 0 : varSpeedCoil.WaterVolFlowAutoSized = true;
4579 : }
4580 0 : state.dataRptCoilSelection->coilSelectionReportObj->setCoilWaterFlowPltSizNum(state,
4581 0 : varSpeedCoil.Name,
4582 0 : varSpeedCoil.VarSpeedCoilType,
4583 : varSpeedCoil.RatedWaterVolFlowRate,
4584 0 : varSpeedCoil.WaterVolFlowAutoSized,
4585 : -999,
4586 : varSpeedCoil.plantLoc.loopNum);
4587 : }
4588 :
4589 18 : if (varSpeedCoil.RatedAirVolFlowRate == DataSizing::AutoSize) {
4590 8 : RatedAirFlowAutoSized = true;
4591 : }
4592 :
4593 18 : if (state.dataSize->CurSysNum > 0) {
4594 1 : if (!RatedAirFlowAutoSized && !SizingDesRunThisAirSys) { // Simulation continue
4595 0 : HardSizeNoDesRunAirFlow = true;
4596 0 : if (varSpeedCoil.RatedAirVolFlowRate > 0.0) {
4597 0 : BaseSizer::reportSizerOutput(state,
4598 0 : format("COIL:{}{}", varSpeedCoil.CoolHeatType, CurrentObjSubfix),
4599 : varSpeedCoil.Name,
4600 : "User-Specified Rated Air Flow Rate [m3/s]",
4601 : varSpeedCoil.RatedAirVolFlowRate);
4602 : }
4603 : } else {
4604 1 : CheckSysSizing(state, format("COIL:{}{}", varSpeedCoil.CoolHeatType, CurrentObjSubfix), varSpeedCoil.Name);
4605 1 : if (state.dataSize->CurOASysNum > 0 && state.dataAirLoop->OutsideAirSys(state.dataSize->CurOASysNum).AirLoopDOASNum > -1) {
4606 : auto const &thisAirloopDOAS =
4607 0 : state.dataAirLoopHVACDOAS->airloopDOAS[state.dataAirLoop->OutsideAirSys(state.dataSize->CurOASysNum).AirLoopDOASNum];
4608 0 : RatedAirVolFlowRateDes = thisAirloopDOAS.SizingMassFlow / state.dataEnvrn->StdRhoAir;
4609 : } else {
4610 1 : if (state.dataSize->FinalSysSizing(state.dataSize->CurSysNum).DesMainVolFlow >= HVAC::SmallAirVolFlow) {
4611 1 : RatedAirVolFlowRateDes = state.dataSize->FinalSysSizing(state.dataSize->CurSysNum).DesMainVolFlow;
4612 : } else {
4613 0 : RatedAirVolFlowRateDes = 0.0;
4614 : }
4615 : }
4616 : }
4617 : }
4618 :
4619 18 : if (state.dataSize->CurZoneEqNum > 0) {
4620 12 : if (!RatedAirFlowAutoSized && !SizingDesRunThisZone) { // Simulation continue
4621 5 : HardSizeNoDesRunAirFlow = true;
4622 5 : if (varSpeedCoil.RatedAirVolFlowRate > 0.0) {
4623 15 : BaseSizer::reportSizerOutput(state,
4624 10 : format("COIL:{}{}", varSpeedCoil.CoolHeatType, CurrentObjSubfix),
4625 : varSpeedCoil.Name,
4626 : "User-Specified Rated Air Flow Rate [m3/s]",
4627 : varSpeedCoil.RatedAirVolFlowRate);
4628 : }
4629 : } else {
4630 7 : CheckZoneSizing(state, format("COIL:{}{}", varSpeedCoil.CoolHeatType, CurrentObjSubfix), varSpeedCoil.Name);
4631 7 : RatedAirVolFlowRateDes = max(state.dataSize->FinalZoneSizing(state.dataSize->CurZoneEqNum).DesCoolVolFlow,
4632 7 : state.dataSize->FinalZoneSizing(state.dataSize->CurZoneEqNum).DesHeatVolFlow);
4633 7 : if (RatedAirVolFlowRateDes < HVAC::SmallAirVolFlow) {
4634 0 : RatedAirVolFlowRateDes = 0.0;
4635 : }
4636 : }
4637 : }
4638 :
4639 18 : if (RatedAirFlowAutoSized) varSpeedCoil.RatedAirVolFlowRate = RatedAirVolFlowRateDes;
4640 :
4641 18 : RatedCapCoolTotalAutoSized = false;
4642 18 : RatedCapCoolSensAutoSized = false;
4643 :
4644 : // size rated total cooling capacity
4645 18 : IsAutoSize = false;
4646 18 : if (varSpeedCoil.RatedCapCoolTotal == DataSizing::AutoSize && (varSpeedCoil.VSCoilType == HVAC::Coil_CoolingWaterToAirHPVSEquationFit ||
4647 9 : varSpeedCoil.VSCoilType == HVAC::Coil_CoolingAirToAirVariableSpeed)) {
4648 6 : RatedCapCoolTotalAutoSized = true;
4649 : }
4650 18 : if (SizingDesRunThisZone || SizingDesRunThisAirSys) HardSizeNoDesRun = false;
4651 18 : if (state.dataSize->CurSysNum > 0) {
4652 1 : if (!RatedCapCoolTotalAutoSized && !SizingDesRunThisAirSys) { // Simulation continue
4653 0 : HardSizeNoDesRun = true;
4654 0 : if (varSpeedCoil.RatedCapCoolTotal > 0.0) {
4655 0 : BaseSizer::reportSizerOutput(state,
4656 0 : format("COIL:{}{}", varSpeedCoil.CoolHeatType, CurrentObjSubfix),
4657 : varSpeedCoil.Name,
4658 : "User-Specified Rated Total Cooling Capacity [W]",
4659 : varSpeedCoil.RatedCapCoolTotal);
4660 : }
4661 : } else {
4662 1 : CheckSysSizing(state, format("COIL:{}{}", varSpeedCoil.CoolHeatType, CurrentObjSubfix), varSpeedCoil.Name);
4663 1 : if (state.dataSize->CurOASysNum > 0 && state.dataAirLoop->OutsideAirSys(state.dataSize->CurOASysNum).AirLoopDOASNum > -1) {
4664 : auto const &thisAirloopDOAS =
4665 0 : state.dataAirLoopHVACDOAS->airloopDOAS[state.dataAirLoop->OutsideAirSys(state.dataSize->CurOASysNum).AirLoopDOASNum];
4666 0 : VolFlowRate = varSpeedCoil.RatedAirVolFlowRate;
4667 0 : MixTemp = thisAirloopDOAS.SizingCoolOATemp;
4668 0 : SupTemp = thisAirloopDOAS.PrecoolTemp;
4669 0 : MixHumRat = thisAirloopDOAS.SizingCoolOAHumRat;
4670 0 : SupHumRat = thisAirloopDOAS.PrecoolHumRat;
4671 0 : RatedCapCoolTotalDes = VolFlowRate * state.dataEnvrn->StdRhoAir *
4672 0 : (Psychrometrics::PsyHFnTdbW(MixTemp, MixHumRat) - Psychrometrics::PsyHFnTdbW(SupTemp, SupHumRat));
4673 0 : if (varSpeedCoil.MSCCapFTemp(varSpeedCoil.NormSpedLevel) > 0) {
4674 0 : MixWetBulb = Psychrometrics::PsyTwbFnTdbWPb(state, MixTemp, MixHumRat, state.dataEnvrn->StdBaroPress, RoutineName);
4675 0 : if (varSpeedCoil.CondenserType == DataHeatBalance::RefrigCondenserType::Air) {
4676 0 : RatedSourceTempCool = thisAirloopDOAS.SizingCoolOATemp;
4677 : } else {
4678 0 : RatedSourceTempCool = GetVSCoilRatedSourceTemp(state, DXCoilNum);
4679 : }
4680 0 : TotCapTempModFac =
4681 0 : Curve::CurveValue(state, varSpeedCoil.MSCCapFTemp(varSpeedCoil.NormSpedLevel), MixWetBulb, RatedSourceTempCool);
4682 0 : RatedCapCoolTotalDes /= TotCapTempModFac;
4683 : }
4684 : } else {
4685 1 : auto const &finalSysSizing = state.dataSize->FinalSysSizing(state.dataSize->CurSysNum);
4686 1 : VolFlowRate = varSpeedCoil.RatedAirVolFlowRate;
4687 1 : if (VolFlowRate >= HVAC::SmallAirVolFlow) {
4688 1 : if (state.dataSize->CurOASysNum > 0) { // coil is in the OA stream
4689 0 : MixTemp = finalSysSizing.OutTempAtCoolPeak;
4690 0 : MixHumRat = finalSysSizing.OutHumRatAtCoolPeak;
4691 0 : SupTemp = finalSysSizing.PrecoolTemp;
4692 0 : SupHumRat = finalSysSizing.PrecoolHumRat;
4693 : } else { // coil is on the main air loop
4694 1 : SupTemp = finalSysSizing.CoolSupTemp;
4695 1 : SupHumRat = finalSysSizing.CoolSupHumRat;
4696 1 : if (state.dataAirSystemsData->PrimaryAirSystems(state.dataSize->CurSysNum).NumOACoolCoils ==
4697 : 0) { // there is no precooling of the OA stream
4698 1 : MixTemp = finalSysSizing.MixTempAtCoolPeak;
4699 1 : MixHumRat = finalSysSizing.MixHumRatAtCoolPeak;
4700 : } else { // there is precooling of OA stream
4701 0 : if (VolFlowRate > 0.0) {
4702 0 : OutAirFrac = finalSysSizing.DesOutAirVolFlow / VolFlowRate;
4703 : } else {
4704 0 : OutAirFrac = 1.0;
4705 : }
4706 0 : OutAirFrac = min(1.0, max(0.0, OutAirFrac));
4707 0 : MixTemp = OutAirFrac * finalSysSizing.PrecoolTemp + (1.0 - OutAirFrac) * finalSysSizing.RetTempAtCoolPeak;
4708 0 : MixHumRat = OutAirFrac * finalSysSizing.PrecoolHumRat + (1.0 - OutAirFrac) * finalSysSizing.RetHumRatAtCoolPeak;
4709 : }
4710 : }
4711 1 : OutTemp = finalSysSizing.OutTempAtCoolPeak;
4712 1 : MixEnth = Psychrometrics::PsyHFnTdbW(MixTemp, MixHumRat);
4713 1 : SupEnth = Psychrometrics::PsyHFnTdbW(SupTemp, SupHumRat);
4714 :
4715 : // design fan heat will be added to coil load
4716 1 : Real64 FanCoolLoad = DataAirSystems::calcFanDesignHeatGain(state, state.dataSize->DataFanIndex, VolFlowRate);
4717 : // inlet/outlet temp is adjusted after enthalpy is calculcated so fan heat is not double counted
4718 1 : Real64 CpAir = Psychrometrics::PsyCpAirFnW(MixHumRat);
4719 1 : if (state.dataAirSystemsData->PrimaryAirSystems(state.dataSize->CurSysNum).supFanPlace == HVAC::FanPlace::BlowThru) {
4720 0 : MixTemp += FanCoolLoad / (CpAir * rhoair * VolFlowRate);
4721 1 : } else if (state.dataAirSystemsData->PrimaryAirSystems(state.dataSize->CurSysNum).supFanPlace == HVAC::FanPlace::DrawThru) {
4722 0 : SupTemp -= FanCoolLoad / (CpAir * rhoair * VolFlowRate);
4723 : }
4724 1 : MixWetBulb = Psychrometrics::PsyTwbFnTdbWPb(state, MixTemp, MixHumRat, state.dataEnvrn->StdBaroPress, RoutineName);
4725 1 : if (varSpeedCoil.CondenserType == DataHeatBalance::RefrigCondenserType::Air) {
4726 0 : RatedSourceTempCool = OutTemp;
4727 : } else {
4728 1 : RatedSourceTempCool = GetVSCoilRatedSourceTemp(state, DXCoilNum);
4729 : }
4730 1 : TotCapTempModFac =
4731 1 : Curve::CurveValue(state, varSpeedCoil.MSCCapFTemp(varSpeedCoil.NormSpedLevel), MixWetBulb, RatedSourceTempCool);
4732 :
4733 : // The mixed air temp for zone equipment without an OA mixer is 0.
4734 : // This test avoids a negative capacity until a solution can be found.
4735 1 : if (MixEnth > SupEnth) {
4736 1 : CoolCapAtPeak = (rhoair * VolFlowRate * (MixEnth - SupEnth)) + FanCoolLoad;
4737 : } else {
4738 0 : CoolCapAtPeak = (rhoair * VolFlowRate * (48000.0 - SupEnth)) + FanCoolLoad;
4739 : }
4740 1 : CoolCapAtPeak = max(0.0, CoolCapAtPeak);
4741 1 : if (TotCapTempModFac > 0.0) {
4742 1 : RatedCapCoolTotalDes = CoolCapAtPeak / TotCapTempModFac;
4743 : } else {
4744 0 : RatedCapCoolTotalDes = CoolCapAtPeak;
4745 : }
4746 : } else {
4747 0 : RatedCapCoolTotalDes = 0.0;
4748 : }
4749 : }
4750 : }
4751 :
4752 17 : } else if (state.dataSize->CurZoneEqNum > 0) {
4753 12 : if (!RatedCapCoolTotalAutoSized && !SizingDesRunThisZone) { // Simulation continue
4754 5 : HardSizeNoDesRun = true;
4755 5 : if (varSpeedCoil.RatedCapCoolTotal > 0.0) {
4756 9 : BaseSizer::reportSizerOutput(state,
4757 6 : format("COIL:{}{}", varSpeedCoil.CoolHeatType, CurrentObjSubfix),
4758 : varSpeedCoil.Name,
4759 : "User-Specified Rated Total Cooling Capacity [W]",
4760 : varSpeedCoil.RatedCapCoolTotal);
4761 : }
4762 : } else {
4763 7 : CheckZoneSizing(state, format("COIL:{}{}", varSpeedCoil.CoolHeatType, CurrentObjSubfix), varSpeedCoil.Name);
4764 7 : auto const &finalZoneSizing = state.dataSize->FinalZoneSizing(state.dataSize->CurZoneEqNum);
4765 7 : VolFlowRate = varSpeedCoil.RatedAirVolFlowRate;
4766 7 : if (VolFlowRate >= HVAC::SmallAirVolFlow) {
4767 7 : if (state.dataSize->ZoneEqDXCoil) {
4768 4 : if (state.dataSize->ZoneEqSizing(state.dataSize->CurZoneEqNum).OAVolFlow > 0.0) {
4769 0 : MixTemp = finalZoneSizing.DesCoolCoilInTemp;
4770 0 : MixHumRat = finalZoneSizing.DesCoolCoilInHumRat;
4771 : } else {
4772 4 : MixTemp = finalZoneSizing.ZoneTempAtCoolPeak;
4773 4 : MixHumRat = finalZoneSizing.ZoneHumRatAtCoolPeak;
4774 : }
4775 : } else {
4776 3 : MixTemp = finalZoneSizing.DesCoolCoilInTemp;
4777 3 : MixHumRat = finalZoneSizing.DesCoolCoilInHumRat;
4778 : }
4779 7 : SupTemp = finalZoneSizing.CoolDesTemp;
4780 7 : SupHumRat = finalZoneSizing.CoolDesHumRat;
4781 7 : TimeStepNumAtMax = finalZoneSizing.TimeStepNumAtCoolMax;
4782 7 : DDNum = finalZoneSizing.CoolDDNum;
4783 7 : if (DDNum > 0 && TimeStepNumAtMax > 0) {
4784 7 : OutTemp = state.dataSize->DesDayWeath(DDNum).Temp(TimeStepNumAtMax);
4785 : } else {
4786 0 : OutTemp = 0.0;
4787 : }
4788 7 : MixEnth = Psychrometrics::PsyHFnTdbW(MixTemp, MixHumRat);
4789 7 : SupEnth = Psychrometrics::PsyHFnTdbW(SupTemp, SupHumRat);
4790 :
4791 : // design fan heat will be added to coil load
4792 7 : Real64 FanCoolLoad = DataAirSystems::calcFanDesignHeatGain(state, state.dataSize->DataFanIndex, VolFlowRate);
4793 : // inlet/outlet temp is adjusted after enthalpy is calculcated so fan heat is not double counted
4794 7 : Real64 CpAir = Psychrometrics::PsyCpAirFnW(MixHumRat);
4795 :
4796 7 : if (state.dataSize->DataFanPlacement == HVAC::FanPlace::BlowThru) {
4797 7 : MixTemp += FanCoolLoad / (CpAir * rhoair * VolFlowRate);
4798 : } else {
4799 0 : SupTemp -= FanCoolLoad / (CpAir * rhoair * VolFlowRate);
4800 : }
4801 :
4802 7 : MixWetBulb = Psychrometrics::PsyTwbFnTdbWPb(state, MixTemp, MixHumRat, state.dataEnvrn->StdBaroPress, RoutineName);
4803 7 : if (varSpeedCoil.CondenserType == DataHeatBalance::RefrigCondenserType::Air) {
4804 5 : RatedSourceTempCool = OutTemp;
4805 : } else {
4806 2 : RatedSourceTempCool = GetVSCoilRatedSourceTemp(state, DXCoilNum);
4807 : }
4808 7 : TotCapTempModFac =
4809 7 : Curve::CurveValue(state, varSpeedCoil.MSCCapFTemp(varSpeedCoil.NormSpedLevel), MixWetBulb, RatedSourceTempCool);
4810 :
4811 : // The mixed air temp for zone equipment without an OA mixer is 0.
4812 : // This test avoids a negative capacity until a solution can be found.
4813 7 : if (MixEnth > SupEnth) {
4814 7 : CoolCapAtPeak = (rhoair * VolFlowRate * (MixEnth - SupEnth)) + FanCoolLoad;
4815 : } else {
4816 0 : CoolCapAtPeak = (rhoair * VolFlowRate * (48000.0 - SupEnth)) + FanCoolLoad;
4817 : }
4818 7 : CoolCapAtPeak = max(0.0, CoolCapAtPeak);
4819 7 : if (TotCapTempModFac > 0.0) {
4820 7 : RatedCapCoolTotalDes = CoolCapAtPeak / TotCapTempModFac;
4821 : } else {
4822 0 : RatedCapCoolTotalDes = CoolCapAtPeak;
4823 : }
4824 : } else {
4825 0 : RatedCapCoolTotalDes = 0.0;
4826 : }
4827 : }
4828 : }
4829 18 : if (RatedCapCoolTotalDes < HVAC::SmallLoad) {
4830 10 : RatedCapCoolTotalDes = 0.0;
4831 : }
4832 18 : if (!HardSizeNoDesRun) {
4833 8 : if (RatedCapCoolTotalAutoSized) {
4834 6 : varSpeedCoil.RatedCapCoolTotal = RatedCapCoolTotalDes;
4835 18 : BaseSizer::reportSizerOutput(state,
4836 12 : format("COIL:{}{}", varSpeedCoil.CoolHeatType, CurrentObjSubfix),
4837 : varSpeedCoil.Name,
4838 : "Design Size Rated Total Cooling Capacity [W]",
4839 : varSpeedCoil.RatedCapCoolTotal);
4840 12 : OutputReportPredefined::PreDefTableEntry(
4841 6 : state, state.dataOutRptPredefined->pdchCoolCoilTotCap, varSpeedCoil.Name, varSpeedCoil.RatedCapCoolTotal);
4842 12 : OutputReportPredefined::PreDefTableEntry(state,
4843 6 : state.dataOutRptPredefined->pdchCoolCoilLatCap,
4844 : varSpeedCoil.Name,
4845 6 : varSpeedCoil.RatedCapCoolTotal - varSpeedCoil.RatedCapCoolSens);
4846 6 : if (varSpeedCoil.RatedCapCoolTotal != 0.0) {
4847 12 : OutputReportPredefined::PreDefTableEntry(state,
4848 6 : state.dataOutRptPredefined->pdchCoolCoilSHR,
4849 : varSpeedCoil.Name,
4850 6 : varSpeedCoil.RatedCapCoolSens / varSpeedCoil.RatedCapCoolTotal);
4851 12 : OutputReportPredefined::PreDefTableEntry(
4852 6 : state, state.dataOutRptPredefined->pdchCoolCoilNomEff, varSpeedCoil.Name, varSpeedCoil.MSRatedCOP(NormSpeed));
4853 : } else {
4854 0 : OutputReportPredefined::PreDefTableEntry(state, state.dataOutRptPredefined->pdchCoolCoilSHR, varSpeedCoil.Name, 0.0);
4855 0 : OutputReportPredefined::PreDefTableEntry(state, state.dataOutRptPredefined->pdchCoolCoilNomEff, varSpeedCoil.Name, 0.0);
4856 : }
4857 12 : OutputReportPredefined::addFootNoteSubTable(
4858 : state,
4859 6 : state.dataOutRptPredefined->pdstCoolCoil,
4860 : "Nominal values are gross at rated conditions, i.e., the supply air fan heat and electric power NOT accounted for.");
4861 : } else {
4862 2 : if (varSpeedCoil.RatedCapCoolTotal > 0.0 && RatedCapCoolTotalDes > 0.0) {
4863 0 : RatedCapCoolTotalUser = varSpeedCoil.RatedCapCoolTotal;
4864 0 : BaseSizer::reportSizerOutput(state,
4865 0 : format("COIL:{}{}", varSpeedCoil.CoolHeatType, CurrentObjSubfix),
4866 : varSpeedCoil.Name,
4867 : "Design Size Rated Total Cooling Capacity [W]",
4868 : RatedCapCoolTotalDes,
4869 : "User-Specified Rated Total Cooling Capacity [W]",
4870 : RatedCapCoolTotalUser);
4871 0 : if (state.dataGlobal->DisplayExtraWarnings) {
4872 0 : if ((std::abs(RatedCapCoolTotalDes - RatedCapCoolTotalUser) / RatedCapCoolTotalUser) >
4873 0 : state.dataSize->AutoVsHardSizingThreshold) {
4874 0 : ShowMessage(state,
4875 0 : format("SizeVarSpeedCoil: Potential issue with equipment sizing for {} {}",
4876 0 : varSpeedCoil.CoolHeatType,
4877 : CurrentObjSubfix));
4878 0 : ShowContinueError(state, format("Coil Name = {}", varSpeedCoil.Name));
4879 0 : ShowContinueError(state, format("User-Specified Rated Total Cooling Capacity of {:.2R} [W]", RatedCapCoolTotalUser));
4880 0 : ShowContinueError(state,
4881 0 : format("differs from Design Size Rated Total Cooling Capacity of {:.2R} [W]", RatedCapCoolTotalDes));
4882 0 : ShowContinueError(state, "This may, or may not, indicate mismatched component sizes.");
4883 0 : ShowContinueError(state, "Verify that the value entered is intended and is consistent with other components.");
4884 : }
4885 : }
4886 : }
4887 : }
4888 :
4889 8 : state.dataRptCoilSelection->coilSelectionReportObj->setCoilEntAirTemp(
4890 8 : state, varSpeedCoil.Name, varSpeedCoil.VarSpeedCoilType, MixTemp, state.dataSize->CurSysNum, state.dataSize->CurZoneEqNum);
4891 8 : state.dataRptCoilSelection->coilSelectionReportObj->setCoilEntAirHumRat(
4892 8 : state, varSpeedCoil.Name, varSpeedCoil.VarSpeedCoilType, MixHumRat);
4893 8 : state.dataRptCoilSelection->coilSelectionReportObj->setCoilLvgAirTemp(state, varSpeedCoil.Name, varSpeedCoil.VarSpeedCoilType, SupTemp);
4894 8 : state.dataRptCoilSelection->coilSelectionReportObj->setCoilLvgAirHumRat(
4895 8 : state, varSpeedCoil.Name, varSpeedCoil.VarSpeedCoilType, SupHumRat);
4896 8 : state.dataRptCoilSelection->coilSelectionReportObj->setCoilAirFlow(
4897 8 : state, varSpeedCoil.Name, varSpeedCoil.VarSpeedCoilType, varSpeedCoil.RatedAirVolFlowRate, RatedAirFlowAutoSized);
4898 8 : state.dataRptCoilSelection->coilSelectionReportObj->setCoilCoolingCapacity(state,
4899 8 : varSpeedCoil.Name,
4900 8 : varSpeedCoil.VarSpeedCoilType,
4901 : RatedCapCoolTotalDes,
4902 : RatedCapCoolTotalAutoSized,
4903 8 : state.dataSize->CurSysNum,
4904 8 : state.dataSize->CurZoneEqNum,
4905 8 : state.dataSize->CurOASysNum,
4906 : 0.0, // no fan load included in sizing
4907 : TotCapTempModFac,
4908 : -999.0,
4909 : -999.0); // VS model doesn't limit, double check
4910 : }
4911 :
4912 : // Set the global DX cooling coil capacity variable for use by other objects
4913 18 : if (varSpeedCoil.VSCoilType == HVAC::Coil_CoolingWaterToAirHPVSEquationFit ||
4914 16 : varSpeedCoil.VSCoilType == HVAC::Coil_CoolingAirToAirVariableSpeed) {
4915 13 : state.dataSize->DXCoolCap = varSpeedCoil.RatedCapCoolTotal;
4916 : }
4917 :
4918 : // size rated heating capacity
4919 18 : if (varSpeedCoil.RatedCapHeat == DataSizing::AutoSize && (varSpeedCoil.VSCoilType == HVAC::Coil_HeatingWaterToAirHPVSEquationFit ||
4920 16 : varSpeedCoil.VSCoilType == HVAC::Coil_HeatingAirToAirVariableSpeed)) {
4921 4 : RatedCapHeatAutoSized = true;
4922 : }
4923 : // simply set heating capacity equal to the cooling capacity
4924 : // VarSpeedCoil(DXCoilNum)%RatedCapHeat = DXCoolCap
4925 18 : if (varSpeedCoil.VSCoilType == HVAC::Coil_HeatingWaterToAirHPVSEquationFit ||
4926 17 : varSpeedCoil.VSCoilType == HVAC::Coil_HeatingAirToAirVariableSpeed) {
4927 5 : if (varSpeedCoil.CompanionCoolingCoilNum > 0) {
4928 1 : RatedCapHeatDes = state.dataVariableSpeedCoils->VarSpeedCoil(varSpeedCoil.CompanionCoolingCoilNum).RatedCapCoolTotal;
4929 1 : varSpeedCoil.RatedCapCoolTotal = RatedCapHeatDes; // AVOID BEING ZERO
4930 : } else {
4931 4 : RatedCapHeatDes = state.dataSize->DXCoolCap; // previous code, can be risky
4932 : }
4933 : // END IF
4934 5 : if (RatedCapHeatAutoSized) {
4935 4 : if (RatedCapHeatDes == DataSizing::AutoSize) {
4936 0 : ShowWarningError(
4937 0 : state, format("COIL:{}:WATERTOAIRHEATPUMP:VARIABLESPEEDEQUATIONFIT \"{}\"", varSpeedCoil.CoolHeatType, varSpeedCoil.Name));
4938 0 : ShowContinueError(state,
4939 0 : format("{}: Heating coil could not be autosized since cooling coil was not previously sized.", RoutineName));
4940 0 : ShowContinueError(state, "... Cooling coil must be upstream of heating coil.");
4941 0 : ShowContinueError(state, "... Manually sizing this heating coil will be required.");
4942 : }
4943 : }
4944 5 : if (RatedCapHeatDes < HVAC::SmallLoad) {
4945 1 : RatedCapHeatDes = 0.0;
4946 : }
4947 5 : state.dataRptCoilSelection->coilSelectionReportObj->setCoilHeatingCapacity(state,
4948 5 : varSpeedCoil.Name,
4949 5 : varSpeedCoil.VarSpeedCoilType,
4950 : RatedCapHeatDes,
4951 : RatedCapHeatAutoSized,
4952 5 : state.dataSize->CurSysNum,
4953 5 : state.dataSize->CurZoneEqNum,
4954 5 : state.dataSize->CurOASysNum,
4955 : 0.0,
4956 : 1.0,
4957 : -999.0,
4958 : -999.0);
4959 : }
4960 18 : if (RatedCapHeatAutoSized) {
4961 4 : varSpeedCoil.RatedCapHeat = RatedCapHeatDes;
4962 12 : BaseSizer::reportSizerOutput(state,
4963 8 : format("COIL:{}{}", varSpeedCoil.CoolHeatType, CurrentObjSubfix),
4964 : varSpeedCoil.Name,
4965 : "Design Size Nominal Heating Capacity [W]",
4966 : RatedCapHeatDes);
4967 8 : OutputReportPredefined::PreDefTableEntry(
4968 4 : state, state.dataOutRptPredefined->pdchHeatCoilNomCap, varSpeedCoil.Name, varSpeedCoil.RatedCapHeat);
4969 4 : if (varSpeedCoil.RatedCapHeat != 0.0) {
4970 8 : OutputReportPredefined::PreDefTableEntry(
4971 4 : state, state.dataOutRptPredefined->pdchHeatCoilNomEff, varSpeedCoil.Name, varSpeedCoil.MSRatedCOP(NormSpeed));
4972 : } else {
4973 0 : OutputReportPredefined::PreDefTableEntry(state, state.dataOutRptPredefined->pdchHeatCoilNomEff, varSpeedCoil.Name, 0.0);
4974 : }
4975 8 : OutputReportPredefined::addFootNoteSubTable(
4976 : state,
4977 4 : state.dataOutRptPredefined->pdstHeatCoil,
4978 : "Nominal values are gross at rated conditions, i.e., the supply air fan heat and electric power NOT accounted for.");
4979 : } else {
4980 14 : if (varSpeedCoil.RatedCapHeat > 0.0 && RatedCapHeatDes > 0.0) {
4981 0 : RatedCapHeatUser = varSpeedCoil.RatedCapHeat;
4982 0 : BaseSizer::reportSizerOutput(state,
4983 0 : format("COIL:{}{}", varSpeedCoil.CoolHeatType, CurrentObjSubfix),
4984 : varSpeedCoil.Name,
4985 : "Design Size Nominal Heating Capacity [W]",
4986 : RatedCapHeatDes,
4987 : "User-Specified Nominal Heating Capacity [W]",
4988 : RatedCapHeatUser);
4989 0 : if (state.dataGlobal->DisplayExtraWarnings) {
4990 0 : if ((std::abs(RatedCapHeatDes - RatedCapHeatUser) / RatedCapHeatUser) > state.dataSize->AutoVsHardSizingThreshold) {
4991 0 : ShowMessage(
4992 : state,
4993 0 : format("SizeVarSpeedCoil: Potential issue with equipment sizing for {} {}", varSpeedCoil.CoolHeatType, CurrentObjSubfix));
4994 0 : ShowContinueError(state, format("Coil Name = {}", varSpeedCoil.Name));
4995 0 : ShowContinueError(state, format("User-Specified Rated Total Heating Capacity of {:.2R} [W]", RatedCapHeatUser));
4996 0 : ShowContinueError(state, format("differs from Design Size Rated Total Heating Capacity of {:.2R} [W]", RatedCapHeatDes));
4997 0 : ShowContinueError(state, "This may, or may not, indicate mismatched component sizes.");
4998 0 : ShowContinueError(state, "Verify that the value entered is intended and is consistent with other components.");
4999 : }
5000 : }
5001 : }
5002 : }
5003 :
5004 : // FORCE BACK TO THE RATED AIR FLOW RATE WITH THE SAME RATIO DEFINED BY THE CATALOG DATA
5005 18 : if (!HardSizeNoDesRunAirFlow) {
5006 13 : if ((RatedCapCoolTotalAutoSized) && (RatedAirFlowAutoSized)) {
5007 6 : RatedAirVolFlowRateDes = varSpeedCoil.RatedCapCoolTotal * varSpeedCoil.MSRatedAirVolFlowPerRatedTotCap(NormSpeed);
5008 7 : } else if ((RatedCapHeatAutoSized) && (RatedAirFlowAutoSized)) {
5009 2 : RatedAirVolFlowRateDes = varSpeedCoil.RatedCapHeat * varSpeedCoil.MSRatedAirVolFlowPerRatedTotCap(NormSpeed);
5010 : }
5011 :
5012 : // write the air flow sizing output
5013 13 : if (RatedAirFlowAutoSized) {
5014 8 : varSpeedCoil.RatedAirVolFlowRate = RatedAirVolFlowRateDes;
5015 24 : BaseSizer::reportSizerOutput(state,
5016 16 : format("COIL:{}{}", varSpeedCoil.CoolHeatType, CurrentObjSubfix),
5017 : varSpeedCoil.Name,
5018 : "Design Size Rated Air Flow Rate [m3/s]",
5019 : RatedAirVolFlowRateDes);
5020 : } else {
5021 5 : if (varSpeedCoil.RatedAirVolFlowRate > 0.0 && RatedAirVolFlowRateDes > 0.0) {
5022 0 : RatedAirVolFlowRateUser = varSpeedCoil.RatedAirVolFlowRate;
5023 0 : BaseSizer::reportSizerOutput(state,
5024 0 : format("COIL:{}{}", varSpeedCoil.CoolHeatType, CurrentObjSubfix),
5025 : varSpeedCoil.Name,
5026 : "Design Size Rated Air Flow Rate [m3/s]",
5027 : RatedAirVolFlowRateDes,
5028 : "User-Specified Rated Air Flow Rate [m3/s]",
5029 : RatedAirVolFlowRateUser);
5030 0 : if (state.dataGlobal->DisplayExtraWarnings) {
5031 0 : if ((std::abs(RatedAirVolFlowRateDes - RatedAirVolFlowRateUser) / RatedAirVolFlowRateUser) >
5032 0 : state.dataSize->AutoVsHardSizingThreshold) {
5033 0 : ShowMessage(state,
5034 0 : format("SizeVarSpeedCoil: Potential issue with equipment sizing for {} {}",
5035 0 : varSpeedCoil.CoolHeatType,
5036 : CurrentObjSubfix));
5037 0 : ShowContinueError(state, format("Coil Name = {}", varSpeedCoil.Name));
5038 0 : ShowContinueError(state, format("User-Specified Rated Air Flow Rate of {:.5R} [m3/s]", RatedAirVolFlowRateUser));
5039 0 : ShowContinueError(state, format("differs from Design Size Rated Air Flow Rate of {:.5R} [m3/s]", RatedAirVolFlowRateDes));
5040 0 : ShowContinueError(state, "This may, or may not, indicate mismatched component sizes.");
5041 0 : ShowContinueError(state, "Verify that the value entered is intended and is consistent with other components.");
5042 : }
5043 : }
5044 : }
5045 : }
5046 13 : state.dataRptCoilSelection->coilSelectionReportObj->setCoilAirFlow(
5047 13 : state, varSpeedCoil.Name, varSpeedCoil.VarSpeedCoilType, RatedAirVolFlowRateDes, RatedAirFlowAutoSized);
5048 : }
5049 :
5050 : // Check that heat pump heating capacity is within 20% of cooling capacity. Check only for heating coil and report both.
5051 18 : if ((varSpeedCoil.VSCoilType == HVAC::Coil_HeatingWaterToAirHPVSEquationFit ||
5052 17 : varSpeedCoil.VSCoilType == HVAC::Coil_HeatingAirToAirVariableSpeed) &&
5053 5 : varSpeedCoil.CompanionCoolingCoilNum > 0) {
5054 :
5055 1 : if (state.dataVariableSpeedCoils->VarSpeedCoil(varSpeedCoil.CompanionCoolingCoilNum).RatedCapCoolTotal > 0.0) {
5056 :
5057 1 : if (std::abs(state.dataVariableSpeedCoils->VarSpeedCoil(varSpeedCoil.CompanionCoolingCoilNum).RatedCapCoolTotal -
5058 1 : varSpeedCoil.RatedCapHeat) /
5059 1 : state.dataVariableSpeedCoils->VarSpeedCoil(varSpeedCoil.CompanionCoolingCoilNum).RatedCapCoolTotal >
5060 : 0.2) {
5061 :
5062 0 : ShowWarningError(
5063 0 : state, format("COIL:{}:WATERTOAIRHEATPUMP:VARIABLESPEEDEQUATIONFIT \"{}\"", varSpeedCoil.CoolHeatType, varSpeedCoil.Name));
5064 0 : ShowContinueError(state,
5065 0 : format("...used with COIL:{}:WATERTOAIRHEATPUMP:VARIABLESPEEDEQUATIONFIT \"{}\"",
5066 0 : state.dataVariableSpeedCoils->VarSpeedCoil(varSpeedCoil.CompanionCoolingCoilNum).CoolHeatType,
5067 0 : state.dataVariableSpeedCoils->VarSpeedCoil(varSpeedCoil.CompanionCoolingCoilNum).Name));
5068 0 : ShowContinueError(state, "...heating capacity is disproportionate (> 20% different) to total cooling capacity");
5069 0 : ShowContinueError(state, format("...heating capacity = {:.3T} W", varSpeedCoil.RatedCapHeat));
5070 0 : ShowContinueError(state,
5071 0 : format("...cooling capacity = {:.3T} W",
5072 0 : state.dataVariableSpeedCoils->VarSpeedCoil(varSpeedCoil.CompanionCoolingCoilNum).RatedCapCoolTotal));
5073 : }
5074 : }
5075 : }
5076 :
5077 : // ASSIGN CAPACITY
5078 18 : switch (varSpeedCoil.VSCoilType) {
5079 13 : case HVAC::Coil_CoolingWaterToAirHPVSEquationFit:
5080 : case HVAC::Coil_CoolingAirToAirVariableSpeed: {
5081 13 : varSpeedCoil.MSRatedTotCap(UpperSpeed) = varSpeedCoil.RatedCapCoolTotal / varSpeedCoil.MSRatedPercentTotCap(NormSpeed);
5082 13 : } break;
5083 5 : case HVAC::Coil_HeatingWaterToAirHPVSEquationFit:
5084 : case HVAC::Coil_HeatingAirToAirVariableSpeed: {
5085 5 : varSpeedCoil.MSRatedTotCap(UpperSpeed) = varSpeedCoil.RatedCapHeat / varSpeedCoil.MSRatedPercentTotCap(NormSpeed);
5086 5 : } break;
5087 0 : case HVAC::CoilDX_HeatPumpWaterHeaterVariableSpeed: {
5088 0 : varSpeedCoil.MSRatedTotCap(UpperSpeed) = varSpeedCoil.RatedCapWH / varSpeedCoil.MSRatedPercentTotCap(NormSpeed);
5089 0 : } break;
5090 : }
5091 :
5092 18 : if (varSpeedCoil.VSCoilType == HVAC::CoilDX_HeatPumpWaterHeaterVariableSpeed) {
5093 0 : HPInletAirHumRat = Psychrometrics::PsyWFnTdbTwbPb(
5094 0 : state, varSpeedCoil.WHRatedInletDBTemp, varSpeedCoil.WHRatedInletWBTemp, state.dataEnvrn->StdBaroPress, RoutineName);
5095 :
5096 0 : for (Mode = varSpeedCoil.NumOfSpeeds; Mode >= 1; --Mode) {
5097 0 : varSpeedCoil.MSRatedTotCap(Mode) = varSpeedCoil.MSRatedTotCap(UpperSpeed) * varSpeedCoil.MSRatedPercentTotCap(Mode);
5098 0 : varSpeedCoil.MSRatedAirVolFlowRate(Mode) = varSpeedCoil.MSRatedTotCap(Mode) * varSpeedCoil.MSRatedAirVolFlowPerRatedTotCap(Mode);
5099 0 : varSpeedCoil.MSRatedAirMassFlowRate(Mode) = varSpeedCoil.MSRatedAirVolFlowRate(Mode) * rhoair;
5100 : // EVAPORATIVE PRECOOLING CONDENSER AIR FLOW RATE
5101 0 : varSpeedCoil.EvapCondAirFlow(Mode) = 0.0;
5102 : }
5103 : } else {
5104 : // HPWH, the mass flow rate will be updated by a revised entering air density
5105 :
5106 18 : if (varSpeedCoil.MSHPDesignSpecIndex > -1 && state.dataUnitarySystems->designSpecMSHP.size() > 0) {
5107 3 : if (varSpeedCoil.VSCoilType == HVAC::Coil_CoolingWaterToAirHPVSEquationFit ||
5108 3 : varSpeedCoil.VSCoilType == HVAC::Coil_CoolingAirToAirVariableSpeed) {
5109 2 : if (state.dataUnitarySystems->designSpecMSHP[varSpeedCoil.MSHPDesignSpecIndex].numOfSpeedCooling != varSpeedCoil.NumOfSpeeds) {
5110 0 : ShowFatalError(state,
5111 0 : format("COIL:{} = {}{} number of speeds not equal to number of speed specified in "
5112 : "UnitarySystemPerformance:Multispeed object.",
5113 0 : varSpeedCoil.CoolHeatType,
5114 : CurrentObjSubfix,
5115 0 : varSpeedCoil.Name));
5116 : } else {
5117 11 : for (Mode = varSpeedCoil.NumOfSpeeds; Mode >= 1; --Mode) {
5118 20 : varSpeedCoil.MSRatedAirVolFlowRate(Mode) =
5119 10 : varSpeedCoil.RatedAirVolFlowRate *
5120 10 : state.dataUnitarySystems->designSpecMSHP[varSpeedCoil.MSHPDesignSpecIndex].coolingVolFlowRatio[Mode - 1];
5121 20 : varSpeedCoil.MSRatedTotCap(Mode) =
5122 10 : varSpeedCoil.MSRatedAirVolFlowRate(Mode) / varSpeedCoil.MSRatedAirVolFlowPerRatedTotCap(Mode);
5123 10 : varSpeedCoil.MSRatedAirMassFlowRate(Mode) = varSpeedCoil.MSRatedAirVolFlowRate(Mode) * rhoair;
5124 : // EVAPORATIVE PRECOOLING CONDENSER AIR FLOW RATE
5125 10 : varSpeedCoil.EvapCondAirFlow(Mode) =
5126 10 : varSpeedCoil.MSRatedTotCap(Mode) * varSpeedCoil.MSRatedEvapCondVolFlowPerRatedTotCap(Mode);
5127 : }
5128 : }
5129 2 : } else if (varSpeedCoil.VSCoilType == HVAC::Coil_HeatingWaterToAirHPVSEquationFit ||
5130 2 : varSpeedCoil.VSCoilType == HVAC::Coil_HeatingAirToAirVariableSpeed) {
5131 2 : if (state.dataUnitarySystems->designSpecMSHP[varSpeedCoil.MSHPDesignSpecIndex].numOfSpeedHeating != varSpeedCoil.NumOfSpeeds) {
5132 0 : ShowFatalError(state,
5133 0 : format("COIL:{}{} = \"{}\" number of speeds not equal to number of speed specified in "
5134 : "UnitarySystemPerformance:Multispeed object.",
5135 0 : varSpeedCoil.CoolHeatType,
5136 : CurrentObjSubfix,
5137 0 : varSpeedCoil.Name));
5138 : } else {
5139 22 : for (Mode = varSpeedCoil.NumOfSpeeds; Mode >= 1; --Mode) {
5140 40 : varSpeedCoil.MSRatedAirVolFlowRate(Mode) =
5141 20 : varSpeedCoil.RatedAirVolFlowRate *
5142 20 : state.dataUnitarySystems->designSpecMSHP[varSpeedCoil.MSHPDesignSpecIndex].heatingVolFlowRatio[Mode - 1];
5143 40 : varSpeedCoil.MSRatedTotCap(Mode) =
5144 20 : varSpeedCoil.MSRatedAirVolFlowRate(Mode) / varSpeedCoil.MSRatedAirVolFlowPerRatedTotCap(Mode);
5145 20 : varSpeedCoil.MSRatedAirMassFlowRate(Mode) = varSpeedCoil.MSRatedAirVolFlowRate(Mode) * rhoair;
5146 : // EVAPORATIVE PRECOOLING CONDENSER AIR FLOW RATE
5147 20 : varSpeedCoil.EvapCondAirFlow(Mode) =
5148 20 : varSpeedCoil.MSRatedTotCap(Mode) * varSpeedCoil.MSRatedEvapCondVolFlowPerRatedTotCap(Mode);
5149 : }
5150 : }
5151 : }
5152 : } else {
5153 108 : for (Mode = varSpeedCoil.NumOfSpeeds; Mode >= 1; --Mode) {
5154 93 : varSpeedCoil.MSRatedTotCap(Mode) = varSpeedCoil.MSRatedTotCap(UpperSpeed) * varSpeedCoil.MSRatedPercentTotCap(Mode);
5155 93 : varSpeedCoil.MSRatedAirVolFlowRate(Mode) = varSpeedCoil.MSRatedTotCap(Mode) * varSpeedCoil.MSRatedAirVolFlowPerRatedTotCap(Mode);
5156 93 : varSpeedCoil.MSRatedAirMassFlowRate(Mode) = varSpeedCoil.MSRatedAirVolFlowRate(Mode) * rhoair;
5157 : // EVAPORATIVE PRECOOLING CONDENSER AIR FLOW RATE
5158 93 : varSpeedCoil.EvapCondAirFlow(Mode) = varSpeedCoil.MSRatedTotCap(Mode) * varSpeedCoil.MSRatedEvapCondVolFlowPerRatedTotCap(Mode);
5159 : }
5160 : }
5161 : }
5162 :
5163 : // size rated power
5164 18 : switch (varSpeedCoil.VSCoilType) {
5165 13 : case HVAC::Coil_CoolingWaterToAirHPVSEquationFit:
5166 : case HVAC::Coil_CoolingAirToAirVariableSpeed: {
5167 13 : varSpeedCoil.RatedCOPCool = varSpeedCoil.MSRatedCOP(varSpeedCoil.NormSpedLevel);
5168 13 : varSpeedCoil.RatedPowerCool = varSpeedCoil.RatedCapCoolTotal / varSpeedCoil.RatedCOPCool;
5169 13 : } break;
5170 5 : case HVAC::Coil_HeatingWaterToAirHPVSEquationFit:
5171 : case HVAC::Coil_HeatingAirToAirVariableSpeed: {
5172 5 : varSpeedCoil.RatedCOPHeat = varSpeedCoil.MSRatedCOP(varSpeedCoil.NormSpedLevel);
5173 5 : varSpeedCoil.RatedPowerHeat = varSpeedCoil.RatedCapHeat / varSpeedCoil.RatedCOPHeat;
5174 5 : varSpeedCoil.RatedCapCoolTotal = varSpeedCoil.RatedCapHeat;
5175 5 : } break;
5176 0 : case HVAC::CoilDX_HeatPumpWaterHeaterVariableSpeed: {
5177 0 : varSpeedCoil.RatedCOPHeat = varSpeedCoil.MSRatedCOP(varSpeedCoil.NormSpedLevel);
5178 0 : varSpeedCoil.RatedPowerHeat = varSpeedCoil.RatedCapWH / varSpeedCoil.RatedCOPHeat;
5179 0 : varSpeedCoil.RatedCapCoolTotal = varSpeedCoil.RatedCapWH * (1.0 - 1.0 / varSpeedCoil.RatedCOPHeat);
5180 0 : } break;
5181 : }
5182 :
5183 : // Size water volumetric flow rate
5184 18 : if ((varSpeedCoil.RatedWaterVolFlowRate == DataSizing::AutoSize) &&
5185 18 : (varSpeedCoil.VSCoilType == HVAC::Coil_CoolingWaterToAirHPVSEquationFit ||
5186 16 : varSpeedCoil.VSCoilType == HVAC::Coil_HeatingWaterToAirHPVSEquationFit)) {
5187 3 : RatedWaterFlowAutoSized = true;
5188 : }
5189 :
5190 : // WSHP condenser can be on either a plant loop or condenser loop. Test each to find plant sizing number.
5191 : // first check to see if coil is connected to a plant loop, no warning on this CALL
5192 18 : if (RatedWaterFlowAutoSized) {
5193 3 : if (varSpeedCoil.CondenserType == DataHeatBalance::RefrigCondenserType::Water)
5194 6 : PltSizNum = PlantUtilities::MyPlantSizingIndex(state,
5195 6 : format("COIL:{}{}", varSpeedCoil.CoolHeatType, CurrentObjSubfix),
5196 : varSpeedCoil.Name,
5197 : varSpeedCoil.WaterInletNodeNum,
5198 : varSpeedCoil.WaterOutletNodeNum,
5199 : ErrorsFound,
5200 : false);
5201 :
5202 3 : if (PltSizNum > 0) {
5203 3 : rho = state.dataPlnt->PlantLoop(varSpeedCoil.plantLoc.loopNum)
5204 3 : .glycol->getDensity(state, state.dataSize->PlantSizData(PltSizNum).ExitTemp, RoutineNameAlt);
5205 3 : cp = state.dataPlnt->PlantLoop(varSpeedCoil.plantLoc.loopNum)
5206 3 : .glycol->getSpecificHeat(state, state.dataSize->PlantSizData(PltSizNum).ExitTemp, RoutineNameAlt);
5207 :
5208 3 : if (varSpeedCoil.VSCoilType == HVAC::Coil_HeatingWaterToAirHPVSEquationFit ||
5209 2 : varSpeedCoil.VSCoilType == HVAC::Coil_HeatingAirToAirVariableSpeed) {
5210 :
5211 1 : RatedWaterVolFlowRateDes = varSpeedCoil.RatedCapHeat / (state.dataSize->PlantSizData(PltSizNum).DeltaT * cp * rho);
5212 :
5213 1 : state.dataRptCoilSelection->coilSelectionReportObj->setCoilLvgWaterTemp(
5214 : state,
5215 1 : varSpeedCoil.Name,
5216 1 : varSpeedCoil.VarSpeedCoilType,
5217 1 : state.dataSize->PlantSizData(PltSizNum).ExitTemp +
5218 1 : state.dataSize->PlantSizData(PltSizNum).DeltaT); // TRACE 3D Plus coil selection report
5219 :
5220 2 : } else if (varSpeedCoil.VSCoilType == HVAC::Coil_CoolingWaterToAirHPVSEquationFit ||
5221 0 : varSpeedCoil.VSCoilType == HVAC::Coil_CoolingAirToAirVariableSpeed) {
5222 :
5223 : // use companion heating coil capacity to calculate volumetric flow rate
5224 2 : if (varSpeedCoil.CompanionCoolingCoilNum > 0) {
5225 0 : SystemCapacity = state.dataVariableSpeedCoils->VarSpeedCoil(varSpeedCoil.CompanionCoolingCoilNum).RatedCapHeat;
5226 : } else {
5227 2 : SystemCapacity = varSpeedCoil.RatedCapCoolTotal;
5228 : }
5229 :
5230 2 : RatedWaterVolFlowRateDes = SystemCapacity / (state.dataSize->PlantSizData(PltSizNum).DeltaT * cp * rho);
5231 :
5232 2 : state.dataRptCoilSelection->coilSelectionReportObj->setCoilLvgWaterTemp(
5233 : state,
5234 2 : varSpeedCoil.Name,
5235 2 : varSpeedCoil.VarSpeedCoilType,
5236 2 : state.dataSize->PlantSizData(PltSizNum).ExitTemp -
5237 2 : state.dataSize->PlantSizData(PltSizNum).DeltaT); // TRACE 3D Plus coil selection report
5238 : }
5239 :
5240 3 : state.dataRptCoilSelection->coilSelectionReportObj->setCoilEntWaterTemp(
5241 : state,
5242 3 : varSpeedCoil.Name,
5243 3 : varSpeedCoil.VarSpeedCoilType,
5244 3 : state.dataSize->PlantSizData(PltSizNum).ExitTemp); // TRACE 3D Plus coil selection report
5245 :
5246 3 : state.dataRptCoilSelection->coilSelectionReportObj->setCoilWaterDeltaT(
5247 : state,
5248 3 : varSpeedCoil.Name,
5249 3 : varSpeedCoil.VarSpeedCoilType,
5250 3 : state.dataSize->PlantSizData(PltSizNum).DeltaT); // TRACE 3D Plus coil selection report
5251 : } else {
5252 0 : ShowSevereError(state, "Autosizing of water flow requires a loop Sizing:Plant object");
5253 0 : ShowContinueError(state, "Autosizing also requires physical connection to a plant or condenser loop.");
5254 0 : ShowContinueError(state, format("Occurs in COIL:{}{} Object = {}", varSpeedCoil.CoolHeatType, CurrentObjSubfix, varSpeedCoil.Name));
5255 0 : ErrorsFound = true;
5256 : }
5257 :
5258 : // WRITE THE WATER SIZING OUTPUT
5259 : // FORCE BACK TO THE RATED WATER FLOW RATE WITH THE SAME RATIO DEFINED BY THE CATLOG DATA
5260 3 : if (RatedCapCoolTotalAutoSized) {
5261 2 : RatedWaterVolFlowRateDes = varSpeedCoil.RatedCapCoolTotal * varSpeedCoil.MSRatedWaterVolFlowPerRatedTotCap(NormSpeed);
5262 1 : } else if (RatedCapHeatAutoSized) {
5263 1 : RatedWaterVolFlowRateDes = varSpeedCoil.RatedCapHeat * varSpeedCoil.MSRatedWaterVolFlowPerRatedTotCap(NormSpeed);
5264 : }
5265 3 : state.dataRptCoilSelection->coilSelectionReportObj->setCoilWaterFlowNodeNums(state,
5266 3 : varSpeedCoil.Name,
5267 3 : varSpeedCoil.VarSpeedCoilType,
5268 : RatedWaterVolFlowRateDes,
5269 : RatedWaterFlowAutoSized,
5270 : varSpeedCoil.WaterInletNodeNum,
5271 : varSpeedCoil.WaterOutletNodeNum,
5272 : varSpeedCoil.plantLoc.loopNum);
5273 3 : varSpeedCoil.RatedWaterVolFlowRate = RatedWaterVolFlowRateDes;
5274 9 : BaseSizer::reportSizerOutput(state,
5275 6 : format("COIL:{}{}", varSpeedCoil.CoolHeatType, CurrentObjSubfix),
5276 : varSpeedCoil.Name,
5277 : "Design Size Rated Water Flow Rate [m3/s]",
5278 : RatedWaterVolFlowRateDes);
5279 : // Ensure water flow rate at lower speed must be lower or
5280 : // equal to the flow rate at higher speed. Otherwise, a severe error is isssued.
5281 30 : for (Mode = 1; Mode <= varSpeedCoil.NumOfSpeeds - 1; ++Mode) {
5282 27 : if (varSpeedCoil.MSRatedWaterVolFlowRate(Mode) > varSpeedCoil.MSRatedWaterVolFlowRate(Mode + 1) * 1.05) {
5283 0 : ShowWarningError(
5284 : state,
5285 0 : format("SizeDXCoil: {} {}, Speed {} Rated Air Flow Rate must be less than or equal to Speed {} Rated Air Flow Rate.",
5286 0 : varSpeedCoil.VarSpeedCoilType,
5287 0 : varSpeedCoil.Name,
5288 : Mode,
5289 0 : Mode + 1));
5290 0 : ShowContinueError(
5291 : state,
5292 0 : format("Instead, {:.2R} > {:.2R}", varSpeedCoil.MSRatedAirVolFlowRate(Mode), varSpeedCoil.MSRatedAirVolFlowRate(Mode + 1)));
5293 0 : ShowFatalError(state, "Preceding conditions cause termination.");
5294 : }
5295 : }
5296 : } else {
5297 15 : if (varSpeedCoil.RatedWaterVolFlowRate > 0.0 && RatedWaterVolFlowRateDes > 0.0) {
5298 0 : RatedWaterVolFlowRateUser = varSpeedCoil.RatedWaterVolFlowRate;
5299 0 : BaseSizer::reportSizerOutput(state,
5300 0 : format("COIL:{}{}", varSpeedCoil.CoolHeatType, CurrentObjSubfix),
5301 : varSpeedCoil.Name,
5302 : "Design Size Rated Water Flow Rate [m3/s]",
5303 : RatedWaterVolFlowRateDes,
5304 : "User-Specified Rated Water Flow Rate [m3/s]",
5305 : RatedWaterVolFlowRateUser);
5306 0 : if (state.dataGlobal->DisplayExtraWarnings) {
5307 0 : if ((std::abs(RatedWaterVolFlowRateDes - RatedWaterVolFlowRateUser) / RatedWaterVolFlowRateUser) >
5308 0 : state.dataSize->AutoVsHardSizingThreshold) {
5309 0 : ShowMessage(
5310 : state,
5311 0 : format("SizeVarSpeedCoil: Potential issue with equipment sizing for {} {}", varSpeedCoil.CoolHeatType, CurrentObjSubfix));
5312 0 : ShowContinueError(state, format("Coil Name = {}", varSpeedCoil.Name));
5313 0 : ShowContinueError(state, format("User-Specified Rated Water Flow Rate of {:.5R} [m3/s]", RatedWaterVolFlowRateUser));
5314 0 : ShowContinueError(state, format("differs from Design Size Rated Water Flow Rate of {:.5R} [m3/s]", RatedWaterVolFlowRateDes));
5315 0 : ShowContinueError(state, "This may, or may not, indicate mismatched component sizes.");
5316 0 : ShowContinueError(state, "Verify that the value entered is intended and is consistent with other components.");
5317 : }
5318 : }
5319 : }
5320 : }
5321 :
5322 : // Save component design water volumetric flow rate.
5323 18 : if (varSpeedCoil.RatedWaterVolFlowRate > 0.0 && varSpeedCoil.VSCoilType == HVAC::CoilDX_HeatPumpWaterHeaterVariableSpeed) {
5324 0 : PlantUtilities::RegisterPlantCompDesignFlow(state, varSpeedCoil.WaterInletNodeNum, varSpeedCoil.RatedWaterVolFlowRate);
5325 : }
5326 : // Use 1/2 flow since both cooling and heating coil will save flow yet only 1 will operate at a time
5327 18 : else if (varSpeedCoil.RatedWaterVolFlowRate > 0.0) {
5328 3 : PlantUtilities::RegisterPlantCompDesignFlow(state, varSpeedCoil.WaterInletNodeNum, 0.5 * varSpeedCoil.RatedWaterVolFlowRate);
5329 : }
5330 :
5331 18 : RatedSourceTempCool = GetVSCoilRatedSourceTemp(state, DXCoilNum);
5332 18 : if (varSpeedCoil.VSCoilType == HVAC::Coil_CoolingWaterToAirHPVSEquationFit ||
5333 16 : varSpeedCoil.VSCoilType == HVAC::Coil_HeatingWaterToAirHPVSEquationFit) {
5334 :
5335 3 : if (PltSizNum > 0) {
5336 3 : rhoW = rho;
5337 : } else {
5338 0 : rhoW = state.dataPlnt->PlantLoop(varSpeedCoil.plantLoc.loopNum).glycol->getDensity(state, RatedSourceTempCool, RoutineName);
5339 : }
5340 :
5341 3 : varSpeedCoil.RatedWaterMassFlowRate = varSpeedCoil.RatedWaterVolFlowRate * rhoW;
5342 33 : for (Mode = varSpeedCoil.NumOfSpeeds; Mode >= 1; --Mode) {
5343 30 : varSpeedCoil.MSRatedWaterVolFlowRate(Mode) = varSpeedCoil.MSRatedTotCap(Mode) * varSpeedCoil.MSRatedWaterVolFlowPerRatedTotCap(Mode);
5344 30 : varSpeedCoil.MSRatedWaterMassFlowRate(Mode) = varSpeedCoil.MSRatedWaterVolFlowRate(Mode) * rhoW;
5345 : }
5346 15 : } else if (varSpeedCoil.VSCoilType == HVAC::CoilDX_HeatPumpWaterHeaterVariableSpeed) {
5347 0 : rhoW = Psychrometrics::RhoH2O(RatedSourceTempCool);
5348 0 : varSpeedCoil.RatedWaterMassFlowRate = varSpeedCoil.RatedWaterVolFlowRate * rhoW;
5349 0 : for (Mode = varSpeedCoil.NumOfSpeeds; Mode >= 1; --Mode) {
5350 0 : varSpeedCoil.MSRatedWaterVolFlowRate(Mode) = varSpeedCoil.MSRatedTotCap(Mode) * varSpeedCoil.MSRatedWaterVolFlowPerRatedTotCap(Mode);
5351 0 : varSpeedCoil.MSWHPumpPower(Mode) = varSpeedCoil.MSRatedTotCap(Mode) * varSpeedCoil.MSWHPumpPowerPerRatedTotCap(Mode);
5352 0 : varSpeedCoil.MSRatedWaterMassFlowRate(Mode) = varSpeedCoil.MSRatedWaterVolFlowRate(Mode) * rhoW;
5353 : }
5354 : }
5355 :
5356 : // Ensure air flow rate at lower speed must be lower or
5357 : // equal to the flow rate at higher speed. Otherwise, a severe error is issued.
5358 123 : for (Mode = 1; Mode <= varSpeedCoil.NumOfSpeeds - 1; ++Mode) {
5359 105 : if (varSpeedCoil.MSRatedAirVolFlowRate(Mode) > varSpeedCoil.MSRatedAirVolFlowRate(Mode + 1)) {
5360 0 : ShowWarningError(state,
5361 0 : format("SizeDXCoil: {} {}, Speed {} Rated Air Flow Rate must be less than or equal to Speed {} Rated Air Flow Rate.",
5362 0 : varSpeedCoil.VarSpeedCoilType,
5363 0 : varSpeedCoil.Name,
5364 : Mode,
5365 0 : Mode + 1));
5366 0 : ShowContinueError(
5367 : state,
5368 0 : format("Instead, {:.2R} > {:.2R}", varSpeedCoil.MSRatedAirVolFlowRate(Mode), varSpeedCoil.MSRatedAirVolFlowRate(Mode + 1)));
5369 0 : ShowFatalError(state, "Preceding conditions cause termination.");
5370 : }
5371 : }
5372 :
5373 : // Ensure capacity at lower speed must be lower or equal to the capacity at higher speed.
5374 123 : for (Mode = 1; Mode <= varSpeedCoil.NumOfSpeeds - 1; ++Mode) {
5375 105 : if (varSpeedCoil.MSRatedTotCap(Mode) > varSpeedCoil.MSRatedTotCap(Mode + 1)) {
5376 0 : ShowWarningError(state,
5377 0 : format("SizeDXCoil: {} {}, Speed {} Rated Total Cooling Capacity must be less than or equal to Speed {} Rated Total "
5378 : "Cooling Capacity.",
5379 0 : varSpeedCoil.VarSpeedCoilType,
5380 0 : varSpeedCoil.Name,
5381 : Mode,
5382 0 : Mode + 1));
5383 0 : ShowContinueError(state, format("Instead, {:.2R} > {:.2R}", varSpeedCoil.MSRatedTotCap(Mode), varSpeedCoil.MSRatedTotCap(Mode + 1)));
5384 0 : ShowFatalError(state, "Preceding conditions cause termination.");
5385 : }
5386 : }
5387 :
5388 : // convert SHR to rated Bypass factor and effective air side surface area
5389 18 : if (varSpeedCoil.VSCoilType == HVAC::Coil_CoolingWaterToAirHPVSEquationFit ||
5390 16 : varSpeedCoil.VSCoilType == HVAC::Coil_CoolingAirToAirVariableSpeed) {
5391 91 : for (Mode = 1; Mode <= varSpeedCoil.NumOfSpeeds; ++Mode) {
5392 78 : varSpeedCoil.MSRatedCBF(Mode) = DXCoils::CalcCBF(state,
5393 78 : varSpeedCoil.VarSpeedCoilType,
5394 78 : varSpeedCoil.Name,
5395 : RatedInletAirTemp,
5396 : RatedInletAirHumRat,
5397 78 : varSpeedCoil.MSRatedTotCap(Mode),
5398 78 : varSpeedCoil.MSRatedAirVolFlowRate(Mode),
5399 78 : varSpeedCoil.MSRatedSHR(Mode),
5400 : true);
5401 78 : if (varSpeedCoil.MSRatedCBF(Mode) > 0.0) {
5402 73 : varSpeedCoil.MSEffectiveAo(Mode) = -std::log(varSpeedCoil.MSRatedCBF(Mode)) * varSpeedCoil.MSRatedAirMassFlowRate(Mode);
5403 : } else {
5404 5 : varSpeedCoil.MSEffectiveAo(Mode) = 0.0;
5405 : }
5406 : }
5407 5 : } else if (varSpeedCoil.VSCoilType == HVAC::CoilDX_HeatPumpWaterHeaterVariableSpeed) {
5408 0 : state.dataHVACGlobal->HPWHInletDBTemp = varSpeedCoil.WHRatedInletDBTemp;
5409 0 : state.dataHVACGlobal->HPWHInletWBTemp = varSpeedCoil.WHRatedInletWBTemp;
5410 :
5411 0 : for (Mode = 1; Mode <= varSpeedCoil.NumOfSpeeds; ++Mode) {
5412 0 : varSpeedCoil.MSRatedAirMassFlowRate(Mode) = varSpeedCoil.MSRatedAirVolFlowRate(Mode) * rhoair;
5413 : }
5414 :
5415 0 : for (Mode = 1; Mode <= varSpeedCoil.NumOfSpeeds; ++Mode) {
5416 : // get cooling capacity, without fan power, i.e. total coil cooling
5417 0 : if (varSpeedCoil.CondPumpPowerInCOP)
5418 0 : HPWHCoolCapacity = varSpeedCoil.MSRatedTotCap(Mode) * (1.0 - 1.0 / varSpeedCoil.MSRatedCOP(Mode)) +
5419 0 : varSpeedCoil.MSWHPumpPower(Mode) - varSpeedCoil.MSWHPumpPower(Mode) * varSpeedCoil.HPWHCondPumpFracToWater;
5420 : else
5421 0 : HPWHCoolCapacity = varSpeedCoil.MSRatedTotCap(Mode) * (1.0 - 1.0 / varSpeedCoil.MSRatedCOP(Mode)) -
5422 0 : varSpeedCoil.MSWHPumpPower(Mode) * varSpeedCoil.HPWHCondPumpFracToWater;
5423 :
5424 0 : varSpeedCoil.MSRatedCBF(Mode) = DXCoils::CalcCBF(state,
5425 0 : varSpeedCoil.VarSpeedCoilType,
5426 0 : varSpeedCoil.Name,
5427 0 : state.dataHVACGlobal->HPWHInletDBTemp,
5428 : HPInletAirHumRat,
5429 : HPWHCoolCapacity,
5430 0 : varSpeedCoil.MSRatedAirVolFlowRate(Mode),
5431 0 : varSpeedCoil.MSRatedSHR(Mode),
5432 : true);
5433 0 : if (varSpeedCoil.MSRatedCBF(Mode) > 0.0) {
5434 0 : varSpeedCoil.MSEffectiveAo(Mode) = -std::log(varSpeedCoil.MSRatedCBF(Mode)) * varSpeedCoil.MSRatedAirMassFlowRate(Mode);
5435 : } else {
5436 0 : varSpeedCoil.MSEffectiveAo(Mode) = 0.0;
5437 : }
5438 : }
5439 :
5440 : // update VarSpeedCoil(DXCoilNum).RatedCapCoolTotal
5441 0 : Mode = varSpeedCoil.NormSpedLevel;
5442 0 : if (varSpeedCoil.CondPumpPowerInCOP) {
5443 0 : varSpeedCoil.RatedCapCoolTotal = varSpeedCoil.MSRatedTotCap(Mode) * (1.0 - 1.0 / varSpeedCoil.MSRatedCOP(Mode)) +
5444 0 : varSpeedCoil.MSWHPumpPower(Mode) -
5445 0 : varSpeedCoil.MSWHPumpPower(Mode) * varSpeedCoil.HPWHCondPumpFracToWater;
5446 : } else {
5447 0 : varSpeedCoil.RatedCapCoolTotal = varSpeedCoil.MSRatedTotCap(Mode) * (1.0 - 1.0 / varSpeedCoil.MSRatedCOP(Mode)) -
5448 0 : varSpeedCoil.MSWHPumpPower(Mode) * varSpeedCoil.HPWHCondPumpFracToWater;
5449 : }
5450 : }
5451 :
5452 : // size rated sensible cooling capacity
5453 18 : RatedCapCoolSensAutoSized = true; // always do that
5454 :
5455 18 : if (varSpeedCoil.RatedAirVolFlowRate >= HVAC::SmallAirVolFlow && (varSpeedCoil.VSCoilType == HVAC::Coil_CoolingWaterToAirHPVSEquationFit ||
5456 16 : varSpeedCoil.VSCoilType == HVAC::Coil_CoolingAirToAirVariableSpeed)) {
5457 13 : RatedAirMassFlowRate =
5458 13 : varSpeedCoil.RatedAirVolFlowRate *
5459 13 : Psychrometrics::PsyRhoAirFnPbTdbW(state, state.dataEnvrn->StdBaroPress, RatedInletAirTemp, RatedInletAirHumRat, RoutineName);
5460 13 : RatedInletEnth = Psychrometrics::PsyHFnTdbW(RatedInletAirTemp, RatedInletAirHumRat);
5461 13 : CBFRated = DXCoils::AdjustCBF(varSpeedCoil.MSRatedCBF(NormSpeed), varSpeedCoil.MSRatedAirMassFlowRate(NormSpeed), RatedAirMassFlowRate);
5462 13 : if (CBFRated > 0.999) CBFRated = 0.999;
5463 13 : if (varSpeedCoil.MSRatedAirMassFlowRate(NormSpeed) > 1.0e-10) {
5464 12 : AirMassFlowRatio = RatedAirMassFlowRate / varSpeedCoil.MSRatedAirMassFlowRate(NormSpeed);
5465 : } else {
5466 1 : AirMassFlowRatio = 1.0;
5467 : }
5468 :
5469 13 : if (varSpeedCoil.MSRatedWaterVolFlowRate(NormSpeed) > 1.0e-10) {
5470 2 : WaterMassFlowRatio = varSpeedCoil.RatedWaterVolFlowRate / varSpeedCoil.MSRatedWaterVolFlowRate(NormSpeed);
5471 : } else {
5472 11 : WaterMassFlowRatio = 1.0;
5473 : }
5474 :
5475 13 : Real64 TempInletWetBulb = RatedInletWetBulbTemp;
5476 65 : CalcTotCapSHR_VSWSHP(state,
5477 : RatedInletAirTemp,
5478 : RatedInletAirHumRat,
5479 : RatedInletEnth,
5480 : TempInletWetBulb,
5481 : AirMassFlowRatio,
5482 : WaterMassFlowRatio,
5483 : RatedAirMassFlowRate,
5484 : CBFRated,
5485 13 : varSpeedCoil.MSRatedTotCap(NormSpeed),
5486 13 : varSpeedCoil.MSCCapFTemp(NormSpeed),
5487 13 : varSpeedCoil.MSCCapAirFFlow(NormSpeed),
5488 13 : varSpeedCoil.MSCCapWaterFFlow(NormSpeed),
5489 : 0.0,
5490 : 0,
5491 : 0,
5492 : 0,
5493 : QLoadTotal1,
5494 : QLoadTotal2,
5495 : QLoadTotal,
5496 : SHR,
5497 : RatedSourceTempCool,
5498 13 : state.dataEnvrn->StdBaroPress,
5499 : 0.0,
5500 : 1,
5501 13 : varSpeedCoil.capModFacTotal);
5502 :
5503 13 : RatedCapCoolSensDes = varSpeedCoil.RatedCapCoolTotal * SHR;
5504 18 : } else if (varSpeedCoil.RatedAirVolFlowRate >= HVAC::SmallAirVolFlow &&
5505 5 : varSpeedCoil.VSCoilType == HVAC::CoilDX_HeatPumpWaterHeaterVariableSpeed) {
5506 0 : SHR = varSpeedCoil.MSRatedSHR(NormSpeed);
5507 0 : RatedCapCoolSensDes = varSpeedCoil.RatedCapCoolTotal * SHR;
5508 : } else {
5509 5 : RatedCapCoolSensDes = 0.0;
5510 : }
5511 :
5512 18 : if (RatedCapCoolSensDes < HVAC::SmallLoad) {
5513 6 : RatedCapCoolSensDes = 0.0;
5514 : }
5515 :
5516 18 : if (varSpeedCoil.VSCoilType == HVAC::Coil_CoolingWaterToAirHPVSEquationFit ||
5517 16 : varSpeedCoil.VSCoilType == HVAC::Coil_CoolingAirToAirVariableSpeed) { // always report for cooling mode
5518 13 : if (RatedCapCoolTotalAutoSized) {
5519 6 : varSpeedCoil.RatedCapCoolSens = RatedCapCoolSensDes;
5520 18 : BaseSizer::reportSizerOutput(state,
5521 12 : format("COIL:{}{}", varSpeedCoil.CoolHeatType, CurrentObjSubfix),
5522 : varSpeedCoil.Name,
5523 : "Design Size Rated Sensible Cooling Capacity [W]",
5524 : varSpeedCoil.RatedCapCoolSens);
5525 :
5526 : } else {
5527 : // sensible capacity does not have an input field
5528 7 : if (RatedCapCoolSensDes > 0.0) {
5529 6 : varSpeedCoil.RatedCapCoolSens = RatedCapCoolSensDes;
5530 18 : BaseSizer::reportSizerOutput(state,
5531 12 : format("COIL:{}{}", varSpeedCoil.CoolHeatType, CurrentObjSubfix),
5532 : varSpeedCoil.Name,
5533 : "Design Size Rated Sensible Cooling Capacity [W]",
5534 : RatedCapCoolSensDes); //, &
5535 : }
5536 : }
5537 26 : OutputReportPredefined::PreDefTableEntry(
5538 13 : state, state.dataOutRptPredefined->pdchCoolCoilTotCap, varSpeedCoil.Name, varSpeedCoil.RatedCapCoolTotal);
5539 26 : OutputReportPredefined::PreDefTableEntry(
5540 13 : state, state.dataOutRptPredefined->pdchCoolCoilSensCap, varSpeedCoil.Name, varSpeedCoil.RatedCapCoolSens);
5541 26 : OutputReportPredefined::PreDefTableEntry(state,
5542 13 : state.dataOutRptPredefined->pdchCoolCoilLatCap,
5543 : varSpeedCoil.Name,
5544 13 : varSpeedCoil.RatedCapCoolTotal - varSpeedCoil.RatedCapCoolSens);
5545 13 : if (varSpeedCoil.RatedCapCoolTotal != 0.0) {
5546 24 : OutputReportPredefined::PreDefTableEntry(state,
5547 12 : state.dataOutRptPredefined->pdchCoolCoilSHR,
5548 : varSpeedCoil.Name,
5549 12 : varSpeedCoil.RatedCapCoolSens / varSpeedCoil.RatedCapCoolTotal);
5550 : } else {
5551 1 : OutputReportPredefined::PreDefTableEntry(state, state.dataOutRptPredefined->pdchCoolCoilSHR, varSpeedCoil.Name, 0.0);
5552 : }
5553 26 : OutputReportPredefined::PreDefTableEntry(
5554 13 : state, state.dataOutRptPredefined->pdchCoolCoilNomEff, varSpeedCoil.Name, varSpeedCoil.MSRatedCOP(varSpeedCoil.NormSpedLevel));
5555 26 : OutputReportPredefined::addFootNoteSubTable(
5556 : state,
5557 13 : state.dataOutRptPredefined->pdstCoolCoil,
5558 : "Nominal values are gross at rated conditions, i.e., the supply air fan heat and electric power NOT accounted for.");
5559 : }
5560 :
5561 : // START SIZING EVAP PRECOOLING PUMP POWER
5562 18 : IsAutoSize = false;
5563 18 : if (varSpeedCoil.VSCoilType == HVAC::Coil_CoolingAirToAirVariableSpeed) {
5564 11 : if (varSpeedCoil.EvapCondPumpElecNomPower == DataSizing::AutoSize) {
5565 0 : IsAutoSize = true;
5566 : }
5567 : // Auto size high speed evap condenser pump power to Total Capacity * 0.004266 w/w (15 w/ton)
5568 11 : EvapCondPumpElecNomPowerDes = varSpeedCoil.RatedCapCoolTotal * 0.004266;
5569 11 : if (IsAutoSize) {
5570 0 : varSpeedCoil.EvapCondPumpElecNomPower = EvapCondPumpElecNomPowerDes;
5571 0 : BaseSizer::reportSizerOutput(state,
5572 : "AS VS COOLING COIL",
5573 : varSpeedCoil.Name,
5574 : "Design Size Evaporative Condenser Pump Rated Power Consumption [W]",
5575 : EvapCondPumpElecNomPowerDes);
5576 : } else {
5577 11 : if (varSpeedCoil.EvapCondPumpElecNomPower > 0.0 && EvapCondPumpElecNomPowerDes > 0.0) {
5578 0 : EvapCondPumpElecNomPowerUser = varSpeedCoil.EvapCondPumpElecNomPower;
5579 0 : BaseSizer::reportSizerOutput(state,
5580 : "AS VS COOLING COIL",
5581 : varSpeedCoil.Name,
5582 : "Design Size Evaporative Condenser Pump Rated Power Consumption [W]",
5583 : EvapCondPumpElecNomPowerDes,
5584 : "User-Specified Evaporative Condenser Pump Rated Power Consumption [W]",
5585 : EvapCondPumpElecNomPowerUser);
5586 0 : if (state.dataGlobal->DisplayExtraWarnings) {
5587 0 : if ((std::abs(EvapCondPumpElecNomPowerDes - EvapCondPumpElecNomPowerUser) / EvapCondPumpElecNomPowerUser) >
5588 0 : state.dataSize->AutoVsHardSizingThreshold) {
5589 0 : ShowMessage(state,
5590 0 : format("SizeVarSpeedCoil: Potential issue with equipment sizing for {} {}",
5591 0 : varSpeedCoil.CoolHeatType,
5592 : CurrentObjSubfix));
5593 0 : ShowContinueError(state, format("Coil Name = {}", varSpeedCoil.Name));
5594 0 : ShowContinueError(state,
5595 0 : format("User-Specified Evaporative Condenser Pump Rated Power Consumption of {:.2R} [W]",
5596 : EvapCondPumpElecNomPowerUser));
5597 0 : ShowContinueError(state,
5598 0 : format("differs from Design Size Evaporative Condenser Pump Rated Power Consumption of {:.2R} [W]",
5599 : EvapCondPumpElecNomPowerDes));
5600 0 : ShowContinueError(state, "This may, or may not, indicate mismatched component sizes.");
5601 0 : ShowContinueError(state, "Verify that the value entered is intended and is consistent with other components.");
5602 : }
5603 : }
5604 : }
5605 : }
5606 : }
5607 : // END SIZING EVAP PRE-COOLING PUMP POWER
5608 :
5609 : // SIZE DEFROST HEATER
5610 :
5611 : // Resistive Defrost Heater Capacity = capacity at the first stage
5612 18 : IsAutoSize = false;
5613 18 : if (varSpeedCoil.VSCoilType == HVAC::Coil_HeatingAirToAirVariableSpeed) {
5614 4 : if (varSpeedCoil.DefrostCapacity == DataSizing::AutoSize) {
5615 0 : IsAutoSize = true;
5616 : }
5617 4 : if (varSpeedCoil.DefrostStrategy == Resistive) {
5618 4 : DefrostCapacityDes = varSpeedCoil.RatedCapHeat;
5619 : } else {
5620 0 : DefrostCapacityDes = 0.0;
5621 : }
5622 4 : if (IsAutoSize) {
5623 0 : varSpeedCoil.DefrostCapacity = DefrostCapacityDes;
5624 0 : BaseSizer::reportSizerOutput(
5625 : state, "AS VS HEATING COIL", varSpeedCoil.Name, "Design Size Resistive Defrost Heater Capacity [W]", DefrostCapacityDes);
5626 : } else {
5627 4 : if (varSpeedCoil.DefrostCapacity > 0.0 && DefrostCapacityDes > 0.0 && !HardSizeNoDesRun) {
5628 1 : DefrostCapacityUser = varSpeedCoil.DefrostCapacity;
5629 1 : BaseSizer::reportSizerOutput(state,
5630 : "AS VS HEATING COIL",
5631 : varSpeedCoil.Name,
5632 : "Design Size Resistive Defrost Heater Capacity [W]",
5633 : DefrostCapacityDes,
5634 : "User-Specified Resistive Defrost Heater Capacity [W]",
5635 : DefrostCapacityUser);
5636 1 : if (state.dataGlobal->DisplayExtraWarnings) {
5637 0 : if ((std::abs(DefrostCapacityDes - DefrostCapacityUser) / DefrostCapacityUser) > state.dataSize->AutoVsHardSizingThreshold) {
5638 0 : ShowMessage(state,
5639 0 : format("SizeVarSpeedCoil: Potential issue with equipment sizing for {} {}",
5640 0 : varSpeedCoil.CoolHeatType,
5641 : CurrentObjSubfix));
5642 0 : ShowContinueError(state, format("Coil Name = {}", varSpeedCoil.Name));
5643 0 : ShowContinueError(state, format("User-Specified Resistive Defrost Heater Capacity of {:.2R} [W]", DefrostCapacityUser));
5644 0 : ShowContinueError(state,
5645 0 : format("differs from Design Size Resistive Defrost Heater Capacity of {:.2R} [W]", DefrostCapacityDes));
5646 0 : ShowContinueError(state, "This may, or may not, indicate mismatched component sizes.");
5647 0 : ShowContinueError(state, "Verify that the value entered is intended and is consistent with other components.");
5648 : }
5649 : }
5650 : }
5651 : }
5652 : }
5653 : // END SIZING DEFROST HEATER
5654 :
5655 : // test autosized sensible and total cooling capacity for total > sensible
5656 18 : if (RatedCapCoolSensAutoSized && RatedCapCoolTotalAutoSized) {
5657 6 : if (varSpeedCoil.RatedCapCoolSens > varSpeedCoil.RatedCapCoolTotal) {
5658 0 : ShowWarningError(state,
5659 0 : format("COIL:{}:WATERTOAIRHEATPUMP:VARIABLESPEEDEQUATIONFIT \"{}\"", varSpeedCoil.CoolHeatType, varSpeedCoil.Name));
5660 0 : ShowContinueError(state, format("{}: Rated Sensible Cooling Capacity > Rated Total Cooling Capacity", RoutineName));
5661 0 : ShowContinueError(state, "Each of these capacity inputs have been autosized.");
5662 0 : ShowContinueError(state, format("Rated Sensible Cooling Capacity = {:.2T} W", varSpeedCoil.RatedCapCoolSens));
5663 0 : ShowContinueError(state, format("Rated Total Cooling Capacity = {:.2T} W", varSpeedCoil.RatedCapCoolTotal));
5664 0 : ShowContinueError(state, "See eio file for further details.");
5665 0 : ShowContinueError(state, "Check Total and Sensible Cooling Capacity Coefficients to ensure they are accurate.");
5666 0 : ShowContinueError(state, "Check Zone and System Sizing objects to verify sizing inputs.");
5667 0 : ShowContinueError(state, "Sizing statistics:");
5668 0 : ShowContinueError(state, format("Entering Air Dry-Bulb Temperature = {:.3T} C", MixTemp));
5669 0 : ShowContinueError(state, format("Entering Air Wet-Bulb Temperature = {:.3T} C", MixWetBulb));
5670 0 : ShowContinueError(state, "Entering Condenser Water Temperature used = 24.4444 C");
5671 0 : ShowContinueError(state, "Used design air and water flow rates (i.e., used 1 for ratioVL and ratioVS)");
5672 0 : ShowContinueError(state, format("ratioTDB = {:.3T}", ((MixTemp + 283.15) / 273.15)));
5673 0 : ShowContinueError(state, format("ratioTWB = {:.3T}", ((MixWetBulb + 283.15) / 273.15)));
5674 0 : ShowContinueError(state, format("ratioTS = {:.3T}", ((85.0 + 283.15) / 273.15)));
5675 0 : ShowContinueError(state, "Rated Sensible Cooling Capacity = Rated Total Cooling Capacity * Sensible Heat Ratio");
5676 0 : ShowContinueError(state, format("Total Cooling Capacity Modifier = {:.5T}", TotCapTempModFac));
5677 0 : ShowContinueError(state, "...Rated Total Cooling Capacity = Total Design Load / Total Cooling Capacity Modifier");
5678 0 : ShowContinueError(state, "Carefully review the Load Side Total, Sensible, and Latent heat transfer rates");
5679 0 : ShowContinueError(state, "... to ensure they meet the expected manufacturers performance specifications.");
5680 : }
5681 12 : } else if (RatedCapCoolTotalAutoSized) {
5682 0 : if (varSpeedCoil.RatedCapCoolSens > varSpeedCoil.RatedCapCoolTotal) {
5683 0 : ShowWarningError(state,
5684 0 : format("COIL:{}:WATERTOAIRHEATPUMP:VARIABLESPEEDEQUATIONFIT \"{}\"", varSpeedCoil.CoolHeatType, varSpeedCoil.Name));
5685 0 : ShowContinueError(state, format("{}: Rated Sensible Cooling Capacity > Rated Total Cooling Capacity", RoutineName));
5686 0 : ShowContinueError(state, "Only the rated total capacity input is autosized, consider autosizing both inputs.");
5687 0 : ShowContinueError(state, format("Rated Sensible Cooling Capacity = {:.2T} W", varSpeedCoil.RatedCapCoolSens));
5688 0 : ShowContinueError(state, format("Rated Total Cooling Capacity = {:.2T} W", varSpeedCoil.RatedCapCoolTotal));
5689 0 : ShowContinueError(state, "See eio file for further details.");
5690 0 : ShowContinueError(state, "Check Total and Sensible Cooling Capacity Coefficients to ensure they are accurate.");
5691 0 : ShowContinueError(state, "Check Zone and System Sizing objects to verify sizing inputs.");
5692 0 : ShowContinueError(state, "Sizing statistics for Total Cooling Capacity:");
5693 0 : ShowContinueError(state, format("Entering Air Wet-Bulb Temperature = {:.3T} C", MixWetBulb));
5694 0 : ShowContinueError(state, "Entering Condenser Water Temperature used = 24.4444 C");
5695 0 : ShowContinueError(state, "Used design air and water flow rates (i.e., used 1 for ratioVL and ratioVS)");
5696 0 : ShowContinueError(state, format("ratioTWB = {:.3T}", ((MixWetBulb + 283.15) / 273.15)));
5697 0 : ShowContinueError(state, format("ratioTS = {:.3T}", ((85.0 + 283.15) / 273.15)));
5698 0 : ShowContinueError(state, "Rated Sensible Cooling Capacity = Rated Total Cooling Capacity * Sensible Heat Ratio");
5699 0 : ShowContinueError(state, "Carefully review the Load Side Total, Sensible, and Latent heat transfer rates");
5700 0 : ShowContinueError(state, "... to ensure they meet the expected manufacturers performance specifications.");
5701 : }
5702 : }
5703 :
5704 36 : Array1D<DataHeatBalance::RefrigCondenserType> CondenserType;
5705 : StandardRatings::HPdefrostControl DefrostControl;
5706 18 : switch (varSpeedCoil.VSCoilType) {
5707 11 : case HVAC::Coil_CoolingAirToAirVariableSpeed:
5708 11 : CondenserType.push_back(varSpeedCoil.CondenserType);
5709 11 : switch (varSpeedCoil.DefrostControl) // defrost control; 1=timed, 2=on-demand
5710 : {
5711 0 : case 2:
5712 0 : DefrostControl = StandardRatings::HPdefrostControl::OnDemand;
5713 0 : break;
5714 11 : case 1:
5715 : default:
5716 11 : DefrostControl = StandardRatings::HPdefrostControl::Timed;
5717 11 : break;
5718 : }
5719 11 : if (varSpeedCoil.RatedCapCoolTotal > 0.0) {
5720 60 : StandardRatings::CalcDXCoilStandardRating(state,
5721 10 : varSpeedCoil.Name,
5722 10 : varSpeedCoil.VarSpeedCoilType,
5723 : varSpeedCoil.VSCoilType,
5724 : varSpeedCoil.NumOfSpeeds,
5725 : varSpeedCoil.MSRatedTotCap,
5726 : varSpeedCoil.MSRatedCOP,
5727 : varSpeedCoil.MSCCapAirFFlow,
5728 : varSpeedCoil.MSCCapFTemp,
5729 : varSpeedCoil.MSEIRAirFFlow,
5730 : varSpeedCoil.MSEIRFTemp,
5731 10 : varSpeedCoil.PLFFPLR,
5732 : varSpeedCoil.MSRatedAirVolFlowRate,
5733 : varSpeedCoil.MSRatedEvaporatorFanPowerPerVolumeFlowRate2017,
5734 : varSpeedCoil.MSRatedEvaporatorFanPowerPerVolumeFlowRate2023,
5735 : CondenserType,
5736 20 : 0, // varSpeedCoil.RegionNum, // ??
5737 10 : varSpeedCoil.MinOATCompressor,
5738 10 : varSpeedCoil.OATempCompressorOn,
5739 20 : false, // varSpeedCoil.OATempCompressorOnOffBlank, // ??
5740 : DefrostControl,
5741 20 : ObjexxFCL::Optional_bool_const(),
5742 10 : varSpeedCoil.RatedCapCoolTotal,
5743 10 : varSpeedCoil.RatedAirVolFlowRate);
5744 : }
5745 11 : break;
5746 7 : default:
5747 7 : break;
5748 : }
5749 18 : }
5750 :
5751 34029 : void CalcVarSpeedCoilCooling(EnergyPlusData &state,
5752 : int const DXCoilNum, // Heat Pump Number
5753 : HVAC::FanOp const fanOp, // Fan/Compressor cycling scheme indicator
5754 : [[maybe_unused]] Real64 const SensDemand, // Cooling Sensible Demand [W] !unused1208
5755 : [[maybe_unused]] Real64 const LatentDemand, // Cooling Latent Demand [W]
5756 : HVAC::CompressorOp const compressorOp, // compressor operation flag
5757 : Real64 const PartLoadRatio, // compressor part load ratio
5758 : [[maybe_unused]] Real64 const OnOffAirFlowRatio, // ratio of compressor on flow to average flow over time step
5759 : Real64 const SpeedRatio, // SpeedRatio varies between 1.0 (higher speed) and 0.0 (lower speed)
5760 : int const SpeedNum // Speed number, high bound
5761 : )
5762 : {
5763 :
5764 : // AUTHOR Bo Shen, based on WaterToAirHeatPumpSimple:CalcHPCoolingSimple
5765 : // DATE WRITTEN March 2012
5766 :
5767 : // PURPOSE OF THIS SUBROUTINE:
5768 : // This subroutine is for simulating the cooling mode of the Variable-Speed Water to Air HP Simple
5769 :
5770 : // METHODOLOGY EMPLOYED:
5771 : // Simulate the heat pump performance using the coefficients and rated conditions, interpolating between speed levels
5772 : // If the LatDegradModelSimFlag is enabled, the coil will be simulated twice:
5773 : // (1)first simulation at the rated conditions (2) second simulation at the
5774 : // actual operating conditions. Then call CalcEffectiveSHR and the effective SHR
5775 : // is adjusted.
5776 : // If the LatDegradModelSimFlag is disabled, the cooling coil is only simulated
5777 : // once at the actual operating conditions.
5778 : // Finally, adjust the heat pump outlet conditions based on the PartLoadRatio
5779 : // and RuntimeFrac.
5780 :
5781 : // SUBROUTINE PARAMETER DEFINITIONS:
5782 : static constexpr std::string_view RoutineName("CalcVarSpeedCoilCooling");
5783 : static constexpr std::string_view RoutineNameSourceSideInletTemp("CalcVarSpeedCoilCooling:SourceSideInletTemp");
5784 34029 : Real64 TimeStepSysSec = state.dataHVACGlobal->TimeStepSysSec;
5785 :
5786 : // SUBROUTINE LOCAL VARIABLE DECLARATIONS:
5787 : Real64 Twet_Rated; // Twet at rated conditions (coil air flow rate and air temperatures), sec
5788 : Real64 Gamma_Rated; // Gamma at rated conditions (coil air flow rate and air temperatures)
5789 :
5790 : Real64 SHRss; // Sensible heat ratio at steady state
5791 : Real64 SHReff; // Effective sensible heat ratio at part-load condition
5792 : Real64 CpSource; // Specific heat of water [J/kg_C]
5793 : Real64 CpAir; // Specific heat of air [J/kg_C]
5794 :
5795 : bool LatDegradModelSimFlag; // Latent degradation model simulation flag
5796 : int NumIteration; // Iteration Counter
5797 : Real64 LoadSideInletDBTemp_Unit; // calc conditions for unit
5798 : Real64 LoadSideInletWBTemp_Unit; // calc conditions for unit
5799 : Real64 LoadSideInletHumRat_Unit; // calc conditions for unit
5800 : Real64 LoadSideInletEnth_Unit; // calc conditions for unit
5801 : Real64 CpAir_Unit; // calc conditions for unit
5802 : Real64 AirMassFlowRatio; // airflow ratio at low speed
5803 : Real64 WaterMassFlowRatio; // airflow ratio at high speed
5804 : Real64 EIRAirFFModFac; // air flow fraction modification
5805 : Real64 EIRWaterFFModFac; // water flow fraction modification
5806 : Real64 EIRTempModFac; // total capacity temperature correctio fraction
5807 : Real64 CBFSpeed; // total capacity temperature correctio fraction
5808 : Real64 SHR; // total capacity temperature correctio fraction
5809 : Real64 EIR; // total capacity temperature correctio fraction
5810 : int MaxSpeed; // maximum speed level
5811 : int SpeedCal; // calculated speed level
5812 : Real64 AoEff; // effective air side surface area
5813 : Real64 QLoadTotal1; // total capacity at low speed
5814 : Real64 QLoadTotal2; // total capacity at high speed
5815 : Real64 Winput1; // power consumption at low speed
5816 : Real64 Winput2; // power consumption at high speed
5817 : Real64 QWasteHeat; // recoverable waste heat
5818 : Real64 QWasteHeat1; // recoverable waste heat at low speed
5819 : Real64 QWasteHeat2; // recoverable waste heat at high speed
5820 : Real64 PLF; // part-load function
5821 : Real64 MaxHumRat; // max possible humidity
5822 : Real64 MaxOutletEnth; // max possible outlet enthalpy
5823 :
5824 : // ADDED VARIABLES FOR air source coil
5825 : Real64 CondInletTemp; // Condenser inlet temperature (C). Outdoor dry-bulb temp for air-cooled condenser.
5826 : // Outdoor Wetbulb +(1 - effectiveness)*(outdoor drybulb - outdoor wetbulb) for evap condenser.
5827 : Real64 CondInletHumRat; // Condenser inlet humidity ratio (kg/kg). Zero for air-cooled condenser.
5828 : // For evap condenser, its the humidity ratio of the air leaving the evap cooling pads.
5829 : Real64 CondAirMassFlow; // Condenser air mass flow rate [kg/s]
5830 : Real64 RhoSourceAir; // Density of air [kg/m3]
5831 : Real64 RhoEvapCondWater; // Density of water used for evaporative condenser [kg/m3]
5832 : Real64 EvapCondEffectSped; // condenser evaporative effectiveness at the speed level
5833 : Real64 RhoWater; // condensed water density
5834 : Real64 SpecHumIn; // inlet air specific humidity
5835 : Real64 SpecHumOut; // outlet air specific humidity
5836 34029 : Real64 rhoair(0); // entering air density
5837 :
5838 34029 : if (state.dataVariableSpeedCoils->firstTime) {
5839 : // Set indoor air conditions to the rated condition
5840 16 : state.dataVariableSpeedCoils->LoadSideInletDBTemp_Init = 26.7;
5841 16 : state.dataVariableSpeedCoils->LoadSideInletHumRat_Init = 0.0111;
5842 16 : state.dataVariableSpeedCoils->LoadSideInletEnth_Init = Psychrometrics::PsyHFnTdbW(state.dataVariableSpeedCoils->LoadSideInletDBTemp_Init,
5843 16 : state.dataVariableSpeedCoils->LoadSideInletHumRat_Init);
5844 16 : state.dataVariableSpeedCoils->CpAir_Init = Psychrometrics::PsyCpAirFnW(state.dataVariableSpeedCoils->LoadSideInletHumRat_Init);
5845 16 : state.dataVariableSpeedCoils->firstTime = false;
5846 : }
5847 :
5848 68058 : state.dataVariableSpeedCoils->LoadSideInletWBTemp_Init =
5849 34029 : Psychrometrics::PsyTwbFnTdbWPb(state,
5850 34029 : state.dataVariableSpeedCoils->LoadSideInletDBTemp_Init,
5851 34029 : state.dataVariableSpeedCoils->LoadSideInletHumRat_Init,
5852 34029 : state.dataEnvrn->OutBaroPress,
5853 : RoutineName);
5854 :
5855 34029 : MaxSpeed = state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).NumOfSpeeds;
5856 :
5857 : // must be placed inside the loop, otherwise cause bug in release mode, need to be present at two places
5858 34029 : if (SpeedNum > MaxSpeed) {
5859 0 : SpeedCal = MaxSpeed;
5860 : } else {
5861 34029 : SpeedCal = SpeedNum;
5862 : }
5863 :
5864 : // LOAD LOCAL VARIABLES FROM DATA STRUCTURE (for code readability)
5865 34029 : if (!(fanOp == HVAC::FanOp::Continuous) && PartLoadRatio > 0.0) {
5866 10430 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).AirMassFlowRate =
5867 10430 : state.dataLoopNodes->Node(state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).AirInletNodeNum).MassFlowRate / PartLoadRatio;
5868 : }
5869 :
5870 34029 : Twet_Rated = state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Twet_Rated;
5871 34029 : Gamma_Rated = state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Gamma_Rated;
5872 :
5873 34029 : state.dataVariableSpeedCoils->LoadSideMassFlowRate = state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).AirMassFlowRate;
5874 :
5875 34029 : if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).VSCoilType == HVAC::Coil_CoolingAirToAirVariableSpeed) {
5876 : // Get condenser outdoor node info from DX COOLING Coil
5877 388 : if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).CondenserInletNodeNum != 0) {
5878 0 : state.dataVariableSpeedCoils->OutdoorDryBulb_CalcVarSpeedCoilCooling =
5879 0 : state.dataLoopNodes->Node(state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).CondenserInletNodeNum).Temp;
5880 0 : state.dataVariableSpeedCoils->OutdoorHumRat_CalcVarSpeedCoilCooling =
5881 0 : state.dataLoopNodes->Node(state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).CondenserInletNodeNum).HumRat;
5882 0 : state.dataVariableSpeedCoils->OutdoorPressure_CalcVarSpeedCoilCooling =
5883 0 : state.dataLoopNodes->Node(state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).CondenserInletNodeNum).Press;
5884 0 : state.dataVariableSpeedCoils->OutdoorWetBulb_CalcVarSpeedCoilCooling =
5885 0 : state.dataLoopNodes->Node(state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).CondenserInletNodeNum).OutAirWetBulb;
5886 : } else {
5887 388 : state.dataVariableSpeedCoils->OutdoorDryBulb_CalcVarSpeedCoilCooling = state.dataEnvrn->OutDryBulbTemp;
5888 388 : state.dataVariableSpeedCoils->OutdoorHumRat_CalcVarSpeedCoilCooling = state.dataEnvrn->OutHumRat;
5889 388 : state.dataVariableSpeedCoils->OutdoorPressure_CalcVarSpeedCoilCooling = state.dataEnvrn->OutBaroPress;
5890 388 : state.dataVariableSpeedCoils->OutdoorWetBulb_CalcVarSpeedCoilCooling = state.dataEnvrn->OutWetBulbTemp;
5891 : }
5892 :
5893 776 : RhoSourceAir = Psychrometrics::PsyRhoAirFnPbTdbW(state,
5894 388 : state.dataVariableSpeedCoils->OutdoorPressure_CalcVarSpeedCoilCooling,
5895 388 : state.dataVariableSpeedCoils->OutdoorDryBulb_CalcVarSpeedCoilCooling,
5896 388 : state.dataVariableSpeedCoils->OutdoorHumRat_CalcVarSpeedCoilCooling);
5897 :
5898 388 : if ((SpeedNum == 1) || (SpeedNum > MaxSpeed) || (SpeedRatio == 1.0)) {
5899 365 : CondAirMassFlow = RhoSourceAir * state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).EvapCondAirFlow(SpeedCal);
5900 : } else {
5901 23 : CondAirMassFlow =
5902 23 : RhoSourceAir * (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).EvapCondAirFlow(SpeedCal) * SpeedRatio +
5903 23 : (1.0 - SpeedRatio) * state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).EvapCondAirFlow(SpeedCal - 1));
5904 : }
5905 :
5906 : // AIR COOL OR EVAP COOLED CONDENSER
5907 388 : if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).CondenserType == DataHeatBalance::RefrigCondenserType::Evap) {
5908 0 : if ((SpeedNum == 1) || (SpeedNum > MaxSpeed) || (SpeedRatio == 1.0)) {
5909 0 : EvapCondEffectSped = state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).EvapCondEffect(SpeedCal);
5910 : } else {
5911 0 : EvapCondEffectSped = state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).EvapCondEffect(SpeedCal) * SpeedRatio +
5912 0 : (1.0 - SpeedRatio) * state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).EvapCondEffect(SpeedCal - 1);
5913 : }
5914 : // (Outdoor wet-bulb temp from DataEnvironment) + (1.0-EvapCondEffectiveness) * (drybulb - wetbulb)
5915 0 : CondInletTemp = state.dataVariableSpeedCoils->OutdoorWetBulb_CalcVarSpeedCoilCooling +
5916 0 : (state.dataVariableSpeedCoils->OutdoorDryBulb_CalcVarSpeedCoilCooling -
5917 0 : state.dataVariableSpeedCoils->OutdoorWetBulb_CalcVarSpeedCoilCooling) *
5918 0 : (1.0 - EvapCondEffectSped);
5919 0 : CondInletHumRat = Psychrometrics::PsyWFnTdbTwbPb(state,
5920 : CondInletTemp,
5921 0 : state.dataVariableSpeedCoils->OutdoorWetBulb_CalcVarSpeedCoilCooling,
5922 0 : state.dataVariableSpeedCoils->OutdoorPressure_CalcVarSpeedCoilCooling);
5923 0 : state.dataVariableSpeedCoils->CompAmbTemp_CalcVarSpeedCoilCooling = CondInletTemp;
5924 : } else { // AIR COOLED CONDENSER
5925 388 : CondInletTemp = state.dataVariableSpeedCoils->OutdoorDryBulb_CalcVarSpeedCoilCooling; // Outdoor dry-bulb temp
5926 776 : state.dataVariableSpeedCoils->CompAmbTemp_CalcVarSpeedCoilCooling =
5927 388 : state.dataVariableSpeedCoils->OutdoorDryBulb_CalcVarSpeedCoilCooling;
5928 388 : CondInletHumRat = state.dataEnvrn->OutHumRat;
5929 : }
5930 :
5931 388 : state.dataVariableSpeedCoils->SourceSideMassFlowRate = CondAirMassFlow;
5932 388 : state.dataVariableSpeedCoils->SourceSideInletTemp = CondInletTemp;
5933 388 : state.dataVariableSpeedCoils->SourceSideInletEnth = Psychrometrics::PsyHFnTdbW(CondInletTemp, CondInletHumRat);
5934 388 : CpSource = Psychrometrics::PsyCpAirFnW(CondInletHumRat);
5935 388 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).CondInletTemp = CondInletTemp;
5936 :
5937 : // If used in a heat pump, the value of MaxOAT in the heating coil overrides that in the cooling coil (in GetInput)
5938 : // Initialize crankcase heater, operates below OAT defined in input deck for HP DX heating coil
5939 388 : if (state.dataVariableSpeedCoils->OutdoorDryBulb_CalcVarSpeedCoilCooling <
5940 388 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MaxOATCrankcaseHeater) {
5941 44 : state.dataVariableSpeedCoils->CrankcaseHeatingPower_CalcVarSpeedCoilCooling =
5942 22 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).CrankcaseHeaterCapacity;
5943 22 : if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).CrankcaseHeaterCapacityCurveIndex > 0) {
5944 1 : state.dataVariableSpeedCoils->CrankcaseHeatingPower_CalcVarSpeedCoilCooling *=
5945 1 : Curve::CurveValue(state,
5946 1 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).CrankcaseHeaterCapacityCurveIndex,
5947 1 : state.dataEnvrn->OutDryBulbTemp);
5948 : }
5949 : } else {
5950 366 : state.dataVariableSpeedCoils->CrankcaseHeatingPower_CalcVarSpeedCoilCooling = 0.0;
5951 : }
5952 : } else {
5953 33641 : state.dataVariableSpeedCoils->SourceSideMassFlowRate = state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).WaterMassFlowRate;
5954 33641 : state.dataVariableSpeedCoils->SourceSideInletTemp = state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).InletWaterTemp;
5955 33641 : state.dataVariableSpeedCoils->SourceSideInletEnth = state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).InletWaterEnthalpy;
5956 33641 : CpSource = state.dataPlnt->PlantLoop(state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).plantLoc.loopNum)
5957 33641 : .glycol->getSpecificHeat(state, state.dataVariableSpeedCoils->SourceSideInletTemp, RoutineNameSourceSideInletTemp);
5958 : }
5959 :
5960 : // Check for flows, do not perform simulation if no flow in load side or source side.
5961 34029 : if (state.dataVariableSpeedCoils->SourceSideMassFlowRate <= 0.0 || state.dataVariableSpeedCoils->LoadSideMassFlowRate <= 0.0) {
5962 :
5963 23557 : if ((state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).VSCoilType == HVAC::Coil_CoolingAirToAirVariableSpeed) &&
5964 23702 : (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).CondenserType == DataHeatBalance::RefrigCondenserType::Air) &&
5965 145 : (state.dataVariableSpeedCoils->LoadSideMassFlowRate > 0.0)) {
5966 : // ALLOW SIMULATION IF AIR-COOLED CONDENSER COIL
5967 57 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).SimFlag = true;
5968 : } else {
5969 23500 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).SimFlag = false;
5970 23516 : return;
5971 : }
5972 : } else {
5973 10472 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).SimFlag = true;
5974 : }
5975 :
5976 10529 : if (compressorOp == HVAC::CompressorOp::Off || state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).RatedCapCoolTotal <= 0.0) {
5977 16 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).SimFlag = false;
5978 16 : return;
5979 : }
5980 :
5981 10797 : if ((state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).VSCoilType == HVAC::Coil_CoolingAirToAirVariableSpeed) &&
5982 284 : (CondInletTemp < state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MinOATCompressor)) {
5983 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).SimFlag = false;
5984 0 : return;
5985 : }
5986 :
5987 : // Loop the calculation at least once depending whether the latent degradation model
5988 : // is enabled. 1st iteration to calculate the QLatent(rated) at (TDB,TWB)indoorair=(26.7C,19.4C)
5989 : // and 2nd iteration to calculate the QLatent(actual)
5990 10513 : if ((PartLoadRatio < 1e-10) || (Twet_Rated <= 0.0) || (Gamma_Rated <= 0.0) || (SpeedNum > 1.0)) {
5991 10502 : LatDegradModelSimFlag = false;
5992 : // Set NumIteration=1 so that latent model would quit after 1 simulation with the actual condition
5993 10502 : NumIteration = 1;
5994 : } else {
5995 11 : LatDegradModelSimFlag = true;
5996 : // Set NumIteration=0 so that latent model would simulate twice with rated and actual condition
5997 11 : NumIteration = 0;
5998 : }
5999 :
6000 : // Set indoor air conditions to the actual condition
6001 10513 : LoadSideInletDBTemp_Unit = state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).InletAirDBTemp;
6002 10513 : LoadSideInletHumRat_Unit = state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).InletAirHumRat;
6003 : LoadSideInletWBTemp_Unit =
6004 10513 : Psychrometrics::PsyTwbFnTdbWPb(state, LoadSideInletDBTemp_Unit, LoadSideInletHumRat_Unit, state.dataEnvrn->OutBaroPress, RoutineName);
6005 10513 : LoadSideInletEnth_Unit = state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).InletAirEnthalpy;
6006 10513 : CpAir_Unit = Psychrometrics::PsyCpAirFnW(LoadSideInletHumRat_Unit);
6007 :
6008 10513 : state.dataHVACGlobal->OnOffFanPartLoadFraction = 1.0;
6009 10513 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).RunFrac = 1.0;
6010 10513 : if ((SpeedNum == 1) && (PartLoadRatio < 1.0)) {
6011 671 : PLF = Curve::CurveValue(state, state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).PLFFPLR, PartLoadRatio);
6012 671 : if (PLF < 0.7) {
6013 0 : PLF = 0.7;
6014 : }
6015 671 : if (fanOp == HVAC::FanOp::Cycling)
6016 650 : state.dataHVACGlobal->OnOffFanPartLoadFraction =
6017 : PLF; // save PLF for fan model, don't change fan power for constant fan mode if coil is off
6018 : // calculate the run time fraction
6019 671 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).RunFrac = PartLoadRatio / PLF;
6020 671 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).PartLoadRatio = PartLoadRatio;
6021 :
6022 671 : if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).RunFrac > 1.0) {
6023 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).RunFrac = 1.0; // Reset coil runtime fraction to 1.0
6024 671 : } else if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).RunFrac < 0.0) {
6025 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).RunFrac = 0.0;
6026 : }
6027 : }
6028 :
6029 : while (true) {
6030 10524 : ++NumIteration;
6031 10524 : if (NumIteration == 1) {
6032 : // Set indoor air conditions to the rated conditions
6033 11 : state.dataVariableSpeedCoils->LoadSideInletDBTemp = state.dataVariableSpeedCoils->LoadSideInletDBTemp_Init;
6034 11 : state.dataVariableSpeedCoils->LoadSideInletHumRat = state.dataVariableSpeedCoils->LoadSideInletHumRat_Init;
6035 11 : state.dataVariableSpeedCoils->LoadSideInletWBTemp = state.dataVariableSpeedCoils->LoadSideInletWBTemp_Init;
6036 11 : state.dataVariableSpeedCoils->LoadSideInletEnth = state.dataVariableSpeedCoils->LoadSideInletEnth_Init;
6037 11 : CpAir = state.dataVariableSpeedCoils->CpAir_Init;
6038 : } else {
6039 : // Set indoor air conditions to the actual condition
6040 10513 : state.dataVariableSpeedCoils->LoadSideInletDBTemp = LoadSideInletDBTemp_Unit;
6041 10513 : state.dataVariableSpeedCoils->LoadSideInletHumRat = LoadSideInletHumRat_Unit;
6042 10513 : state.dataVariableSpeedCoils->LoadSideInletWBTemp = LoadSideInletWBTemp_Unit;
6043 10513 : state.dataVariableSpeedCoils->LoadSideInletEnth = LoadSideInletEnth_Unit;
6044 10513 : CpAir = CpAir_Unit;
6045 : }
6046 :
6047 : // must be placed inside the loop, otherwise cause bug in release mode
6048 10524 : if (SpeedNum > MaxSpeed) {
6049 0 : SpeedCal = MaxSpeed;
6050 : } else {
6051 10524 : SpeedCal = SpeedNum;
6052 : }
6053 :
6054 10524 : if ((SpeedNum == 1) || (SpeedNum > MaxSpeed) || (SpeedRatio == 1.0)) {
6055 7158 : AirMassFlowRatio =
6056 7158 : state.dataVariableSpeedCoils->LoadSideMassFlowRate / state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).DesignAirMassFlowRate;
6057 :
6058 7158 : if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).VSCoilType == HVAC::Coil_CoolingAirToAirVariableSpeed) {
6059 272 : WaterMassFlowRatio = 1.0;
6060 : } else {
6061 6886 : WaterMassFlowRatio = state.dataVariableSpeedCoils->SourceSideMassFlowRate /
6062 6886 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).DesignWaterMassFlowRate;
6063 : }
6064 :
6065 7158 : CBFSpeed = DXCoils::AdjustCBF(state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedCBF(SpeedCal),
6066 7158 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedAirMassFlowRate(SpeedCal),
6067 7158 : state.dataVariableSpeedCoils->LoadSideMassFlowRate);
6068 :
6069 7158 : if (CBFSpeed > 0.999) CBFSpeed = 0.999;
6070 :
6071 7158 : CalcTotCapSHR_VSWSHP(state,
6072 7158 : state.dataVariableSpeedCoils->LoadSideInletDBTemp,
6073 7158 : state.dataVariableSpeedCoils->LoadSideInletHumRat,
6074 7158 : state.dataVariableSpeedCoils->LoadSideInletEnth,
6075 7158 : state.dataVariableSpeedCoils->LoadSideInletWBTemp,
6076 : AirMassFlowRatio,
6077 : WaterMassFlowRatio,
6078 7158 : state.dataVariableSpeedCoils->LoadSideMassFlowRate,
6079 : CBFSpeed,
6080 7158 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedTotCap(SpeedCal),
6081 7158 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSCCapFTemp(SpeedCal),
6082 7158 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSCCapAirFFlow(SpeedCal),
6083 7158 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSCCapWaterFFlow(SpeedCal),
6084 : 0.0,
6085 : 0,
6086 : 0,
6087 : 0,
6088 : QLoadTotal1,
6089 : QLoadTotal2,
6090 7158 : state.dataVariableSpeedCoils->QLoadTotal,
6091 : SHR,
6092 7158 : state.dataVariableSpeedCoils->SourceSideInletTemp,
6093 7158 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).InletAirPressure,
6094 : 0.0,
6095 : 1,
6096 7158 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).capModFacTotal);
6097 :
6098 28632 : EIRTempModFac = Curve::CurveValue(state,
6099 7158 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSEIRFTemp(SpeedCal),
6100 7158 : state.dataVariableSpeedCoils->LoadSideInletWBTemp,
6101 7158 : state.dataVariableSpeedCoils->SourceSideInletTemp);
6102 : EIRAirFFModFac =
6103 7158 : Curve::CurveValue(state, state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSEIRAirFFlow(SpeedCal), AirMassFlowRatio);
6104 :
6105 7158 : if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).VSCoilType == HVAC::Coil_CoolingAirToAirVariableSpeed) {
6106 272 : EIRWaterFFModFac = 1.0;
6107 : } else {
6108 : EIRWaterFFModFac =
6109 6886 : Curve::CurveValue(state, state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSEIRWaterFFlow(SpeedCal), WaterMassFlowRatio);
6110 : }
6111 :
6112 7158 : EIR = (1.0 / state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedCOP(SpeedCal)) * EIRTempModFac * EIRAirFFModFac *
6113 : EIRWaterFFModFac;
6114 :
6115 7158 : CBFSpeed = DXCoils::AdjustCBF(state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedCBF(SpeedCal),
6116 7158 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedAirMassFlowRate(SpeedCal),
6117 7158 : state.dataVariableSpeedCoils->LoadSideMassFlowRate);
6118 :
6119 7158 : if (CBFSpeed > 0.999) CBFSpeed = 0.999;
6120 :
6121 7158 : CalcTotCapSHR_VSWSHP(state,
6122 7158 : state.dataVariableSpeedCoils->LoadSideInletDBTemp,
6123 7158 : state.dataVariableSpeedCoils->LoadSideInletHumRat,
6124 7158 : state.dataVariableSpeedCoils->LoadSideInletEnth,
6125 7158 : state.dataVariableSpeedCoils->LoadSideInletWBTemp,
6126 : AirMassFlowRatio,
6127 : WaterMassFlowRatio,
6128 7158 : state.dataVariableSpeedCoils->LoadSideMassFlowRate,
6129 : CBFSpeed,
6130 7158 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedTotCap(SpeedCal),
6131 7158 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSCCapFTemp(SpeedCal),
6132 7158 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSCCapAirFFlow(SpeedCal),
6133 7158 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSCCapWaterFFlow(SpeedCal),
6134 : 0.0,
6135 : 0,
6136 : 0,
6137 : 0,
6138 : QLoadTotal1,
6139 : QLoadTotal2,
6140 7158 : state.dataVariableSpeedCoils->QLoadTotal,
6141 : SHR,
6142 7158 : state.dataVariableSpeedCoils->SourceSideInletTemp,
6143 7158 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).InletAirPressure,
6144 : 0.0,
6145 : 1,
6146 7158 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).capModFacTotal);
6147 :
6148 7158 : state.dataVariableSpeedCoils->Winput = state.dataVariableSpeedCoils->QLoadTotal * EIR;
6149 :
6150 14316 : if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).VSCoilType == HVAC::Coil_CoolingAirToAirVariableSpeed) {
6151 272 : QWasteHeat = 0.0;
6152 : } else {
6153 6886 : QWasteHeat =
6154 6886 : state.dataVariableSpeedCoils->Winput * state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSWasteHeatFrac(SpeedCal);
6155 6886 : QWasteHeat *= Curve::CurveValue(state,
6156 6886 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSWasteHeat(SpeedCal),
6157 6886 : state.dataVariableSpeedCoils->LoadSideInletWBTemp,
6158 6886 : state.dataVariableSpeedCoils->SourceSideInletTemp);
6159 : }
6160 : } else {
6161 3366 : AirMassFlowRatio =
6162 3366 : state.dataVariableSpeedCoils->LoadSideMassFlowRate / state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).DesignAirMassFlowRate;
6163 :
6164 3366 : if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).VSCoilType == HVAC::Coil_CoolingAirToAirVariableSpeed) {
6165 23 : WaterMassFlowRatio = 1.0;
6166 : } else {
6167 3343 : WaterMassFlowRatio = state.dataVariableSpeedCoils->SourceSideMassFlowRate /
6168 3343 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).DesignWaterMassFlowRate;
6169 : }
6170 :
6171 3366 : AoEff = state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSEffectiveAo(SpeedCal) * SpeedRatio +
6172 3366 : (1.0 - SpeedRatio) * state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSEffectiveAo(SpeedCal - 1);
6173 :
6174 3366 : CBFSpeed = std::exp(-AoEff / state.dataVariableSpeedCoils->LoadSideMassFlowRate);
6175 :
6176 3366 : if (CBFSpeed > 0.999) CBFSpeed = 0.999;
6177 :
6178 3366 : CalcTotCapSHR_VSWSHP(state,
6179 3366 : state.dataVariableSpeedCoils->LoadSideInletDBTemp,
6180 3366 : state.dataVariableSpeedCoils->LoadSideInletHumRat,
6181 3366 : state.dataVariableSpeedCoils->LoadSideInletEnth,
6182 3366 : state.dataVariableSpeedCoils->LoadSideInletWBTemp,
6183 : AirMassFlowRatio,
6184 : WaterMassFlowRatio,
6185 3366 : state.dataVariableSpeedCoils->LoadSideMassFlowRate,
6186 : CBFSpeed,
6187 3366 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedTotCap(SpeedCal - 1),
6188 3366 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSCCapFTemp(SpeedCal - 1),
6189 3366 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSCCapAirFFlow(SpeedCal - 1),
6190 3366 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSCCapWaterFFlow(SpeedCal - 1),
6191 3366 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedTotCap(SpeedCal),
6192 3366 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSCCapFTemp(SpeedCal),
6193 3366 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSCCapAirFFlow(SpeedCal),
6194 3366 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSCCapWaterFFlow(SpeedCal),
6195 : QLoadTotal1,
6196 : QLoadTotal2,
6197 3366 : state.dataVariableSpeedCoils->QLoadTotal,
6198 : SHR,
6199 3366 : state.dataVariableSpeedCoils->SourceSideInletTemp,
6200 3366 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).InletAirPressure,
6201 : SpeedRatio,
6202 : 2,
6203 3366 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).capModFacTotal);
6204 :
6205 3366 : SpeedCal = SpeedNum - 1;
6206 13464 : EIRTempModFac = Curve::CurveValue(state,
6207 3366 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSEIRFTemp(SpeedCal),
6208 3366 : state.dataVariableSpeedCoils->LoadSideInletWBTemp,
6209 3366 : state.dataVariableSpeedCoils->SourceSideInletTemp);
6210 : EIRAirFFModFac =
6211 3366 : Curve::CurveValue(state, state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSEIRAirFFlow(SpeedCal), AirMassFlowRatio);
6212 :
6213 3366 : if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).VSCoilType == HVAC::Coil_CoolingAirToAirVariableSpeed) {
6214 23 : EIRWaterFFModFac = 1.0;
6215 : } else {
6216 : EIRWaterFFModFac =
6217 3343 : Curve::CurveValue(state, state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSEIRWaterFFlow(SpeedCal), WaterMassFlowRatio);
6218 : }
6219 :
6220 3366 : EIR = (1.0 / state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedCOP(SpeedCal)) * EIRTempModFac * EIRAirFFModFac *
6221 : EIRWaterFFModFac;
6222 3366 : Winput1 = QLoadTotal1 * EIR;
6223 :
6224 3366 : if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).VSCoilType == HVAC::Coil_CoolingAirToAirVariableSpeed) {
6225 23 : QWasteHeat1 = 0.0;
6226 : } else {
6227 3343 : QWasteHeat1 = Winput1 * state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSWasteHeatFrac(SpeedCal);
6228 3343 : QWasteHeat1 *= Curve::CurveValue(state,
6229 3343 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSWasteHeat(SpeedCal),
6230 3343 : state.dataVariableSpeedCoils->LoadSideInletWBTemp,
6231 3343 : state.dataVariableSpeedCoils->SourceSideInletTemp);
6232 : }
6233 :
6234 3366 : SpeedCal = SpeedNum;
6235 13464 : EIRTempModFac = Curve::CurveValue(state,
6236 3366 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSEIRFTemp(SpeedCal),
6237 3366 : state.dataVariableSpeedCoils->LoadSideInletWBTemp,
6238 3366 : state.dataVariableSpeedCoils->SourceSideInletTemp);
6239 : EIRAirFFModFac =
6240 3366 : Curve::CurveValue(state, state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSEIRAirFFlow(SpeedCal), AirMassFlowRatio);
6241 :
6242 3366 : if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).VSCoilType == HVAC::Coil_CoolingAirToAirVariableSpeed) {
6243 23 : EIRWaterFFModFac = 1.0;
6244 : } else {
6245 : EIRWaterFFModFac =
6246 3343 : Curve::CurveValue(state, state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSEIRWaterFFlow(SpeedCal), WaterMassFlowRatio);
6247 : }
6248 :
6249 3366 : EIR = (1.0 / state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedCOP(SpeedCal)) * EIRTempModFac * EIRAirFFModFac *
6250 : EIRWaterFFModFac;
6251 3366 : Winput2 = QLoadTotal2 * EIR;
6252 :
6253 3366 : if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).VSCoilType == HVAC::Coil_CoolingAirToAirVariableSpeed) {
6254 23 : QWasteHeat2 = 0.0;
6255 : } else {
6256 3343 : QWasteHeat2 = Winput2 * state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSWasteHeatFrac(SpeedCal);
6257 3343 : QWasteHeat2 *= Curve::CurveValue(state,
6258 3343 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSWasteHeat(SpeedCal),
6259 3343 : state.dataVariableSpeedCoils->LoadSideInletWBTemp,
6260 3343 : state.dataVariableSpeedCoils->SourceSideInletTemp);
6261 : }
6262 :
6263 3366 : state.dataVariableSpeedCoils->Winput = Winput2 * SpeedRatio + (1.0 - SpeedRatio) * Winput1;
6264 3366 : QWasteHeat = QWasteHeat2 * SpeedRatio + (1.0 - SpeedRatio) * QWasteHeat1;
6265 : }
6266 :
6267 10524 : state.dataVariableSpeedCoils->QSensible = state.dataVariableSpeedCoils->QLoadTotal * SHR;
6268 :
6269 10524 : state.dataVariableSpeedCoils->QSource = state.dataVariableSpeedCoils->QLoadTotal + state.dataVariableSpeedCoils->Winput - QWasteHeat;
6270 :
6271 10524 : if (state.dataVariableSpeedCoils->QSource < 0) {
6272 0 : state.dataVariableSpeedCoils->QSource = 0.0;
6273 0 : QWasteHeat = state.dataVariableSpeedCoils->QLoadTotal + state.dataVariableSpeedCoils->Winput;
6274 : }
6275 :
6276 : // Check if the Sensible Load is greater than the Total Cooling Load
6277 10524 : if (state.dataVariableSpeedCoils->QSensible > state.dataVariableSpeedCoils->QLoadTotal) {
6278 0 : state.dataVariableSpeedCoils->QSensible = state.dataVariableSpeedCoils->QLoadTotal;
6279 : }
6280 :
6281 10524 : if (LatDegradModelSimFlag) {
6282 : // Calculate for SHReff using the Latent Degradation Model
6283 22 : if (NumIteration == 1) {
6284 11 : state.dataVariableSpeedCoils->QLatRated = state.dataVariableSpeedCoils->QLoadTotal - state.dataVariableSpeedCoils->QSensible;
6285 11 : } else if (NumIteration == 2) {
6286 11 : state.dataVariableSpeedCoils->QLatActual = state.dataVariableSpeedCoils->QLoadTotal - state.dataVariableSpeedCoils->QSensible;
6287 11 : SHRss = state.dataVariableSpeedCoils->QSensible / state.dataVariableSpeedCoils->QLoadTotal;
6288 66 : SHReff = CalcEffectiveSHR(state,
6289 : DXCoilNum,
6290 : SHRss,
6291 : fanOp,
6292 11 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).RunFrac,
6293 11 : state.dataVariableSpeedCoils->QLatRated,
6294 11 : state.dataVariableSpeedCoils->QLatActual,
6295 11 : state.dataVariableSpeedCoils->LoadSideInletDBTemp,
6296 11 : state.dataVariableSpeedCoils->LoadSideInletWBTemp);
6297 : // Update sensible capacity based on effective SHR
6298 11 : state.dataVariableSpeedCoils->QSensible = state.dataVariableSpeedCoils->QLoadTotal * SHReff;
6299 11 : goto LOOP_exit;
6300 : }
6301 : } else {
6302 : // Assume SHReff=SHRss
6303 10502 : SHReff = state.dataVariableSpeedCoils->QSensible / state.dataVariableSpeedCoils->QLoadTotal;
6304 10502 : goto LOOP_exit;
6305 : }
6306 : }
6307 10513 : LOOP_exit:;
6308 :
6309 : // considering hot gas reheat here
6310 10513 : if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).HOTGASREHEATFLG > 0) {
6311 0 : state.dataVariableSpeedCoils->QLoadTotal -= QWasteHeat;
6312 0 : state.dataVariableSpeedCoils->QSensible -= QWasteHeat;
6313 0 : SHReff = state.dataVariableSpeedCoils->QSensible / state.dataVariableSpeedCoils->QLoadTotal;
6314 : }
6315 :
6316 10513 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).BasinHeaterPower = 0.0;
6317 10513 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).CrankcaseHeaterPower = 0.0;
6318 :
6319 10513 : if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).VSCoilType == HVAC::Coil_CoolingAirToAirVariableSpeed) {
6320 284 : if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).CondenserType == DataHeatBalance::RefrigCondenserType::Evap) {
6321 : //******************
6322 : // WATER CONSUMPTION IN m3 OF WATER FOR DIRECT
6323 : // H2O [m3/s] = Delta W[kgWater/kgDryAir]*Mass Flow Air[kgDryAir/s]
6324 : // /RhoWater [kgWater/m3]
6325 : //******************
6326 0 : RhoEvapCondWater = Psychrometrics::RhoH2O(state.dataVariableSpeedCoils->OutdoorDryBulb_CalcVarSpeedCoilCooling);
6327 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).EvapWaterConsumpRate =
6328 0 : (CondInletHumRat - state.dataVariableSpeedCoils->OutdoorHumRat_CalcVarSpeedCoilCooling) * CondAirMassFlow / RhoEvapCondWater *
6329 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).RunFrac;
6330 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).EvapCondPumpElecPower =
6331 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).EvapCondPumpElecNomPower *
6332 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).RunFrac;
6333 : // Calculate basin heater power
6334 0 : CalcBasinHeaterPower(state,
6335 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).BasinHeaterPowerFTempDiff,
6336 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).basinHeaterSched,
6337 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).BasinHeaterSetPointTemp,
6338 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).BasinHeaterPower);
6339 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).BasinHeaterPower *=
6340 0 : (1.0 - state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).RunFrac);
6341 : }
6342 :
6343 284 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).CrankcaseHeaterPower =
6344 284 : state.dataVariableSpeedCoils->CrankcaseHeatingPower_CalcVarSpeedCoilCooling *
6345 284 : (1.0 - state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).RunFrac);
6346 :
6347 : // set water system demand request (if needed)
6348 284 : if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).EvapWaterSupplyMode == WaterSupplyFromTank) {
6349 0 : state.dataWaterData->WaterStorage(state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).EvapWaterSupTankID)
6350 0 : .VdotRequestDemand(state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).EvapWaterTankDemandARRID) =
6351 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).EvapWaterConsumpRate;
6352 : }
6353 : }
6354 :
6355 10513 : if ((PartLoadRatio > 0.0 && fanOp == HVAC::FanOp::Continuous) || (fanOp == HVAC::FanOp::Cycling)) {
6356 : // calculate coil outlet state variables
6357 21022 : state.dataVariableSpeedCoils->LoadSideOutletEnth =
6358 10511 : state.dataVariableSpeedCoils->LoadSideInletEnth -
6359 10511 : state.dataVariableSpeedCoils->QLoadTotal / state.dataVariableSpeedCoils->LoadSideMassFlowRate;
6360 21022 : state.dataVariableSpeedCoils->LoadSideOutletDBTemp =
6361 10511 : state.dataVariableSpeedCoils->LoadSideInletDBTemp -
6362 10511 : state.dataVariableSpeedCoils->QSensible / (state.dataVariableSpeedCoils->LoadSideMassFlowRate * CpAir);
6363 :
6364 10511 : MaxHumRat = Psychrometrics::PsyWFnTdbRhPb(state,
6365 10511 : state.dataVariableSpeedCoils->LoadSideOutletDBTemp,
6366 : 0.9999,
6367 10511 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).InletAirPressure,
6368 : RoutineName);
6369 10511 : MaxOutletEnth = Psychrometrics::PsyHFnTdbW(state.dataVariableSpeedCoils->LoadSideOutletDBTemp, MaxHumRat);
6370 10511 : if (state.dataVariableSpeedCoils->LoadSideOutletEnth > MaxOutletEnth) {
6371 142 : state.dataVariableSpeedCoils->LoadSideOutletEnth = MaxOutletEnth;
6372 : // QLoadTotal = LoadSideMassFlowRate * (LoadSideInletEnth - LoadSideOutletEnth)
6373 : }
6374 10511 : state.dataVariableSpeedCoils->LoadSideOutletHumRat = Psychrometrics::PsyWFnTdbH(
6375 10511 : state, state.dataVariableSpeedCoils->LoadSideOutletDBTemp, state.dataVariableSpeedCoils->LoadSideOutletEnth, RoutineName);
6376 10511 : if (state.dataVariableSpeedCoils->LoadSideOutletHumRat > MaxHumRat) {
6377 16 : state.dataVariableSpeedCoils->LoadSideOutletHumRat = MaxHumRat;
6378 : }
6379 : }
6380 :
6381 : // Actual outlet conditions are "average" for time step
6382 10513 : if (fanOp == HVAC::FanOp::Continuous) {
6383 : // continuous fan, cycling compressor
6384 83 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).OutletAirEnthalpy =
6385 83 : PartLoadRatio * state.dataVariableSpeedCoils->LoadSideOutletEnth +
6386 83 : (1.0 - PartLoadRatio) * state.dataVariableSpeedCoils->LoadSideInletEnth;
6387 83 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).OutletAirHumRat =
6388 83 : PartLoadRatio * state.dataVariableSpeedCoils->LoadSideOutletHumRat +
6389 83 : (1.0 - PartLoadRatio) * state.dataVariableSpeedCoils->LoadSideInletHumRat;
6390 83 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).OutletAirDBTemp =
6391 83 : Psychrometrics::PsyTdbFnHW(state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).OutletAirEnthalpy,
6392 83 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).OutletAirHumRat);
6393 83 : state.dataVariableSpeedCoils->PLRCorrLoadSideMdot = state.dataVariableSpeedCoils->LoadSideMassFlowRate;
6394 : } else {
6395 : // default to cycling fan, cycling compressor
6396 10430 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).OutletAirEnthalpy = state.dataVariableSpeedCoils->LoadSideOutletEnth;
6397 10430 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).OutletAirHumRat = state.dataVariableSpeedCoils->LoadSideOutletHumRat;
6398 10430 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).OutletAirDBTemp = state.dataVariableSpeedCoils->LoadSideOutletDBTemp;
6399 10430 : state.dataVariableSpeedCoils->PLRCorrLoadSideMdot = state.dataVariableSpeedCoils->LoadSideMassFlowRate * PartLoadRatio;
6400 : }
6401 :
6402 : // scale heat transfer rates to PLR and power to RTF
6403 10513 : state.dataVariableSpeedCoils->QLoadTotal *= PartLoadRatio;
6404 10513 : state.dataVariableSpeedCoils->QSensible *= PartLoadRatio;
6405 : // count the powr separately
6406 10513 : state.dataVariableSpeedCoils->Winput *= state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).RunFrac;
6407 10513 : state.dataVariableSpeedCoils->QSource *= PartLoadRatio;
6408 10513 : QWasteHeat *= PartLoadRatio;
6409 :
6410 : // Update heat pump data structure
6411 10513 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Power = state.dataVariableSpeedCoils->Winput;
6412 10513 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).QLoadTotal = state.dataVariableSpeedCoils->QLoadTotal;
6413 10513 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).QSensible = state.dataVariableSpeedCoils->QSensible;
6414 10513 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).QLatent =
6415 10513 : state.dataVariableSpeedCoils->QLoadTotal - state.dataVariableSpeedCoils->QSensible;
6416 10513 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Energy = state.dataVariableSpeedCoils->Winput * TimeStepSysSec;
6417 10513 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).EnergyLoadTotal = state.dataVariableSpeedCoils->QLoadTotal * TimeStepSysSec;
6418 10513 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).EnergySensible = state.dataVariableSpeedCoils->QSensible * TimeStepSysSec;
6419 10513 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).EnergyLatent =
6420 10513 : (state.dataVariableSpeedCoils->QLoadTotal - state.dataVariableSpeedCoils->QSensible) * TimeStepSysSec;
6421 10513 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).CrankcaseHeaterConsumption =
6422 10513 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).CrankcaseHeaterPower * TimeStepSysSec;
6423 10513 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).EvapWaterConsump =
6424 10513 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).EvapWaterConsumpRate * TimeStepSysSec;
6425 10513 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).BasinHeaterConsumption =
6426 10513 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).BasinHeaterPower * TimeStepSysSec;
6427 10513 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).EvapCondPumpElecConsumption =
6428 10513 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).EvapCondPumpElecPower * TimeStepSysSec;
6429 10513 : if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).RunFrac == 0.0) {
6430 2 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).COP = 0.0;
6431 : } else {
6432 10511 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).COP =
6433 10511 : state.dataVariableSpeedCoils->QLoadTotal / state.dataVariableSpeedCoils->Winput;
6434 : }
6435 10513 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).PartLoadRatio = PartLoadRatio;
6436 10513 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).AirMassFlowRate = state.dataVariableSpeedCoils->PLRCorrLoadSideMdot;
6437 10513 : rhoair = Psychrometrics::PsyRhoAirFnPbTdbW(state,
6438 10513 : state.dataEnvrn->OutBaroPress,
6439 10513 : state.dataVariableSpeedCoils->LoadSideInletDBTemp,
6440 10513 : state.dataVariableSpeedCoils->LoadSideInletHumRat,
6441 : RoutineName);
6442 : // This seems wrong, initializing mass flow rate to StdRhoAir or actual air density,
6443 : // then using that mass flow rate, then back calculating volume using inlet conditions.
6444 : // Volume should be constant through a fan and air mass flow rate should vary based on inlet conditions.
6445 10513 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).AirVolFlowRate =
6446 10513 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).AirMassFlowRate / rhoair;
6447 :
6448 10513 : if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).VSCoilType == HVAC::Coil_CoolingAirToAirVariableSpeed) {
6449 284 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).WaterMassFlowRate = 0.0;
6450 284 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).OutletWaterTemp = 0.0;
6451 284 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).OutletWaterEnthalpy = 0.0;
6452 284 : state.dataHeatBal->HeatReclaimVS_Coil(DXCoilNum).AvailCapacity = state.dataVariableSpeedCoils->QSource;
6453 284 : if (state.dataHeatBal->HeatReclaimVS_Coil(DXCoilNum).WaterHeatingDesuperheaterReclaimedHeatTotal > 0.0)
6454 0 : state.dataVariableSpeedCoils->QSource -= state.dataHeatBal->HeatReclaimVS_Coil(DXCoilNum).WaterHeatingDesuperheaterReclaimedHeatTotal;
6455 : } else {
6456 10229 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).WaterMassFlowRate = state.dataVariableSpeedCoils->SourceSideMassFlowRate;
6457 10229 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).OutletWaterTemp =
6458 10229 : state.dataVariableSpeedCoils->SourceSideInletTemp +
6459 10229 : state.dataVariableSpeedCoils->QSource / (state.dataVariableSpeedCoils->SourceSideMassFlowRate * CpSource);
6460 10229 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).OutletWaterEnthalpy =
6461 10229 : state.dataVariableSpeedCoils->SourceSideInletEnth +
6462 10229 : state.dataVariableSpeedCoils->QSource / state.dataVariableSpeedCoils->SourceSideMassFlowRate;
6463 10229 : state.dataHeatBal->HeatReclaimVS_Coil(DXCoilNum).AvailCapacity = state.dataVariableSpeedCoils->QSource;
6464 10229 : if (state.dataHeatBal->HeatReclaimVS_Coil(DXCoilNum).WaterHeatingDesuperheaterReclaimedHeatTotal > 0.0)
6465 1 : state.dataVariableSpeedCoils->QSource -= state.dataHeatBal->HeatReclaimVS_Coil(DXCoilNum).WaterHeatingDesuperheaterReclaimedHeatTotal;
6466 : }
6467 10513 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).QSource = state.dataVariableSpeedCoils->QSource;
6468 10513 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).EnergySource = state.dataVariableSpeedCoils->QSource * TimeStepSysSec;
6469 :
6470 10513 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).QWasteHeat = QWasteHeat;
6471 :
6472 10513 : if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).CondensateCollectMode == CondensateToTank) {
6473 : // calculate and report condensation rates (how much water extracted from the air stream)
6474 : // water flow of water in m3/s for water system interactions
6475 0 : RhoWater = Psychrometrics::RhoH2O((state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).InletAirDBTemp +
6476 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).OutletAirDBTemp) /
6477 : 2.0);
6478 : // CR9155 Remove specific humidity calculations
6479 0 : SpecHumIn = state.dataVariableSpeedCoils->LoadSideInletHumRat;
6480 0 : SpecHumOut = state.dataVariableSpeedCoils->LoadSideOutletHumRat;
6481 : // mdot * del HumRat / rho water
6482 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).CondensateVdot =
6483 0 : max(0.0, (state.dataVariableSpeedCoils->LoadSideMassFlowRate * (SpecHumIn - SpecHumOut) / RhoWater));
6484 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).CondensateVol =
6485 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).CondensateVdot * TimeStepSysSec;
6486 : }
6487 : }
6488 :
6489 0 : void CalcVarSpeedHPWH(EnergyPlusData &state,
6490 : int const DXCoilNum, // the number of the DX coil to be simulated
6491 : Real64 const PartLoadRatio, // sensible water heating load / full load sensible water heating capacity
6492 : Real64 const SpeedRatio, // SpeedRatio varies between 1.0 (higher speed) and 0.0 (lower speed)
6493 : int const SpeedNum, // Speed number, high bound
6494 : HVAC::FanOp const fanOp // Continuous fan OR cycling compressor
6495 : )
6496 : {
6497 :
6498 : // SUBROUTINE INFORMATION:
6499 : // AUTHOR Bo Shen, ORNL
6500 : // DATE WRITTEN 12/2014
6501 :
6502 : // PURPOSE OF THIS SUBROUTINE:
6503 : // Calculates the gross cooling capacity of a variable-speed heat pump water heater evaporator and
6504 : // heating capacity of the condenser coil given the rated heating capacity and COP.
6505 :
6506 : // METHODOLOGY EMPLOYED:
6507 : // The routine requires the user to enter the total heating capacity and COP for the
6508 : // heat pump water heater along with logicals defining if fan and condenser pump are included at numerous speed levels.
6509 : // Since manufacturer's can rate their HPWH equipment with or without including condenser
6510 : // pump heat, this information is required to accurately determine the condenser's leaving
6511 : // water temperature. In addition, knowledge of the fan heat is required to back into
6512 : // a compressor COP.
6513 :
6514 : // SUBROUTINE PARAMETER DEFINITIONS:
6515 : static constexpr std::string_view RoutineName("CalcVarSpeedHPWH");
6516 0 : Real64 TimeStepSysSec = state.dataHVACGlobal->TimeStepSysSec;
6517 :
6518 : // SUBROUTINE LOCAL VARIABLE DECLARATIONS:
6519 : Real64 OperatingHeatingCapacity; // Water heating operating capacity including the impact of capacity and COP curves (W)
6520 : Real64 OperatingHeatingCOP; // Water heating operating COP including the impact of capacity and COP curves (W/W)
6521 : Real64 OperatingHeatingPower; // Water heating operating Power (W)
6522 : Real64 CompressorPower; // Power consumed by compressor only (W)
6523 :
6524 : Real64 TotalTankHeatingCapacity; // Water heating capacity corrected for condenser water pump heat (W)
6525 : Real64 TankHeatingCOP; // Water heating COP corrected for fan and condenser water pump power (W/W)
6526 : // (these previous 2 variables also include the impact of capacity and COP curves)
6527 : Real64 EvapCoolingCapacity; // Air cooling capacity corrected for evap fan and cond water pump heat (W)
6528 : Real64 InletWaterTemp; // Condenser water inlet temperature (C)
6529 : Real64 OutletWaterTemp; // Condenser water outlet temperature (C)
6530 : Real64 EvapInletMassFlowRate; // Evaporator air inlet mass flow rate (m3/s)
6531 : Real64 CondInletMassFlowRate; // Condenser water inlet mass flow rate (m3/s)
6532 : Real64 CpWater; // Specific heat of condenser inlet water (J/Kg/k)
6533 : Real64 InletAirTemp; // HPWH inlet air temperature (dry-bulb or wet-bulb) (C)
6534 : Real64 AirMassFlowRatio; // Ratio of evaporator inlet air mass flow rate to rated mass flow rate
6535 : Real64 WaterMassFlowRatio; // Ratio of evaporator inlet water mass flow rate to rated mass flow rate
6536 : Real64 PumpHeatToWater; // Amount of pump heat attributed to heating water
6537 : Real64 PLF; // part-load function
6538 : Real64 CBFSpeed; // bypass factor as individual speed level
6539 : Real64 COPAirFFModFac; // air flow fraction modification
6540 : Real64 COPWaterFFModFac; // water flow fraction modification
6541 : Real64 COPTempModFac; // total capacity temperature correctio fraction
6542 : Real64 TOTCAPAirFFModFac; // air flow fraction modification
6543 : Real64 TOTCAPWaterFFModFac; // water flow fraction modification
6544 : Real64 TOTCAPTempModFac; // total capacity temperature correctio fraction
6545 : Real64 SHR; // total capacity temperature correctio fraction
6546 : Real64 COP; // total capacity temperature correctio fraction
6547 : Real64 AoEff; // effective air side surface area
6548 : Real64 Winput1; // power consumption at low speed
6549 : Real64 Winput2; // power consumption at high speed
6550 : Real64 LoadPressure; // evaporator inlet pressure
6551 : Real64 hDelta; // Change in air enthalpy across the cooling coil [J/kg]
6552 : Real64 hADP; // Apparatus dew point enthalpy [J/kg]
6553 : Real64 tADP; // Apparatus dew point temperature [C]
6554 : Real64 wADP; // Apparatus dew point humidity ratio [kg/kg]
6555 : Real64 hTinwADP; // Enthalpy at inlet dry-bulb and wADP [J/kg]
6556 : Real64 WHCAP1; // total heating capacity at low speed [W]
6557 : Real64 WHCAP2; // total heating capacity at high speed [W]
6558 : Real64 CpAir; // Specific heat of air [J/kg_C]
6559 : Real64 MaxHumRat; // max possible humidity
6560 : Real64 MaxOutletEnth; // max possible outlet enthalpy
6561 : int EvapInletNode; // Evaporator air inlet node number
6562 : int SpeedCal; // calculated speed level
6563 0 : Real64 rhoair = 0.0; // entering air density
6564 0 : Real64 RhoWater = 0.0; // water density
6565 :
6566 : // note: load side is the evaporator side, and source side is the condenser side
6567 :
6568 0 : int CondInletNode = state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).WaterInletNodeNum;
6569 0 : int CondOutletNode = state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).WaterOutletNodeNum;
6570 : // If heat pump water heater is OFF, set outlet to inlet and RETURN
6571 0 : if (PartLoadRatio == 0.0) {
6572 0 : state.dataLoopNodes->Node(CondOutletNode) = state.dataLoopNodes->Node(CondInletNode);
6573 0 : return;
6574 : } else {
6575 0 : EvapInletNode = state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).AirInletNodeNum;
6576 0 : InletWaterTemp = state.dataLoopNodes->Node(CondInletNode).Temp;
6577 0 : CondInletMassFlowRate = state.dataLoopNodes->Node(CondInletNode).MassFlowRate;
6578 0 : EvapInletMassFlowRate = state.dataLoopNodes->Node(EvapInletNode).MassFlowRate;
6579 0 : CpWater = Psychrometrics::CPHW(InletWaterTemp);
6580 0 : CompressorPower = 0.0;
6581 0 : OperatingHeatingPower = 0.0;
6582 0 : TankHeatingCOP = 0.0;
6583 : }
6584 :
6585 : // LOAD LOCAL VARIABLES FROM DATA STRUCTURE (for code readability)
6586 0 : if (!(fanOp == HVAC::FanOp::Continuous) && PartLoadRatio > 0.0) {
6587 0 : CondInletMassFlowRate = CondInletMassFlowRate / PartLoadRatio;
6588 0 : EvapInletMassFlowRate = EvapInletMassFlowRate / PartLoadRatio;
6589 : }
6590 :
6591 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).AirMassFlowRate = EvapInletMassFlowRate;
6592 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).WaterMassFlowRate = CondInletMassFlowRate;
6593 :
6594 : // determine inlet air temperature type for curve objects
6595 0 : if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).InletAirTemperatureType == HVAC::OATType::WetBulb) {
6596 0 : InletAirTemp = state.dataHVACGlobal->HPWHInletWBTemp;
6597 : } else {
6598 0 : InletAirTemp = state.dataHVACGlobal->HPWHInletDBTemp;
6599 : }
6600 :
6601 : // check if indoor evaporator or outdoor evaporator
6602 0 : Real64 CrankcaseHeatingPower = 0.0;
6603 0 : if (EvapInletNode != 0) {
6604 0 : state.dataVariableSpeedCoils->LoadSideInletDBTemp = state.dataLoopNodes->Node(EvapInletNode).Temp;
6605 0 : state.dataVariableSpeedCoils->LoadSideInletHumRat = state.dataLoopNodes->Node(EvapInletNode).HumRat;
6606 0 : LoadPressure = state.dataLoopNodes->Node(EvapInletNode).Press;
6607 : // prevent the air pressure not given
6608 0 : if (LoadPressure < 10.0) LoadPressure = state.dataEnvrn->OutBaroPress;
6609 :
6610 0 : state.dataVariableSpeedCoils->LoadSideInletWBTemp = state.dataLoopNodes->Node(EvapInletNode).OutAirWetBulb;
6611 0 : state.dataVariableSpeedCoils->LoadSideInletEnth = state.dataLoopNodes->Node(EvapInletNode).Enthalpy;
6612 : } else {
6613 0 : state.dataVariableSpeedCoils->LoadSideInletDBTemp = state.dataEnvrn->OutDryBulbTemp;
6614 0 : state.dataVariableSpeedCoils->LoadSideInletHumRat = state.dataEnvrn->OutHumRat;
6615 0 : LoadPressure = state.dataEnvrn->OutBaroPress;
6616 0 : state.dataVariableSpeedCoils->LoadSideInletWBTemp = state.dataEnvrn->OutWetBulbTemp;
6617 0 : state.dataVariableSpeedCoils->LoadSideInletEnth = state.dataEnvrn->OutEnthalpy;
6618 :
6619 : // Initialize crankcase heater, operates below OAT defined in input deck for HP DX heating coil
6620 0 : if (state.dataEnvrn->OutDryBulbTemp < state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MaxOATCrankcaseHeater) {
6621 0 : CrankcaseHeatingPower = state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).CrankcaseHeaterCapacity;
6622 0 : if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).CrankcaseHeaterCapacityCurveIndex > 0) {
6623 0 : CrankcaseHeatingPower *=
6624 0 : Curve::CurveValue(state,
6625 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).CrankcaseHeaterCapacityCurveIndex,
6626 0 : state.dataEnvrn->OutDryBulbTemp);
6627 : }
6628 : };
6629 : }
6630 :
6631 0 : state.dataVariableSpeedCoils->LoadSideMassFlowRate = EvapInletMassFlowRate;
6632 0 : state.dataVariableSpeedCoils->SourceSideMassFlowRate = CondInletMassFlowRate;
6633 0 : state.dataVariableSpeedCoils->SourceSideInletTemp = InletWaterTemp;
6634 0 : state.dataVariableSpeedCoils->SourceSideInletEnth = state.dataLoopNodes->Node(CondInletNode).Enthalpy;
6635 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).InletWaterEnthalpy = state.dataVariableSpeedCoils->SourceSideInletEnth;
6636 :
6637 : // Check for flows, do not perform simulation if no flow in load side or source side.
6638 0 : if ((state.dataVariableSpeedCoils->SourceSideMassFlowRate <= 0.0) || (state.dataVariableSpeedCoils->LoadSideMassFlowRate <= 0.0)) {
6639 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).SimFlag = false;
6640 0 : return;
6641 : } else {
6642 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).SimFlag = true;
6643 : }
6644 :
6645 : // part-load calculation
6646 0 : state.dataHVACGlobal->OnOffFanPartLoadFraction = 1.0;
6647 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).RunFrac = 1.0;
6648 0 : if ((SpeedNum == 1) && (PartLoadRatio < 1.0)) {
6649 0 : PLF = Curve::CurveValue(state, state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).PLFFPLR, PartLoadRatio);
6650 0 : if (PLF < 0.7) {
6651 0 : PLF = 0.7;
6652 : }
6653 0 : if (fanOp == HVAC::FanOp::Cycling)
6654 0 : state.dataHVACGlobal->OnOffFanPartLoadFraction =
6655 : PLF; // save PLF for fan model, don't change fan power for constant fan mode if coil is off
6656 : // calculate the run time fraction
6657 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).RunFrac = PartLoadRatio / PLF;
6658 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).PartLoadRatio = PartLoadRatio;
6659 :
6660 0 : if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).RunFrac > 1.0) {
6661 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).RunFrac = 1.0; // Reset coil runtime fraction to 1.0
6662 0 : } else if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).RunFrac < 0.0) {
6663 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).RunFrac = 0.0;
6664 : }
6665 : }
6666 :
6667 0 : int MaxSpeed = state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).NumOfSpeeds;
6668 :
6669 : // interpolate between speeds
6670 : // must be placed inside the loop, otherwise cause bug in release mode
6671 0 : if (SpeedNum > MaxSpeed) {
6672 0 : SpeedCal = MaxSpeed;
6673 : } else {
6674 0 : SpeedCal = SpeedNum;
6675 : }
6676 :
6677 0 : Real64 locFanElecPower = 0.0; // local for fan electric power
6678 0 : if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).SupplyFanIndex > 0) {
6679 0 : locFanElecPower = state.dataFans->fans(state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).SupplyFanIndex)->totalPower;
6680 : }
6681 0 : if ((SpeedNum == 1) || (SpeedNum > MaxSpeed) || (SpeedRatio == 1.0)) {
6682 0 : AirMassFlowRatio =
6683 0 : state.dataVariableSpeedCoils->LoadSideMassFlowRate / state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).DesignAirMassFlowRate;
6684 0 : WaterMassFlowRatio =
6685 0 : state.dataVariableSpeedCoils->SourceSideMassFlowRate / state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).DesignWaterMassFlowRate;
6686 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).HPWHCondPumpElecNomPower =
6687 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSWHPumpPower(SpeedCal);
6688 :
6689 0 : COPTempModFac = Curve::CurveValue(state,
6690 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSEIRFTemp(SpeedCal),
6691 : InletAirTemp,
6692 0 : state.dataVariableSpeedCoils->SourceSideInletTemp);
6693 : COPAirFFModFac =
6694 0 : Curve::CurveValue(state, state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSEIRAirFFlow(SpeedCal), AirMassFlowRatio);
6695 : COPWaterFFModFac =
6696 0 : Curve::CurveValue(state, state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSEIRWaterFFlow(SpeedCal), WaterMassFlowRatio);
6697 :
6698 0 : COP = state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedCOP(SpeedCal) * COPTempModFac * COPAirFFModFac * COPWaterFFModFac;
6699 :
6700 0 : TOTCAPTempModFac = Curve::CurveValue(state,
6701 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSCCapFTemp(SpeedCal),
6702 : InletAirTemp,
6703 0 : state.dataVariableSpeedCoils->SourceSideInletTemp);
6704 : // Get capacity modifying factor (function of mass flow) for off-rated conditions
6705 : TOTCAPAirFFModFac =
6706 0 : Curve::CurveValue(state, state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSCCapAirFFlow(SpeedCal), AirMassFlowRatio);
6707 : // Get capacity modifying factor (function of mass flow) for off-rated conditions
6708 : TOTCAPWaterFFModFac =
6709 0 : Curve::CurveValue(state, state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSCCapWaterFFlow(SpeedCal), WaterMassFlowRatio);
6710 :
6711 0 : OperatingHeatingCapacity = state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedTotCap(SpeedCal) * TOTCAPTempModFac *
6712 : TOTCAPAirFFModFac * TOTCAPWaterFFModFac;
6713 :
6714 0 : state.dataVariableSpeedCoils->Winput = OperatingHeatingCapacity / COP;
6715 0 : OperatingHeatingPower = state.dataVariableSpeedCoils->Winput;
6716 :
6717 0 : OperatingHeatingCOP = COP;
6718 0 : PumpHeatToWater = state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).HPWHCondPumpElecNomPower *
6719 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).HPWHCondPumpFracToWater;
6720 0 : TankHeatingCOP = OperatingHeatingCOP;
6721 :
6722 : // account for pump heat if not included in total water heating capacity
6723 0 : if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).CondPumpHeatInCapacity) {
6724 0 : TotalTankHeatingCapacity = OperatingHeatingCapacity;
6725 : } else {
6726 0 : TotalTankHeatingCapacity = OperatingHeatingCapacity + PumpHeatToWater;
6727 : }
6728 :
6729 : // calculate evaporator total cooling capacity
6730 0 : if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).FanPowerIncludedInCOP) {
6731 0 : if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).CondPumpPowerInCOP) {
6732 : // make sure fan power is full load fan power, it isn't though,
6733 0 : CompressorPower = OperatingHeatingPower - locFanElecPower / state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).RunFrac -
6734 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).HPWHCondPumpElecNomPower;
6735 0 : if (OperatingHeatingPower > 0.0) TankHeatingCOP = TotalTankHeatingCapacity / OperatingHeatingPower;
6736 : } else {
6737 0 : CompressorPower = OperatingHeatingPower - locFanElecPower / state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).RunFrac;
6738 0 : if ((OperatingHeatingPower + state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).HPWHCondPumpElecNomPower) > 0.0)
6739 0 : TankHeatingCOP = TotalTankHeatingCapacity /
6740 0 : (OperatingHeatingPower + state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).HPWHCondPumpElecNomPower);
6741 : }
6742 : } else {
6743 0 : if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).CondPumpPowerInCOP) {
6744 : // make sure fan power is full load fan power
6745 0 : CompressorPower = OperatingHeatingPower - state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).HPWHCondPumpElecNomPower;
6746 0 : if ((OperatingHeatingPower + locFanElecPower / state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).RunFrac) > 0.0)
6747 0 : TankHeatingCOP = TotalTankHeatingCapacity /
6748 0 : (OperatingHeatingPower + locFanElecPower / state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).RunFrac);
6749 : } else {
6750 0 : CompressorPower = OperatingHeatingPower;
6751 0 : if ((OperatingHeatingPower + locFanElecPower / state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).RunFrac +
6752 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).HPWHCondPumpElecNomPower) > 0.0)
6753 0 : TankHeatingCOP = TotalTankHeatingCapacity /
6754 0 : (OperatingHeatingPower + locFanElecPower / state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).RunFrac +
6755 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).HPWHCondPumpElecNomPower);
6756 : }
6757 : }
6758 :
6759 0 : if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).CondPumpHeatInCapacity) {
6760 0 : EvapCoolingCapacity = TotalTankHeatingCapacity - PumpHeatToWater - CompressorPower;
6761 : } else {
6762 0 : EvapCoolingCapacity = TotalTankHeatingCapacity - CompressorPower;
6763 : }
6764 :
6765 0 : CBFSpeed = DXCoils::AdjustCBF(state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedCBF(SpeedCal),
6766 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedAirMassFlowRate(SpeedCal),
6767 0 : state.dataVariableSpeedCoils->LoadSideMassFlowRate);
6768 :
6769 : } else {
6770 0 : AirMassFlowRatio =
6771 0 : state.dataVariableSpeedCoils->LoadSideMassFlowRate / state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).DesignAirMassFlowRate;
6772 0 : WaterMassFlowRatio =
6773 0 : state.dataVariableSpeedCoils->SourceSideMassFlowRate / state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).DesignWaterMassFlowRate;
6774 0 : AoEff = state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSEffectiveAo(SpeedCal) * SpeedRatio +
6775 0 : (1.0 - SpeedRatio) * state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSEffectiveAo(SpeedCal - 1);
6776 0 : CBFSpeed = std::exp(-AoEff / state.dataVariableSpeedCoils->LoadSideMassFlowRate);
6777 :
6778 : // calculate low speed
6779 0 : SpeedCal = SpeedNum - 1;
6780 :
6781 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).HPWHCondPumpElecNomPower =
6782 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSWHPumpPower(SpeedCal);
6783 0 : COPTempModFac = Curve::CurveValue(state,
6784 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSEIRFTemp(SpeedCal),
6785 : InletAirTemp,
6786 0 : state.dataVariableSpeedCoils->SourceSideInletTemp);
6787 : COPAirFFModFac =
6788 0 : Curve::CurveValue(state, state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSEIRAirFFlow(SpeedCal), AirMassFlowRatio);
6789 : COPWaterFFModFac =
6790 0 : Curve::CurveValue(state, state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSEIRWaterFFlow(SpeedCal), WaterMassFlowRatio);
6791 :
6792 0 : COP = state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedCOP(SpeedCal) * COPTempModFac * COPAirFFModFac * COPWaterFFModFac;
6793 :
6794 0 : TOTCAPTempModFac = Curve::CurveValue(state,
6795 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSCCapFTemp(SpeedCal),
6796 : InletAirTemp,
6797 0 : state.dataVariableSpeedCoils->SourceSideInletTemp);
6798 : // Get capacity modifying factor (function of mass flow) for off-rated conditions
6799 : TOTCAPAirFFModFac =
6800 0 : Curve::CurveValue(state, state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSCCapAirFFlow(SpeedCal), AirMassFlowRatio);
6801 : // Get capacity modifying factor (function of mass flow) for off-rated conditions
6802 : TOTCAPWaterFFModFac =
6803 0 : Curve::CurveValue(state, state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSCCapWaterFFlow(SpeedCal), WaterMassFlowRatio);
6804 :
6805 0 : OperatingHeatingCapacity = state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedTotCap(SpeedCal) * TOTCAPTempModFac *
6806 : TOTCAPAirFFModFac * TOTCAPWaterFFModFac;
6807 :
6808 0 : state.dataVariableSpeedCoils->Winput = OperatingHeatingCapacity / COP;
6809 0 : Winput1 = state.dataVariableSpeedCoils->Winput;
6810 0 : WHCAP1 = OperatingHeatingCapacity;
6811 :
6812 : // calculate upper speed
6813 0 : SpeedCal = SpeedNum;
6814 :
6815 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).HPWHCondPumpElecNomPower =
6816 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSWHPumpPower(SpeedCal);
6817 0 : COPTempModFac = Curve::CurveValue(state,
6818 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSEIRFTemp(SpeedCal),
6819 : InletAirTemp,
6820 0 : state.dataVariableSpeedCoils->SourceSideInletTemp);
6821 : COPAirFFModFac =
6822 0 : Curve::CurveValue(state, state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSEIRAirFFlow(SpeedCal), AirMassFlowRatio);
6823 : COPWaterFFModFac =
6824 0 : Curve::CurveValue(state, state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSEIRWaterFFlow(SpeedCal), WaterMassFlowRatio);
6825 :
6826 0 : COP = state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedCOP(SpeedCal) * COPTempModFac * COPAirFFModFac * COPWaterFFModFac;
6827 :
6828 0 : TOTCAPTempModFac = Curve::CurveValue(state,
6829 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSCCapFTemp(SpeedCal),
6830 : InletAirTemp,
6831 0 : state.dataVariableSpeedCoils->SourceSideInletTemp);
6832 : // Get capacity modifying factor (function of mass flow) for off-rated conditions
6833 : TOTCAPAirFFModFac =
6834 0 : Curve::CurveValue(state, state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSCCapAirFFlow(SpeedCal), AirMassFlowRatio);
6835 : // Get capacity modifying factor (function of mass flow) for off-rated conditions
6836 : TOTCAPWaterFFModFac =
6837 0 : Curve::CurveValue(state, state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSCCapWaterFFlow(SpeedCal), WaterMassFlowRatio);
6838 :
6839 0 : OperatingHeatingCapacity = state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedTotCap(SpeedCal) * TOTCAPTempModFac *
6840 : TOTCAPAirFFModFac * TOTCAPWaterFFModFac;
6841 :
6842 0 : Winput2 = OperatingHeatingCapacity / COP;
6843 0 : WHCAP2 = OperatingHeatingCapacity;
6844 :
6845 : // interpolation
6846 0 : state.dataVariableSpeedCoils->Winput = Winput2 * SpeedRatio + (1.0 - SpeedRatio) * Winput1;
6847 0 : OperatingHeatingPower = state.dataVariableSpeedCoils->Winput;
6848 0 : OperatingHeatingCapacity = WHCAP2 * SpeedRatio + (1.0 - SpeedRatio) * WHCAP1;
6849 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).HPWHCondPumpElecNomPower =
6850 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSWHPumpPower(SpeedNum) * SpeedRatio +
6851 0 : (1.0 - SpeedRatio) * state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSWHPumpPower(SpeedNum - 1);
6852 :
6853 0 : OperatingHeatingCOP = OperatingHeatingCapacity / OperatingHeatingPower;
6854 0 : TankHeatingCOP = OperatingHeatingCOP;
6855 :
6856 0 : PumpHeatToWater = state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).HPWHCondPumpElecNomPower *
6857 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).HPWHCondPumpFracToWater;
6858 :
6859 : // account for pump heat if not included in total water heating capacity
6860 0 : if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).CondPumpHeatInCapacity) {
6861 0 : TotalTankHeatingCapacity = OperatingHeatingCapacity;
6862 : } else {
6863 0 : TotalTankHeatingCapacity = OperatingHeatingCapacity + PumpHeatToWater;
6864 : }
6865 :
6866 0 : Real64 HPRTF = state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).RunFrac;
6867 : // calculate evaporator total cooling capacity
6868 0 : if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).FanPowerIncludedInCOP) {
6869 0 : if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).CondPumpPowerInCOP) {
6870 : // make sure fan power is full load fan power
6871 0 : CompressorPower = OperatingHeatingPower - locFanElecPower / HPRTF -
6872 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).HPWHCondPumpElecNomPower;
6873 0 : if (OperatingHeatingPower > 0.0) TankHeatingCOP = TotalTankHeatingCapacity / OperatingHeatingPower;
6874 : } else {
6875 0 : CompressorPower = OperatingHeatingPower - locFanElecPower / HPRTF;
6876 0 : if ((OperatingHeatingPower + state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).HPWHCondPumpElecNomPower) > 0.0)
6877 0 : TankHeatingCOP = TotalTankHeatingCapacity /
6878 0 : (OperatingHeatingPower + state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).HPWHCondPumpElecNomPower);
6879 : }
6880 : } else {
6881 0 : if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).CondPumpPowerInCOP) {
6882 : // make sure fan power is full load fan power
6883 0 : CompressorPower = OperatingHeatingPower - state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).HPWHCondPumpElecNomPower;
6884 0 : if ((OperatingHeatingPower + locFanElecPower / HPRTF) > 0.0)
6885 0 : TankHeatingCOP = TotalTankHeatingCapacity / (OperatingHeatingPower + locFanElecPower / HPRTF);
6886 : } else {
6887 0 : CompressorPower = OperatingHeatingPower;
6888 0 : if ((OperatingHeatingPower + locFanElecPower / HPRTF +
6889 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).HPWHCondPumpElecNomPower) > 0.0)
6890 0 : TankHeatingCOP = TotalTankHeatingCapacity / (OperatingHeatingPower + locFanElecPower / HPRTF +
6891 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).HPWHCondPumpElecNomPower);
6892 : }
6893 : }
6894 :
6895 0 : if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).CondPumpHeatInCapacity) {
6896 0 : EvapCoolingCapacity = TotalTankHeatingCapacity - PumpHeatToWater - CompressorPower;
6897 : } else {
6898 0 : EvapCoolingCapacity = TotalTankHeatingCapacity - CompressorPower;
6899 : }
6900 : }
6901 :
6902 0 : state.dataVariableSpeedCoils->QSource = TotalTankHeatingCapacity;
6903 0 : state.dataVariableSpeedCoils->QLoadTotal = EvapCoolingCapacity;
6904 0 : state.dataHVACGlobal->DXCoilTotalCapacity = EvapCoolingCapacity; // for standard rating calculation
6905 0 : SHR = 1.0;
6906 : // if indoor, calculate SHR
6907 0 : if (EvapInletNode != 0) {
6908 0 : if (CBFSpeed > 0.999) CBFSpeed = 0.999;
6909 :
6910 0 : if (CBFSpeed < 0.001) {
6911 0 : SHR = 1.0;
6912 : } else {
6913 0 : hDelta = state.dataVariableSpeedCoils->QLoadTotal / state.dataVariableSpeedCoils->LoadSideMassFlowRate;
6914 0 : hADP = state.dataVariableSpeedCoils->LoadSideInletEnth - hDelta / (1.0 - CBFSpeed);
6915 0 : tADP = Psychrometrics::PsyTsatFnHPb(state, hADP, LoadPressure, RoutineName);
6916 0 : wADP = Psychrometrics::PsyWFnTdbH(state, tADP, hADP, RoutineName);
6917 0 : hTinwADP = Psychrometrics::PsyHFnTdbW(state.dataVariableSpeedCoils->LoadSideInletDBTemp, wADP);
6918 0 : if ((state.dataVariableSpeedCoils->LoadSideInletEnth - hADP) > 1.e-10) {
6919 0 : SHR = min((hTinwADP - hADP) / (state.dataVariableSpeedCoils->LoadSideInletEnth - hADP), 1.0);
6920 : } else {
6921 0 : SHR = 1.0;
6922 : }
6923 : }
6924 : }
6925 :
6926 0 : state.dataVariableSpeedCoils->QSensible = state.dataVariableSpeedCoils->QLoadTotal * SHR;
6927 :
6928 : // determine condenser water inlet/outlet condition at full capacity
6929 0 : if (CondInletMassFlowRate == 0.0) {
6930 0 : OutletWaterTemp = InletWaterTemp;
6931 : } else {
6932 0 : OutletWaterTemp = InletWaterTemp + TotalTankHeatingCapacity / (CpWater * CondInletMassFlowRate);
6933 : }
6934 :
6935 0 : state.dataLoopNodes->Node(CondOutletNode).Temp = OutletWaterTemp;
6936 :
6937 0 : state.dataLoopNodes->Node(CondOutletNode).MassFlowRate = state.dataLoopNodes->Node(CondInletNode).MassFlowRate;
6938 :
6939 : // send heating capacity and COP to water heater module for standards rating calculation
6940 : // total heating capacity including condenser pump
6941 0 : state.dataVariableSpeedCoils->VSHPWHHeatingCapacity = TotalTankHeatingCapacity;
6942 : // total heating COP including compressor, fan, and condenser pump
6943 0 : state.dataVariableSpeedCoils->VSHPWHHeatingCOP = TankHeatingCOP;
6944 :
6945 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).TotalHeatingEnergyRate = TotalTankHeatingCapacity * PartLoadRatio;
6946 : // calculate total compressor plus condenser pump power, fan power reported in fan module
6947 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).ElecWaterHeatingPower =
6948 0 : (CompressorPower + state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).HPWHCondPumpElecNomPower) *
6949 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).RunFrac;
6950 :
6951 : // pass the outputs for the cooling coil section
6952 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).BasinHeaterPower = 0.0;
6953 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).CrankcaseHeaterPower =
6954 0 : CrankcaseHeatingPower * (1.0 - state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).RunFrac);
6955 :
6956 : // calculate coil outlet state variables
6957 0 : state.dataVariableSpeedCoils->LoadSideOutletEnth =
6958 0 : state.dataVariableSpeedCoils->LoadSideInletEnth -
6959 0 : state.dataVariableSpeedCoils->QLoadTotal / state.dataVariableSpeedCoils->LoadSideMassFlowRate;
6960 0 : CpAir = Psychrometrics::PsyCpAirFnW(state.dataVariableSpeedCoils->LoadSideInletHumRat);
6961 0 : state.dataVariableSpeedCoils->LoadSideOutletDBTemp =
6962 0 : state.dataVariableSpeedCoils->LoadSideInletDBTemp -
6963 0 : state.dataVariableSpeedCoils->QSensible / (state.dataVariableSpeedCoils->LoadSideMassFlowRate * CpAir);
6964 :
6965 0 : MaxHumRat = Psychrometrics::PsyWFnTdbRhPb(state,
6966 0 : state.dataVariableSpeedCoils->LoadSideOutletDBTemp,
6967 : 0.9999,
6968 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).InletAirPressure,
6969 : RoutineName);
6970 0 : MaxOutletEnth = Psychrometrics::PsyHFnTdbW(state.dataVariableSpeedCoils->LoadSideOutletDBTemp, MaxHumRat);
6971 0 : if (state.dataVariableSpeedCoils->LoadSideOutletEnth > MaxOutletEnth) {
6972 0 : state.dataVariableSpeedCoils->LoadSideOutletEnth = MaxOutletEnth;
6973 : }
6974 0 : state.dataVariableSpeedCoils->LoadSideOutletHumRat = Psychrometrics::PsyWFnTdbH(
6975 0 : state, state.dataVariableSpeedCoils->LoadSideOutletDBTemp, state.dataVariableSpeedCoils->LoadSideOutletEnth, RoutineName);
6976 0 : if (state.dataVariableSpeedCoils->LoadSideOutletHumRat > MaxHumRat) {
6977 0 : state.dataVariableSpeedCoils->LoadSideOutletHumRat = MaxHumRat;
6978 : }
6979 :
6980 : // Actual outlet conditions are "average" for time step
6981 0 : if (fanOp == HVAC::FanOp::Continuous) {
6982 : // continuous fan, cycling compressor
6983 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).OutletAirEnthalpy =
6984 0 : PartLoadRatio * state.dataVariableSpeedCoils->LoadSideOutletEnth +
6985 0 : (1.0 - PartLoadRatio) * state.dataVariableSpeedCoils->LoadSideInletEnth;
6986 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).OutletAirHumRat =
6987 0 : PartLoadRatio * state.dataVariableSpeedCoils->LoadSideOutletHumRat +
6988 0 : (1.0 - PartLoadRatio) * state.dataVariableSpeedCoils->LoadSideInletHumRat;
6989 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).OutletAirDBTemp =
6990 0 : Psychrometrics::PsyTdbFnHW(state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).OutletAirEnthalpy,
6991 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).OutletAirHumRat);
6992 0 : state.dataVariableSpeedCoils->PLRCorrLoadSideMdot = state.dataVariableSpeedCoils->LoadSideMassFlowRate;
6993 : } else {
6994 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).OutletAirEnthalpy = state.dataVariableSpeedCoils->LoadSideOutletEnth;
6995 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).OutletAirHumRat = state.dataVariableSpeedCoils->LoadSideOutletHumRat;
6996 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).OutletAirDBTemp = state.dataVariableSpeedCoils->LoadSideOutletDBTemp;
6997 0 : state.dataVariableSpeedCoils->PLRCorrLoadSideMdot = state.dataVariableSpeedCoils->LoadSideMassFlowRate * PartLoadRatio;
6998 : }
6999 :
7000 : // scale heat transfer rates to PLR and power to RTF
7001 0 : state.dataVariableSpeedCoils->QLoadTotal *= PartLoadRatio;
7002 0 : state.dataVariableSpeedCoils->QSensible *= PartLoadRatio;
7003 : // count the powr separately
7004 0 : state.dataVariableSpeedCoils->Winput *=
7005 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).RunFrac; //+ VarSpeedCoil(DXCoilNum)%CrankcaseHeaterPower &
7006 : //+ VarSpeedCoil(DXCoilNum)%BasinHeaterPower + VarSpeedCoil(DXCoilNum)%EvapCondPumpElecPower
7007 0 : state.dataVariableSpeedCoils->QSource *= PartLoadRatio;
7008 :
7009 : // Update heat pump data structure
7010 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).HPWHCondPumpElecNomPower =
7011 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).HPWHCondPumpElecNomPower *
7012 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).RunFrac; // water heating pump power
7013 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Power = state.dataVariableSpeedCoils->Winput;
7014 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).QLoadTotal = state.dataVariableSpeedCoils->QLoadTotal;
7015 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).QSensible = state.dataVariableSpeedCoils->QSensible;
7016 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).QLatent =
7017 0 : state.dataVariableSpeedCoils->QLoadTotal - state.dataVariableSpeedCoils->QSensible;
7018 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).QSource = state.dataVariableSpeedCoils->QSource;
7019 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Energy = state.dataVariableSpeedCoils->Winput * TimeStepSysSec;
7020 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).EnergyLoadTotal = state.dataVariableSpeedCoils->QLoadTotal * TimeStepSysSec;
7021 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).EnergySensible = state.dataVariableSpeedCoils->QSensible * TimeStepSysSec;
7022 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).EnergyLatent =
7023 0 : (state.dataVariableSpeedCoils->QLoadTotal - state.dataVariableSpeedCoils->QSensible) * TimeStepSysSec;
7024 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).EnergySource = state.dataVariableSpeedCoils->QSource * TimeStepSysSec;
7025 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).CrankcaseHeaterConsumption =
7026 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).CrankcaseHeaterPower * TimeStepSysSec;
7027 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).EvapWaterConsump = 0.0;
7028 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).BasinHeaterConsumption = 0.0;
7029 : // re-use EvapCondPumpElecConsumption to store WH pump energy consumption
7030 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).EvapCondPumpElecConsumption =
7031 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).HPWHCondPumpElecNomPower * TimeStepSysSec;
7032 0 : if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).RunFrac == 0.0) {
7033 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).COP = 0.0;
7034 : } else {
7035 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).COP =
7036 0 : state.dataVariableSpeedCoils->QLoadTotal / state.dataVariableSpeedCoils->Winput;
7037 : }
7038 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).PartLoadRatio = PartLoadRatio;
7039 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).AirMassFlowRate = state.dataVariableSpeedCoils->PLRCorrLoadSideMdot;
7040 0 : rhoair = Psychrometrics::PsyRhoAirFnPbTdbW(state,
7041 0 : state.dataEnvrn->OutBaroPress,
7042 0 : state.dataVariableSpeedCoils->LoadSideInletDBTemp,
7043 0 : state.dataVariableSpeedCoils->LoadSideInletHumRat,
7044 : RoutineName);
7045 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).AirVolFlowRate =
7046 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).AirMassFlowRate / rhoair;
7047 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).WaterMassFlowRate = state.dataVariableSpeedCoils->SourceSideMassFlowRate;
7048 0 : RhoWater = Psychrometrics::RhoH2O(InletWaterTemp); // initialize
7049 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).WaterVolFlowRate =
7050 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).WaterMassFlowRate / RhoWater;
7051 :
7052 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).OutletWaterTemp =
7053 0 : state.dataVariableSpeedCoils->SourceSideInletTemp +
7054 0 : state.dataVariableSpeedCoils->QSource / (state.dataVariableSpeedCoils->SourceSideMassFlowRate * CpWater);
7055 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).OutletWaterEnthalpy =
7056 0 : state.dataVariableSpeedCoils->SourceSideInletEnth +
7057 0 : state.dataVariableSpeedCoils->QSource / state.dataVariableSpeedCoils->SourceSideMassFlowRate;
7058 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).QWasteHeat = 0.0;
7059 :
7060 0 : if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).bIsDesuperheater) // desuperheater doesn't save power and cooling energy variables
7061 : {
7062 : // source side is the water side; load side is the air side
7063 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Power = 0.0;
7064 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).QLoadTotal = 0.0;
7065 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).QSensible = 0.0;
7066 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).QLatent = 0.0;
7067 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Energy = 0.0;
7068 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).EnergyLoadTotal = 0.0;
7069 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).EnergySensible = 0.0;
7070 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).EnergyLatent = 0.0;
7071 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).CrankcaseHeaterConsumption = 0.0;
7072 : }
7073 : }
7074 :
7075 0 : void setVarSpeedHPWHFanType(EnergyPlusData &state, int const dXCoilNum, HVAC::FanType fanType)
7076 : {
7077 0 : state.dataVariableSpeedCoils->VarSpeedCoil(dXCoilNum).supplyFanType = fanType;
7078 0 : }
7079 :
7080 0 : void setVarSpeedHPWHFanIndex(EnergyPlusData &state, int const dXCoilNum, int const fanIndex)
7081 : {
7082 0 : state.dataVariableSpeedCoils->VarSpeedCoil(dXCoilNum).SupplyFanIndex = fanIndex;
7083 0 : }
7084 :
7085 33673 : void CalcVarSpeedCoilHeating(EnergyPlusData &state,
7086 : int const DXCoilNum, // Heat Pump Number
7087 : HVAC::FanOp const fanOp, // Fan/Compressor cycling scheme indicator
7088 : [[maybe_unused]] Real64 const SensDemand, // Cooling Sensible Demand [W] !unused1208
7089 : HVAC::CompressorOp const compressorOp, // compressor operation flag
7090 : Real64 const PartLoadRatio, // compressor part load ratio
7091 : [[maybe_unused]] Real64 const OnOffAirFlowRatio, // ratio of compressor on flow to average flow over time step
7092 : Real64 const SpeedRatio, // SpeedRatio varies between 1.0 (higher speed) and 0.0 (lower speed)
7093 : int const SpeedNum // Speed number, high bound, i.e. SpeedNum - 1 is the other side
7094 : )
7095 : {
7096 :
7097 : // AUTHOR Bo Shen, based on WaterToAirHeatPumpSimple:CalcHPHeatingSimple
7098 : // DATE WRITTEN March 2012
7099 :
7100 : // PURPOSE OF THIS SUBROUTINE:
7101 : // This subroutine is for simulating the heating mode of the Variable Speed Water to Air HP Simple
7102 :
7103 : // METHODOLOGY EMPLOYED:
7104 : // Simulate the heat pump performance using the coefficients and rated conditions
7105 : // Finally, adjust the heat pump outlet conditions based on the PartLoadRatio
7106 : // and RuntimeFrac.
7107 :
7108 : // SUBROUTINE PARAMETER DEFINITIONS:
7109 : static constexpr std::string_view RoutineName("CalcVarSpeedCoilHeating");
7110 : static constexpr std::string_view RoutineNameSourceSideInletTemp("CalcVarSpeedCoilHeating:SourceSideInletTemp");
7111 33673 : Real64 TimeStepSysSec = state.dataHVACGlobal->TimeStepSysSec;
7112 :
7113 : // SUBROUTINE LOCAL VARIABLE DECLARATIONS:
7114 : Real64 CpSource; // Specific heat of water [J/kg_C]
7115 : Real64 AirMassFlowRatio; // airflow ratio at low speed
7116 : Real64 WaterMassFlowRatio; // airflow ratio at high speed
7117 : Real64 TotCapAirFFModFac; // air flow fraction modification
7118 : Real64 TotCapWaterFFModFac; // water flow fraction modification
7119 : Real64 TotCapTempModFac; // total capacity temperature correction fraction
7120 : Real64 EIRAirFFModFac; // air flow fraction modification
7121 : Real64 EIRWaterFFModFac; // water flow fraction modification
7122 : Real64 EIRTempModFac; // total capacity temperature correction fraction
7123 : Real64 EIR; // total capacity temperature correction fraction
7124 : int SpeedCal; // calculated speed level
7125 : Real64 QLoadTotal1; // heating capacity at low speed
7126 : Real64 QLoadTotal2; // heating capacity at high speed
7127 : Real64 Winput1; // power consumption at low speed
7128 : Real64 Winput2; // power consumption at high speed
7129 : Real64 QWasteHeat; // recoverable waste heat
7130 : Real64 QWasteHeat1; // recoverable waste heat at low speed
7131 : Real64 QWasteHeat2; // recoverable waste heat at high speed
7132 : Real64 PLF; // part-load function
7133 33673 : Real64 rhoair(0.0); // entering air density
7134 :
7135 : // ADDED VARIABLES FOR air source coil
7136 33673 : int MaxSpeed = state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).NumOfSpeeds;
7137 :
7138 : // LOAD LOCAL VARIABLES FROM DATA STRUCTURE (for code readability)
7139 33673 : if (!(fanOp == HVAC::FanOp::Continuous) && PartLoadRatio > 0.0) {
7140 17652 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).AirMassFlowRate =
7141 17652 : state.dataLoopNodes->Node(state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).AirInletNodeNum).MassFlowRate / PartLoadRatio;
7142 : }
7143 :
7144 33673 : state.dataVariableSpeedCoils->LoadSideMassFlowRate = state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).AirMassFlowRate;
7145 33673 : state.dataVariableSpeedCoils->LoadSideInletDBTemp = state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).InletAirDBTemp;
7146 33673 : state.dataVariableSpeedCoils->LoadSideInletHumRat = state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).InletAirHumRat;
7147 :
7148 33673 : state.dataVariableSpeedCoils->LoadSideInletWBTemp = Psychrometrics::PsyTwbFnTdbWPb(state,
7149 33673 : state.dataVariableSpeedCoils->LoadSideInletDBTemp,
7150 33673 : state.dataVariableSpeedCoils->LoadSideInletHumRat,
7151 33673 : state.dataEnvrn->OutBaroPress,
7152 : RoutineName);
7153 33673 : state.dataVariableSpeedCoils->LoadSideInletEnth = state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).InletAirEnthalpy;
7154 33673 : Real64 CpAir = Psychrometrics::PsyCpAirFnW(state.dataVariableSpeedCoils->LoadSideInletHumRat); // Specific heat of air [J/kg_C]
7155 :
7156 33673 : if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).VSCoilType == HVAC::Coil_HeatingAirToAirVariableSpeed) {
7157 : // Get condenser outdoor node info from DX Heating Coil
7158 36 : if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).CondenserInletNodeNum != 0) {
7159 0 : state.dataVariableSpeedCoils->OutdoorDryBulb =
7160 0 : state.dataLoopNodes->Node(state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).CondenserInletNodeNum).Temp;
7161 0 : state.dataVariableSpeedCoils->OutdoorHumRat =
7162 0 : state.dataLoopNodes->Node(state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).CondenserInletNodeNum).HumRat;
7163 0 : state.dataVariableSpeedCoils->OutdoorPressure =
7164 0 : state.dataLoopNodes->Node(state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).CondenserInletNodeNum).Press;
7165 0 : state.dataVariableSpeedCoils->OutdoorWetBulb =
7166 0 : state.dataLoopNodes->Node(state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).CondenserInletNodeNum).OutAirWetBulb;
7167 : } else {
7168 36 : state.dataVariableSpeedCoils->OutdoorDryBulb = state.dataEnvrn->OutDryBulbTemp;
7169 36 : state.dataVariableSpeedCoils->OutdoorHumRat = state.dataEnvrn->OutHumRat;
7170 36 : state.dataVariableSpeedCoils->OutdoorPressure = state.dataEnvrn->OutBaroPress;
7171 36 : state.dataVariableSpeedCoils->OutdoorWetBulb = state.dataEnvrn->OutWetBulbTemp;
7172 : }
7173 36 : state.dataVariableSpeedCoils->SourceSideMassFlowRate = 1.0; // not used and avoid divided by zero
7174 36 : state.dataVariableSpeedCoils->SourceSideInletTemp = state.dataVariableSpeedCoils->OutdoorDryBulb;
7175 36 : state.dataVariableSpeedCoils->SourceSideInletEnth =
7176 36 : Psychrometrics::PsyHFnTdbW(state.dataVariableSpeedCoils->OutdoorDryBulb, state.dataVariableSpeedCoils->OutdoorHumRat);
7177 36 : CpSource = Psychrometrics::PsyCpAirFnW(state.dataEnvrn->OutHumRat);
7178 :
7179 : // Initialize crankcase heater, operates below OAT defined in input deck for HP DX heating coil
7180 36 : if (state.dataVariableSpeedCoils->OutdoorDryBulb < state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MaxOATCrankcaseHeater) {
7181 33 : state.dataVariableSpeedCoils->CrankcaseHeatingPower = state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).CrankcaseHeaterCapacity;
7182 33 : if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).CrankcaseHeaterCapacityCurveIndex > 0) {
7183 1 : state.dataVariableSpeedCoils->CrankcaseHeatingPower *=
7184 1 : Curve::CurveValue(state,
7185 1 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).CrankcaseHeaterCapacityCurveIndex,
7186 1 : state.dataEnvrn->OutDryBulbTemp);
7187 : }
7188 : } else {
7189 3 : state.dataVariableSpeedCoils->CrankcaseHeatingPower = 0.0;
7190 : }
7191 : } else {
7192 33637 : state.dataVariableSpeedCoils->SourceSideMassFlowRate = state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).WaterMassFlowRate;
7193 33637 : state.dataVariableSpeedCoils->SourceSideInletTemp = state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).InletWaterTemp;
7194 33637 : state.dataVariableSpeedCoils->SourceSideInletEnth = state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).InletWaterEnthalpy;
7195 33637 : CpSource = state.dataPlnt->PlantLoop(state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).plantLoc.loopNum)
7196 33637 : .glycol->getSpecificHeat(state, state.dataVariableSpeedCoils->SourceSideInletTemp, RoutineNameSourceSideInletTemp);
7197 : }
7198 :
7199 : // Check for flows, do not perform simulation if no flow in load side or source side.
7200 33673 : if ((state.dataVariableSpeedCoils->SourceSideMassFlowRate <= 0.0) || (state.dataVariableSpeedCoils->LoadSideMassFlowRate <= 0.0)) {
7201 16038 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).SimFlag = false;
7202 16038 : return;
7203 : } else {
7204 17635 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).SimFlag = true;
7205 : }
7206 :
7207 17659 : if ((state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).VSCoilType == HVAC::Coil_HeatingAirToAirVariableSpeed) &&
7208 24 : (state.dataVariableSpeedCoils->OutdoorDryBulb < state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MinOATCompressor)) {
7209 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).SimFlag = false;
7210 0 : return;
7211 : }
7212 :
7213 17635 : if (compressorOp == HVAC::CompressorOp::Off) {
7214 1 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).SimFlag = false;
7215 1 : return;
7216 : }
7217 :
7218 17634 : if (SpeedNum > MaxSpeed) {
7219 0 : SpeedCal = MaxSpeed;
7220 : } else {
7221 17634 : SpeedCal = SpeedNum;
7222 : }
7223 :
7224 17634 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).RunFrac = 1.0;
7225 17634 : state.dataHVACGlobal->OnOffFanPartLoadFraction = 1.0;
7226 17634 : if ((SpeedNum == 1) && (PartLoadRatio < 1.0)) {
7227 39 : PLF = Curve::CurveValue(state, state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).PLFFPLR, PartLoadRatio);
7228 39 : if (PLF < 0.7) {
7229 0 : PLF = 0.7;
7230 : }
7231 39 : if (fanOp == HVAC::FanOp::Cycling)
7232 32 : state.dataHVACGlobal->OnOffFanPartLoadFraction =
7233 : PLF; // save PLF for fan model, don't change fan power for constant fan mode if coil is off
7234 : // calculate the run time fraction
7235 39 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).RunFrac = PartLoadRatio / PLF;
7236 39 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).PartLoadRatio = PartLoadRatio;
7237 :
7238 39 : if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).RunFrac > 1.0) {
7239 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).RunFrac = 1.0; // Reset coil runtime fraction to 1.0
7240 39 : } else if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).RunFrac < 0.0) {
7241 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).RunFrac = 0.0;
7242 : }
7243 : }
7244 :
7245 17634 : if ((SpeedNum == 1) || (SpeedNum > MaxSpeed) || (SpeedRatio == 1.0)) {
7246 12217 : AirMassFlowRatio =
7247 12217 : state.dataVariableSpeedCoils->LoadSideMassFlowRate / state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).DesignAirMassFlowRate;
7248 :
7249 12217 : if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).VSCoilType == HVAC::Coil_HeatingAirToAirVariableSpeed) {
7250 18 : WaterMassFlowRatio = 1.0;
7251 : } else {
7252 12199 : WaterMassFlowRatio = state.dataVariableSpeedCoils->SourceSideMassFlowRate /
7253 12199 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).DesignWaterMassFlowRate;
7254 : }
7255 :
7256 48868 : TotCapTempModFac = Curve::CurveValue(state,
7257 12217 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSCCapFTemp(SpeedCal),
7258 12217 : state.dataVariableSpeedCoils->LoadSideInletDBTemp,
7259 12217 : state.dataVariableSpeedCoils->SourceSideInletTemp);
7260 : TotCapAirFFModFac =
7261 12217 : Curve::CurveValue(state, state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSCCapAirFFlow(SpeedCal), AirMassFlowRatio);
7262 :
7263 12217 : if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).VSCoilType == HVAC::Coil_HeatingAirToAirVariableSpeed) {
7264 18 : TotCapWaterFFModFac = 1.0;
7265 : } else {
7266 : TotCapWaterFFModFac =
7267 12199 : Curve::CurveValue(state, state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSCCapWaterFFlow(SpeedCal), WaterMassFlowRatio);
7268 : }
7269 :
7270 12217 : state.dataVariableSpeedCoils->QLoadTotal = state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedTotCap(SpeedCal) *
7271 12217 : TotCapTempModFac * TotCapAirFFModFac * TotCapWaterFFModFac;
7272 12217 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).capModFacTotal = TotCapTempModFac * TotCapAirFFModFac * TotCapWaterFFModFac;
7273 24434 : state.dataVariableSpeedCoils->TotRatedCapacity =
7274 12217 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedTotCap(SpeedCal); // for defrosting power cal
7275 :
7276 48868 : EIRTempModFac = Curve::CurveValue(state,
7277 12217 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSEIRFTemp(SpeedCal),
7278 12217 : state.dataVariableSpeedCoils->LoadSideInletDBTemp,
7279 12217 : state.dataVariableSpeedCoils->SourceSideInletTemp);
7280 : EIRAirFFModFac =
7281 12217 : Curve::CurveValue(state, state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSEIRAirFFlow(SpeedCal), AirMassFlowRatio);
7282 :
7283 12217 : if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).VSCoilType == HVAC::Coil_HeatingAirToAirVariableSpeed) {
7284 18 : EIRWaterFFModFac = 1.0;
7285 : } else {
7286 : EIRWaterFFModFac =
7287 12199 : Curve::CurveValue(state, state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSEIRWaterFFlow(SpeedCal), WaterMassFlowRatio);
7288 : }
7289 :
7290 12217 : EIR = (1.0 / state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedCOP(SpeedCal)) * EIRTempModFac * EIRAirFFModFac *
7291 : EIRWaterFFModFac;
7292 12217 : state.dataVariableSpeedCoils->Winput = state.dataVariableSpeedCoils->QLoadTotal * EIR;
7293 :
7294 24434 : if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).VSCoilType == HVAC::Coil_HeatingAirToAirVariableSpeed) {
7295 18 : QWasteHeat = 0.0;
7296 : } else {
7297 12199 : QWasteHeat = state.dataVariableSpeedCoils->Winput * state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSWasteHeatFrac(SpeedCal);
7298 12199 : QWasteHeat *= Curve::CurveValue(state,
7299 12199 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSWasteHeat(SpeedCal),
7300 12199 : state.dataVariableSpeedCoils->LoadSideInletDBTemp,
7301 12199 : state.dataVariableSpeedCoils->SourceSideInletTemp);
7302 : }
7303 :
7304 : } else {
7305 5417 : AirMassFlowRatio =
7306 5417 : state.dataVariableSpeedCoils->LoadSideMassFlowRate / state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).DesignAirMassFlowRate;
7307 :
7308 5417 : if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).VSCoilType == HVAC::Coil_HeatingAirToAirVariableSpeed) {
7309 5 : WaterMassFlowRatio = 1.0;
7310 : } else {
7311 5412 : WaterMassFlowRatio = state.dataVariableSpeedCoils->SourceSideMassFlowRate /
7312 5412 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).DesignWaterMassFlowRate;
7313 : }
7314 :
7315 5417 : SpeedCal = SpeedNum - 1;
7316 21668 : TotCapTempModFac = Curve::CurveValue(state,
7317 5417 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSCCapFTemp(SpeedCal),
7318 5417 : state.dataVariableSpeedCoils->LoadSideInletDBTemp,
7319 5417 : state.dataVariableSpeedCoils->SourceSideInletTemp);
7320 : TotCapAirFFModFac =
7321 5417 : Curve::CurveValue(state, state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSCCapAirFFlow(SpeedCal), AirMassFlowRatio);
7322 :
7323 5417 : if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).VSCoilType == HVAC::Coil_HeatingAirToAirVariableSpeed) {
7324 5 : TotCapWaterFFModFac = 1.0;
7325 : } else {
7326 : TotCapWaterFFModFac =
7327 5412 : Curve::CurveValue(state, state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSCCapWaterFFlow(SpeedCal), WaterMassFlowRatio);
7328 : }
7329 :
7330 5417 : QLoadTotal1 = state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedTotCap(SpeedCal) * TotCapTempModFac * TotCapAirFFModFac *
7331 : TotCapWaterFFModFac;
7332 :
7333 21668 : EIRTempModFac = Curve::CurveValue(state,
7334 5417 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSEIRFTemp(SpeedCal),
7335 5417 : state.dataVariableSpeedCoils->LoadSideInletDBTemp,
7336 5417 : state.dataVariableSpeedCoils->SourceSideInletTemp);
7337 : EIRAirFFModFac =
7338 5417 : Curve::CurveValue(state, state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSEIRAirFFlow(SpeedCal), AirMassFlowRatio);
7339 :
7340 5417 : if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).VSCoilType == HVAC::Coil_HeatingAirToAirVariableSpeed) {
7341 5 : EIRWaterFFModFac = 1.0;
7342 : } else {
7343 : EIRWaterFFModFac =
7344 5412 : Curve::CurveValue(state, state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSEIRWaterFFlow(SpeedCal), WaterMassFlowRatio);
7345 : }
7346 :
7347 5417 : EIR = (1.0 / state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedCOP(SpeedCal)) * EIRTempModFac * EIRAirFFModFac *
7348 : EIRWaterFFModFac;
7349 5417 : Winput1 = QLoadTotal1 * EIR;
7350 :
7351 5417 : if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).VSCoilType == HVAC::Coil_HeatingAirToAirVariableSpeed) {
7352 5 : QWasteHeat1 = 0.0;
7353 : } else {
7354 5412 : QWasteHeat1 = Winput1 * state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSWasteHeatFrac(SpeedCal);
7355 5412 : QWasteHeat1 *= Curve::CurveValue(state,
7356 5412 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSWasteHeat(SpeedCal),
7357 5412 : state.dataVariableSpeedCoils->LoadSideInletDBTemp,
7358 5412 : state.dataVariableSpeedCoils->SourceSideInletTemp);
7359 : }
7360 :
7361 5417 : SpeedCal = SpeedNum;
7362 21668 : TotCapTempModFac = Curve::CurveValue(state,
7363 5417 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSCCapFTemp(SpeedCal),
7364 5417 : state.dataVariableSpeedCoils->LoadSideInletDBTemp,
7365 5417 : state.dataVariableSpeedCoils->SourceSideInletTemp);
7366 : TotCapAirFFModFac =
7367 5417 : Curve::CurveValue(state, state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSCCapAirFFlow(SpeedCal), AirMassFlowRatio);
7368 :
7369 5417 : if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).VSCoilType == HVAC::Coil_HeatingAirToAirVariableSpeed) {
7370 5 : TotCapWaterFFModFac = 1.0;
7371 : } else {
7372 : TotCapWaterFFModFac =
7373 5412 : Curve::CurveValue(state, state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSCCapWaterFFlow(SpeedCal), WaterMassFlowRatio);
7374 : }
7375 :
7376 5417 : QLoadTotal2 = state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedTotCap(SpeedCal) * TotCapTempModFac * TotCapAirFFModFac *
7377 : TotCapWaterFFModFac;
7378 :
7379 21668 : EIRTempModFac = Curve::CurveValue(state,
7380 5417 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSEIRFTemp(SpeedCal),
7381 5417 : state.dataVariableSpeedCoils->LoadSideInletDBTemp,
7382 5417 : state.dataVariableSpeedCoils->SourceSideInletTemp);
7383 : EIRAirFFModFac =
7384 5417 : Curve::CurveValue(state, state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSEIRAirFFlow(SpeedCal), AirMassFlowRatio);
7385 :
7386 5417 : if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).VSCoilType == HVAC::Coil_HeatingAirToAirVariableSpeed) {
7387 5 : EIRWaterFFModFac = 1.0;
7388 : } else {
7389 : EIRWaterFFModFac =
7390 5412 : Curve::CurveValue(state, state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSEIRWaterFFlow(SpeedCal), WaterMassFlowRatio);
7391 : }
7392 :
7393 5417 : EIR = (1.0 / state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedCOP(SpeedCal)) * EIRTempModFac * EIRAirFFModFac *
7394 : EIRWaterFFModFac;
7395 5417 : Winput2 = QLoadTotal2 * EIR;
7396 :
7397 5417 : if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).VSCoilType == HVAC::Coil_HeatingAirToAirVariableSpeed) {
7398 5 : QWasteHeat2 = 0.0;
7399 : } else {
7400 5412 : QWasteHeat2 = Winput2 * state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSWasteHeatFrac(SpeedCal);
7401 5412 : QWasteHeat2 *= Curve::CurveValue(state,
7402 5412 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSWasteHeat(SpeedCal),
7403 5412 : state.dataVariableSpeedCoils->LoadSideInletDBTemp,
7404 5412 : state.dataVariableSpeedCoils->SourceSideInletTemp);
7405 : }
7406 :
7407 5417 : state.dataVariableSpeedCoils->QLoadTotal = QLoadTotal2 * SpeedRatio + (1.0 - SpeedRatio) * QLoadTotal1;
7408 5417 : state.dataVariableSpeedCoils->Winput = Winput2 * SpeedRatio + (1.0 - SpeedRatio) * Winput1;
7409 5417 : QWasteHeat = QWasteHeat2 * SpeedRatio + (1.0 - SpeedRatio) * QWasteHeat1;
7410 5417 : state.dataVariableSpeedCoils->TotRatedCapacity =
7411 5417 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedTotCap(SpeedCal) * SpeedRatio +
7412 5417 : (1.0 - SpeedRatio) * state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedTotCap(SpeedCal - 1);
7413 : }
7414 :
7415 17634 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).CrankcaseHeaterPower = 0.0; // necessary to clear zero for water source coils
7416 17634 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).DefrostPower = 0.0; // clear the defrost power
7417 17634 : if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).VSCoilType == HVAC::Coil_HeatingAirToAirVariableSpeed) {
7418 : // Calculating adjustment factors for defrost
7419 : // Calculate delta w through outdoor coil by assuming a coil temp of 0.82*DBT-9.7(F) per DOE2.1E
7420 23 : state.dataVariableSpeedCoils->OutdoorCoilT = 0.82 * state.dataVariableSpeedCoils->OutdoorDryBulb - 8.589;
7421 23 : state.dataVariableSpeedCoils->OutdoorCoildw =
7422 23 : max(1.0e-6,
7423 23 : (state.dataVariableSpeedCoils->OutdoorHumRat -
7424 23 : Psychrometrics::PsyWFnTdpPb(state, state.dataVariableSpeedCoils->OutdoorCoilT, state.dataVariableSpeedCoils->OutdoorPressure)));
7425 :
7426 : // Initializing defrost adjustment factors
7427 23 : state.dataVariableSpeedCoils->LoadDueToDefrost = 0.0;
7428 23 : state.dataVariableSpeedCoils->HeatingCapacityMultiplier = 1.0;
7429 23 : state.dataVariableSpeedCoils->FractionalDefrostTime = 0.0;
7430 23 : state.dataVariableSpeedCoils->InputPowerMultiplier = 1.0;
7431 : // Check outdoor temperature to determine of defrost is active
7432 23 : if (state.dataVariableSpeedCoils->OutdoorDryBulb <= state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MaxOATDefrost) {
7433 : // Calculate defrost adjustment factors depending on defrost control type
7434 19 : if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).DefrostControl == Timed) {
7435 12 : state.dataVariableSpeedCoils->FractionalDefrostTime = state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).DefrostTime;
7436 12 : if (state.dataVariableSpeedCoils->FractionalDefrostTime > 0.0) {
7437 11 : if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).FrostHeatingCapacityMultiplierEMSOverrideOn &&
7438 1 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).FrostHeatingInputPowerMultiplierEMSOverrideOn) {
7439 2 : state.dataVariableSpeedCoils->HeatingCapacityMultiplier =
7440 1 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).FrostHeatingCapacityMultiplierEMSOverrideValue;
7441 1 : state.dataVariableSpeedCoils->InputPowerMultiplier =
7442 1 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).FrostHeatingInputPowerMultiplierEMSOverrideValue;
7443 : } else {
7444 9 : state.dataVariableSpeedCoils->HeatingCapacityMultiplier = 0.909 - 107.33 * state.dataVariableSpeedCoils->OutdoorCoildw;
7445 9 : state.dataVariableSpeedCoils->InputPowerMultiplier = 0.90 - 36.45 * state.dataVariableSpeedCoils->OutdoorCoildw;
7446 18 : if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).FrostHeatingCapacityMultiplierEMSOverrideOn ||
7447 9 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).FrostHeatingInputPowerMultiplierEMSOverrideOn) {
7448 0 : ShowWarningMessage(
7449 : state,
7450 0 : format("The Frost Heating Capacity Multiplier actuator and the Frost Heating Input Power Multiplier "
7451 : "actuator must be both provided for DX heating coil {}",
7452 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name));
7453 0 : ShowContinueError(state, "EMS actuators are ignored. Simulation is continuing.");
7454 : }
7455 : }
7456 : }
7457 : } else { // else defrost control is on-demand
7458 7 : state.dataVariableSpeedCoils->FractionalDefrostTime = 1.0 / (1.0 + 0.01446 / state.dataVariableSpeedCoils->OutdoorCoildw);
7459 7 : if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).FrostHeatingCapacityMultiplierEMSOverrideOn &&
7460 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).FrostHeatingInputPowerMultiplierEMSOverrideOn) {
7461 0 : state.dataVariableSpeedCoils->HeatingCapacityMultiplier =
7462 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).FrostHeatingCapacityMultiplierEMSOverrideValue;
7463 0 : state.dataVariableSpeedCoils->InputPowerMultiplier =
7464 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).FrostHeatingInputPowerMultiplierEMSOverrideValue;
7465 : } else {
7466 7 : state.dataVariableSpeedCoils->HeatingCapacityMultiplier = 0.875 * (1.0 - state.dataVariableSpeedCoils->FractionalDefrostTime);
7467 7 : state.dataVariableSpeedCoils->InputPowerMultiplier = 0.954 * (1.0 - state.dataVariableSpeedCoils->FractionalDefrostTime);
7468 14 : if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).FrostHeatingCapacityMultiplierEMSOverrideOn ||
7469 7 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).FrostHeatingInputPowerMultiplierEMSOverrideOn) {
7470 0 : ShowWarningMessage(state,
7471 0 : format("The Frost Heating Capacity Multiplier actuator and the Frost Heating Input Power Multiplier "
7472 : "actuator must be both provided for DX heating coil {}",
7473 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name));
7474 0 : ShowContinueError(state, "EMS actuators are ignored. Simulation is continuing.");
7475 : }
7476 : }
7477 : }
7478 : // correction fractional defrost time shorten by runtime fraction
7479 19 : state.dataVariableSpeedCoils->FractionalDefrostTime *= state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).RunFrac;
7480 :
7481 19 : if (state.dataVariableSpeedCoils->FractionalDefrostTime > 0.0) {
7482 : // Calculate defrost adjustment factors depending on defrost control strategy
7483 17 : if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).DefrostStrategy == ReverseCycle) {
7484 0 : state.dataVariableSpeedCoils->LoadDueToDefrost = (0.01 * state.dataVariableSpeedCoils->FractionalDefrostTime) *
7485 0 : (7.222 - state.dataVariableSpeedCoils->OutdoorDryBulb) *
7486 0 : (state.dataVariableSpeedCoils->TotRatedCapacity / 1.01667);
7487 0 : state.dataVariableSpeedCoils->DefrostEIRTempModFac =
7488 0 : Curve::CurveValue(state,
7489 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).DefrostEIRFT,
7490 0 : max(15.555, state.dataVariableSpeedCoils->LoadSideInletWBTemp),
7491 0 : max(15.555, state.dataVariableSpeedCoils->OutdoorDryBulb));
7492 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).DefrostPower =
7493 0 : state.dataVariableSpeedCoils->DefrostEIRTempModFac * (state.dataVariableSpeedCoils->TotRatedCapacity / 1.01667) *
7494 0 : state.dataVariableSpeedCoils->FractionalDefrostTime;
7495 : } else { // Defrost strategy is resistive
7496 17 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).DefrostPower =
7497 17 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).DefrostCapacity *
7498 17 : state.dataVariableSpeedCoils->FractionalDefrostTime;
7499 : }
7500 : } else { // Defrost is not active because (OutDryBulbTemp > VarSpeedCoil(DXCoilNum).MaxOATDefrost)
7501 2 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).DefrostPower = 0.0;
7502 : }
7503 : }
7504 :
7505 23 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).CrankcaseHeaterPower =
7506 23 : state.dataVariableSpeedCoils->CrankcaseHeatingPower * (1.0 - state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).RunFrac);
7507 : //! Modify total heating capacity based on defrost heating capacity multiplier
7508 : //! MaxHeatCap passed from parent object VRF Condenser and is used to limit capacity of TU's to that available from condenser
7509 : // IF(PRESENT(MaxHeatCap))THEN
7510 : // TotCap = MIN(MaxHeatCap,TotCap * HeatingCapacityMultiplier)
7511 : // ELSE
7512 : // TotCap = TotCap * HeatingCapacityMultiplier
7513 : // END IF
7514 46 : state.dataVariableSpeedCoils->QLoadTotal =
7515 23 : state.dataVariableSpeedCoils->QLoadTotal * state.dataVariableSpeedCoils->HeatingCapacityMultiplier -
7516 23 : state.dataVariableSpeedCoils->LoadDueToDefrost;
7517 : // count the powr separately
7518 23 : state.dataVariableSpeedCoils->Winput *= state.dataVariableSpeedCoils->InputPowerMultiplier; //+ VarSpeedCoil(DXCoilNum)%DefrostPower
7519 : }
7520 :
7521 17634 : state.dataVariableSpeedCoils->QSource = state.dataVariableSpeedCoils->QLoadTotal + QWasteHeat - state.dataVariableSpeedCoils->Winput;
7522 17634 : state.dataVariableSpeedCoils->QSensible = state.dataVariableSpeedCoils->QLoadTotal;
7523 :
7524 17634 : if (state.dataVariableSpeedCoils->QSource < 0) {
7525 1 : state.dataVariableSpeedCoils->QSource = 0.0;
7526 1 : QWasteHeat = state.dataVariableSpeedCoils->Winput - state.dataVariableSpeedCoils->QLoadTotal;
7527 : }
7528 :
7529 : // calculate coil outlet state variables
7530 35268 : state.dataVariableSpeedCoils->LoadSideOutletEnth =
7531 17634 : state.dataVariableSpeedCoils->LoadSideInletEnth +
7532 17634 : state.dataVariableSpeedCoils->QLoadTotal / state.dataVariableSpeedCoils->LoadSideMassFlowRate;
7533 35268 : state.dataVariableSpeedCoils->LoadSideOutletDBTemp =
7534 17634 : state.dataVariableSpeedCoils->LoadSideInletDBTemp +
7535 17634 : state.dataVariableSpeedCoils->QSensible / (state.dataVariableSpeedCoils->LoadSideMassFlowRate * CpAir);
7536 17634 : state.dataVariableSpeedCoils->LoadSideOutletHumRat = Psychrometrics::PsyWFnTdbH(
7537 17634 : state, state.dataVariableSpeedCoils->LoadSideOutletDBTemp, state.dataVariableSpeedCoils->LoadSideOutletEnth, RoutineName);
7538 :
7539 : // Actual outlet conditions are "average" for time step
7540 17634 : if (fanOp == HVAC::FanOp::Continuous) {
7541 : // continuous fan, cycling compressor
7542 24 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).OutletAirEnthalpy =
7543 24 : PartLoadRatio * state.dataVariableSpeedCoils->LoadSideOutletEnth +
7544 24 : (1.0 - PartLoadRatio) * state.dataVariableSpeedCoils->LoadSideInletEnth;
7545 24 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).OutletAirHumRat =
7546 24 : PartLoadRatio * state.dataVariableSpeedCoils->LoadSideOutletHumRat +
7547 24 : (1.0 - PartLoadRatio) * state.dataVariableSpeedCoils->LoadSideInletHumRat;
7548 24 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).OutletAirDBTemp =
7549 24 : Psychrometrics::PsyTdbFnHW(state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).OutletAirEnthalpy,
7550 24 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).OutletAirHumRat);
7551 24 : state.dataVariableSpeedCoils->PLRCorrLoadSideMdot = state.dataVariableSpeedCoils->LoadSideMassFlowRate;
7552 : } else {
7553 : // default to cycling fan, cycling compressor
7554 17610 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).OutletAirEnthalpy = state.dataVariableSpeedCoils->LoadSideOutletEnth;
7555 17610 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).OutletAirHumRat = state.dataVariableSpeedCoils->LoadSideOutletHumRat;
7556 17610 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).OutletAirDBTemp = state.dataVariableSpeedCoils->LoadSideOutletDBTemp;
7557 17610 : state.dataVariableSpeedCoils->PLRCorrLoadSideMdot = state.dataVariableSpeedCoils->LoadSideMassFlowRate * PartLoadRatio;
7558 : }
7559 :
7560 : // scale heat transfer rates to PLR and power to RTF
7561 17634 : state.dataVariableSpeedCoils->QLoadTotal *= PartLoadRatio;
7562 17634 : state.dataVariableSpeedCoils->QSensible *= PartLoadRatio;
7563 : // count the powr separately
7564 35268 : state.dataVariableSpeedCoils->Winput *=
7565 17634 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).RunFrac; //+ VarSpeedCoil(DXCoilNum)%CrankcaseHeaterPower
7566 17634 : state.dataVariableSpeedCoils->QSource *= PartLoadRatio;
7567 17634 : QWasteHeat *= PartLoadRatio;
7568 :
7569 : // Update heat pump data structure
7570 17634 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Power = state.dataVariableSpeedCoils->Winput;
7571 17634 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).QLoadTotal = state.dataVariableSpeedCoils->QLoadTotal;
7572 17634 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).QSensible = state.dataVariableSpeedCoils->QSensible;
7573 17634 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).QSource = state.dataVariableSpeedCoils->QSource;
7574 17634 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Energy = state.dataVariableSpeedCoils->Winput * TimeStepSysSec;
7575 17634 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).EnergyLoadTotal = state.dataVariableSpeedCoils->QLoadTotal * TimeStepSysSec;
7576 17634 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).EnergySensible = state.dataVariableSpeedCoils->QSensible * TimeStepSysSec;
7577 17634 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).EnergyLatent = 0.0;
7578 17634 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).EnergySource = state.dataVariableSpeedCoils->QSource * TimeStepSysSec;
7579 17634 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).CrankcaseHeaterConsumption =
7580 17634 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).CrankcaseHeaterPower * TimeStepSysSec;
7581 17634 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).DefrostConsumption =
7582 17634 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).DefrostPower * TimeStepSysSec;
7583 17634 : if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).RunFrac == 0.0) {
7584 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).COP = 0.0;
7585 : } else {
7586 17634 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).COP =
7587 17634 : state.dataVariableSpeedCoils->QLoadTotal / state.dataVariableSpeedCoils->Winput;
7588 : }
7589 17634 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).PartLoadRatio = PartLoadRatio;
7590 17634 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).AirMassFlowRate = state.dataVariableSpeedCoils->PLRCorrLoadSideMdot;
7591 17634 : rhoair = Psychrometrics::PsyRhoAirFnPbTdbW(state,
7592 17634 : state.dataEnvrn->OutBaroPress,
7593 17634 : state.dataVariableSpeedCoils->LoadSideInletDBTemp,
7594 17634 : state.dataVariableSpeedCoils->LoadSideInletHumRat,
7595 : RoutineName);
7596 17634 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).AirVolFlowRate =
7597 17634 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).AirMassFlowRate / rhoair;
7598 :
7599 17634 : if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).VSCoilType == HVAC::Coil_HeatingAirToAirVariableSpeed) {
7600 23 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).WaterMassFlowRate = 0.0;
7601 23 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).OutletWaterTemp = 0.0;
7602 23 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).OutletWaterEnthalpy = 0.0;
7603 : } else {
7604 17611 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).WaterMassFlowRate = state.dataVariableSpeedCoils->SourceSideMassFlowRate;
7605 17611 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).OutletWaterTemp =
7606 17611 : state.dataVariableSpeedCoils->SourceSideInletTemp -
7607 17611 : state.dataVariableSpeedCoils->QSource / (state.dataVariableSpeedCoils->SourceSideMassFlowRate * CpSource);
7608 17611 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).OutletWaterEnthalpy =
7609 17611 : state.dataVariableSpeedCoils->SourceSideInletEnth -
7610 17611 : state.dataVariableSpeedCoils->QSource / state.dataVariableSpeedCoils->SourceSideMassFlowRate;
7611 : }
7612 :
7613 17634 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).QWasteHeat = QWasteHeat;
7614 : }
7615 :
7616 8 : Real64 GetCoilCapacityVariableSpeed(EnergyPlusData &state,
7617 : std::string const &CoilType, // must match coil types in this module
7618 : std::string const &CoilName, // must match coil names for the coil type
7619 : bool &ErrorsFound // set to true if problem
7620 : )
7621 : {
7622 :
7623 : // FUNCTION INFORMATION:
7624 : // AUTHOR Bo Shen, based on WaterToAirHeatPumpSimple:GetCoilCapacity
7625 : // DATE WRITTEN March 2012
7626 :
7627 : // PURPOSE OF THIS FUNCTION:
7628 : // This function looks up the rated coil capacity at the nominal speed level for the given coil and returns it. If
7629 : // incorrect coil type or name is given, ErrorsFound is returned as true and capacity is returned
7630 : // as negative.
7631 :
7632 : // Return value
7633 : Real64 CoilCapacity; // returned capacity of matched coil
7634 :
7635 : // FUNCTION LOCAL VARIABLE DECLARATIONS:
7636 : int WhichCoil;
7637 :
7638 : // Obtains and Allocates WatertoAirHP related parameters from input file
7639 8 : if (state.dataVariableSpeedCoils->GetCoilsInputFlag) { // First time subroutine has been entered
7640 0 : GetVarSpeedCoilInput(state);
7641 0 : state.dataVariableSpeedCoils->GetCoilsInputFlag = false;
7642 : }
7643 :
7644 14 : if (Util::SameString(CoilType, "COIL:COOLING:WATERTOAIRHEATPUMP:VARIABLESPEEDEQUATIONFIT") ||
7645 12 : Util::SameString(CoilType, "COIL:HEATING:WATERTOAIRHEATPUMP:VARIABLESPEEDEQUATIONFIT") ||
7646 20 : Util::SameString(CoilType, "COIL:COOLING:DX:VARIABLESPEED") || Util::SameString(CoilType, "COIL:HEATING:DX:VARIABLESPEED") ||
7647 8 : Util::SameString(CoilType, "COIL:WATERHEATING:AIRTOWATERHEATPUMP:VARIABLESPEED")) {
7648 8 : WhichCoil = Util::FindItemInList(CoilName, state.dataVariableSpeedCoils->VarSpeedCoil);
7649 8 : if (WhichCoil != 0) {
7650 16 : if (Util::SameString(CoilType, "COIL:HEATING:WATERTOAIRHEATPUMP:VARIABLESPEEDEQUATIONFIT") ||
7651 16 : Util::SameString(CoilType, "COIL:HEATING:DX:VARIABLESPEED")) {
7652 0 : CoilCapacity = state.dataVariableSpeedCoils->VarSpeedCoil(WhichCoil).RatedCapHeat;
7653 8 : } else if (Util::SameString(CoilType, "COIL:WATERHEATING:AIRTOWATERHEATPUMP:VARIABLESPEED")) {
7654 0 : CoilCapacity = state.dataVariableSpeedCoils->VarSpeedCoil(WhichCoil).RatedCapWH;
7655 : } else {
7656 8 : CoilCapacity = state.dataVariableSpeedCoils->VarSpeedCoil(WhichCoil).RatedCapCoolTotal;
7657 : }
7658 : }
7659 : } else {
7660 0 : WhichCoil = 0;
7661 : }
7662 :
7663 8 : if (WhichCoil == 0) {
7664 0 : ShowSevereError(state, format("GetCoilCapacityVariableSpeed: Could not find CoilType=\"{}\" with Name=\"{}\"", CoilType, CoilName));
7665 0 : ErrorsFound = true;
7666 0 : CoilCapacity = -1000.0;
7667 : }
7668 :
7669 8 : return CoilCapacity;
7670 : }
7671 :
7672 27 : int GetCoilIndexVariableSpeed(EnergyPlusData &state,
7673 : std::string const &CoilType, // must match coil types in this module
7674 : std::string const &CoilName, // must match coil names for the coil type
7675 : bool &ErrorsFound // set to true if problem
7676 : )
7677 : {
7678 :
7679 : // FUNCTION INFORMATION:
7680 : // AUTHOR Bo Shen, based on WaterToAirHeatPumpSimple:GetCoilIndex
7681 : // DATE WRITTEN March 2012
7682 :
7683 : // PURPOSE OF THIS FUNCTION:
7684 : // This function looks up the coil index for the given coil and returns it. If incorrect
7685 : // coil type or name is given, ErrorsFound is returned as true and index is returned as zero.
7686 :
7687 : // Return value
7688 : int IndexNum; // returned index of matched coil
7689 :
7690 : // Obtains and Allocates WatertoAirHP related parameters from input file
7691 27 : if (state.dataVariableSpeedCoils->GetCoilsInputFlag) { // First time subroutine has been entered
7692 13 : GetVarSpeedCoilInput(state);
7693 13 : state.dataVariableSpeedCoils->GetCoilsInputFlag = false;
7694 : }
7695 :
7696 27 : IndexNum = Util::FindItemInList(CoilName, state.dataVariableSpeedCoils->VarSpeedCoil);
7697 :
7698 27 : if (IndexNum == 0) {
7699 0 : ShowSevereError(state, format("GetCoilIndexVariableSpeed: Could not find CoilType=\"{}\" with Name=\"{}\"", CoilType, CoilName));
7700 0 : ErrorsFound = true;
7701 : }
7702 :
7703 27 : return IndexNum;
7704 : }
7705 :
7706 1 : Real64 GetCoilAirFlowRateVariableSpeed(EnergyPlusData &state,
7707 : std::string const &CoilType, // must match coil types in this module
7708 : std::string const &CoilName, // must match coil names for the coil type
7709 : bool &ErrorsFound // set to true if problem
7710 : )
7711 : {
7712 :
7713 : // FUNCTION INFORMATION:
7714 : // AUTHOR Bo Shen, based on WaterToAirHeatPumpSimple:GetCoilAirFlowRate
7715 : // DATE WRITTEN March 2012
7716 :
7717 : // PURPOSE OF THIS FUNCTION:
7718 : // This function looks up the max coil air flow rate for the given coil and returns it. If incorrect
7719 : // coil type or name is given, ErrorsFound is returned as true and capacity is returned as negative.
7720 :
7721 : // Return value
7722 : Real64 CoilAirFlowRate; // returned air volume flow rate of matched coil
7723 :
7724 : // FUNCTION LOCAL VARIABLE DECLARATIONS:
7725 : int WhichCoil;
7726 :
7727 : // Obtains and Allocates WatertoAirHP related parameters from input file
7728 1 : if (state.dataVariableSpeedCoils->GetCoilsInputFlag) { // First time subroutine has been entered
7729 0 : GetVarSpeedCoilInput(state);
7730 0 : state.dataVariableSpeedCoils->GetCoilsInputFlag = false;
7731 : }
7732 :
7733 2 : if (Util::SameString(CoilType, "COIL:COOLING:WATERTOAIRHEATPUMP:VARIABLESPEEDEQUATIONFIT") ||
7734 2 : Util::SameString(CoilType, "COIL:HEATING:WATERTOAIRHEATPUMP:VARIABLESPEEDEQUATIONFIT") ||
7735 3 : Util::SameString(CoilType, "COIL:COOLING:DX:VARIABLESPEED") || Util::SameString(CoilType, "COIL:HEATING:DX:VARIABLESPEED") ||
7736 1 : Util::SameString(CoilType, "COIL:WATERHEATING:AIRTOWATERHEATPUMP:VARIABLESPEED")) {
7737 1 : WhichCoil = Util::FindItemInList(CoilName, state.dataVariableSpeedCoils->VarSpeedCoil);
7738 1 : if (WhichCoil != 0) {
7739 1 : if (state.dataVariableSpeedCoils->VarSpeedCoil(WhichCoil).RatedAirVolFlowRate == DataSizing::AutoSize) { // means autosize
7740 0 : CoilAirFlowRate = state.dataVariableSpeedCoils->VarSpeedCoil(WhichCoil).RatedAirVolFlowRate;
7741 : } else {
7742 1 : CoilAirFlowRate = state.dataVariableSpeedCoils->VarSpeedCoil(WhichCoil).MSRatedAirVolFlowRate(
7743 1 : state.dataVariableSpeedCoils->VarSpeedCoil(WhichCoil).NumOfSpeeds) /
7744 1 : state.dataVariableSpeedCoils->VarSpeedCoil(WhichCoil).MSRatedAirVolFlowRate(
7745 1 : state.dataVariableSpeedCoils->VarSpeedCoil(WhichCoil).NormSpedLevel) *
7746 1 : state.dataVariableSpeedCoils->VarSpeedCoil(WhichCoil).RatedAirVolFlowRate;
7747 : } // use largest air flow rate
7748 : }
7749 : } else {
7750 0 : WhichCoil = 0;
7751 : }
7752 :
7753 1 : if (WhichCoil == 0) {
7754 0 : ShowSevereError(state, format("GetCoilAirFlowRateVariableSpeed: Could not find CoilType=\"{}\" with Name=\"{}\"", CoilType, CoilName));
7755 0 : ErrorsFound = true;
7756 0 : CoilAirFlowRate = -1000.0;
7757 : }
7758 :
7759 1 : return CoilAirFlowRate;
7760 : }
7761 :
7762 0 : int GetVSCoilPLFFPLR(EnergyPlusData &state,
7763 : std::string const &CoilType, // must match coil types in this module
7764 : std::string const &CoilName, // must match coil names for the coil type
7765 : bool &ErrorsFound // set to true if problem
7766 : )
7767 : {
7768 :
7769 : // FUNCTION INFORMATION:
7770 : // AUTHOR Bo Shen
7771 : // DATE WRITTEN 12/2014
7772 :
7773 : // PURPOSE OF THIS FUNCTION:
7774 : // This function looks up the given coil and returns PLR curve index. If incorrect
7775 : // coil type or name is given, ErrorsFound is returned as true and value is returned as zero.
7776 :
7777 : // Return value
7778 : int PLRNumber; // returned outlet node of matched coil
7779 :
7780 : // FUNCTION LOCAL VARIABLE DECLARATIONS:
7781 : int WhichCoil;
7782 :
7783 : // Obtains and Allocates WatertoAirHP related parameters from input file
7784 0 : if (state.dataVariableSpeedCoils->GetCoilsInputFlag) { // First time subroutine has been entered
7785 0 : GetVarSpeedCoilInput(state);
7786 0 : state.dataVariableSpeedCoils->GetCoilsInputFlag = false;
7787 : }
7788 :
7789 0 : WhichCoil = Util::FindItemInList(CoilName, state.dataVariableSpeedCoils->VarSpeedCoil);
7790 0 : if (WhichCoil != 0) {
7791 0 : PLRNumber = state.dataVariableSpeedCoils->VarSpeedCoil(WhichCoil).PLFFPLR;
7792 : }
7793 :
7794 0 : if (WhichCoil == 0) {
7795 0 : ShowSevereError(state, format("GetVSCoilPLFFPLR: Could not find CoilType=\"{}\" with Name=\"{}\"", CoilType, CoilName));
7796 0 : ErrorsFound = true;
7797 0 : PLRNumber = 0;
7798 : }
7799 :
7800 0 : return PLRNumber;
7801 : }
7802 :
7803 5 : int GetVSCoilCapFTCurveIndex(EnergyPlusData &state,
7804 : int const CoilIndex, // must match coil names for the coil type
7805 : bool &ErrorsFound // set to true if problem
7806 : )
7807 : {
7808 :
7809 : // FUNCTION INFORMATION:
7810 : // AUTHOR Richard Raustad
7811 : // DATE WRITTEN 7/2017
7812 :
7813 : // PURPOSE OF THIS FUNCTION:
7814 : // This function looks up the given coil and returns CapFT curve index. If incorrect
7815 : // coil index is given, ErrorsFound is returned as true and value is returned as zero.
7816 :
7817 : // Return value
7818 : int CapFTIndex; // returned CapFT curve index of matched coil
7819 :
7820 : // Obtains and Allocates WatertoAirHP related parameters from input file
7821 5 : if (state.dataVariableSpeedCoils->GetCoilsInputFlag) { // First time subroutine has been entered
7822 0 : GetVarSpeedCoilInput(state);
7823 0 : state.dataVariableSpeedCoils->GetCoilsInputFlag = false;
7824 : }
7825 :
7826 5 : if (CoilIndex == 0) {
7827 0 : ShowSevereError(state, "GetVSCoilCapFTCurveIndex: Could not find Coil");
7828 0 : ErrorsFound = true;
7829 0 : CapFTIndex = 0;
7830 : } else {
7831 5 : CapFTIndex =
7832 5 : state.dataVariableSpeedCoils->VarSpeedCoil(CoilIndex).MSCCapFTemp(state.dataVariableSpeedCoils->VarSpeedCoil(CoilIndex).NumOfSpeeds);
7833 : }
7834 :
7835 5 : return CapFTIndex;
7836 : }
7837 :
7838 1 : int GetCoilInletNodeVariableSpeed(EnergyPlusData &state,
7839 : std::string const &CoilType, // must match coil types in this module
7840 : std::string const &CoilName, // must match coil names for the coil type
7841 : bool &ErrorsFound // set to true if problem
7842 : )
7843 : {
7844 :
7845 : // FUNCTION INFORMATION:
7846 : // AUTHOR Bo Shen, based on WaterToAirHeatPumpSimple:GetCoilInletNode
7847 : // DATE WRITTEN March 2012
7848 :
7849 : // PURPOSE OF THIS FUNCTION:
7850 : // This function looks up the given coil and returns the inlet node. If incorrect
7851 : // coil type or name is given, ErrorsFound is returned as true and value is returned as zero.
7852 :
7853 : // Return value
7854 : int NodeNumber; // returned outlet node of matched coil
7855 :
7856 : // FUNCTION LOCAL VARIABLE DECLARATIONS:
7857 : int WhichCoil;
7858 :
7859 : // Obtains and Allocates WatertoAirHP related parameters from input file
7860 1 : if (state.dataVariableSpeedCoils->GetCoilsInputFlag) { // First time subroutine has been entered
7861 0 : GetVarSpeedCoilInput(state);
7862 0 : state.dataVariableSpeedCoils->GetCoilsInputFlag = false;
7863 : }
7864 :
7865 1 : WhichCoil = Util::FindItemInList(CoilName, state.dataVariableSpeedCoils->VarSpeedCoil);
7866 1 : if (WhichCoil != 0) {
7867 1 : NodeNumber = state.dataVariableSpeedCoils->VarSpeedCoil(WhichCoil).AirInletNodeNum;
7868 : }
7869 :
7870 1 : if (WhichCoil == 0) {
7871 0 : ShowSevereError(state, format("GetCoilInletNodeVariableSpeed: Could not find CoilType=\"{}\" with Name=\"{}\"", CoilType, CoilName));
7872 0 : ErrorsFound = true;
7873 0 : NodeNumber = 0;
7874 : }
7875 :
7876 1 : return NodeNumber;
7877 : }
7878 :
7879 4 : int GetCoilOutletNodeVariableSpeed(EnergyPlusData &state,
7880 : std::string const &CoilType, // must match coil types in this module
7881 : std::string const &CoilName, // must match coil names for the coil type
7882 : bool &ErrorsFound // set to true if problem
7883 : )
7884 : {
7885 :
7886 : // FUNCTION INFORMATION:
7887 : // AUTHOR Bo Shen, based on WaterToAirHeatPumpSimple:GetCoilOutletNode
7888 : // DATE WRITTEN March 2012
7889 :
7890 : // PURPOSE OF THIS FUNCTION:
7891 : // This function looks up the given coil and returns the outlet node. If incorrect
7892 : // coil type or name is given, ErrorsFound is returned as true and value is returned as zero.
7893 :
7894 : // Return value
7895 : int NodeNumber; // returned outlet node of matched coil
7896 :
7897 : // FUNCTION LOCAL VARIABLE DECLARATIONS:
7898 : int WhichCoil;
7899 :
7900 : // Obtains and Allocates WatertoAirHP related parameters from input file
7901 4 : if (state.dataVariableSpeedCoils->GetCoilsInputFlag) { // First time subroutine has been entered
7902 3 : GetVarSpeedCoilInput(state);
7903 3 : state.dataVariableSpeedCoils->GetCoilsInputFlag = false;
7904 : }
7905 :
7906 4 : WhichCoil = Util::FindItemInList(CoilName, state.dataVariableSpeedCoils->VarSpeedCoil);
7907 4 : if (WhichCoil != 0) {
7908 4 : NodeNumber = state.dataVariableSpeedCoils->VarSpeedCoil(WhichCoil).AirOutletNodeNum;
7909 : }
7910 :
7911 4 : if (WhichCoil == 0) {
7912 0 : ShowSevereError(state, format("GetCoilOutletNodeVariableSpeed: Could not find CoilType=\"{}\" with Name=\"{}\"", CoilType, CoilName));
7913 0 : ErrorsFound = true;
7914 0 : NodeNumber = 0;
7915 : }
7916 :
7917 4 : return NodeNumber;
7918 : }
7919 :
7920 8 : int GetVSCoilCondenserInletNode(EnergyPlusData &state,
7921 : std::string const &CoilName, // must match coil names for the coil type
7922 : bool &ErrorsFound // set to true if problem
7923 : )
7924 : {
7925 :
7926 : // FUNCTION INFORMATION:
7927 : // AUTHOR Bo Shen, based on DXCoil:GetCoilCondenserInletNode
7928 : // DATE WRITTEN July 2012
7929 :
7930 : // PURPOSE OF THIS FUNCTION:
7931 : // This function looks up the given coil and returns the condenser inlet node. If
7932 : // incorrect coil name is given, ErrorsFound is returned as true.
7933 :
7934 : // Return value
7935 : int CondNode; // returned condenser node number of matched coil
7936 :
7937 : // FUNCTION LOCAL VARIABLE DECLARATIONS:
7938 : int WhichCoil;
7939 :
7940 : // Obtains and Allocates WatertoAirHP related parameters from input file
7941 8 : if (state.dataVariableSpeedCoils->GetCoilsInputFlag) { // First time subroutine has been entered
7942 0 : GetVarSpeedCoilInput(state);
7943 0 : state.dataVariableSpeedCoils->GetCoilsInputFlag = false;
7944 : }
7945 :
7946 8 : WhichCoil = Util::FindItemInList(CoilName, state.dataVariableSpeedCoils->VarSpeedCoil);
7947 8 : if (WhichCoil != 0) {
7948 8 : CondNode = state.dataVariableSpeedCoils->VarSpeedCoil(WhichCoil).CondenserInletNodeNum;
7949 : } else {
7950 0 : ShowSevereError(state, format("GetCoilCondenserInletNode: Invalid VS DX Coil, Type= VS DX Cooling Name=\"{}\"", CoilName));
7951 0 : ErrorsFound = true;
7952 0 : CondNode = 0;
7953 : }
7954 :
7955 8 : return CondNode;
7956 : }
7957 :
7958 13 : Real64 GetVSCoilMinOATCompressor(EnergyPlusData &state,
7959 : int const CoilIndex, // index to cooling coil
7960 : bool &ErrorsFound // set to true if problem
7961 : )
7962 : {
7963 : // Obtains and Allocates WatertoAirHP related parameters from input file
7964 13 : if (state.dataVariableSpeedCoils->GetCoilsInputFlag) { // First time subroutine has been entered
7965 0 : GetVarSpeedCoilInput(state);
7966 0 : state.dataVariableSpeedCoils->GetCoilsInputFlag = false;
7967 : }
7968 :
7969 13 : if (CoilIndex == 0) {
7970 0 : ShowSevereError(state, "GetVSCoilMinOATCompressor: Index passed = 0");
7971 0 : ShowContinueError(state, "... returning Min OAT as -1000.");
7972 0 : ErrorsFound = true;
7973 0 : return -1000.0;
7974 : } else {
7975 13 : return state.dataVariableSpeedCoils->VarSpeedCoil(CoilIndex).MinOATCompressor;
7976 : }
7977 : }
7978 :
7979 7 : int GetVSCoilNumOfSpeeds(EnergyPlusData &state,
7980 : std::string const &CoilName, // must match coil names for the coil type
7981 : bool &ErrorsFound // set to true if problem
7982 : )
7983 : {
7984 :
7985 : // FUNCTION INFORMATION:
7986 : // AUTHOR Richard Raustad, FSEC
7987 : // DATE WRITTEN March 2013
7988 :
7989 : // PURPOSE OF THIS FUNCTION:
7990 : // This function looks up the given coil and returns number of speeds. If
7991 : // incorrect coil name is given, ErrorsFound is returned as true.
7992 :
7993 : // Return value
7994 : int Speeds; // returned number of speeds
7995 :
7996 : // Obtains and Allocates WatertoAirHP related parameters from input file
7997 7 : if (state.dataVariableSpeedCoils->GetCoilsInputFlag) { // First time subroutine has been entered
7998 0 : GetVarSpeedCoilInput(state);
7999 0 : state.dataVariableSpeedCoils->GetCoilsInputFlag = false;
8000 : }
8001 :
8002 7 : int WhichCoil = Util::FindItemInList(CoilName, state.dataVariableSpeedCoils->VarSpeedCoil);
8003 7 : if (WhichCoil != 0) {
8004 7 : Speeds = state.dataVariableSpeedCoils->VarSpeedCoil(WhichCoil).NumOfSpeeds;
8005 : } else {
8006 0 : ShowSevereError(state, format("GetVSCoilNumOfSpeeds: Invalid VS DX Coil, Type= VS DX Coil Name=\"{}\"", CoilName));
8007 0 : ErrorsFound = true;
8008 0 : Speeds = 0;
8009 : }
8010 :
8011 7 : return Speeds;
8012 : }
8013 :
8014 28 : Real64 GetVSCoilRatedSourceTemp(EnergyPlusData &state, int const CoilIndex)
8015 : {
8016 28 : Real64 RatedSourceTemp = 0.0;
8017 28 : switch (state.dataVariableSpeedCoils->VarSpeedCoil(CoilIndex).VSCoilType) {
8018 7 : case HVAC::Coil_CoolingWaterToAirHPVSEquationFit: {
8019 7 : RatedSourceTemp = RatedInletWaterTemp;
8020 7 : } break;
8021 3 : case HVAC::Coil_HeatingWaterToAirHPVSEquationFit: {
8022 3 : RatedSourceTemp = RatedInletWaterTempHeat;
8023 3 : } break;
8024 1 : case HVAC::CoilDX_HeatPumpWaterHeaterVariableSpeed: {
8025 1 : RatedSourceTemp = state.dataVariableSpeedCoils->VarSpeedCoil(CoilIndex).WHRatedInletWaterTemp;
8026 1 : } break;
8027 12 : case HVAC::Coil_CoolingAirToAirVariableSpeed: {
8028 12 : RatedSourceTemp = RatedAmbAirTemp;
8029 12 : } break;
8030 5 : case HVAC::Coil_HeatingAirToAirVariableSpeed: {
8031 5 : RatedSourceTemp = RatedAmbAirTempHeat;
8032 5 : } break;
8033 0 : default: {
8034 0 : assert(false);
8035 : } break;
8036 : }
8037 28 : return RatedSourceTemp;
8038 : }
8039 :
8040 12 : void SetVarSpeedCoilData(EnergyPlusData &state,
8041 : int const WSHPNum, // Number of OA Controller
8042 : bool &ErrorsFound, // Set to true if certain errors found
8043 : ObjexxFCL::Optional_int CompanionCoolingCoilNum, // Index to cooling coil for heating coil = SimpleWSHPNum
8044 : ObjexxFCL::Optional_int CompanionHeatingCoilNum, // Index to heating coil for cooling coil = SimpleWSHPNum
8045 : ObjexxFCL::Optional_int MSHPDesignSpecIndex // index to UnitarySystemPerformance:Multispeed object
8046 : )
8047 : {
8048 :
8049 : // SUBROUTINE INFORMATION:
8050 : // AUTHOR Bo Shen, based on WaterToAirHeatPumpSimple:SetWSHPData
8051 : // DATE WRITTEN March 2012
8052 :
8053 : // PURPOSE OF THIS SUBROUTINE:
8054 : // This routine was designed to "push" information from a parent object to this WSHP coil object.
8055 :
8056 : // Obtains and Allocates WatertoAirHP related parameters from input file
8057 12 : if (state.dataVariableSpeedCoils->GetCoilsInputFlag) { // First time subroutine has been entered
8058 0 : GetVarSpeedCoilInput(state);
8059 0 : state.dataVariableSpeedCoils->GetCoilsInputFlag = false;
8060 : }
8061 :
8062 12 : if (WSHPNum <= 0 || WSHPNum > state.dataVariableSpeedCoils->NumVarSpeedCoils) {
8063 0 : ShowSevereError(state,
8064 0 : format("SetVarSpeedCoilData: called with VS WSHP Coil Number out of range={} should be >0 and <{}",
8065 : WSHPNum,
8066 0 : state.dataVariableSpeedCoils->NumVarSpeedCoils));
8067 0 : ErrorsFound = true;
8068 0 : return;
8069 : }
8070 :
8071 12 : if (present(CompanionCoolingCoilNum)) {
8072 0 : state.dataVariableSpeedCoils->VarSpeedCoil(WSHPNum).CompanionCoolingCoilNum = CompanionCoolingCoilNum;
8073 0 : state.dataVariableSpeedCoils->VarSpeedCoil(WSHPNum).FindCompanionUpStreamCoil = true;
8074 0 : state.dataVariableSpeedCoils->VarSpeedCoil(CompanionCoolingCoilNum).CompanionHeatingCoilNum = WSHPNum;
8075 : }
8076 :
8077 12 : if (present(CompanionHeatingCoilNum)) {
8078 1 : state.dataVariableSpeedCoils->VarSpeedCoil(WSHPNum).CompanionHeatingCoilNum = CompanionHeatingCoilNum;
8079 1 : state.dataVariableSpeedCoils->VarSpeedCoil(CompanionHeatingCoilNum).CompanionCoolingCoilNum = WSHPNum;
8080 : }
8081 :
8082 12 : if (present(MSHPDesignSpecIndex)) {
8083 11 : state.dataVariableSpeedCoils->VarSpeedCoil(WSHPNum).MSHPDesignSpecIndex = MSHPDesignSpecIndex;
8084 : }
8085 : }
8086 :
8087 67679 : void UpdateVarSpeedCoil(EnergyPlusData &state, int const DXCoilNum)
8088 : {
8089 : // SUBROUTINE INFORMATION:
8090 : // AUTHOR Bo Shen, based on WaterToAirHeatPumpSimple:UpdateSimpleWSHP
8091 : // DATE WRITTEN March 2012
8092 :
8093 : // PURPOSE OF THIS SUBROUTINE:
8094 : // This subroutine updates the Water to Air Heat Pump outlet nodes.
8095 :
8096 : // METHODOLOGY EMPLOYED:
8097 : // Data is moved from the HP data structure to the HP outlet nodes.
8098 :
8099 : // Using/Aliasing
8100 67679 : Real64 TimeStepSysSec = state.dataHVACGlobal->TimeStepSysSec;
8101 :
8102 67679 : auto &varSpeedCoil = state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum);
8103 :
8104 : // WatertoAirHP(DXCoilNum)%SimFlag=.FALSE.
8105 67679 : if (!varSpeedCoil.SimFlag) {
8106 : // Heatpump is off; just pass through conditions
8107 39555 : varSpeedCoil.Power = 0.0;
8108 39555 : varSpeedCoil.QLoadTotal = 0.0;
8109 39555 : varSpeedCoil.QSensible = 0.0;
8110 39555 : varSpeedCoil.QLatent = 0.0;
8111 39555 : varSpeedCoil.QSource = 0.0;
8112 39555 : varSpeedCoil.Energy = 0.0;
8113 39555 : varSpeedCoil.EnergyLoadTotal = 0.0;
8114 39555 : varSpeedCoil.EnergySensible = 0.0;
8115 39555 : varSpeedCoil.EnergyLatent = 0.0;
8116 39555 : varSpeedCoil.EnergySource = 0.0;
8117 39555 : varSpeedCoil.COP = 0.0;
8118 39555 : varSpeedCoil.RunFrac = 0.0;
8119 39555 : varSpeedCoil.PartLoadRatio = 0.0;
8120 :
8121 39555 : varSpeedCoil.OutletAirDBTemp = varSpeedCoil.InletAirDBTemp;
8122 39555 : varSpeedCoil.OutletAirHumRat = varSpeedCoil.InletAirHumRat;
8123 39555 : varSpeedCoil.OutletAirEnthalpy = varSpeedCoil.InletAirEnthalpy;
8124 39555 : varSpeedCoil.OutletWaterTemp = varSpeedCoil.InletWaterTemp;
8125 39555 : varSpeedCoil.OutletWaterEnthalpy = varSpeedCoil.InletWaterEnthalpy;
8126 : }
8127 :
8128 67679 : int AirInletNode = varSpeedCoil.AirInletNodeNum;
8129 67679 : int WaterInletNode = varSpeedCoil.WaterInletNodeNum;
8130 67679 : int AirOutletNode = varSpeedCoil.AirOutletNodeNum;
8131 67679 : int WaterOutletNode = varSpeedCoil.WaterOutletNodeNum;
8132 :
8133 : // Set the air outlet nodes of the WatertoAirHPSimple
8134 67679 : state.dataLoopNodes->Node(AirOutletNode).MassFlowRate = state.dataLoopNodes->Node(AirInletNode).MassFlowRate; // LoadSideMassFlowRate
8135 67679 : state.dataLoopNodes->Node(AirOutletNode).Temp = varSpeedCoil.OutletAirDBTemp;
8136 67679 : state.dataLoopNodes->Node(AirOutletNode).HumRat = varSpeedCoil.OutletAirHumRat;
8137 67679 : state.dataLoopNodes->Node(AirOutletNode).Enthalpy = varSpeedCoil.OutletAirEnthalpy;
8138 :
8139 : // Set the air outlet nodes for properties that just pass through & not used
8140 67679 : state.dataLoopNodes->Node(AirOutletNode).Quality = state.dataLoopNodes->Node(AirInletNode).Quality;
8141 67679 : state.dataLoopNodes->Node(AirOutletNode).Press = state.dataLoopNodes->Node(AirInletNode).Press;
8142 67679 : state.dataLoopNodes->Node(AirOutletNode).MassFlowRateMin = state.dataLoopNodes->Node(AirInletNode).MassFlowRateMin;
8143 67679 : state.dataLoopNodes->Node(AirOutletNode).MassFlowRateMax = state.dataLoopNodes->Node(AirInletNode).MassFlowRateMax; // LoadSideMassFlowRate
8144 67679 : state.dataLoopNodes->Node(AirOutletNode).MassFlowRateMinAvail = state.dataLoopNodes->Node(AirInletNode).MassFlowRateMinAvail;
8145 67679 : state.dataLoopNodes->Node(AirOutletNode).MassFlowRateMaxAvail =
8146 67679 : state.dataLoopNodes->Node(AirInletNode).MassFlowRateMaxAvail; // LoadSideMassFlowRate
8147 :
8148 : // Set the water outlet node of the WatertoAirHPSimple
8149 : // Set the water outlet nodes for properties that just pass through & not used
8150 67679 : if (WaterInletNode != 0 && WaterOutletNode != 0) {
8151 67273 : PlantUtilities::SafeCopyPlantNode(state, WaterInletNode, WaterOutletNode);
8152 67273 : state.dataLoopNodes->Node(WaterOutletNode).Temp = varSpeedCoil.OutletWaterTemp;
8153 67273 : state.dataLoopNodes->Node(WaterOutletNode).Enthalpy = varSpeedCoil.OutletWaterEnthalpy;
8154 : }
8155 :
8156 67679 : varSpeedCoil.Energy = varSpeedCoil.Power * TimeStepSysSec;
8157 67679 : varSpeedCoil.EnergyLoadTotal = varSpeedCoil.QLoadTotal * TimeStepSysSec;
8158 67679 : varSpeedCoil.EnergySensible = varSpeedCoil.QSensible * TimeStepSysSec;
8159 67679 : varSpeedCoil.EnergyLatent = varSpeedCoil.QLatent * TimeStepSysSec;
8160 67679 : varSpeedCoil.EnergySource = varSpeedCoil.QSource * TimeStepSysSec;
8161 :
8162 67679 : if (state.dataContaminantBalance->Contaminant.CO2Simulation) {
8163 1 : state.dataLoopNodes->Node(AirOutletNode).CO2 = state.dataLoopNodes->Node(AirInletNode).CO2;
8164 : }
8165 :
8166 67679 : if (state.dataContaminantBalance->Contaminant.GenericContamSimulation) {
8167 1 : state.dataLoopNodes->Node(AirOutletNode).GenContam = state.dataLoopNodes->Node(AirInletNode).GenContam;
8168 : }
8169 :
8170 67679 : if (varSpeedCoil.reportCoilFinalSizes) {
8171 23 : if (!state.dataGlobal->WarmupFlag && !state.dataGlobal->DoingHVACSizingSimulations && !state.dataGlobal->DoingSizing) {
8172 19 : if (varSpeedCoil.VSCoilType == HVAC::Coil_CoolingWaterToAirHPVSEquationFit ||
8173 17 : varSpeedCoil.VSCoilType == HVAC::Coil_CoolingAirToAirVariableSpeed) { // cooling coil
8174 13 : state.dataRptCoilSelection->coilSelectionReportObj->setCoilFinalSizes(state,
8175 13 : varSpeedCoil.Name,
8176 13 : varSpeedCoil.VarSpeedCoilType,
8177 : varSpeedCoil.RatedCapCoolTotal,
8178 : varSpeedCoil.RatedCapCoolSens,
8179 : varSpeedCoil.RatedAirVolFlowRate,
8180 : varSpeedCoil.RatedWaterMassFlowRate);
8181 6 : } else if (varSpeedCoil.VSCoilType == HVAC::Coil_HeatingWaterToAirHPVSEquationFit ||
8182 5 : varSpeedCoil.VSCoilType == HVAC::Coil_HeatingAirToAirVariableSpeed) { // heating coil
8183 6 : state.dataRptCoilSelection->coilSelectionReportObj->setCoilFinalSizes(state,
8184 6 : varSpeedCoil.Name,
8185 6 : varSpeedCoil.VarSpeedCoilType,
8186 : varSpeedCoil.RatedCapHeat,
8187 : varSpeedCoil.RatedCapHeat,
8188 : varSpeedCoil.RatedAirVolFlowRate,
8189 : varSpeedCoil.RatedWaterMassFlowRate);
8190 : }
8191 19 : varSpeedCoil.reportCoilFinalSizes = false;
8192 : }
8193 : }
8194 67679 : if (varSpeedCoil.VSCoilType == HVAC::Coil_CoolingWaterToAirHPVSEquationFit ||
8195 34042 : varSpeedCoil.VSCoilType == HVAC::Coil_CoolingAirToAirVariableSpeed) {
8196 : // Add power to global variable so power can be summed by parent object
8197 34011 : state.dataHVACGlobal->DXElecCoolingPower = varSpeedCoil.Power;
8198 33668 : } else if (varSpeedCoil.VSCoilType == HVAC::Coil_HeatingWaterToAirHPVSEquationFit) {
8199 : // Add power to global variable so power can be summed by parent object
8200 33636 : state.dataHVACGlobal->DXElecHeatingPower = varSpeedCoil.Power;
8201 32 : } else if (varSpeedCoil.VSCoilType == HVAC::Coil_HeatingAirToAirVariableSpeed) {
8202 : // Add power to global variable so power can be summed by parent object
8203 31 : state.dataHVACGlobal->DXElecHeatingPower = varSpeedCoil.Power + varSpeedCoil.CrankcaseHeaterPower;
8204 31 : state.dataHVACGlobal->DefrostElecPower = varSpeedCoil.DefrostPower;
8205 : }
8206 67679 : }
8207 :
8208 11 : Real64 CalcEffectiveSHR(EnergyPlusData &state,
8209 : int const DXCoilNum, // Index number for cooling coil
8210 : Real64 const SHRss, // Steady-state sensible heat ratio
8211 : HVAC::FanOp const fanOp, // Fan/compressor cycling scheme indicator
8212 : Real64 const RTF, // Compressor run-time fraction
8213 : Real64 const QLatRated, // Rated latent capacity
8214 : Real64 const QLatActual, // Actual latent capacity
8215 : Real64 const EnteringDB, // Entering air dry-bulb temperature
8216 : Real64 const EnteringWB // Entering air wet-bulb temperature
8217 : )
8218 : {
8219 :
8220 : // FUNCTION INFORMATION:
8221 : // AUTHOR Bo Shen, based on WaterToAirHeatPumpSimple:CalcEffectiveSHR
8222 : // DATE WRITTEN March 2012
8223 :
8224 : // PURPOSE OF THIS FUNCTION:
8225 : // Adjust sensible heat ratio to account for degradation of DX coil latent
8226 : // capacity at part-load (cycling) conditions.
8227 :
8228 : // METHODOLOGY EMPLOYED:
8229 : // With model parameters entered by the user, the part-load latent performance
8230 : // of a DX cooling coil is determined for a constant air flow system with
8231 : // a cooling coil that cycles on/off. The model calculates the time
8232 : // required for condensate to begin falling from the cooling coil.
8233 : // Runtimes greater than this are integrated to a "part-load" latent
8234 : // capacity which is used to determine the "part-load" sensible heat ratio.
8235 : // See reference below for additional details (linear decay model, Eq. 8b).
8236 :
8237 : // For cycling fan operation, a modified version of Henderson and Rengarajan (1996)
8238 : // model is used by ultilizing the fan delay time as the time-off (or time duration
8239 : // for the re-evaporation of moisture from time coil). Refer to Tang, C.C. (2005)
8240 :
8241 : // Return value
8242 : Real64 SHReff; // Effective sensible heat ratio, includes degradation due to cycling effects
8243 :
8244 : // FUNCTION LOCAL VARIABLE DECLARATIONS:
8245 : Real64 Twet; // Nominal time for condensate to begin leaving the coil's condensate drain line
8246 : // at the current operating conditions (sec)
8247 : Real64 Gamma; // Initial moisture evaporation rate divided by steady-state AC latent capacity
8248 : // at the current operating conditions
8249 : Real64 Twet_max; // Maximum allowed value for Twet
8250 : Real64 Ton; // Coil on time (sec)
8251 : Real64 Toff; // Coil off time (sec)
8252 : Real64 Toffa; // Actual coil off time (sec). Equations valid for Toff <= (2.0 * Twet/Gamma)
8253 : Real64 aa; // Intermediate variable
8254 : Real64 To1; // Intermediate variable (first guess at To). To = time to the start of moisture removal
8255 : Real64 To2; // Intermediate variable (second guess at To). To = time to the start of moisture removal
8256 : Real64 Error; // Error for iteration (DO) loop
8257 : Real64 LHRmult; // Latent Heat Ratio (LHR) multiplier. The effective latent heat ratio LHR = (1-SHRss)*LHRmult
8258 :
8259 11 : Real64 Twet_Rated = state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Twet_Rated; // [s]
8260 11 : Real64 Gamma_Rated = state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Gamma_Rated;
8261 11 : Real64 MaxONOFFCyclesperHour = state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MaxONOFFCyclesperHour; // [cycles/hr]
8262 11 : Real64 LatentCapacityTimeConstant = state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).LatentCapacityTimeConstant; // [s]
8263 11 : Real64 FanDelayTime = state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).FanDelayTime; // [s]
8264 :
8265 : // No moisture evaporation (latent degradation) occurs for runtime fraction of 1.0
8266 : // All latent degradation model parameters cause divide by 0.0 if not greater than 0.0
8267 : // Latent degradation model parameters initialize to 0.0 meaning no evaporation model used.
8268 11 : if ((RTF >= 1.0) || (QLatRated == 0.0) || (QLatActual == 0.0) || (Twet_Rated <= 0.0) || (Gamma_Rated <= 0.0) ||
8269 7 : (MaxONOFFCyclesperHour <= 0.0) || (LatentCapacityTimeConstant <= 0.0) || (RTF <= 0.0)) {
8270 4 : SHReff = SHRss;
8271 4 : return SHReff;
8272 : }
8273 :
8274 7 : Twet_max = 9999.0; // high limit for Twet
8275 :
8276 : // Calculate the model parameters at the actual operating conditions
8277 7 : Twet = min(Twet_Rated * QLatRated / (QLatActual + 1.e-10), Twet_max);
8278 7 : Gamma = Gamma_Rated * QLatRated * (EnteringDB - EnteringWB) / ((26.7 - 19.4) * QLatActual + 1.e-10);
8279 :
8280 : // Calculate the compressor on and off times using a converntional thermostat curve
8281 7 : Ton = 3600.0 / (4.0 * MaxONOFFCyclesperHour * (1.0 - RTF)); // duration of cooling coil on-cycle (sec)
8282 :
8283 7 : if ((fanOp == HVAC::FanOp::Cycling) && (FanDelayTime != 0.0)) {
8284 : // For FanOp::Cycling, moisture is evaporated from the cooling coil back to the air stream
8285 : // until the fan cycle off. Assume no evaporation from the coil after the fan shuts off.
8286 0 : Toff = FanDelayTime;
8287 : } else {
8288 : // For FanOp::Continuous, moisture is evaporated from the cooling coil back to the air stream
8289 : // for the entire heat pump off-cycle.
8290 7 : Toff = 3600.0 / (4.0 * MaxONOFFCyclesperHour * RTF); // duration of cooling coil off-cycle (sec)
8291 : }
8292 :
8293 : // Cap Toff to meet the equation restriction
8294 7 : if (Gamma > 0.0) {
8295 7 : Toffa = min(Toff, 2.0 * Twet / Gamma);
8296 : } else {
8297 0 : Toffa = Toff;
8298 : }
8299 :
8300 : // Use sucessive substitution to solve for To
8301 7 : aa = (Gamma * Toffa) - (0.25 / Twet) * pow_2(Gamma) * pow_2(Toffa);
8302 :
8303 7 : To1 = aa + LatentCapacityTimeConstant;
8304 7 : Error = 1.0;
8305 14 : while (Error > 0.001) {
8306 7 : To2 = aa - LatentCapacityTimeConstant * (std::exp(-To1 / LatentCapacityTimeConstant) - 1.0);
8307 7 : Error = std::abs((To2 - To1) / To1);
8308 7 : To1 = To2;
8309 : }
8310 :
8311 : // Adjust Sensible Heat Ratio (SHR) using Latent Heat Ratio (LHR) multiplier
8312 : // Floating underflow errors occur when -Ton/LatentCapacityTimeConstant is a large negative number.
8313 : // Cap lower limit at -700 to avoid the underflow errors.
8314 7 : aa = std::exp(max(-700.0, -Ton / LatentCapacityTimeConstant));
8315 : // Calculate latent heat ratio multiplier
8316 7 : LHRmult = max(((Ton - To2) / (Ton + LatentCapacityTimeConstant * (aa - 1.0))), 0.0);
8317 :
8318 : // Calculate part-load or "effective" sensible heat ratio
8319 7 : SHReff = 1.0 - (1.0 - SHRss) * LHRmult;
8320 :
8321 7 : if (SHReff < SHRss) SHReff = SHRss; // Effective SHR can be less than the steady-state SHR
8322 7 : if (SHReff > 1.0) SHReff = 1.0; // Effective sensible heat ratio can't be greater than 1.0
8323 :
8324 7 : return SHReff;
8325 : }
8326 :
8327 17696 : void CalcTotCapSHR_VSWSHP(EnergyPlusData &state,
8328 : Real64 const InletDryBulb, // inlet air dry bulb temperature [C]
8329 : Real64 const InletHumRat, // inlet air humidity ratio [kg water / kg dry air]
8330 : Real64 const InletEnthalpy, // inlet air specific enthalpy [J/kg]
8331 : Real64 &InletWetBulb, // inlet air wet bulb temperature [C]
8332 : Real64 const AirMassFlowRatio, // Ratio of actual air mass flow to nominal air mass flow
8333 : Real64 const WaterMassFlowRatio, // Ratio of actual water mass flow to nominal water mass flow
8334 : Real64 const AirMassFlow, // actual mass flow for capacity and SHR calculation
8335 : Real64 const CBF, // coil bypass factor
8336 : Real64 const TotCapNom1, // nominal total capacity at low speed [W]
8337 : int const CCapFTemp1, // capacity modifier curve index, function of entering wetbulb at low speed
8338 : int const CCapAirFFlow1, // capacity modifier curve, function of actual air flow vs rated flow at low speed
8339 : int const CCapWaterFFlow1, // capacity modifier curve, function of actual water flow vs rated flow at low speed
8340 : Real64 const TotCapNom2, // nominal total capacity at high speed [W]
8341 : int const CCapFTemp2, // capacity modifier curve index, function of entering wetbulb at high speed
8342 : int const CCapAirFFlow2, // capacity modifier curve, function of actual air flow vs rated flow at high speed
8343 : int const CCapWaterFFlow2, // capacity modifier curve, function of actual water flow vs rated flow at high speed
8344 : Real64 &TotCap1, // total capacity at the given conditions [W] at low speed
8345 : Real64 &TotCap2, // total capacity at the given conditions [W] at high speed
8346 : Real64 &TotCapSpeed, // integrated total capacity corresponding to the speed ratio
8347 : Real64 &SHR, // sensible heat ratio at the given conditions
8348 : Real64 const CondInletTemp, // Condenser inlet temperature [C]
8349 : Real64 const Pressure, // air pressure [Pa]
8350 : Real64 const SpeedRatio, // from 0.0 to 1.0
8351 : int const NumSpeeds, // number of speeds for input
8352 : Real64 &TotCapModFac // capacity modification factor, func of temp and func of flow
8353 : )
8354 : {
8355 :
8356 : // SUBROUTINE INFORMATION:
8357 : // AUTHOR Bo Shen, , based on DX:CalcTotCapSHR, introducing two speed levels
8358 : // DATE WRITTEN March 2012
8359 :
8360 : // PURPOSE OF THIS SUBROUTINE:
8361 : // Calculates total capacity and sensible heat ratio of a DX coil at the specified conditions
8362 :
8363 : // METHODOLOGY EMPLOYED:
8364 : // With the rated performance data entered by the user, the model employs some of the
8365 : // DOE-2.1E curve fits to adjust the capacity and SHR of the unit as a function
8366 : // of entering air temperatures and supply air flow rate (actual vs rated flow). The model
8367 : // does NOT employ the exact same methodology to calculate performance as DOE-2, although
8368 : // some of the DOE-2 curve fits are employed by this model.
8369 :
8370 : // The model checks for coil dryout conditions, and adjusts the calculated performance appropriately.
8371 :
8372 : // REFERENCES:
8373 : // ASHRAE HVAC 2 Toolkit page 4-81.
8374 : // Henderson, H.I. Jr., K. Rengarajan and D.B. Shirey, III. 1992.The impact of comfort
8375 : // control on air conditioner energy use in humid climates. ASHRAE Transactions 98(2):
8376 : // 104-113.
8377 : // Henderson, H.I. Jr., Danny Parker and Y.J. Huang. 2000.Improving DOE-2's RESYS routine:
8378 : // User Defined Functions to Provide More Accurate Part Load Energy Use and Humidity
8379 : // Predictions. Proceedings of ACEEE Conference.
8380 :
8381 : // SUBROUTINE PARAMETER DEFINITIONS:
8382 : static constexpr std::string_view RoutineName("CalcTotCapSHR_VSWSHP");
8383 17696 : constexpr int MaxIter = 30; // Maximum number of iterations for dry evaporator calculations
8384 17696 : constexpr Real64 Tolerance = 0.01; // Error tolerance for dry evaporator iterations
8385 :
8386 : // SUBROUTINE LOCAL VARIABLE DECLARATIONS:
8387 : Real64 TotCapWaterFlowModFac1; // Total capacity modifier (function of actual supply water flow vs nominal flow) at low speed
8388 : Real64 TotCapTempModFac2; // Total capacity modifier (function of entering wetbulb, outside water inlet temp) at high speed
8389 : Real64 TotCapAirFlowModFac2; // Total capacity modifier (function of actual supply air flow vs nominal flow) at high speed
8390 : Real64 TotCapWaterFlowModFac2; // Total capacity modifier (function of actual supply water flow vs nominal flow) at high speed
8391 : Real64 TotCapCalc; // temporary calculated value of total capacity [W]
8392 : Real64 TotCapCalc1; // temporary calculated value of total capacity [W] at low speed
8393 : Real64 TotCapCalc2; // temporary calculated value of total capacity [W] at high speed
8394 :
8395 17696 : int Counter = 0; // Error tolerance for dry evaporator iterations
8396 17696 : Real64 RF = 0.4; // Relaxation factor for dry evaporator iterations
8397 17696 : Real64 werror = 0.0; // Deviation of humidity ratio in dry evaporator iteration loop
8398 17696 : Real64 SHRCalc = SHR; // initialize temporary calculated value of SHR
8399 17696 : Real64 InletWetBulbCalc = InletWetBulb; // calculated inlet wetbulb temperature used for finding dry coil point [C]
8400 17696 : Real64 InletHumRatCalc = InletHumRat; // calculated inlet humidity ratio used for finding dry coil point [kg water / kg dry air]
8401 17696 : bool LoopOn = true; // flag to control the loop iteration
8402 :
8403 : // LOOP WHILE (ABS(werror) .gt. Tolerance .OR. Counter == 0)
8404 35402 : while (LoopOn) {
8405 : // Get capacity modifying factor (function of inlet wetbulb & condenser inlet temp) for off-rated conditions
8406 17706 : Real64 TotCapTempModFac1 = Curve::CurveValue(state, CCapFTemp1, InletWetBulbCalc, CondInletTemp);
8407 : // Get capacity modifying factor (function of mass flow) for off-rated conditions
8408 17706 : Real64 TotCapAirFlowModFac1 = Curve::CurveValue(state, CCapAirFFlow1, AirMassFlowRatio);
8409 : // Get capacity modifying factor (function of mass flow) for off-rated conditions
8410 17706 : if (CCapWaterFFlow1 == 0) {
8411 589 : TotCapWaterFlowModFac1 = 1.0;
8412 : } else {
8413 17117 : TotCapWaterFlowModFac1 = Curve::CurveValue(state, CCapWaterFFlow1, WaterMassFlowRatio);
8414 : }
8415 :
8416 : // Get total capacity
8417 17706 : if (NumSpeeds < 2) { // ONLY ONE SPEED
8418 14340 : TotCapCalc = TotCapNom1 * TotCapAirFlowModFac1 * TotCapWaterFlowModFac1 * TotCapTempModFac1;
8419 14340 : TotCapCalc1 = TotCapCalc;
8420 14340 : TotCapCalc2 = 0.0;
8421 14340 : TotCapModFac = TotCapAirFlowModFac1 * TotCapWaterFlowModFac1 * TotCapTempModFac1;
8422 : } else {
8423 3366 : TotCapTempModFac2 = Curve::CurveValue(state, CCapFTemp2, InletWetBulbCalc, CondInletTemp);
8424 3366 : TotCapAirFlowModFac2 = Curve::CurveValue(state, CCapAirFFlow2, AirMassFlowRatio);
8425 :
8426 3366 : if (CCapWaterFFlow2 == 0) {
8427 23 : TotCapWaterFlowModFac2 = 1.0;
8428 : } else {
8429 3343 : TotCapWaterFlowModFac2 = Curve::CurveValue(state, CCapWaterFFlow2, WaterMassFlowRatio);
8430 : }
8431 :
8432 3366 : TotCapCalc1 = TotCapNom1 * TotCapAirFlowModFac1 * TotCapWaterFlowModFac1 * TotCapTempModFac1;
8433 3366 : TotCapCalc2 = TotCapNom2 * TotCapAirFlowModFac2 * TotCapWaterFlowModFac2 * TotCapTempModFac2;
8434 :
8435 3366 : TotCapCalc = TotCapCalc2 * SpeedRatio + (1.0 - SpeedRatio) * TotCapCalc1;
8436 3366 : TotCapModFac = (TotCapAirFlowModFac2 * TotCapWaterFlowModFac2 * TotCapTempModFac2) * SpeedRatio +
8437 3366 : (1.0 - SpeedRatio) * (TotCapAirFlowModFac1 * TotCapWaterFlowModFac1 * TotCapTempModFac1);
8438 : }
8439 :
8440 17706 : Real64 localCBF = max(0.0, CBF); // negative coil bypass factor is physically impossible
8441 :
8442 : // Calculate apparatus dew point conditions using TotCap and CBF
8443 17706 : Real64 hDelta = TotCapCalc / AirMassFlow; // Change in air enthalpy across the cooling coil [J/kg]
8444 17706 : Real64 hADP = InletEnthalpy - hDelta / (1.0 - localCBF); // Apparatus dew point enthalpy [J/kg]
8445 17706 : Real64 tADP = Psychrometrics::PsyTsatFnHPb(state, hADP, Pressure, RoutineName); // Apparatus dew point temperature [C]
8446 17706 : Real64 wADP = Psychrometrics::PsyWFnTdbH(state, tADP, hADP, RoutineName); // Apparatus dew point humidity ratio [kg/kg]
8447 17706 : Real64 hTinwADP = Psychrometrics::PsyHFnTdbW(InletDryBulb, wADP); // Enthalpy at inlet dry-bulb and wADP [J/kg]
8448 17706 : if (TotCapCalc > 1.0e-10) {
8449 17699 : SHRCalc = min((hTinwADP - hADP) / (InletEnthalpy - hADP), 1.0); // temporary calculated value of SHR
8450 : } else {
8451 7 : SHRCalc = 1.0;
8452 : }
8453 :
8454 : // Check for dry evaporator conditions (win < wadp)
8455 17706 : if (wADP > InletHumRatCalc || (Counter >= 1 && Counter < MaxIter)) {
8456 17 : if (InletHumRatCalc == 0.0) InletHumRatCalc = 0.00001;
8457 17 : werror = (InletHumRatCalc - wADP) / InletHumRatCalc;
8458 : // Increase InletHumRatCalc at constant inlet air temp to find coil dry-out point. Then use the
8459 : // capacity at the dry-out point to determine exiting conditions from coil. This is required
8460 : // since the TotCapTempModFac doesn't work properly with dry-coil conditions.
8461 17 : InletHumRatCalc = RF * wADP + (1.0 - RF) * InletHumRatCalc;
8462 17 : InletWetBulbCalc = Psychrometrics::PsyTwbFnTdbWPb(state, InletDryBulb, InletHumRatCalc, Pressure);
8463 17 : ++Counter;
8464 34 : if (std::abs(werror) > Tolerance) {
8465 10 : LoopOn = true; // Recalculate with modified inlet conditions
8466 : } else {
8467 7 : LoopOn = false;
8468 : }
8469 : } else {
8470 17689 : LoopOn = false;
8471 : }
8472 : } // END LOOP
8473 :
8474 : // Calculate full load output conditions
8475 17696 : if (SHRCalc > 1.0 || Counter > 0) SHRCalc = 1.0; // if Counter > 0 means a dry coil so SHR = 1
8476 :
8477 17696 : SHR = SHRCalc;
8478 17696 : TotCap1 = TotCapCalc1;
8479 17696 : TotCap2 = TotCapCalc2;
8480 17696 : TotCapSpeed = TotCapCalc;
8481 17696 : InletWetBulb = InletWetBulbCalc;
8482 17696 : }
8483 :
8484 2 : Real64 getVarSpeedPartLoadRatio(EnergyPlusData &state, int const DXCoilNum)
8485 : {
8486 2 : return state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).PartLoadRatio;
8487 : }
8488 :
8489 : } // namespace VariableSpeedCoils
8490 :
8491 : } // namespace EnergyPlus
|
