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")) {
2069 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).DefrostStrategy = ReverseCycle;
2070 : }
2071 13 : if (Util::SameString(AlphArray(7), "Resistive")) {
2072 13 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).DefrostStrategy = Resistive;
2073 : }
2074 13 : if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).DefrostStrategy == 0) {
2075 0 : ShowSevereError(
2076 : state,
2077 0 : format("{}{}=\"{}\", invalid", RoutineName, CurrentModuleObject, state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name));
2078 0 : ShowContinueError(state, format("...illegal {}=\"{}\".", cAlphaFields(7), AlphArray(7)));
2079 0 : ShowContinueError(state, "...valid values for this field are ReverseCycle or Resistive.");
2080 0 : ErrorsFound = true;
2081 : }
2082 :
2083 13 : if (Util::SameString(AlphArray(8), "Timed")) {
2084 12 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).DefrostControl = Timed;
2085 : }
2086 13 : if (Util::SameString(AlphArray(8), "OnDemand")) {
2087 1 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).DefrostControl = OnDemand;
2088 : }
2089 13 : if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).DefrostControl == 0) {
2090 0 : ShowSevereError(
2091 : state,
2092 0 : format("{}{}=\"{}\", invalid", RoutineName, CurrentModuleObject, state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name));
2093 0 : ShowContinueError(state, format("...illegal {}=\"{}\".", cAlphaFields(8), AlphArray(8)));
2094 0 : ShowContinueError(state, "...valid values for this field are Timed or OnDemand.");
2095 0 : ErrorsFound = true;
2096 : }
2097 :
2098 : // Set minimum OAT for heat pump compressor operation
2099 13 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MinOATCompressor = NumArray(5);
2100 :
2101 : // reserved for HSPF calculation
2102 13 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).OATempCompressorOn = NumArray(6);
2103 :
2104 : // Set maximum outdoor temp for defrost to occur
2105 13 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MaxOATDefrost = NumArray(7);
2106 :
2107 : // Set crankcase heater capacity
2108 13 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).CrankcaseHeaterCapacity = NumArray(8);
2109 13 : if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).CrankcaseHeaterCapacity < 0.0) {
2110 0 : ShowSevereError(
2111 : state,
2112 0 : format("{}{}=\"{}\", invalid", RoutineName, CurrentModuleObject, state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name));
2113 0 : ShowContinueError(state, format("...{} cannot be < 0.0.", cNumericFields(9)));
2114 0 : ShowContinueError(state, format("...entered value=[{:.2T}].", NumArray(9)));
2115 0 : ErrorsFound = true;
2116 : }
2117 :
2118 : // Set crankcase heater cutout temperature
2119 13 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MaxOATCrankcaseHeater = NumArray(9);
2120 :
2121 : // Set defrost time period
2122 13 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).DefrostTime = NumArray(10);
2123 13 : if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).DefrostTime == 0.0 &&
2124 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).DefrostControl == 1) {
2125 0 : ShowWarningError(
2126 0 : state, format("{}{}=\"{}\", ", RoutineName, CurrentModuleObject, state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name));
2127 0 : ShowContinueError(state, format("...{} = 0.0 for defrost control = TIMED.", cNumericFields(5)));
2128 : }
2129 :
2130 : // Set defrost capacity (for resistive defrost)
2131 13 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).DefrostCapacity = NumArray(11);
2132 13 : if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).DefrostCapacity == 0.0 &&
2133 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).DefrostStrategy == 2) {
2134 0 : ShowWarningError(
2135 0 : state, format("{}{}=\"{}\", ", RoutineName, CurrentModuleObject, state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name));
2136 0 : ShowContinueError(state, format("...{} = 0.0 for defrost strategy = RESISTIVE.", cNumericFields(6)));
2137 : }
2138 :
2139 133 : for (int I = 1; I <= state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).NumOfSpeeds; ++I) {
2140 120 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedTotCap(I) = NumArray(12 + (I - 1) * 5);
2141 120 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedCOP(I) = NumArray(13 + (I - 1) * 5);
2142 120 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedAirVolFlowRate(I) = NumArray(14 + (I - 1) * 5);
2143 120 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedEvaporatorFanPowerPerVolumeFlowRate2017(I) = NumArray(15 + (I - 1) * 5);
2144 120 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedEvaporatorFanPowerPerVolumeFlowRate2023(I) = NumArray(16 + (I - 1) * 5);
2145 :
2146 120 : if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedTotCap(I) < 1.e-10) {
2147 0 : ShowSevereError(state,
2148 0 : format("{}{}=\"{}\", invalid value",
2149 : RoutineName,
2150 : CurrentModuleObject,
2151 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name));
2152 0 : ShowContinueError(state,
2153 0 : format("...too small {}=[{:.2R}].",
2154 0 : cNumericFields(12 + (I - 1) * 3),
2155 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedTotCap(I)));
2156 0 : ErrorsFound = true;
2157 : }
2158 :
2159 120 : AlfaFieldIncre = 9 + (I - 1) * 4;
2160 120 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSCCapFTemp(I) =
2161 120 : Curve::GetCurveIndex(state, AlphArray(AlfaFieldIncre)); // convert curve name to number
2162 120 : if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSCCapFTemp(I) == 0) {
2163 0 : if (lAlphaBlanks(AlfaFieldIncre)) {
2164 0 : ShowSevereError(state,
2165 0 : format("{}{}=\"{}\", missing",
2166 : RoutineName,
2167 : CurrentModuleObject,
2168 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name));
2169 0 : ShowContinueError(state, format("...required {} is blank.", cAlphaFields(AlfaFieldIncre)));
2170 : } else {
2171 0 : ShowSevereError(state,
2172 0 : format("{}{}=\"{}\", invalid",
2173 : RoutineName,
2174 : CurrentModuleObject,
2175 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name));
2176 0 : ShowContinueError(state, format("...not found {}=\"{}\".", cAlphaFields(AlfaFieldIncre), AlphArray(AlfaFieldIncre)));
2177 : }
2178 0 : ErrorsFound = true;
2179 : } else {
2180 : // Verify Curve Object, only legal type is BiQuadratic
2181 360 : ErrorsFound |= Curve::CheckCurveDims(state,
2182 120 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSCCapFTemp(I), // Curve index
2183 : {2}, // Valid dimensions
2184 : RoutineName, // Routine name
2185 : CurrentModuleObject, // Object Type
2186 120 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name, // Object Name
2187 120 : cAlphaFields(AlfaFieldIncre)); // Field Name
2188 :
2189 120 : if (!ErrorsFound) {
2190 240 : CurveVal = Curve::CurveValue(
2191 120 : state, state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSCCapFTemp(I), RatedInletAirTempHeat, RatedAmbAirTempHeat);
2192 120 : if (CurveVal > 1.10 || CurveVal < 0.90) {
2193 60 : ShowWarningError(state,
2194 60 : format("{}{}=\"{}\", curve values",
2195 : RoutineName,
2196 : CurrentModuleObject,
2197 30 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name));
2198 60 : ShowContinueError(
2199 60 : state, format("...{} output is not equal to 1.0 (+ or - 10%) at rated conditions.", cAlphaFields(AlfaFieldIncre)));
2200 30 : ShowContinueError(state, format("...Curve output at rated conditions = {:.3T}", CurveVal));
2201 : }
2202 : }
2203 : }
2204 :
2205 120 : AlfaFieldIncre = 10 + (I - 1) * 4;
2206 120 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSCCapAirFFlow(I) =
2207 120 : Curve::GetCurveIndex(state, AlphArray(AlfaFieldIncre)); // convert curve name to number
2208 120 : if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSCCapAirFFlow(I) == 0) {
2209 0 : if (lAlphaBlanks(AlfaFieldIncre)) {
2210 0 : ShowSevereError(state,
2211 0 : format("{}{}=\"{}\", missing",
2212 : RoutineName,
2213 : CurrentModuleObject,
2214 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name));
2215 0 : ShowContinueError(state, format("...required {} is blank.", cAlphaFields(AlfaFieldIncre)));
2216 : } else {
2217 0 : ShowSevereError(state,
2218 0 : format("{}{}=\"{}\", invalid",
2219 : RoutineName,
2220 : CurrentModuleObject,
2221 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name));
2222 0 : ShowContinueError(state, format("...not found {}=\"{}\".", cAlphaFields(AlfaFieldIncre), AlphArray(AlfaFieldIncre)));
2223 : }
2224 0 : ErrorsFound = true;
2225 : } else {
2226 : // Verify Curve Object, only legal type is Quadratic
2227 360 : ErrorsFound |= Curve::CheckCurveDims(state,
2228 120 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSCCapAirFFlow(I), // Curve index
2229 : {1}, // Valid dimensions
2230 : RoutineName, // Routine name
2231 : CurrentModuleObject, // Object Type
2232 120 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name, // Object Name
2233 120 : cAlphaFields(AlfaFieldIncre)); // Field Name
2234 :
2235 120 : if (!ErrorsFound) {
2236 120 : CurveVal = Curve::CurveValue(state, state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSCCapAirFFlow(I), 1.0);
2237 120 : if (CurveVal > 1.10 || CurveVal < 0.90) {
2238 0 : ShowWarningError(state,
2239 0 : format("{}{}=\"{}\", curve values",
2240 : RoutineName,
2241 : CurrentModuleObject,
2242 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name));
2243 0 : ShowContinueError(
2244 0 : state, format("...{} output is not equal to 1.0 (+ or - 10%) at rated conditions.", cAlphaFields(AlfaFieldIncre)));
2245 0 : ShowContinueError(state, format("...Curve output at rated conditions = {:.3T}", CurveVal));
2246 : }
2247 : }
2248 : }
2249 :
2250 120 : AlfaFieldIncre = 11 + (I - 1) * 4;
2251 120 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSEIRFTemp(I) =
2252 120 : Curve::GetCurveIndex(state, AlphArray(AlfaFieldIncre)); // convert curve name to number
2253 120 : if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSEIRFTemp(I) == 0) {
2254 0 : if (lAlphaBlanks(AlfaFieldIncre)) {
2255 0 : ShowSevereError(state,
2256 0 : format("{}{}=\"{}\", missing",
2257 : RoutineName,
2258 : CurrentModuleObject,
2259 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name));
2260 0 : ShowContinueError(state, format("...required {} is blank.", cAlphaFields(AlfaFieldIncre)));
2261 : } else {
2262 0 : ShowSevereError(state,
2263 0 : format("{}{}=\"{}\", invalid",
2264 : RoutineName,
2265 : CurrentModuleObject,
2266 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name));
2267 0 : ShowContinueError(state, format("...not found {}=\"{}\".", cAlphaFields(AlfaFieldIncre), AlphArray(AlfaFieldIncre)));
2268 : }
2269 0 : ErrorsFound = true;
2270 : } else {
2271 : // Verify Curve Object, only legal type is BiQuadratic
2272 360 : ErrorsFound |= Curve::CheckCurveDims(state,
2273 120 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSEIRFTemp(I), // Curve index
2274 : {2}, // Valid dimensions
2275 : RoutineName, // Routine name
2276 : CurrentModuleObject, // Object Type
2277 120 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name, // Object Name
2278 120 : cAlphaFields(AlfaFieldIncre)); // Field Name
2279 :
2280 120 : if (!ErrorsFound) {
2281 240 : CurveVal = Curve::CurveValue(
2282 120 : state, state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSEIRFTemp(I), RatedInletAirTempHeat, RatedAmbAirTempHeat);
2283 120 : if (CurveVal > 1.10 || CurveVal < 0.90) {
2284 60 : ShowWarningError(state,
2285 60 : format("{}{}=\"{}\", curve values",
2286 : RoutineName,
2287 : CurrentModuleObject,
2288 30 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name));
2289 60 : ShowContinueError(
2290 60 : state, format("...{} output is not equal to 1.0 (+ or - 10%) at rated conditions.", cAlphaFields(AlfaFieldIncre)));
2291 30 : ShowContinueError(state, format("...Curve output at rated conditions = {:.3T}", CurveVal));
2292 : }
2293 : }
2294 : }
2295 :
2296 120 : AlfaFieldIncre = 12 + (I - 1) * 4;
2297 120 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSEIRAirFFlow(I) =
2298 120 : Curve::GetCurveIndex(state, AlphArray(AlfaFieldIncre)); // convert curve name to number
2299 120 : if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSEIRAirFFlow(I) == 0) {
2300 0 : if (lAlphaBlanks(AlfaFieldIncre)) {
2301 0 : ShowSevereError(state,
2302 0 : format("{}{}=\"{}\", missing",
2303 : RoutineName,
2304 : CurrentModuleObject,
2305 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name));
2306 0 : ShowContinueError(state, format("...required {} is blank.", cAlphaFields(AlfaFieldIncre)));
2307 : } else {
2308 0 : ShowSevereError(state,
2309 0 : format("{}{}=\"{}\", invalid",
2310 : RoutineName,
2311 : CurrentModuleObject,
2312 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name));
2313 0 : ShowContinueError(state, format("...not found {}=\"{}\".", cAlphaFields(AlfaFieldIncre), AlphArray(AlfaFieldIncre)));
2314 : }
2315 0 : ErrorsFound = true;
2316 : } else {
2317 : // Verify Curve Object, only legal type is Quadratic
2318 360 : ErrorsFound |= Curve::CheckCurveDims(state,
2319 120 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSEIRAirFFlow(I), // Curve index
2320 : {1}, // Valid dimensions
2321 : RoutineName, // Routine name
2322 : CurrentModuleObject, // Object Type
2323 120 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name, // Object Name
2324 120 : cAlphaFields(AlfaFieldIncre)); // Field Name
2325 :
2326 120 : if (!ErrorsFound) {
2327 120 : CurveVal = Curve::CurveValue(state, state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSEIRAirFFlow(I), 1.0);
2328 120 : if (CurveVal > 1.10 || CurveVal < 0.90) {
2329 0 : ShowWarningError(state,
2330 0 : format("{}{}=\"{}\", curve values",
2331 : RoutineName,
2332 : CurrentModuleObject,
2333 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name));
2334 0 : ShowContinueError(
2335 0 : state, format("...{} output is not equal to 1.0 (+ or - 10%) at rated conditions.", cAlphaFields(AlfaFieldIncre)));
2336 0 : ShowContinueError(state, format("...Curve output at rated conditions = {:.3T}", CurveVal));
2337 : }
2338 : }
2339 : }
2340 : }
2341 :
2342 13 : if (ErrorsFound) {
2343 0 : continue;
2344 : }
2345 :
2346 133 : for (int I = 1; I <= state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).NumOfSpeeds; ++I) {
2347 120 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedPercentTotCap(I) =
2348 120 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedTotCap(I) /
2349 240 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedTotCap(
2350 120 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).NumOfSpeeds);
2351 120 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedAirVolFlowPerRatedTotCap(I) =
2352 120 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedAirVolFlowRate(I) /
2353 120 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedTotCap(I);
2354 : }
2355 :
2356 : // CurrentModuleObject = "Coil:Heating:DX:Variablespeed "
2357 26 : SetupOutputVariable(state,
2358 : "Heating Coil Electricity Energy",
2359 : Constant::Units::J,
2360 13 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Energy,
2361 : OutputProcessor::TimeStepType::System,
2362 : OutputProcessor::StoreType::Sum,
2363 13 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name,
2364 : Constant::eResource::Electricity,
2365 : OutputProcessor::Group::HVAC,
2366 : OutputProcessor::EndUseCat::Heating);
2367 26 : SetupOutputVariable(state,
2368 : "Heating Coil Heating Energy",
2369 : Constant::Units::J,
2370 13 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).EnergyLoadTotal,
2371 : OutputProcessor::TimeStepType::System,
2372 : OutputProcessor::StoreType::Sum,
2373 13 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name,
2374 : Constant::eResource::EnergyTransfer,
2375 : OutputProcessor::Group::HVAC,
2376 : OutputProcessor::EndUseCat::HeatingCoils);
2377 26 : SetupOutputVariable(state,
2378 : "Heating Coil Source Side Heat Transfer Energy",
2379 : Constant::Units::J,
2380 13 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).EnergySource,
2381 : OutputProcessor::TimeStepType::System,
2382 : OutputProcessor::StoreType::Sum,
2383 13 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name);
2384 :
2385 : // create predefined report entries
2386 26 : OutputReportPredefined::PreDefTableEntry(
2387 13 : state, state.dataOutRptPredefined->pdchHeatCoilType, state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name, CurrentModuleObject);
2388 26 : OutputReportPredefined::PreDefTableEntry(state,
2389 13 : state.dataOutRptPredefined->pdchHeatCoilNomCap,
2390 13 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name,
2391 13 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).RatedCapHeat);
2392 26 : OutputReportPredefined::PreDefTableEntry(state,
2393 13 : state.dataOutRptPredefined->pdchHeatCoilNomEff,
2394 13 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name,
2395 26 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedCOP(
2396 13 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).NormSpedLevel));
2397 : }
2398 :
2399 : //-------------------------AIR SOURCE HEATING---END
2400 :
2401 : //------------------------VARIABLE-SPEED AIR SOURCE HPWH---BEGIN
2402 49 : CurrentModuleObject = "COIL:WATERHEATING:AIRTOWATERHEATPUMP:VARIABLESPEED"; // for reporting
2403 :
2404 56 : for (int CoilCounter = 1; CoilCounter <= NumHPWHAirToWater; ++CoilCounter) {
2405 :
2406 7 : ++DXCoilNum;
2407 :
2408 7 : state.dataInputProcessing->inputProcessor->getObjectItem(state,
2409 : CurrentModuleObject,
2410 : CoilCounter,
2411 : AlphArray,
2412 : NumAlphas,
2413 : NumArray,
2414 : NumNums,
2415 : IOStat,
2416 : lNumericBlanks,
2417 : lAlphaBlanks,
2418 : cAlphaFields,
2419 : cNumericFields);
2420 : // ErrorsFound will be set to True if problem was found, left untouched otherwise
2421 7 : GlobalNames::VerifyUniqueCoilName(state, CurrentModuleObject, AlphArray(1), ErrorsFound, CurrentModuleObject + " Name");
2422 :
2423 7 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).bIsDesuperheater = false;
2424 7 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).CondenserType = DataHeatBalance::RefrigCondenserType::WaterHeater;
2425 7 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).CoolHeatType = "WATERHEATING";
2426 7 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).VSCoilType = HVAC::CoilDX_HeatPumpWaterHeaterVariableSpeed;
2427 7 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).VarSpeedCoilType =
2428 14 : HVAC::cAllCoilTypes(HVAC::CoilDX_HeatPumpWaterHeaterVariableSpeed);
2429 :
2430 7 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name = AlphArray(1);
2431 7 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).NumOfSpeeds = int(NumArray(1));
2432 7 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).NormSpedLevel = int(NumArray(2));
2433 :
2434 7 : if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).NumOfSpeeds < 1) {
2435 0 : ShowSevereError(
2436 : state,
2437 0 : format("{}{}=\"{}\", invalid", RoutineName, CurrentModuleObject, state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name));
2438 0 : ShowContinueError(state, format("...{} must be >= 1. entered number is {:.0T}", cNumericFields(1), NumArray(1)));
2439 0 : ErrorsFound = true;
2440 : }
2441 :
2442 7 : if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).NormSpedLevel >
2443 7 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).NumOfSpeeds) {
2444 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).NormSpedLevel =
2445 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).NumOfSpeeds;
2446 : }
2447 :
2448 7 : if ((state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).NormSpedLevel >
2449 14 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).NumOfSpeeds) ||
2450 7 : (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).NormSpedLevel <= 0)) {
2451 0 : ShowSevereError(
2452 : state,
2453 0 : format("{}{}=\"{}\", invalid", RoutineName, CurrentModuleObject, state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name));
2454 0 : ShowContinueError(state, format("...{} must be valid speed level entered number is {:.0T}", cNumericFields(2), NumArray(2)));
2455 0 : ErrorsFound = true;
2456 : }
2457 :
2458 7 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).RatedCapWH = NumArray(3);
2459 7 : if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).RatedCapWH <= 0.0) {
2460 0 : ShowSevereError(
2461 : state,
2462 0 : format("{}{}=\"{}\", invalid", RoutineName, CurrentModuleObject, state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name));
2463 0 : ShowContinueError(state, format("...{} must be > 0.0, entered value=[{:.2T}].", cNumericFields(3), NumArray(3)));
2464 0 : ErrorsFound = true;
2465 : }
2466 :
2467 7 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).WHRatedInletDBTemp = NumArray(4);
2468 7 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).WHRatedInletWBTemp = NumArray(5);
2469 7 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).WHRatedInletWaterTemp = NumArray(6);
2470 :
2471 7 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).RatedAirVolFlowRate = NumArray(7);
2472 7 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).RatedWaterVolFlowRate = NumArray(8);
2473 :
2474 7 : if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).RatedAirVolFlowRate != Constant::AutoCalculate) {
2475 5 : if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).RatedAirVolFlowRate <= 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(7), NumArray(7)));
2480 0 : ErrorsFound = true;
2481 : }
2482 : }
2483 :
2484 7 : if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).RatedWaterVolFlowRate != Constant::AutoCalculate) {
2485 5 : if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).RatedWaterVolFlowRate <= 0.0) {
2486 0 : ShowSevereError(
2487 : state,
2488 0 : format("{}{}=\"{}\", invalid", RoutineName, CurrentModuleObject, state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name));
2489 0 : ShowContinueError(state, format("...{} must be > 0.0 entered value=[{:.3T}].", cNumericFields(8), NumArray(8)));
2490 0 : ErrorsFound = true;
2491 : }
2492 : }
2493 :
2494 7 : if (Util::SameString(AlphArray(2), "Yes") || Util::SameString(AlphArray(2), "No")) {
2495 : // initialized to TRUE on allocate
2496 7 : if (Util::SameString(AlphArray(2), "No")) {
2497 7 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).FanPowerIncludedInCOP = false;
2498 : } else {
2499 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).FanPowerIncludedInCOP = true;
2500 : }
2501 : } else {
2502 0 : ShowSevereError(
2503 : state,
2504 0 : format("{}{}=\"{}\", invalid", RoutineName, CurrentModuleObject, state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name));
2505 0 : ShowContinueError(state, format(",,,invalid choice for {}. Entered choice = {}", cAlphaFields(2), AlphArray(2)));
2506 0 : ShowContinueError(state, "Valid choices are Yes or No.");
2507 0 : ErrorsFound = true;
2508 : }
2509 :
2510 7 : if (Util::SameString(AlphArray(3), "Yes") || Util::SameString(AlphArray(3), "No")) {
2511 : // initialized to FALSE on allocate
2512 7 : if (Util::SameString(AlphArray(3), "Yes")) {
2513 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).CondPumpPowerInCOP = true;
2514 : } else {
2515 7 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).CondPumpPowerInCOP = false;
2516 : }
2517 : } else {
2518 0 : ShowSevereError(
2519 : state,
2520 0 : format("{}{}=\"{}\", invalid", RoutineName, CurrentModuleObject, state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name));
2521 0 : ShowContinueError(state, format(",,,invalid choice for {}. Entered choice = {}", cAlphaFields(3), AlphArray(3)));
2522 0 : ShowContinueError(state, "Valid choices are Yes or No.");
2523 0 : ErrorsFound = true;
2524 : }
2525 :
2526 7 : if (Util::SameString(AlphArray(4), "Yes") || Util::SameString(AlphArray(4), "No")) {
2527 : // initialized to FALSE on allocate
2528 7 : if (Util::SameString(AlphArray(4), "Yes")) {
2529 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).CondPumpHeatInCapacity = true;
2530 : } else {
2531 7 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).CondPumpHeatInCapacity = false;
2532 : }
2533 : } else {
2534 0 : ShowSevereError(
2535 : state,
2536 0 : format("{}{}=\"{}\", invalid", RoutineName, CurrentModuleObject, state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name));
2537 0 : ShowContinueError(state, format(",,,invalid choice for {}. Entered choice = {}", cAlphaFields(4), AlphArray(4)));
2538 0 : ShowContinueError(state, "Valid choices are Yes or No.");
2539 0 : ErrorsFound = true;
2540 : }
2541 :
2542 7 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).HPWHCondPumpFracToWater = NumArray(9);
2543 14 : if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).HPWHCondPumpFracToWater <= 0.0 ||
2544 7 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).HPWHCondPumpFracToWater > 1.0) {
2545 0 : ShowSevereError(
2546 : state,
2547 0 : format("{}{}=\"{}\", invalid", RoutineName, CurrentModuleObject, state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name));
2548 0 : ShowContinueError(state, format("...{} must be >= 0 and <= 1. entered value=[{:.3T}].", cNumericFields(10), NumArray(9)));
2549 0 : ErrorsFound = true;
2550 : }
2551 :
2552 7 : if (!state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).CondPumpHeatInCapacity) {
2553 7 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).HPWHCondPumpFracToWater = 0.0;
2554 : }
2555 :
2556 : // Air nodes
2557 7 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).AirInletNodeNum =
2558 14 : GetOnlySingleNode(state,
2559 7 : AlphArray(5),
2560 : ErrorsFound,
2561 : DataLoopNode::ConnectionObjectType::CoilWaterHeatingAirToWaterHeatPumpVariableSpeed,
2562 7 : AlphArray(1),
2563 : DataLoopNode::NodeFluidType::Air,
2564 : DataLoopNode::ConnectionType::Inlet,
2565 : NodeInputManager::CompFluidStream::Primary,
2566 : DataLoopNode::ObjectIsNotParent);
2567 :
2568 7 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).AirOutletNodeNum =
2569 21 : GetOnlySingleNode(state,
2570 7 : AlphArray(6),
2571 : ErrorsFound,
2572 : DataLoopNode::ConnectionObjectType::CoilWaterHeatingAirToWaterHeatPumpVariableSpeed,
2573 7 : AlphArray(1),
2574 : DataLoopNode::NodeFluidType::Air,
2575 : DataLoopNode::ConnectionType::Outlet,
2576 : NodeInputManager::CompFluidStream::Primary,
2577 : DataLoopNode::ObjectIsNotParent);
2578 :
2579 7 : BranchNodeConnections::TestCompSet(state, CurrentModuleObject, AlphArray(1), AlphArray(5), AlphArray(6), "Air Nodes");
2580 :
2581 : // Check if the air inlet node is OA node, to justify whether the coil is placed in zone or not
2582 7 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).IsDXCoilInZone =
2583 7 : !OutAirNodeManager::CheckOutAirNodeNumber(state, state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).AirInletNodeNum);
2584 :
2585 : // Water nodes
2586 7 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).WaterInletNodeNum =
2587 14 : GetOnlySingleNode(state,
2588 7 : AlphArray(7),
2589 : ErrorsFound,
2590 : DataLoopNode::ConnectionObjectType::CoilWaterHeatingAirToWaterHeatPumpVariableSpeed,
2591 7 : AlphArray(1),
2592 : DataLoopNode::NodeFluidType::Water,
2593 : DataLoopNode::ConnectionType::Inlet,
2594 : NodeInputManager::CompFluidStream::Secondary,
2595 : DataLoopNode::ObjectIsNotParent);
2596 :
2597 7 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).WaterOutletNodeNum =
2598 21 : GetOnlySingleNode(state,
2599 7 : AlphArray(8),
2600 : ErrorsFound,
2601 : DataLoopNode::ConnectionObjectType::CoilWaterHeatingAirToWaterHeatPumpVariableSpeed,
2602 7 : AlphArray(1),
2603 : DataLoopNode::NodeFluidType::Water,
2604 : DataLoopNode::ConnectionType::Outlet,
2605 : NodeInputManager::CompFluidStream::Secondary,
2606 : DataLoopNode::ObjectIsNotParent);
2607 :
2608 7 : BranchNodeConnections::TestCompSet(state, CurrentModuleObject, AlphArray(1), AlphArray(7), AlphArray(8), "Water Nodes");
2609 :
2610 7 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).CrankcaseHeaterCapacity = NumArray(10);
2611 7 : if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).CrankcaseHeaterCapacity < 0.0) {
2612 0 : ShowSevereError(
2613 : state,
2614 0 : format("{}{}=\"{}\", invalid", RoutineName, CurrentModuleObject, state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name));
2615 0 : ShowContinueError(state, format("...{} must be >= 0.0 entered value=[{:.1T}].", cNumericFields(10), NumArray(10)));
2616 0 : ErrorsFound = true;
2617 : }
2618 :
2619 7 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MaxOATCrankcaseHeater = NumArray(11);
2620 7 : if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MaxOATCrankcaseHeater < 0.0) {
2621 0 : ShowSevereError(
2622 : state,
2623 0 : format("{}{}=\"{}\", invalid", RoutineName, CurrentModuleObject, state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name));
2624 0 : ShowContinueError(state, format("...{} must be >= 0 {{C}}. entered value=[{:.1T}].", cNumericFields(11), NumArray(11)));
2625 0 : ErrorsFound = true;
2626 : }
2627 :
2628 7 : if (!lAlphaBlanks(9)) {
2629 2 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).CrankcaseHeaterCapacityCurveIndex = Curve::GetCurveIndex(state, AlphArray(9));
2630 2 : if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).CrankcaseHeaterCapacityCurveIndex == 0) { // can't find the curve
2631 0 : ShowSevereError(state,
2632 0 : format("{} = {}: {} not found = {}",
2633 : CurrentModuleObject,
2634 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name,
2635 : cAlphaFields(9),
2636 : AlphArray(9)));
2637 0 : ErrorsFound = true;
2638 : } else {
2639 2 : ErrorsFound |=
2640 8 : Curve::CheckCurveDims(state,
2641 2 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).CrankcaseHeaterCapacityCurveIndex, // Curve index
2642 : {1}, // Valid dimensions
2643 : RoutineName, // Routine name
2644 : CurrentModuleObject, // Object Type
2645 2 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name, // Object Name
2646 2 : cAlphaFields(9)); // Field Name
2647 : }
2648 : }
2649 :
2650 7 : if (Util::SameString(AlphArray(10), "DryBulbTemperature")) {
2651 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).InletAirTemperatureType = HVAC::OATType::DryBulb;
2652 7 : } else if (Util::SameString(AlphArray(10), "WetBulbTemperature")) {
2653 7 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).InletAirTemperatureType = HVAC::OATType::WetBulb;
2654 : } else {
2655 : // wrong temperature type selection
2656 0 : ShowSevereError(
2657 : state,
2658 0 : format("{}{}=\"{}\", invalid", RoutineName, CurrentModuleObject, state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name));
2659 0 : ShowContinueError(state, format("...{} must be DryBulbTemperature or WetBulbTemperature.", cAlphaFields(10)));
2660 0 : ShowContinueError(state, format("...entered value=\"{}\".", AlphArray(10)));
2661 0 : ErrorsFound = true;
2662 : }
2663 :
2664 : // set rated inlet air temperature for curve object verification
2665 7 : if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).InletAirTemperatureType == HVAC::OATType::WetBulb) {
2666 7 : WHInletAirTemp = state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).WHRatedInletWBTemp;
2667 : } else {
2668 0 : WHInletAirTemp = state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).WHRatedInletDBTemp;
2669 : }
2670 : // set rated water temperature for curve object verification
2671 7 : WHInletWaterTemp = state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).WHRatedInletWaterTemp;
2672 :
2673 : // part load curve
2674 7 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).PLFFPLR =
2675 7 : Curve::GetCurveIndex(state, AlphArray(11)); // convert curve name to number
2676 7 : if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).PLFFPLR == 0) {
2677 0 : if (lAlphaBlanks(11)) {
2678 0 : ShowSevereError(
2679 : state,
2680 0 : format("{}{}=\"{}\", missing", RoutineName, CurrentModuleObject, state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name));
2681 0 : ShowContinueError(state, format("...required {} is blank.", cAlphaFields(11)));
2682 : } else {
2683 0 : ShowSevereError(
2684 : state,
2685 0 : format("{}{}=\"{}\", invalid", RoutineName, CurrentModuleObject, state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name));
2686 0 : ShowContinueError(state, format("...not found {}=\"{}\".", cAlphaFields(11), AlphArray(11)));
2687 : }
2688 0 : ErrorsFound = true;
2689 : } else {
2690 7 : CurveVal = Curve::CurveValue(state, state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).PLFFPLR, 1.0);
2691 7 : if (CurveVal > 1.10 || CurveVal < 0.90) {
2692 4 : ShowWarningError(state,
2693 4 : format("{}{}=\"{}\", curve values",
2694 : RoutineName,
2695 : CurrentModuleObject,
2696 2 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name));
2697 2 : ShowContinueError(state, format("...{} output is not equal to 1.0 (+ or - 10%) at rated conditions.", cAlphaFields(11)));
2698 2 : ShowContinueError(state, format("...Curve output at rated conditions = {:.3T}", CurveVal));
2699 : }
2700 : }
2701 :
2702 77 : for (int I = 1; I <= state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).NumOfSpeeds; ++I) {
2703 70 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedTotCap(I) = NumArray(12 + (I - 1) * 6);
2704 70 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedCOP(I) = NumArray(13 + (I - 1) * 6);
2705 70 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedSHR(I) = NumArray(14 + (I - 1) * 6);
2706 70 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedAirVolFlowRate(I) = NumArray(15 + (I - 1) * 6);
2707 70 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedWaterVolFlowRate(I) = NumArray(16 + (I - 1) * 6);
2708 70 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSWHPumpPower(I) = NumArray(17 + (I - 1) * 6);
2709 :
2710 70 : AlfaFieldIncre = 12 + (I - 1) * 6;
2711 70 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSCCapFTemp(I) =
2712 70 : Curve::GetCurveIndex(state, AlphArray(AlfaFieldIncre)); // convert curve name to number
2713 70 : if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSCCapFTemp(I) == 0) {
2714 0 : if (lAlphaBlanks(AlfaFieldIncre)) {
2715 0 : ShowSevereError(state,
2716 0 : format("{}{}=\"{}\", missing",
2717 : RoutineName,
2718 : CurrentModuleObject,
2719 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name));
2720 0 : ShowContinueError(state, format("...required {} is blank.", cAlphaFields(AlfaFieldIncre)));
2721 : } else {
2722 0 : ShowSevereError(state,
2723 0 : format("{}{}=\"{}\", invalid",
2724 : RoutineName,
2725 : CurrentModuleObject,
2726 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name));
2727 0 : ShowContinueError(state, format("...not found {}=\"{}\".", cAlphaFields(AlfaFieldIncre), AlphArray(AlfaFieldIncre)));
2728 : }
2729 0 : ErrorsFound = true;
2730 : } else {
2731 : // Verify Curve Object, only legal type is BiQuadratic
2732 210 : ErrorsFound |= Curve::CheckCurveDims(state,
2733 70 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSCCapFTemp(I), // Curve index
2734 : {2}, // Valid dimensions
2735 : RoutineName, // Routine name
2736 : CurrentModuleObject, // Object Type
2737 70 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name, // Object Name
2738 70 : cAlphaFields(AlfaFieldIncre)); // Field Name
2739 :
2740 70 : if (!ErrorsFound) {
2741 140 : CurveVal = Curve::CurveValue(
2742 70 : state, state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSCCapFTemp(I), WHInletAirTemp, WHInletWaterTemp);
2743 70 : if (CurveVal > 1.10 || CurveVal < 0.90) {
2744 40 : ShowWarningError(state,
2745 40 : format("{}{}=\"{}\", curve values",
2746 : RoutineName,
2747 : CurrentModuleObject,
2748 20 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name));
2749 40 : ShowContinueError(
2750 40 : state, format("...{} output is not equal to 1.0 (+ or - 10%) at rated conditions.", cAlphaFields(AlfaFieldIncre)));
2751 20 : ShowContinueError(state, format("...Curve output at rated conditions = {:.3T}", CurveVal));
2752 : }
2753 : }
2754 : }
2755 :
2756 70 : AlfaFieldIncre = 13 + (I - 1) * 6;
2757 70 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSCCapAirFFlow(I) =
2758 70 : Curve::GetCurveIndex(state, AlphArray(AlfaFieldIncre)); // convert curve name to number
2759 70 : if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSCCapAirFFlow(I) == 0) {
2760 0 : if (lAlphaBlanks(AlfaFieldIncre)) {
2761 0 : ShowSevereError(state,
2762 0 : format("{}{}=\"{}\", missing",
2763 : RoutineName,
2764 : CurrentModuleObject,
2765 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name));
2766 0 : ShowContinueError(state, format("...required {} is blank.", cAlphaFields(AlfaFieldIncre)));
2767 : } else {
2768 0 : ShowSevereError(state,
2769 0 : format("{}{}=\"{}\", invalid",
2770 : RoutineName,
2771 : CurrentModuleObject,
2772 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name));
2773 0 : ShowContinueError(state, format("...not found {}=\"{}\".", cAlphaFields(AlfaFieldIncre), AlphArray(AlfaFieldIncre)));
2774 : }
2775 0 : ErrorsFound = true;
2776 : } else {
2777 : // Verify Curve Object, only legal type is Quadratic
2778 210 : ErrorsFound |= Curve::CheckCurveDims(state,
2779 70 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSCCapAirFFlow(I), // Curve index
2780 : {1}, // Valid dimensions
2781 : RoutineName, // Routine name
2782 : CurrentModuleObject, // Object Type
2783 70 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name, // Object Name
2784 70 : cAlphaFields(AlfaFieldIncre)); // Field Name
2785 :
2786 70 : if (!ErrorsFound) {
2787 70 : CurveVal = Curve::CurveValue(state, state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSCCapAirFFlow(I), 1.0);
2788 70 : if (CurveVal > 1.10 || CurveVal < 0.90) {
2789 0 : ShowWarningError(state,
2790 0 : format("{}{}=\"{}\", curve values",
2791 : RoutineName,
2792 : CurrentModuleObject,
2793 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name));
2794 0 : ShowContinueError(
2795 0 : state, format("...{} output is not equal to 1.0 (+ or - 10%) at rated conditions.", cAlphaFields(AlfaFieldIncre)));
2796 0 : ShowContinueError(state, format("...Curve output at rated conditions = {:.3T}", CurveVal));
2797 : }
2798 : }
2799 : }
2800 :
2801 70 : AlfaFieldIncre = 14 + (I - 1) * 6;
2802 70 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSCCapWaterFFlow(I) =
2803 70 : Curve::GetCurveIndex(state, AlphArray(AlfaFieldIncre)); // convert curve name to number
2804 70 : if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSCCapWaterFFlow(I) == 0) {
2805 0 : if (lAlphaBlanks(AlfaFieldIncre)) {
2806 0 : ShowSevereError(state,
2807 0 : format("{}{}=\"{}\", missing",
2808 : RoutineName,
2809 : CurrentModuleObject,
2810 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name));
2811 0 : ShowContinueError(state, format("...required {} is blank.", cAlphaFields(AlfaFieldIncre)));
2812 : } else {
2813 0 : ShowSevereError(state,
2814 0 : format("{}{}=\"{}\", invalid",
2815 : RoutineName,
2816 : CurrentModuleObject,
2817 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name));
2818 0 : ShowContinueError(state, format("...not found {}=\"{}\".", cAlphaFields(AlfaFieldIncre), AlphArray(AlfaFieldIncre)));
2819 : }
2820 0 : ErrorsFound = true;
2821 : } else {
2822 : // Verify Curve Object, only legal type is Quadratic
2823 210 : ErrorsFound |= Curve::CheckCurveDims(state,
2824 70 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSCCapWaterFFlow(I), // Curve index
2825 : {1}, // Valid dimensions
2826 : RoutineName, // Routine name
2827 : CurrentModuleObject, // Object Type
2828 70 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name, // Object Name
2829 70 : cAlphaFields(AlfaFieldIncre)); // Field Name
2830 :
2831 70 : if (!ErrorsFound) {
2832 70 : CurveVal = Curve::CurveValue(state, state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSCCapWaterFFlow(I), 1.0);
2833 70 : if (CurveVal > 1.10 || CurveVal < 0.90) {
2834 0 : ShowWarningError(state,
2835 0 : format("{}{}=\"{}\", curve values",
2836 : RoutineName,
2837 : CurrentModuleObject,
2838 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name));
2839 0 : ShowContinueError(
2840 0 : state, format("...{} output is not equal to 1.0 (+ or - 10%) at rated conditions.", cAlphaFields(AlfaFieldIncre)));
2841 0 : ShowContinueError(state, format("...Curve output at rated conditions = {:.3T}", CurveVal));
2842 : }
2843 : }
2844 : }
2845 :
2846 70 : AlfaFieldIncre = 15 + (I - 1) * 6;
2847 70 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSEIRFTemp(I) =
2848 70 : Curve::GetCurveIndex(state, AlphArray(AlfaFieldIncre)); // convert curve name to number
2849 70 : if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSEIRFTemp(I) == 0) {
2850 0 : if (lAlphaBlanks(AlfaFieldIncre)) {
2851 0 : ShowSevereError(state,
2852 0 : format("{}{}=\"{}\", missing",
2853 : RoutineName,
2854 : CurrentModuleObject,
2855 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name));
2856 0 : ShowContinueError(state, format("...required {} is blank.", cAlphaFields(AlfaFieldIncre)));
2857 : } else {
2858 0 : ShowSevereError(state,
2859 0 : format("{}{}=\"{}\", invalid",
2860 : RoutineName,
2861 : CurrentModuleObject,
2862 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name));
2863 0 : ShowContinueError(state, format("...not found {}=\"{}\".", cAlphaFields(AlfaFieldIncre), AlphArray(AlfaFieldIncre)));
2864 : }
2865 0 : ErrorsFound = true;
2866 : } else {
2867 : // Verify Curve Object, only legal type is BiQuadratic
2868 210 : ErrorsFound |= Curve::CheckCurveDims(state,
2869 70 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSEIRFTemp(I), // Curve index
2870 : {2}, // Valid dimensions
2871 : RoutineName, // Routine name
2872 : CurrentModuleObject, // Object Type
2873 70 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name, // Object Name
2874 70 : cAlphaFields(AlfaFieldIncre)); // Field Name
2875 :
2876 70 : if (!ErrorsFound) {
2877 140 : CurveVal = Curve::CurveValue(
2878 70 : state, state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSEIRFTemp(I), WHInletAirTemp, WHInletWaterTemp);
2879 70 : if (CurveVal > 1.10 || CurveVal < 0.90) {
2880 40 : ShowWarningError(state,
2881 40 : format("{}{}=\"{}\", curve values",
2882 : RoutineName,
2883 : CurrentModuleObject,
2884 20 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name));
2885 40 : ShowContinueError(
2886 40 : state, format("...{} output is not equal to 1.0 (+ or - 10%) at rated conditions.", cAlphaFields(AlfaFieldIncre)));
2887 20 : ShowContinueError(state, format("...Curve output at rated conditions = {:.3T}", CurveVal));
2888 : }
2889 : }
2890 : }
2891 :
2892 70 : AlfaFieldIncre = 16 + (I - 1) * 6;
2893 70 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSEIRAirFFlow(I) =
2894 70 : Curve::GetCurveIndex(state, AlphArray(AlfaFieldIncre)); // convert curve name to number
2895 70 : if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSEIRAirFFlow(I) == 0) {
2896 0 : if (lAlphaBlanks(AlfaFieldIncre)) {
2897 0 : ShowSevereError(state,
2898 0 : format("{}{}=\"{}\", missing",
2899 : RoutineName,
2900 : CurrentModuleObject,
2901 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name));
2902 0 : ShowContinueError(state, format("...required {} is blank.", cAlphaFields(AlfaFieldIncre)));
2903 : } else {
2904 0 : ShowSevereError(state,
2905 0 : format("{}{}=\"{}\", invalid",
2906 : RoutineName,
2907 : CurrentModuleObject,
2908 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name));
2909 0 : ShowContinueError(state, format("...not found {}=\"{}\".", cAlphaFields(AlfaFieldIncre), AlphArray(AlfaFieldIncre)));
2910 : }
2911 0 : ErrorsFound = true;
2912 : } else {
2913 : // Verify Curve Object, only legal type is Quadratic
2914 210 : ErrorsFound |= Curve::CheckCurveDims(state,
2915 70 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSEIRAirFFlow(I), // Curve index
2916 : {1}, // Valid dimensions
2917 : RoutineName, // Routine name
2918 : CurrentModuleObject, // Object Type
2919 70 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name, // Object Name
2920 70 : cAlphaFields(AlfaFieldIncre)); // Field Name
2921 :
2922 70 : if (!ErrorsFound) {
2923 70 : CurveVal = Curve::CurveValue(state, state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSEIRAirFFlow(I), 1.0);
2924 70 : if (CurveVal > 1.10 || CurveVal < 0.90) {
2925 0 : ShowWarningError(state,
2926 0 : format("{}{}=\"{}\", curve values",
2927 : RoutineName,
2928 : CurrentModuleObject,
2929 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name));
2930 0 : ShowContinueError(
2931 0 : state, format("...{} output is not equal to 1.0 (+ or - 10%) at rated conditions.", cAlphaFields(AlfaFieldIncre)));
2932 0 : ShowContinueError(state, format("...Curve output at rated conditions = {:.3T}", CurveVal));
2933 : }
2934 : }
2935 : }
2936 :
2937 70 : AlfaFieldIncre = 17 + (I - 1) * 6;
2938 70 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSEIRWaterFFlow(I) =
2939 70 : Curve::GetCurveIndex(state, AlphArray(AlfaFieldIncre)); // convert curve name to number
2940 70 : if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSEIRWaterFFlow(I) == 0) {
2941 0 : if (lAlphaBlanks(AlfaFieldIncre)) {
2942 0 : ShowSevereError(state,
2943 0 : format("{}{}=\"{}\", missing",
2944 : RoutineName,
2945 : CurrentModuleObject,
2946 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name));
2947 0 : ShowContinueError(state, format("...required {} is blank.", cAlphaFields(AlfaFieldIncre)));
2948 : } else {
2949 0 : ShowSevereError(state,
2950 0 : format("{}{}=\"{}\", invalid",
2951 : RoutineName,
2952 : CurrentModuleObject,
2953 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name));
2954 0 : ShowContinueError(state, format("...not found {}=\"{}\".", cAlphaFields(AlfaFieldIncre), AlphArray(AlfaFieldIncre)));
2955 : }
2956 0 : ErrorsFound = true;
2957 : } else {
2958 : // Verify Curve Object, only legal type is Quadratic
2959 210 : ErrorsFound |= Curve::CheckCurveDims(state,
2960 70 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSEIRWaterFFlow(I), // Curve index
2961 : {1}, // Valid dimensions
2962 : RoutineName, // Routine name
2963 : CurrentModuleObject, // Object Type
2964 70 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name, // Object Name
2965 70 : cAlphaFields(AlfaFieldIncre)); // Field Name
2966 :
2967 70 : if (!ErrorsFound) {
2968 70 : CurveVal = Curve::CurveValue(state, state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSEIRWaterFFlow(I), 1.0);
2969 70 : if (CurveVal > 1.10 || CurveVal < 0.90) {
2970 0 : ShowWarningError(state,
2971 0 : format("{}{}=\"{}\", curve values",
2972 : RoutineName,
2973 : CurrentModuleObject,
2974 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name));
2975 0 : ShowContinueError(
2976 0 : state, format("...{} output is not equal to 1.0 (+ or - 10%) at rated conditions.", cAlphaFields(AlfaFieldIncre)));
2977 0 : ShowContinueError(state, format("...Curve output at rated conditions = {:.3T}", CurveVal));
2978 : }
2979 : }
2980 : }
2981 : }
2982 :
2983 : // get scale values
2984 77 : for (int I = 1; I <= state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).NumOfSpeeds; ++I) {
2985 70 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedPercentTotCap(I) =
2986 70 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedTotCap(I) /
2987 140 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedTotCap(
2988 70 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).NumOfSpeeds);
2989 70 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedAirVolFlowPerRatedTotCap(I) =
2990 70 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedAirVolFlowRate(I) /
2991 70 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedTotCap(I);
2992 70 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedWaterVolFlowPerRatedTotCap(I) =
2993 70 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedWaterVolFlowRate(I) /
2994 70 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedTotCap(I);
2995 70 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSWHPumpPowerPerRatedTotCap(I) =
2996 70 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSWHPumpPower(I) /
2997 70 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedTotCap(I);
2998 : }
2999 :
3000 : // CurrentModuleObject = "Coil:Waterheating:Airtowaterheatpump:Variablespeed"
3001 14 : SetupOutputVariable(state,
3002 : "Cooling Coil Electricity Energy",
3003 : Constant::Units::J,
3004 7 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Energy,
3005 : OutputProcessor::TimeStepType::System,
3006 : OutputProcessor::StoreType::Sum,
3007 7 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name,
3008 : Constant::eResource::Electricity,
3009 : OutputProcessor::Group::HVAC,
3010 : OutputProcessor::EndUseCat::Heating);
3011 14 : SetupOutputVariable(state,
3012 : "Cooling Coil Sensible Cooling Energy",
3013 : Constant::Units::J,
3014 7 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).EnergySensible,
3015 : OutputProcessor::TimeStepType::System,
3016 : OutputProcessor::StoreType::Sum,
3017 7 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name);
3018 14 : SetupOutputVariable(state,
3019 : "Cooling Coil Latent Cooling Energy",
3020 : Constant::Units::J,
3021 7 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).EnergyLatent,
3022 : OutputProcessor::TimeStepType::System,
3023 : OutputProcessor::StoreType::Sum,
3024 7 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name);
3025 14 : SetupOutputVariable(state,
3026 : "Cooling Coil Water Side Heat Transfer Energy",
3027 : Constant::Units::J,
3028 7 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).EnergySource,
3029 : OutputProcessor::TimeStepType::System,
3030 : OutputProcessor::StoreType::Sum,
3031 7 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name,
3032 : Constant::eResource::PlantLoopHeatingDemand,
3033 : OutputProcessor::Group::HVAC,
3034 : OutputProcessor::EndUseCat::HeatingCoils);
3035 :
3036 7 : if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).IsDXCoilInZone) {
3037 14 : SetupOutputVariable(state,
3038 : "Cooling Coil Cooling Energy",
3039 : Constant::Units::J,
3040 7 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).EnergyLoadTotal,
3041 : OutputProcessor::TimeStepType::System,
3042 : OutputProcessor::StoreType::Sum,
3043 7 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name,
3044 : Constant::eResource::EnergyTransfer,
3045 : OutputProcessor::Group::HVAC,
3046 : OutputProcessor::EndUseCat::CoolingCoils);
3047 : } else {
3048 0 : SetupOutputVariable(state,
3049 : "Cooling Coil Cooling Energy",
3050 : Constant::Units::J,
3051 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).EnergyLoadTotal,
3052 : OutputProcessor::TimeStepType::System,
3053 : OutputProcessor::StoreType::Sum,
3054 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name);
3055 : }
3056 :
3057 7 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).RatedCapCoolSens =
3058 : DataSizing::AutoSize; // always auto-sized, to be determined in the sizing calculation
3059 : }
3060 : //---------------------------VARIABLE-SPEED AIR SOURCE HPWH END --------------
3061 :
3062 49 : AlphArray.deallocate();
3063 49 : cAlphaFields.deallocate();
3064 49 : lAlphaBlanks.deallocate();
3065 49 : cNumericFields.deallocate();
3066 49 : lNumericBlanks.deallocate();
3067 49 : NumArray.deallocate();
3068 :
3069 49 : if (ErrorsFound) {
3070 0 : ShowFatalError(state, format("{}Errors found getting input. Program terminates.", RoutineName));
3071 : }
3072 :
3073 116 : for (DXCoilNum = 1; DXCoilNum <= state.dataVariableSpeedCoils->NumVarSpeedCoils; ++DXCoilNum) {
3074 96 : if ((state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).VSCoilType == HVAC::Coil_CoolingAirToAirVariableSpeed) ||
3075 29 : (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).VSCoilType == HVAC::Coil_HeatingAirToAirVariableSpeed)) {
3076 : // Setup Report variables for the Heat Pump
3077 :
3078 : // cooling and heating coils separately
3079 51 : if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).VSCoilType == HVAC::Coil_CoolingAirToAirVariableSpeed) {
3080 : // air source cooling coils
3081 76 : SetupOutputVariable(state,
3082 : "Cooling Coil Air Mass Flow Rate",
3083 : Constant::Units::kg_s,
3084 38 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).AirMassFlowRate,
3085 : OutputProcessor::TimeStepType::System,
3086 : OutputProcessor::StoreType::Average,
3087 38 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name);
3088 76 : SetupOutputVariable(state,
3089 : "Cooling Coil Air Inlet Temperature",
3090 : Constant::Units::C,
3091 38 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).InletAirDBTemp,
3092 : OutputProcessor::TimeStepType::System,
3093 : OutputProcessor::StoreType::Average,
3094 38 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name);
3095 76 : SetupOutputVariable(state,
3096 : "Cooling Coil Air Inlet Humidity Ratio",
3097 : Constant::Units::kgWater_kgDryAir,
3098 38 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).InletAirHumRat,
3099 : OutputProcessor::TimeStepType::System,
3100 : OutputProcessor::StoreType::Average,
3101 38 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name);
3102 76 : SetupOutputVariable(state,
3103 : "Cooling Coil Latent Cooling Rate",
3104 : Constant::Units::W,
3105 38 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).QLatent,
3106 : OutputProcessor::TimeStepType::System,
3107 : OutputProcessor::StoreType::Average,
3108 38 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name);
3109 76 : SetupOutputVariable(state,
3110 : "Cooling Coil Air Outlet Temperature",
3111 : Constant::Units::C,
3112 38 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).OutletAirDBTemp,
3113 : OutputProcessor::TimeStepType::System,
3114 : OutputProcessor::StoreType::Average,
3115 38 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name);
3116 76 : SetupOutputVariable(state,
3117 : "Cooling Coil Air Outlet Humidity Ratio",
3118 : Constant::Units::kgWater_kgDryAir,
3119 38 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).OutletAirHumRat,
3120 : OutputProcessor::TimeStepType::System,
3121 : OutputProcessor::StoreType::Average,
3122 38 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name);
3123 76 : SetupOutputVariable(state,
3124 : "Cooling Coil Sensible Cooling Rate",
3125 : Constant::Units::W,
3126 38 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).QSensible,
3127 : OutputProcessor::TimeStepType::System,
3128 : OutputProcessor::StoreType::Average,
3129 38 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name);
3130 76 : SetupOutputVariable(state,
3131 : "Cooling Coil Total Cooling Rate",
3132 : Constant::Units::W,
3133 38 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).QLoadTotal,
3134 : OutputProcessor::TimeStepType::System,
3135 : OutputProcessor::StoreType::Average,
3136 38 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name);
3137 76 : SetupOutputVariable(state,
3138 : "Cooling Coil Part Load Ratio",
3139 : Constant::Units::None,
3140 38 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).PartLoadRatio,
3141 : OutputProcessor::TimeStepType::System,
3142 : OutputProcessor::StoreType::Average,
3143 38 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name);
3144 76 : SetupOutputVariable(state,
3145 : "Cooling Coil Electricity Rate",
3146 : Constant::Units::W,
3147 38 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Power,
3148 : OutputProcessor::TimeStepType::System,
3149 : OutputProcessor::StoreType::Average,
3150 38 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name);
3151 76 : SetupOutputVariable(state,
3152 : "Cooling Coil Runtime Fraction",
3153 : Constant::Units::None,
3154 38 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).RunFrac,
3155 : OutputProcessor::TimeStepType::System,
3156 : OutputProcessor::StoreType::Average,
3157 38 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name);
3158 76 : SetupOutputVariable(state,
3159 : "Cooling Coil Source Side Heat Transfer Rate",
3160 : Constant::Units::W,
3161 38 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).QSource,
3162 : OutputProcessor::TimeStepType::System,
3163 : OutputProcessor::StoreType::Average,
3164 38 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name);
3165 76 : SetupOutputVariable(state,
3166 : "Cooling Coil Upper Speed Level",
3167 : Constant::Units::None,
3168 38 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).SpeedNumReport,
3169 : OutputProcessor::TimeStepType::System,
3170 : OutputProcessor::StoreType::Average,
3171 38 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name);
3172 76 : SetupOutputVariable(state,
3173 : "Cooling Coil Neighboring Speed Levels Ratio",
3174 : Constant::Units::None,
3175 38 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).SpeedRatioReport,
3176 : OutputProcessor::TimeStepType::System,
3177 : OutputProcessor::StoreType::Average,
3178 38 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name);
3179 :
3180 38 : if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).CondensateCollectMode == CondensateToTank) {
3181 0 : SetupOutputVariable(state,
3182 : "Cooling Coil Condensate Volume Flow Rate",
3183 : Constant::Units::m3_s,
3184 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).CondensateVdot,
3185 : OutputProcessor::TimeStepType::System,
3186 : OutputProcessor::StoreType::Average,
3187 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name);
3188 0 : SetupOutputVariable(state,
3189 : "Cooling Coil Condensate Volume",
3190 : Constant::Units::m3,
3191 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).CondensateVol,
3192 : OutputProcessor::TimeStepType::System,
3193 : OutputProcessor::StoreType::Sum,
3194 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name,
3195 : Constant::eResource::OnSiteWater,
3196 : OutputProcessor::Group::HVAC,
3197 : OutputProcessor::EndUseCat::Condensate);
3198 : }
3199 :
3200 38 : if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).ReportEvapCondVars) {
3201 2 : SetupOutputVariable(state,
3202 : "Cooling Coil Condenser Inlet Temperature",
3203 : Constant::Units::C,
3204 1 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).CondInletTemp,
3205 : OutputProcessor::TimeStepType::System,
3206 : OutputProcessor::StoreType::Average,
3207 1 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name);
3208 2 : SetupOutputVariable(state,
3209 : "Cooling Coil Evaporative Condenser Water Volume",
3210 : Constant::Units::m3,
3211 1 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).EvapWaterConsump,
3212 : OutputProcessor::TimeStepType::System,
3213 : OutputProcessor::StoreType::Sum,
3214 1 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name,
3215 : Constant::eResource::Water,
3216 : OutputProcessor::Group::HVAC,
3217 : OutputProcessor::EndUseCat::Cooling);
3218 2 : SetupOutputVariable(state,
3219 : "Cooling Coil Evaporative Condenser Mains Water Volume",
3220 : Constant::Units::m3,
3221 1 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).EvapWaterConsump,
3222 : OutputProcessor::TimeStepType::System,
3223 : OutputProcessor::StoreType::Sum,
3224 1 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name,
3225 : Constant::eResource::MainsWater,
3226 : OutputProcessor::Group::HVAC,
3227 : OutputProcessor::EndUseCat::Cooling);
3228 2 : SetupOutputVariable(state,
3229 : "Cooling Coil Evaporative Condenser Pump Electricity Rate",
3230 : Constant::Units::W,
3231 1 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).EvapCondPumpElecPower,
3232 : OutputProcessor::TimeStepType::System,
3233 : OutputProcessor::StoreType::Average,
3234 1 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name);
3235 2 : SetupOutputVariable(state,
3236 : "Cooling Coil Evaporative Condenser Pump Electricity Energy",
3237 : Constant::Units::J,
3238 1 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).EvapCondPumpElecConsumption,
3239 : OutputProcessor::TimeStepType::System,
3240 : OutputProcessor::StoreType::Sum,
3241 1 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name,
3242 : Constant::eResource::Electricity,
3243 : OutputProcessor::Group::HVAC,
3244 : OutputProcessor::EndUseCat::Cooling);
3245 1 : if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).BasinHeaterPowerFTempDiff > 0.0) {
3246 0 : SetupOutputVariable(state,
3247 : "Cooling Coil Basin Heater Electricity Rate",
3248 : Constant::Units::W,
3249 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).BasinHeaterPower,
3250 : OutputProcessor::TimeStepType::System,
3251 : OutputProcessor::StoreType::Average,
3252 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name);
3253 0 : SetupOutputVariable(state,
3254 : "Cooling Coil Basin Heater Electricity Energy",
3255 : Constant::Units::J,
3256 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).BasinHeaterConsumption,
3257 : OutputProcessor::TimeStepType::System,
3258 : OutputProcessor::StoreType::Sum,
3259 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name,
3260 : Constant::eResource::Electricity,
3261 : OutputProcessor::Group::HVAC,
3262 : OutputProcessor::EndUseCat::Cooling);
3263 : }
3264 : }
3265 :
3266 76 : SetupOutputVariable(state,
3267 : "Cooling Coil Crankcase Heater Electricity Rate",
3268 : Constant::Units::W,
3269 38 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).CrankcaseHeaterPower,
3270 : OutputProcessor::TimeStepType::System,
3271 : OutputProcessor::StoreType::Average,
3272 38 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name);
3273 76 : SetupOutputVariable(state,
3274 : "Cooling Coil Crankcase Heater Electricity Energy",
3275 : Constant::Units::J,
3276 38 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).CrankcaseHeaterConsumption,
3277 : OutputProcessor::TimeStepType::System,
3278 : OutputProcessor::StoreType::Sum,
3279 38 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name,
3280 : Constant::eResource::Electricity,
3281 : OutputProcessor::Group::HVAC,
3282 : OutputProcessor::EndUseCat::Cooling);
3283 : } else {
3284 : // air source heating coils
3285 26 : SetupOutputVariable(state,
3286 : "Heating Coil Air Mass Flow Rate",
3287 : Constant::Units::kg_s,
3288 13 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).AirMassFlowRate,
3289 : OutputProcessor::TimeStepType::System,
3290 : OutputProcessor::StoreType::Average,
3291 13 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name);
3292 26 : SetupOutputVariable(state,
3293 : "Heating Coil Air Inlet Temperature",
3294 : Constant::Units::C,
3295 13 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).InletAirDBTemp,
3296 : OutputProcessor::TimeStepType::System,
3297 : OutputProcessor::StoreType::Average,
3298 13 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name);
3299 26 : SetupOutputVariable(state,
3300 : "Heating Coil Air Inlet Humidity Ratio",
3301 : Constant::Units::kgWater_kgDryAir,
3302 13 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).InletAirHumRat,
3303 : OutputProcessor::TimeStepType::System,
3304 : OutputProcessor::StoreType::Average,
3305 13 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name);
3306 26 : SetupOutputVariable(state,
3307 : "Heating Coil Air Outlet Temperature",
3308 : Constant::Units::C,
3309 13 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).OutletAirDBTemp,
3310 : OutputProcessor::TimeStepType::System,
3311 : OutputProcessor::StoreType::Average,
3312 13 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name);
3313 26 : SetupOutputVariable(state,
3314 : "Heating Coil Air Outlet Humidity Ratio",
3315 : Constant::Units::kgWater_kgDryAir,
3316 13 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).OutletAirHumRat,
3317 : OutputProcessor::TimeStepType::System,
3318 : OutputProcessor::StoreType::Average,
3319 13 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name);
3320 26 : SetupOutputVariable(state,
3321 : "Heating Coil Sensible Heating Rate",
3322 : Constant::Units::W,
3323 13 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).QSensible,
3324 : OutputProcessor::TimeStepType::System,
3325 : OutputProcessor::StoreType::Average,
3326 13 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name);
3327 26 : SetupOutputVariable(state,
3328 : "Heating Coil Heating Rate",
3329 : Constant::Units::W,
3330 13 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).QLoadTotal,
3331 : OutputProcessor::TimeStepType::System,
3332 : OutputProcessor::StoreType::Average,
3333 13 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name);
3334 26 : SetupOutputVariable(state,
3335 : "Heating Coil Part Load Ratio",
3336 : Constant::Units::None,
3337 13 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).PartLoadRatio,
3338 : OutputProcessor::TimeStepType::System,
3339 : OutputProcessor::StoreType::Average,
3340 13 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name);
3341 26 : SetupOutputVariable(state,
3342 : "Heating Coil Electricity Rate",
3343 : Constant::Units::W,
3344 13 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Power,
3345 : OutputProcessor::TimeStepType::System,
3346 : OutputProcessor::StoreType::Average,
3347 13 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name);
3348 26 : SetupOutputVariable(state,
3349 : "Heating Coil Runtime Fraction",
3350 : Constant::Units::None,
3351 13 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).RunFrac,
3352 : OutputProcessor::TimeStepType::System,
3353 : OutputProcessor::StoreType::Average,
3354 13 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name);
3355 :
3356 26 : SetupOutputVariable(state,
3357 : "Heating Coil Source Side Heat Transfer Rate",
3358 : Constant::Units::W,
3359 13 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).QSource,
3360 : OutputProcessor::TimeStepType::System,
3361 : OutputProcessor::StoreType::Average,
3362 13 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name);
3363 26 : SetupOutputVariable(state,
3364 : "Heating Coil Upper Speed Level",
3365 : Constant::Units::None,
3366 13 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).SpeedNumReport,
3367 : OutputProcessor::TimeStepType::System,
3368 : OutputProcessor::StoreType::Average,
3369 13 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name);
3370 26 : SetupOutputVariable(state,
3371 : "Heating Coil Neighboring Speed Levels Ratio",
3372 : Constant::Units::None,
3373 13 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).SpeedRatioReport,
3374 : OutputProcessor::TimeStepType::System,
3375 : OutputProcessor::StoreType::Average,
3376 13 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name);
3377 :
3378 26 : SetupOutputVariable(state,
3379 : "Heating Coil Defrost Electricity Rate",
3380 : Constant::Units::W,
3381 13 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).DefrostPower,
3382 : OutputProcessor::TimeStepType::System,
3383 : OutputProcessor::StoreType::Average,
3384 13 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name);
3385 26 : SetupOutputVariable(state,
3386 : "Heating Coil Defrost Electricity Energy",
3387 : Constant::Units::J,
3388 13 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).DefrostConsumption,
3389 : OutputProcessor::TimeStepType::System,
3390 : OutputProcessor::StoreType::Sum,
3391 13 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name,
3392 : Constant::eResource::Electricity,
3393 : OutputProcessor::Group::HVAC,
3394 : OutputProcessor::EndUseCat::Heating);
3395 26 : SetupOutputVariable(state,
3396 : "Heating Coil Crankcase Heater Electricity Rate",
3397 : Constant::Units::W,
3398 13 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).CrankcaseHeaterPower,
3399 : OutputProcessor::TimeStepType::System,
3400 : OutputProcessor::StoreType::Average,
3401 13 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name);
3402 26 : SetupOutputVariable(state,
3403 : "Heating Coil Crankcase Heater Electricity Energy",
3404 : Constant::Units::J,
3405 13 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).CrankcaseHeaterConsumption,
3406 : OutputProcessor::TimeStepType::System,
3407 : OutputProcessor::StoreType::Sum,
3408 13 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name,
3409 : Constant::eResource::Electricity,
3410 : OutputProcessor::Group::HVAC,
3411 : OutputProcessor::EndUseCat::Heating);
3412 :
3413 13 : if (state.dataGlobal->AnyEnergyManagementSystemInModel) {
3414 0 : SetupEMSActuator(state,
3415 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).VarSpeedCoilType,
3416 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name,
3417 : "Frost Heating Capacity Multiplier",
3418 : "[]",
3419 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).FrostHeatingCapacityMultiplierEMSOverrideOn,
3420 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).FrostHeatingCapacityMultiplierEMSOverrideValue);
3421 :
3422 0 : SetupEMSActuator(state,
3423 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).VarSpeedCoilType,
3424 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name,
3425 : "Frost Heating Input Power Multiplier",
3426 : "[]",
3427 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).FrostHeatingInputPowerMultiplierEMSOverrideOn,
3428 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).FrostHeatingInputPowerMultiplierEMSOverrideValue);
3429 : }
3430 : }
3431 : } else {
3432 :
3433 16 : if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).VSCoilType ==
3434 : HVAC::Coil_CoolingWaterToAirHPVSEquationFit) { // fix coil type
3435 : // cooling WAHP coil
3436 : // Setup Report variables for water source Heat Pump
3437 10 : SetupOutputVariable(state,
3438 : "Cooling Coil Electricity Rate",
3439 : Constant::Units::W,
3440 5 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Power,
3441 : OutputProcessor::TimeStepType::System,
3442 : OutputProcessor::StoreType::Average,
3443 5 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name);
3444 10 : SetupOutputVariable(state,
3445 : "Cooling Coil Total Cooling Rate",
3446 : Constant::Units::W,
3447 5 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).QLoadTotal,
3448 : OutputProcessor::TimeStepType::System,
3449 : OutputProcessor::StoreType::Average,
3450 5 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name);
3451 10 : SetupOutputVariable(state,
3452 : "Cooling Coil Sensible Cooling Rate",
3453 : Constant::Units::W,
3454 5 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).QSensible,
3455 : OutputProcessor::TimeStepType::System,
3456 : OutputProcessor::StoreType::Average,
3457 5 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name);
3458 10 : SetupOutputVariable(state,
3459 : "Cooling Coil Latent Cooling Rate",
3460 : Constant::Units::W,
3461 5 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).QLatent,
3462 : OutputProcessor::TimeStepType::System,
3463 : OutputProcessor::StoreType::Average,
3464 5 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name);
3465 10 : SetupOutputVariable(state,
3466 : "Cooling Coil Source Side Heat Transfer Rate",
3467 : Constant::Units::W,
3468 5 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).QSource,
3469 : OutputProcessor::TimeStepType::System,
3470 : OutputProcessor::StoreType::Average,
3471 5 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name);
3472 10 : SetupOutputVariable(state,
3473 : "Cooling Coil Part Load Ratio",
3474 : Constant::Units::None,
3475 5 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).PartLoadRatio,
3476 : OutputProcessor::TimeStepType::System,
3477 : OutputProcessor::StoreType::Average,
3478 5 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name);
3479 10 : SetupOutputVariable(state,
3480 : "Cooling Coil Runtime Fraction",
3481 : Constant::Units::None,
3482 5 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).RunFrac,
3483 : OutputProcessor::TimeStepType::System,
3484 : OutputProcessor::StoreType::Average,
3485 5 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name);
3486 :
3487 10 : SetupOutputVariable(state,
3488 : "Cooling Coil Air Mass Flow Rate",
3489 : Constant::Units::kg_s,
3490 5 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).AirMassFlowRate,
3491 : OutputProcessor::TimeStepType::System,
3492 : OutputProcessor::StoreType::Average,
3493 5 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name);
3494 10 : SetupOutputVariable(state,
3495 : "Cooling Coil Air Inlet Temperature",
3496 : Constant::Units::C,
3497 5 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).InletAirDBTemp,
3498 : OutputProcessor::TimeStepType::System,
3499 : OutputProcessor::StoreType::Average,
3500 5 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name);
3501 10 : SetupOutputVariable(state,
3502 : "Cooling Coil Air Inlet Humidity Ratio",
3503 : Constant::Units::kgWater_kgDryAir,
3504 5 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).InletAirHumRat,
3505 : OutputProcessor::TimeStepType::System,
3506 : OutputProcessor::StoreType::Average,
3507 5 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name);
3508 10 : SetupOutputVariable(state,
3509 : "Cooling Coil Air Outlet Temperature",
3510 : Constant::Units::C,
3511 5 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).OutletAirDBTemp,
3512 : OutputProcessor::TimeStepType::System,
3513 : OutputProcessor::StoreType::Average,
3514 5 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name);
3515 10 : SetupOutputVariable(state,
3516 : "Cooling Coil Air Outlet Humidity Ratio",
3517 : Constant::Units::kgWater_kgDryAir,
3518 5 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).OutletAirHumRat,
3519 : OutputProcessor::TimeStepType::System,
3520 : OutputProcessor::StoreType::Average,
3521 5 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name);
3522 10 : SetupOutputVariable(state,
3523 : "Cooling Coil Source Side Mass Flow Rate",
3524 : Constant::Units::kg_s,
3525 5 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).WaterMassFlowRate,
3526 : OutputProcessor::TimeStepType::System,
3527 : OutputProcessor::StoreType::Average,
3528 5 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name);
3529 10 : SetupOutputVariable(state,
3530 : "Cooling Coil Source Side Inlet Temperature",
3531 : Constant::Units::C,
3532 5 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).InletWaterTemp,
3533 : OutputProcessor::TimeStepType::System,
3534 : OutputProcessor::StoreType::Average,
3535 5 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name);
3536 10 : SetupOutputVariable(state,
3537 : "Cooling Coil Source Side Outlet Temperature",
3538 : Constant::Units::C,
3539 5 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).OutletWaterTemp,
3540 : OutputProcessor::TimeStepType::System,
3541 : OutputProcessor::StoreType::Average,
3542 5 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name);
3543 :
3544 10 : SetupOutputVariable(state,
3545 : "Cooling Coil Upper Speed Level",
3546 : Constant::Units::None,
3547 5 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).SpeedNumReport,
3548 : OutputProcessor::TimeStepType::System,
3549 : OutputProcessor::StoreType::Average,
3550 5 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name);
3551 10 : SetupOutputVariable(state,
3552 : "Cooling Coil Neighboring Speed Levels Ratio",
3553 : Constant::Units::None,
3554 5 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).SpeedRatioReport,
3555 : OutputProcessor::TimeStepType::System,
3556 : OutputProcessor::StoreType::Average,
3557 5 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name);
3558 10 : SetupOutputVariable(state,
3559 : "Cooling Coil Recoverable Heat Transfer Rate",
3560 : Constant::Units::W,
3561 5 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).QWasteHeat,
3562 : OutputProcessor::TimeStepType::System,
3563 : OutputProcessor::StoreType::Average,
3564 5 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name);
3565 11 : } else if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).VSCoilType ==
3566 : HVAC::Coil_HeatingWaterToAirHPVSEquationFit) { // fix coil type
3567 : // heating WAHP coil
3568 : // Setup Report variables for water source Heat Pump
3569 8 : SetupOutputVariable(state,
3570 : "Heating Coil Electricity Rate",
3571 : Constant::Units::W,
3572 4 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Power,
3573 : OutputProcessor::TimeStepType::System,
3574 : OutputProcessor::StoreType::Average,
3575 4 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name);
3576 8 : SetupOutputVariable(state,
3577 : "Heating Coil Heating Rate",
3578 : Constant::Units::W,
3579 4 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).QLoadTotal,
3580 : OutputProcessor::TimeStepType::System,
3581 : OutputProcessor::StoreType::Average,
3582 4 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name);
3583 8 : SetupOutputVariable(state,
3584 : "Heating Coil Sensible Heating Rate",
3585 : Constant::Units::W,
3586 4 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).QSensible,
3587 : OutputProcessor::TimeStepType::System,
3588 : OutputProcessor::StoreType::Average,
3589 4 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name);
3590 :
3591 8 : SetupOutputVariable(state,
3592 : "Heating Coil Source Side Heat Transfer Rate",
3593 : Constant::Units::W,
3594 4 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).QSource,
3595 : OutputProcessor::TimeStepType::System,
3596 : OutputProcessor::StoreType::Average,
3597 4 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name);
3598 8 : SetupOutputVariable(state,
3599 : "Heating Coil Part Load Ratio",
3600 : Constant::Units::None,
3601 4 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).PartLoadRatio,
3602 : OutputProcessor::TimeStepType::System,
3603 : OutputProcessor::StoreType::Average,
3604 4 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name);
3605 8 : SetupOutputVariable(state,
3606 : "Heating Coil Runtime Fraction",
3607 : Constant::Units::None,
3608 4 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).RunFrac,
3609 : OutputProcessor::TimeStepType::System,
3610 : OutputProcessor::StoreType::Average,
3611 4 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name);
3612 :
3613 8 : SetupOutputVariable(state,
3614 : "Heating Coil Air Mass Flow Rate",
3615 : Constant::Units::kg_s,
3616 4 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).AirMassFlowRate,
3617 : OutputProcessor::TimeStepType::System,
3618 : OutputProcessor::StoreType::Average,
3619 4 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name);
3620 8 : SetupOutputVariable(state,
3621 : "Heating Coil Air Inlet Temperature",
3622 : Constant::Units::C,
3623 4 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).InletAirDBTemp,
3624 : OutputProcessor::TimeStepType::System,
3625 : OutputProcessor::StoreType::Average,
3626 4 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name);
3627 8 : SetupOutputVariable(state,
3628 : "Heating Coil Air Inlet Humidity Ratio",
3629 : Constant::Units::kgWater_kgDryAir,
3630 4 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).InletAirHumRat,
3631 : OutputProcessor::TimeStepType::System,
3632 : OutputProcessor::StoreType::Average,
3633 4 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name);
3634 8 : SetupOutputVariable(state,
3635 : "Heating Coil Air Outlet Temperature",
3636 : Constant::Units::C,
3637 4 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).OutletAirDBTemp,
3638 : OutputProcessor::TimeStepType::System,
3639 : OutputProcessor::StoreType::Average,
3640 4 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name);
3641 8 : SetupOutputVariable(state,
3642 : "Heating Coil Air Outlet Humidity Ratio",
3643 : Constant::Units::kgWater_kgDryAir,
3644 4 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).OutletAirHumRat,
3645 : OutputProcessor::TimeStepType::System,
3646 : OutputProcessor::StoreType::Average,
3647 4 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name);
3648 8 : SetupOutputVariable(state,
3649 : "Heating Coil Source Side Mass Flow Rate",
3650 : Constant::Units::kg_s,
3651 4 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).WaterMassFlowRate,
3652 : OutputProcessor::TimeStepType::System,
3653 : OutputProcessor::StoreType::Average,
3654 4 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name);
3655 8 : SetupOutputVariable(state,
3656 : "Heating Coil Source Side Inlet Temperature",
3657 : Constant::Units::C,
3658 4 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).InletWaterTemp,
3659 : OutputProcessor::TimeStepType::System,
3660 : OutputProcessor::StoreType::Average,
3661 4 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name);
3662 8 : SetupOutputVariable(state,
3663 : "Heating Coil Source Side Outlet Temperature",
3664 : Constant::Units::C,
3665 4 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).OutletWaterTemp,
3666 : OutputProcessor::TimeStepType::System,
3667 : OutputProcessor::StoreType::Average,
3668 4 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name);
3669 :
3670 8 : SetupOutputVariable(state,
3671 : "Heating Coil Upper Speed Level",
3672 : Constant::Units::None,
3673 4 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).SpeedNumReport,
3674 : OutputProcessor::TimeStepType::System,
3675 : OutputProcessor::StoreType::Average,
3676 4 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name);
3677 8 : SetupOutputVariable(state,
3678 : "Heating Coil Neighboring Speed Levels Ratio",
3679 : Constant::Units::None,
3680 4 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).SpeedRatioReport,
3681 : OutputProcessor::TimeStepType::System,
3682 : OutputProcessor::StoreType::Average,
3683 4 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name);
3684 8 : SetupOutputVariable(state,
3685 : "Heating Coil Recoverable Heat Transfer Rate",
3686 : Constant::Units::W,
3687 4 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).QWasteHeat,
3688 : OutputProcessor::TimeStepType::System,
3689 : OutputProcessor::StoreType::Average,
3690 4 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name);
3691 7 : } else if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).VSCoilType == HVAC::CoilDX_HeatPumpWaterHeaterVariableSpeed) {
3692 : // air source water heating coil
3693 14 : SetupOutputVariable(state,
3694 : "Cooling Coil Water Heating Electricity Rate",
3695 : Constant::Units::W,
3696 7 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Power,
3697 : OutputProcessor::TimeStepType::System,
3698 : OutputProcessor::StoreType::Average,
3699 7 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name);
3700 14 : SetupOutputVariable(state,
3701 : "Cooling Coil Total Cooling Rate",
3702 : Constant::Units::W,
3703 7 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).QLoadTotal,
3704 : OutputProcessor::TimeStepType::System,
3705 : OutputProcessor::StoreType::Average,
3706 7 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name);
3707 14 : SetupOutputVariable(state,
3708 : "Cooling Coil Sensible Cooling Rate",
3709 : Constant::Units::W,
3710 7 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).QSensible,
3711 : OutputProcessor::TimeStepType::System,
3712 : OutputProcessor::StoreType::Average,
3713 7 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name);
3714 14 : SetupOutputVariable(state,
3715 : "Cooling Coil Latent Cooling Rate",
3716 : Constant::Units::W,
3717 7 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).QLatent,
3718 : OutputProcessor::TimeStepType::System,
3719 : OutputProcessor::StoreType::Average,
3720 7 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name);
3721 14 : SetupOutputVariable(state,
3722 : "Cooling Coil Total Water Heating Rate",
3723 : Constant::Units::W,
3724 7 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).TotalHeatingEnergyRate,
3725 : OutputProcessor::TimeStepType::System,
3726 : OutputProcessor::StoreType::Average,
3727 7 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name);
3728 14 : SetupOutputVariable(state,
3729 : "Cooling Coil Part Load Ratio",
3730 : Constant::Units::None,
3731 7 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).PartLoadRatio,
3732 : OutputProcessor::TimeStepType::System,
3733 : OutputProcessor::StoreType::Average,
3734 7 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name);
3735 14 : SetupOutputVariable(state,
3736 : "Cooling Coil Runtime Fraction",
3737 : Constant::Units::None,
3738 7 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).RunFrac,
3739 : OutputProcessor::TimeStepType::System,
3740 : OutputProcessor::StoreType::Average,
3741 7 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name);
3742 :
3743 14 : SetupOutputVariable(state,
3744 : "Cooling Coil Air Mass Flow Rate",
3745 : Constant::Units::kg_s,
3746 7 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).AirMassFlowRate,
3747 : OutputProcessor::TimeStepType::System,
3748 : OutputProcessor::StoreType::Average,
3749 7 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name);
3750 14 : SetupOutputVariable(state,
3751 : "Cooling Coil Air Inlet Temperature",
3752 : Constant::Units::C,
3753 7 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).InletAirDBTemp,
3754 : OutputProcessor::TimeStepType::System,
3755 : OutputProcessor::StoreType::Average,
3756 7 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name);
3757 14 : SetupOutputVariable(state,
3758 : "Cooling Coil Air Inlet Humidity Ratio",
3759 : Constant::Units::kgWater_kgDryAir,
3760 7 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).InletAirHumRat,
3761 : OutputProcessor::TimeStepType::System,
3762 : OutputProcessor::StoreType::Average,
3763 7 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name);
3764 14 : SetupOutputVariable(state,
3765 : "Cooling Coil Air Outlet Temperature",
3766 : Constant::Units::C,
3767 7 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).OutletAirDBTemp,
3768 : OutputProcessor::TimeStepType::System,
3769 : OutputProcessor::StoreType::Average,
3770 7 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name);
3771 14 : SetupOutputVariable(state,
3772 : "Cooling Coil Air Outlet Humidity Ratio",
3773 : Constant::Units::kgWater_kgDryAir,
3774 7 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).OutletAirHumRat,
3775 : OutputProcessor::TimeStepType::System,
3776 : OutputProcessor::StoreType::Average,
3777 7 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name);
3778 14 : SetupOutputVariable(state,
3779 : "Cooling Coil Water Mass Flow Rate",
3780 : Constant::Units::kg_s,
3781 7 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).WaterMassFlowRate,
3782 : OutputProcessor::TimeStepType::System,
3783 : OutputProcessor::StoreType::Average,
3784 7 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name);
3785 14 : SetupOutputVariable(state,
3786 : "Cooling Coil Water Inlet Temperature",
3787 : Constant::Units::C,
3788 7 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).InletWaterTemp,
3789 : OutputProcessor::TimeStepType::System,
3790 : OutputProcessor::StoreType::Average,
3791 7 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name);
3792 14 : SetupOutputVariable(state,
3793 : "Cooling Coil Water Outlet Temperature",
3794 : Constant::Units::C,
3795 7 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).OutletWaterTemp,
3796 : OutputProcessor::TimeStepType::System,
3797 : OutputProcessor::StoreType::Average,
3798 7 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name);
3799 :
3800 14 : SetupOutputVariable(state,
3801 : "Cooling Coil Crankcase Heater Electricity Rate",
3802 : Constant::Units::W,
3803 7 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).CrankcaseHeaterPower,
3804 : OutputProcessor::TimeStepType::System,
3805 : OutputProcessor::StoreType::Average,
3806 7 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name);
3807 14 : SetupOutputVariable(state,
3808 : "Cooling Coil Crankcase Heater Electricity Energy",
3809 : Constant::Units::J,
3810 7 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).CrankcaseHeaterConsumption,
3811 : OutputProcessor::TimeStepType::System,
3812 : OutputProcessor::StoreType::Sum,
3813 7 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name,
3814 : Constant::eResource::Electricity,
3815 : OutputProcessor::Group::HVAC,
3816 : OutputProcessor::EndUseCat::Heating);
3817 :
3818 14 : SetupOutputVariable(state,
3819 : "Cooling Coil Upper Speed Level",
3820 : Constant::Units::None,
3821 7 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).SpeedNumReport,
3822 : OutputProcessor::TimeStepType::System,
3823 : OutputProcessor::StoreType::Average,
3824 7 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name);
3825 14 : SetupOutputVariable(state,
3826 : "Cooling Coil Neighboring Speed Levels Ratio",
3827 : Constant::Units::None,
3828 7 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).SpeedRatioReport,
3829 : OutputProcessor::TimeStepType::System,
3830 : OutputProcessor::StoreType::Average,
3831 7 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name);
3832 :
3833 14 : SetupOutputVariable(state,
3834 : "Cooling Coil Water Heating Pump Electricity Rate",
3835 : Constant::Units::W,
3836 7 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).HPWHCondPumpElecNomPower,
3837 : OutputProcessor::TimeStepType::System,
3838 : OutputProcessor::StoreType::Average,
3839 7 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name);
3840 14 : SetupOutputVariable(state,
3841 : "Cooling Coil Water Heating Pump Electricity Energy",
3842 : Constant::Units::J,
3843 7 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).EvapCondPumpElecConsumption,
3844 : OutputProcessor::TimeStepType::System,
3845 : OutputProcessor::StoreType::Sum,
3846 7 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name,
3847 : Constant::eResource::Electricity,
3848 : OutputProcessor::Group::HVAC,
3849 : OutputProcessor::EndUseCat::Heating);
3850 : }
3851 : }
3852 : }
3853 :
3854 49 : if (ErrorsFound) {
3855 0 : ShowFatalError(
3856 0 : state, format("{}Errors found in getting {} input. Preceding condition(s) causes termination.", RoutineName, CurrentModuleObject));
3857 : }
3858 49 : }
3859 :
3860 : // Beginning Initialization Section of the Module
3861 : //******************************************************************************
3862 :
3863 67679 : void InitVarSpeedCoil(EnergyPlusData &state,
3864 : int const DXCoilNum, // Current DXCoilNum under simulation
3865 : Real64 const SensLoad, // Control zone sensible load[W]
3866 : Real64 const LatentLoad, // Control zone latent load[W]
3867 : HVAC::FanOp const fanOp, // fan operating mode
3868 : [[maybe_unused]] Real64 const OnOffAirFlowRatio, // ratio of compressor on flow to average flow over time step
3869 : Real64 const SpeedRatio, // compressor speed ratio
3870 : int const SpeedNum // compressor speed number
3871 : )
3872 : {
3873 :
3874 : // SUBROUTINE INFORMATION:
3875 : // AUTHOR Bo Shen, based on MODULE WaterToAirHeatPumpSimple:InitSimpleWatertoAirHP
3876 : // DATE WRITTEN March, 2012
3877 : // MODIFIED Bo Shen, 12/2014, add variable-speed HPWH
3878 :
3879 : // PURPOSE OF THIS SUBROUTINE:
3880 : // This subroutine is for initializations of the variable speed Water to Air HP Components.
3881 :
3882 : // METHODOLOGY EMPLOYED:
3883 : // Uses the status flags to trigger initializations.
3884 :
3885 : // SUBROUTINE PARAMETER DEFINITIONS:
3886 : static constexpr std::string_view RoutineNameSimpleWatertoAirHP("InitSimpleWatertoAirHP");
3887 :
3888 : // SUBROUTINE LOCAL VARIABLE DECLARATIONS:
3889 : int WaterInletNode; // Node Number of the Water inlet
3890 : Real64 rho; // local fluid density
3891 : Real64 Cp; // local fluid specific heat
3892 : int SpeedCal; // calculated speed level
3893 : bool ErrorsFound; // TRUE when errors found, air loop initialization error
3894 : Real64 RatedVolFlowPerRatedTotCap; // Rated Air Volume Flow Rate divided by Rated Total Capacity [m3/s-W)
3895 : Real64 RatedHeatPumpIndoorAirTemp; // Indoor dry-bulb temperature to heat pump evaporator at rated conditions [C]
3896 : Real64 RatedHeatPumpIndoorHumRat; // Inlet humidity ratio to heat pump evaporator at rated conditions [kg/kg]
3897 : Real64 WaterFlowScale; // water flow scaling factor match rated flow rate
3898 :
3899 : // SUBROUTINE PARAMETER DEFINITIONS:
3900 : static constexpr std::string_view RoutineName = "InitVarSpeedCoil";
3901 67679 : int AirInletNode = state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).AirInletNodeNum;
3902 :
3903 67679 : if (state.dataVariableSpeedCoils->MyOneTimeFlag) {
3904 : // initialize the environment and sizing flags
3905 16 : state.dataVariableSpeedCoils->MySizeFlag.allocate(state.dataVariableSpeedCoils->NumVarSpeedCoils);
3906 16 : state.dataVariableSpeedCoils->MyEnvrnFlag.allocate(state.dataVariableSpeedCoils->NumVarSpeedCoils);
3907 16 : state.dataVariableSpeedCoils->MyPlantScanFlag.allocate(state.dataVariableSpeedCoils->NumVarSpeedCoils);
3908 16 : state.dataVariableSpeedCoils->MySizeFlag = true;
3909 16 : state.dataVariableSpeedCoils->MyEnvrnFlag = true;
3910 16 : state.dataVariableSpeedCoils->MyPlantScanFlag = true;
3911 16 : state.dataVariableSpeedCoils->MyOneTimeFlag = false;
3912 : }
3913 :
3914 67679 : state.dataHVACGlobal->DXCT = HVAC::DXCoilType::Regular; // hard-code to non-DOAS sizing routine for cfm/ton until .ISHundredPercentDOASDXCoil
3915 : // member from DXcoils.cc is added to VarSpeedCoil object
3916 :
3917 : // variable-speed heat pump water heating, begin
3918 67679 : if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).VSCoilType == HVAC::CoilDX_HeatPumpWaterHeaterVariableSpeed &&
3919 0 : state.dataVariableSpeedCoils->MySizeFlag(DXCoilNum)) {
3920 :
3921 0 : ErrorsFound = false;
3922 0 : SizeVarSpeedCoil(state, DXCoilNum, ErrorsFound);
3923 0 : if (ErrorsFound) {
3924 0 : ShowFatalError(state, format("{}: Failed to size variable speed coil.", RoutineName));
3925 : }
3926 :
3927 : // get rated coil bypass factor excluding fan heat
3928 :
3929 0 : state.dataVariableSpeedCoils->MySizeFlag(DXCoilNum) = false;
3930 : }
3931 : // variable-speed heat pump water heating, end
3932 :
3933 : // water source
3934 101721 : if ((state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).VSCoilType == HVAC::Coil_CoolingWaterToAirHPVSEquationFit) ||
3935 34042 : (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).VSCoilType == HVAC::Coil_HeatingWaterToAirHPVSEquationFit)) { // fix coil type
3936 67273 : if (state.dataVariableSpeedCoils->MyPlantScanFlag(DXCoilNum) && allocated(state.dataPlnt->PlantLoop)) {
3937 : // switch from coil type numbers in DataHVACGlobals, to coil type numbers in plant.
3938 3 : DataPlant::PlantEquipmentType CoilVSWAHPType(DataPlant::PlantEquipmentType::Invalid);
3939 3 : if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).VSCoilType == HVAC::Coil_CoolingWaterToAirHPVSEquationFit) {
3940 2 : CoilVSWAHPType = DataPlant::PlantEquipmentType::CoilVSWAHPCoolingEquationFit;
3941 1 : } else if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).VSCoilType == HVAC::Coil_HeatingWaterToAirHPVSEquationFit) {
3942 1 : CoilVSWAHPType = DataPlant::PlantEquipmentType::CoilVSWAHPHeatingEquationFit;
3943 : }
3944 3 : ErrorsFound = false;
3945 6 : PlantUtilities::ScanPlantLoopsForObject(state,
3946 3 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name,
3947 : CoilVSWAHPType,
3948 3 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).plantLoc,
3949 : ErrorsFound,
3950 : _,
3951 : _,
3952 : _,
3953 : _,
3954 : _);
3955 3 : if (ErrorsFound) {
3956 0 : ShowFatalError(state, "InitVarSpeedCoil: Program terminated for previous conditions.");
3957 : }
3958 3 : state.dataVariableSpeedCoils->MyPlantScanFlag(DXCoilNum) = false;
3959 : }
3960 : } else {
3961 406 : state.dataVariableSpeedCoils->MyPlantScanFlag(DXCoilNum) = false;
3962 : }
3963 :
3964 67697 : if (!state.dataGlobal->SysSizingCalc && state.dataVariableSpeedCoils->MySizeFlag(DXCoilNum) &&
3965 18 : !state.dataVariableSpeedCoils->MyPlantScanFlag(DXCoilNum)) {
3966 : // for each furnace, do the sizing once.
3967 18 : ErrorsFound = false;
3968 18 : SizeVarSpeedCoil(state, DXCoilNum, ErrorsFound);
3969 18 : if (ErrorsFound) {
3970 0 : ShowFatalError(state, format("{}: Failed to size variable speed coil.", RoutineName));
3971 : }
3972 :
3973 18 : state.dataVariableSpeedCoils->MySizeFlag(DXCoilNum) = false;
3974 :
3975 : // Multispeed Cooling
3976 34 : if ((state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).VSCoilType == HVAC::Coil_CoolingWaterToAirHPVSEquationFit) ||
3977 16 : (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).VSCoilType == HVAC::Coil_CoolingAirToAirVariableSpeed)) {
3978 86 : for (int Mode = 1; Mode <= state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).NumOfSpeeds; ++Mode) {
3979 74 : if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).RatedCapCoolTotal <= 0.0) {
3980 1 : break;
3981 : }
3982 : // Check for zero capacity or zero max flow rate
3983 73 : if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedTotCap(Mode) <= 0.0) {
3984 0 : ShowSevereError(state,
3985 0 : format("Sizing: {} {} has zero rated total capacity at speed {}",
3986 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).VarSpeedCoilType,
3987 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name,
3988 : Mode));
3989 0 : ErrorsFound = true;
3990 : }
3991 73 : if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedAirVolFlowRate(Mode) <= 0.0) {
3992 0 : ShowSevereError(state,
3993 0 : format("Sizing: {} {} has zero rated air flow rate at speed {}",
3994 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).VarSpeedCoilType,
3995 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name,
3996 : Mode));
3997 0 : ErrorsFound = true;
3998 : }
3999 73 : if (ErrorsFound) {
4000 0 : ShowFatalError(state, "Preceding condition causes termination.");
4001 : }
4002 : // Check for valid range of (Rated Air Volume Flow Rate / Rated Total Capacity)
4003 73 : RatedVolFlowPerRatedTotCap = state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedAirVolFlowRate(Mode) /
4004 73 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedTotCap(Mode);
4005 : }
4006 : // call coil model with everything set at rating point
4007 13 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).InletAirDBTemp = RatedInletAirTemp;
4008 13 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).InletAirHumRat =
4009 13 : Psychrometrics::PsyWFnTdbTwbPb(state, RatedInletAirTemp, RatedInletWetBulbTemp, DataEnvironment::StdPressureSeaLevel);
4010 13 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).InletAirEnthalpy =
4011 13 : Psychrometrics::PsyHFnTdbW(RatedInletAirTemp, state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).InletAirHumRat);
4012 13 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).InletAirPressure = DataEnvironment::StdPressureSeaLevel;
4013 :
4014 13 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).AirMassFlowRate =
4015 13 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).RatedAirVolFlowRate *
4016 26 : Psychrometrics::PsyRhoAirFnPbTdbW(state,
4017 : DataEnvironment::StdPressureSeaLevel,
4018 : RatedInletAirTemp,
4019 13 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).InletAirHumRat);
4020 : // store environment data fill back in after rating point calc is over
4021 13 : Real64 holdOutDryBulbTemp = state.dataEnvrn->OutDryBulbTemp;
4022 13 : Real64 holdOutHumRat = state.dataEnvrn->OutHumRat;
4023 13 : Real64 holdOutWetBulb = state.dataEnvrn->OutWetBulbTemp;
4024 13 : Real64 holdOutBaroPress = state.dataEnvrn->OutBaroPress;
4025 13 : Real64 ratedOutdoorAirWetBulb = 23.9; // from I/O ref. more precise value?
4026 :
4027 13 : state.dataEnvrn->OutDryBulbTemp = RatedAmbAirTemp;
4028 13 : state.dataEnvrn->OutWetBulbTemp = ratedOutdoorAirWetBulb;
4029 13 : state.dataEnvrn->OutBaroPress = DataEnvironment::StdPressureSeaLevel; // assume rating is for sea level.
4030 26 : state.dataEnvrn->OutHumRat =
4031 13 : Psychrometrics::PsyWFnTdbTwbPb(state, RatedAmbAirTemp, ratedOutdoorAirWetBulb, DataEnvironment::StdPressureSeaLevel, RoutineName);
4032 13 : if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).CondenserInletNodeNum > 0) {
4033 0 : state.dataLoopNodes->Node(state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).CondenserInletNodeNum).Temp = RatedAmbAirTemp;
4034 0 : state.dataLoopNodes->Node(state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).CondenserInletNodeNum).HumRat =
4035 0 : state.dataEnvrn->OutHumRat;
4036 0 : state.dataLoopNodes->Node(state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).CondenserInletNodeNum).Press =
4037 : DataEnvironment::StdPressureSeaLevel;
4038 0 : state.dataLoopNodes->Node(state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).CondenserInletNodeNum).OutAirWetBulb =
4039 : ratedOutdoorAirWetBulb;
4040 : }
4041 13 : if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).VSCoilType ==
4042 : HVAC::Coil_CoolingWaterToAirHPVSEquationFit) { // need to set water info for WSHP
4043 2 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).WaterMassFlowRate =
4044 4 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedWaterMassFlowRate(
4045 2 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).NumOfSpeeds);
4046 2 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).InletWaterTemp = RatedInletWaterTemp; // 85 F cooling mode
4047 2 : Real64 CpSource = state.dataPlnt->PlantLoop(state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).plantLoc.loopNum)
4048 2 : .glycol->getSpecificHeat(state, state.dataVariableSpeedCoils->SourceSideInletTemp, RoutineName);
4049 2 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).InletWaterEnthalpy =
4050 2 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).InletWaterTemp * CpSource;
4051 : }
4052 :
4053 : // calculate coil model at rating point
4054 13 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).RunFrac = 1.0;
4055 13 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).DesignAirMassFlowRate =
4056 26 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedAirMassFlowRate(
4057 13 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).NumOfSpeeds);
4058 13 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).DesignAirVolFlowRate =
4059 26 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedAirVolFlowRate(
4060 13 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).NumOfSpeeds);
4061 13 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).DesignWaterMassFlowRate =
4062 26 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedWaterMassFlowRate(
4063 13 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).NumOfSpeeds);
4064 13 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).DesignWaterVolFlowRate =
4065 26 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedWaterVolFlowRate(
4066 13 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).NumOfSpeeds);
4067 :
4068 13 : CalcVarSpeedCoilCooling(state,
4069 : DXCoilNum,
4070 : HVAC::FanOp::Continuous,
4071 : SensLoad,
4072 : LatentLoad,
4073 : HVAC::CompressorOp::On,
4074 : 1.0,
4075 : 1.0,
4076 : 1.0,
4077 13 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).NumOfSpeeds);
4078 : // coil outlets
4079 13 : Real64 RatedOutletWetBulb(0.0);
4080 39 : RatedOutletWetBulb = Psychrometrics::PsyTwbFnTdbWPb(state,
4081 13 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).OutletAirDBTemp,
4082 13 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).OutletAirHumRat,
4083 : DataEnvironment::StdPressureSeaLevel,
4084 : RoutineName);
4085 13 : state.dataRptCoilSelection->coilSelectionReportObj->setRatedCoilConditions(
4086 : state,
4087 13 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name,
4088 13 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).VarSpeedCoilType,
4089 13 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).QLoadTotal, // this is the report variable
4090 13 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).QSensible, // this is the report variable
4091 13 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).AirMassFlowRate,
4092 13 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).InletAirDBTemp,
4093 13 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).InletAirHumRat,
4094 : RatedInletWetBulbTemp,
4095 13 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).OutletAirDBTemp,
4096 13 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).OutletAirHumRat,
4097 : RatedOutletWetBulb,
4098 : RatedAmbAirTemp,
4099 : ratedOutdoorAirWetBulb,
4100 26 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedCBF(
4101 13 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).NumOfSpeeds),
4102 : -999.0); // coil effectiveness not define for DX
4103 :
4104 : // now replace the outdoor air conditions set above for one time rating point calc
4105 13 : state.dataEnvrn->OutDryBulbTemp = holdOutDryBulbTemp;
4106 13 : state.dataEnvrn->OutHumRat = holdOutHumRat;
4107 13 : state.dataEnvrn->OutWetBulbTemp = holdOutWetBulb;
4108 13 : state.dataEnvrn->OutBaroPress = holdOutBaroPress;
4109 : }
4110 :
4111 : // Multispeed Heating
4112 35 : if ((state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).VSCoilType == HVAC::Coil_HeatingWaterToAirHPVSEquationFit) ||
4113 17 : (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).VSCoilType == HVAC::Coil_HeatingAirToAirVariableSpeed)) {
4114 5 : RatedHeatPumpIndoorAirTemp = 21.11; // 21.11C or 70F
4115 5 : RatedHeatPumpIndoorHumRat = 0.00881; // Humidity ratio corresponding to 70F dry bulb/60F wet bulb
4116 50 : for (int Mode = 1; Mode <= state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).NumOfSpeeds; ++Mode) {
4117 :
4118 45 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedAirMassFlowRate(Mode) =
4119 45 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedAirVolFlowRate(Mode) *
4120 45 : Psychrometrics::PsyRhoAirFnPbTdbW(
4121 45 : state, state.dataEnvrn->OutBaroPress, RatedHeatPumpIndoorAirTemp, RatedHeatPumpIndoorHumRat, RoutineName);
4122 : // Check for valid range of (Rated Air Volume Flow Rate / Rated Total Capacity)
4123 45 : RatedVolFlowPerRatedTotCap = state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedAirVolFlowRate(Mode) /
4124 45 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedTotCap(Mode);
4125 : }
4126 : // call coil model with everthing set at rating point
4127 5 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).InletAirDBTemp = RatedInletAirTempHeat;
4128 5 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).InletAirHumRat =
4129 5 : Psychrometrics::PsyWFnTdbTwbPb(state, RatedInletAirTempHeat, RatedInletWetBulbTemp, DataEnvironment::StdPressureSeaLevel);
4130 5 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).InletAirEnthalpy =
4131 5 : Psychrometrics::PsyHFnTdbW(RatedInletAirTempHeat, state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).InletAirHumRat);
4132 5 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).InletAirPressure = DataEnvironment::StdPressureSeaLevel;
4133 :
4134 5 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).AirMassFlowRate =
4135 5 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).RatedAirVolFlowRate *
4136 10 : Psychrometrics::PsyRhoAirFnPbTdbW(state,
4137 : DataEnvironment::StdPressureSeaLevel,
4138 : RatedInletAirTempHeat,
4139 5 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).InletAirHumRat);
4140 : // store environment data fill back in after rating point calc is over
4141 5 : Real64 holdOutDryBulbTemp = state.dataEnvrn->OutDryBulbTemp;
4142 5 : Real64 holdOutHumRat = state.dataEnvrn->OutHumRat;
4143 5 : Real64 holdOutWetBulb = state.dataEnvrn->OutWetBulbTemp;
4144 5 : Real64 holdOutBaroPress = state.dataEnvrn->OutBaroPress;
4145 :
4146 5 : state.dataEnvrn->OutDryBulbTemp = RatedAmbAirTempHeat;
4147 5 : state.dataEnvrn->OutWetBulbTemp = RatedAmbAirWBHeat;
4148 5 : state.dataEnvrn->OutBaroPress = DataEnvironment::StdPressureSeaLevel; // assume rating is for sea level.
4149 10 : state.dataEnvrn->OutHumRat =
4150 5 : Psychrometrics::PsyWFnTdbTwbPb(state, RatedAmbAirTempHeat, RatedAmbAirWBHeat, DataEnvironment::StdPressureSeaLevel, RoutineName);
4151 5 : if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).CondenserInletNodeNum > 0) {
4152 0 : state.dataLoopNodes->Node(state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).CondenserInletNodeNum).Temp = RatedAmbAirTempHeat;
4153 0 : state.dataLoopNodes->Node(state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).CondenserInletNodeNum).HumRat =
4154 0 : state.dataEnvrn->OutHumRat;
4155 0 : state.dataLoopNodes->Node(state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).CondenserInletNodeNum).Press =
4156 : DataEnvironment::StdPressureSeaLevel;
4157 0 : state.dataLoopNodes->Node(state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).CondenserInletNodeNum).OutAirWetBulb =
4158 : RatedAmbAirWBHeat;
4159 : }
4160 :
4161 5 : if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).VSCoilType ==
4162 : HVAC::Coil_HeatingWaterToAirHPVSEquationFit) { // need to set water info for WSHP
4163 1 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).WaterMassFlowRate =
4164 2 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedWaterMassFlowRate(
4165 1 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).NumOfSpeeds);
4166 1 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).InletWaterTemp = RatedInletWaterTempHeat; // 21.11C or 70F, heating mode
4167 1 : Real64 CpSource = state.dataPlnt->PlantLoop(state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).plantLoc.loopNum)
4168 1 : .glycol->getSpecificHeat(state, state.dataVariableSpeedCoils->SourceSideInletTemp, RoutineName);
4169 1 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).InletWaterEnthalpy =
4170 1 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).InletWaterTemp * CpSource;
4171 : }
4172 :
4173 : // calculate coil model at rating point
4174 5 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).RunFrac = 1.0;
4175 5 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).DesignAirMassFlowRate =
4176 10 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedAirMassFlowRate(
4177 5 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).NumOfSpeeds);
4178 5 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).DesignAirVolFlowRate =
4179 10 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedAirVolFlowRate(
4180 5 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).NumOfSpeeds);
4181 5 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).DesignWaterMassFlowRate =
4182 10 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedWaterMassFlowRate(
4183 5 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).NumOfSpeeds);
4184 5 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).DesignWaterVolFlowRate =
4185 10 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedWaterVolFlowRate(
4186 5 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).NumOfSpeeds);
4187 5 : CalcVarSpeedCoilHeating(state,
4188 : DXCoilNum,
4189 : HVAC::FanOp::Continuous,
4190 : SensLoad,
4191 : HVAC::CompressorOp::On,
4192 : 1.0,
4193 : 1.0,
4194 : 1.0,
4195 5 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).NumOfSpeeds);
4196 : // coil outlets
4197 5 : Real64 RatedOutletWetBulb(0.0);
4198 15 : RatedOutletWetBulb = Psychrometrics::PsyTwbFnTdbWPb(state,
4199 5 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).OutletAirDBTemp,
4200 5 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).OutletAirHumRat,
4201 : DataEnvironment::StdPressureSeaLevel,
4202 : RoutineName);
4203 5 : state.dataRptCoilSelection->coilSelectionReportObj->setRatedCoilConditions(
4204 : state,
4205 5 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name,
4206 5 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).VarSpeedCoilType,
4207 5 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).QLoadTotal, // this is the report variable
4208 5 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).QSensible, // this is the report variable
4209 5 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).AirMassFlowRate,
4210 5 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).InletAirDBTemp,
4211 5 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).InletAirHumRat,
4212 : RatedInletWetBulbTemp,
4213 5 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).OutletAirDBTemp,
4214 5 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).OutletAirHumRat,
4215 : RatedOutletWetBulb,
4216 : RatedAmbAirTempHeat,
4217 : RatedAmbAirWBHeat,
4218 10 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedCBF(
4219 5 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).NumOfSpeeds),
4220 : -999.0); // coil effectiveness not define for DX
4221 :
4222 : // now replace the outdoor air conditions set above for one time rating point calc
4223 5 : state.dataEnvrn->OutDryBulbTemp = holdOutDryBulbTemp;
4224 5 : state.dataEnvrn->OutHumRat = holdOutHumRat;
4225 5 : state.dataEnvrn->OutWetBulbTemp = holdOutWetBulb;
4226 5 : state.dataEnvrn->OutBaroPress = holdOutBaroPress;
4227 : }
4228 :
4229 : // store fan info for coil
4230 18 : if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).SupplyFanIndex > 0) {
4231 5 : state.dataRptCoilSelection->coilSelectionReportObj->setCoilSupplyFanInfo(
4232 : state,
4233 5 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name,
4234 5 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).VarSpeedCoilType,
4235 5 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).SupplyFanName,
4236 5 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).supplyFanType,
4237 5 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).SupplyFanIndex);
4238 : }
4239 : }
4240 :
4241 67679 : if (SpeedNum > state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).NumOfSpeeds) {
4242 0 : SpeedCal = state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).NumOfSpeeds;
4243 67679 : } else if (SpeedNum < 1) {
4244 0 : SpeedCal = 1;
4245 : } else {
4246 67679 : SpeedCal = SpeedNum;
4247 : }
4248 67679 : if ((SpeedNum <= 1) || (SpeedNum > state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).NumOfSpeeds)) {
4249 42668 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).DesignAirMassFlowRate =
4250 42668 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedAirMassFlowRate(SpeedCal);
4251 42668 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).DesignAirVolFlowRate =
4252 42668 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedAirVolFlowRate(SpeedCal);
4253 42668 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).DesignWaterMassFlowRate =
4254 42668 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedWaterMassFlowRate(SpeedCal);
4255 42668 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).DesignWaterVolFlowRate =
4256 42668 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedWaterVolFlowRate(SpeedCal);
4257 : } else {
4258 25011 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).DesignAirMassFlowRate =
4259 25011 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedAirMassFlowRate(SpeedCal) * SpeedRatio +
4260 25011 : (1.0 - SpeedRatio) * state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedAirMassFlowRate(SpeedCal - 1);
4261 25011 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).DesignAirVolFlowRate =
4262 25011 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedAirVolFlowRate(SpeedCal) * SpeedRatio +
4263 25011 : (1.0 - SpeedRatio) * state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedAirVolFlowRate(SpeedCal - 1);
4264 25011 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).DesignWaterMassFlowRate =
4265 25011 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedWaterMassFlowRate(SpeedCal) * SpeedRatio +
4266 25011 : (1.0 - SpeedRatio) * state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedWaterMassFlowRate(SpeedCal - 1);
4267 25011 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).DesignWaterVolFlowRate =
4268 25011 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedWaterVolFlowRate(SpeedCal) * SpeedRatio +
4269 25011 : (1.0 - SpeedRatio) * state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedWaterVolFlowRate(SpeedCal - 1);
4270 : }
4271 :
4272 : // Do the Begin Environment initializations
4273 67696 : if (state.dataGlobal->BeginEnvrnFlag && state.dataVariableSpeedCoils->MyEnvrnFlag(DXCoilNum) &&
4274 17 : !state.dataVariableSpeedCoils->MyPlantScanFlag(DXCoilNum)) {
4275 : // Do the initializations to start simulation
4276 :
4277 : // Initialize all report variables to a known state at beginning of simulation
4278 17 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).AirVolFlowRate = 0.0;
4279 17 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).InletAirDBTemp = 0.0;
4280 17 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).InletAirHumRat = 0.0;
4281 17 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).OutletAirDBTemp = 0.0;
4282 17 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).OutletAirHumRat = 0.0;
4283 17 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).WaterVolFlowRate = 0.0;
4284 17 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).WaterMassFlowRate = 0.0;
4285 17 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).InletWaterTemp = 0.0;
4286 17 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).InletWaterEnthalpy = 0.0;
4287 17 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).OutletWaterEnthalpy = 0.0;
4288 17 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).OutletWaterTemp = 0.0;
4289 17 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Power = 0.0;
4290 17 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).QLoadTotal = 0.0;
4291 17 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).QSensible = 0.0;
4292 17 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).QLatent = 0.0;
4293 17 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).QSource = 0.0;
4294 17 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Energy = 0.0;
4295 17 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).EnergyLoadTotal = 0.0;
4296 17 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).EnergySensible = 0.0;
4297 17 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).EnergyLatent = 0.0;
4298 17 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).EnergySource = 0.0;
4299 17 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).COP = 0.0;
4300 17 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).RunFrac = 0.0;
4301 17 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).PartLoadRatio = 0.0;
4302 :
4303 30 : if ((state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).VSCoilType == HVAC::Coil_HeatingWaterToAirHPVSEquationFit) ||
4304 13 : (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).VSCoilType == HVAC::Coil_CoolingWaterToAirHPVSEquationFit)) {
4305 8 : WaterInletNode = state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).WaterInletNodeNum;
4306 :
4307 8 : rho = state.dataPlnt->PlantLoop(state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).plantLoc.loopNum)
4308 8 : .glycol->getDensity(state, Constant::CWInitConvTemp, RoutineNameSimpleWatertoAirHP);
4309 8 : Cp = state.dataPlnt->PlantLoop(state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).plantLoc.loopNum)
4310 8 : .glycol->getSpecificHeat(state, Constant::CWInitConvTemp, RoutineNameSimpleWatertoAirHP);
4311 :
4312 : // VarSpeedCoil(DXCoilNum)%DesignWaterMassFlowRate= &
4313 : // rho * VarSpeedCoil(DXCoilNum)%RatedWaterVolFlowRate
4314 :
4315 24 : PlantUtilities::InitComponentNodes(state,
4316 : 0.0,
4317 16 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedWaterMassFlowRate(
4318 8 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).NumOfSpeeds),
4319 8 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).WaterInletNodeNum,
4320 8 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).WaterOutletNodeNum);
4321 :
4322 8 : state.dataLoopNodes->Node(WaterInletNode).Temp = 5.0;
4323 8 : state.dataLoopNodes->Node(WaterInletNode).Enthalpy = Cp * state.dataLoopNodes->Node(WaterInletNode).Temp;
4324 8 : state.dataLoopNodes->Node(WaterInletNode).Quality = 0.0;
4325 8 : state.dataLoopNodes->Node(WaterInletNode).Press = 0.0;
4326 8 : state.dataLoopNodes->Node(WaterInletNode).HumRat = 0.0;
4327 :
4328 8 : state.dataLoopNodes->Node(state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).WaterOutletNodeNum).Temp = 5.0;
4329 8 : state.dataLoopNodes->Node(state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).WaterOutletNodeNum).Enthalpy =
4330 8 : Cp * state.dataLoopNodes->Node(WaterInletNode).Temp;
4331 8 : state.dataLoopNodes->Node(state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).WaterOutletNodeNum).Quality = 0.0;
4332 8 : state.dataLoopNodes->Node(state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).WaterOutletNodeNum).Press = 0.0;
4333 8 : state.dataLoopNodes->Node(state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).WaterOutletNodeNum).HumRat = 0.0;
4334 : }
4335 :
4336 17 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).SimFlag = true;
4337 17 : state.dataHeatBal->HeatReclaimVS_Coil(DXCoilNum).AvailCapacity = 0.0;
4338 :
4339 17 : state.dataVariableSpeedCoils->MyEnvrnFlag(DXCoilNum) = false;
4340 :
4341 : } // End If for the Begin Environment initializations
4342 :
4343 67679 : if (!state.dataGlobal->BeginEnvrnFlag) {
4344 66993 : state.dataVariableSpeedCoils->MyEnvrnFlag(DXCoilNum) = true;
4345 : }
4346 :
4347 : // Do the following initializations (every time step): This should be the info from
4348 : // the previous components outlets or the node data in this section.
4349 : // First set the conditions for the air into the heat pump model
4350 :
4351 : // Set water and air inlet nodes
4352 :
4353 67679 : WaterInletNode = state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).WaterInletNodeNum;
4354 :
4355 67679 : if ((SensLoad != 0.0 || LatentLoad != 0.0) && (state.dataLoopNodes->Node(AirInletNode).MassFlowRate > 0.0)) {
4356 28182 : if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedWaterMassFlowRate(
4357 28182 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).NormSpedLevel) > 0.0) {
4358 27877 : WaterFlowScale = state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).RatedWaterMassFlowRate /
4359 27877 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedWaterMassFlowRate(
4360 27877 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).NormSpedLevel);
4361 27877 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).WaterMassFlowRate =
4362 27877 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).DesignWaterMassFlowRate * WaterFlowScale;
4363 : } else {
4364 305 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).WaterMassFlowRate = 0.0;
4365 : }
4366 :
4367 28182 : if (fanOp == HVAC::FanOp::Continuous) {
4368 : // continuous fan, cycling compressor
4369 92 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).AirMassFlowRate = state.dataLoopNodes->Node(AirInletNode).MassFlowRate;
4370 : // VarSpeedCoil(DXCoilNum)%AirMassFlowRate = VarSpeedCoil(DXCoilNum)%DesignAirVolFlowRate* &
4371 : // PsyRhoAirFnPbTdbW(state, OutBaroPress,Node(AirInletNode)%Temp,Node(AirInletNode)%HumRat)
4372 : // If air flow is less than 25% rated flow. Then set air flow to the 25% of rated conditions
4373 92 : if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).AirMassFlowRate <
4374 92 : 0.25 * state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).DesignAirVolFlowRate *
4375 184 : Psychrometrics::PsyRhoAirFnPbTdbW(state,
4376 92 : state.dataEnvrn->OutBaroPress,
4377 92 : state.dataLoopNodes->Node(AirInletNode).Temp,
4378 92 : state.dataLoopNodes->Node(AirInletNode).HumRat)) {
4379 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).AirMassFlowRate =
4380 0 : 0.25 * state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).DesignAirVolFlowRate *
4381 0 : Psychrometrics::PsyRhoAirFnPbTdbW(state,
4382 0 : state.dataEnvrn->OutBaroPress,
4383 0 : state.dataLoopNodes->Node(AirInletNode).Temp,
4384 0 : state.dataLoopNodes->Node(AirInletNode).HumRat);
4385 : }
4386 : } else { // CYCLIC FAN, NOT CORRECTION, WILL BE PROCESSED IN THE FOLLOWING SUBROUTINES
4387 28090 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).AirMassFlowRate = state.dataLoopNodes->Node(AirInletNode).MassFlowRate;
4388 : }
4389 :
4390 : } else { // heat pump is off
4391 39497 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).WaterMassFlowRate = 0.0;
4392 39497 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).AirMassFlowRate = 0.0;
4393 : }
4394 :
4395 101722 : if ((state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).VSCoilType == HVAC::Coil_HeatingWaterToAirHPVSEquationFit) ||
4396 34043 : (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).VSCoilType == HVAC::Coil_CoolingWaterToAirHPVSEquationFit)) {
4397 201819 : PlantUtilities::SetComponentFlowRate(state,
4398 67273 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).WaterMassFlowRate,
4399 67273 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).WaterInletNodeNum,
4400 67273 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).WaterOutletNodeNum,
4401 67273 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).plantLoc);
4402 :
4403 67273 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).InletWaterTemp = state.dataLoopNodes->Node(WaterInletNode).Temp;
4404 67273 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).InletWaterEnthalpy = state.dataLoopNodes->Node(WaterInletNode).Enthalpy;
4405 : } else {
4406 406 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).InletWaterTemp = 0.0;
4407 406 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).InletWaterEnthalpy = 0.0;
4408 : }
4409 :
4410 67679 : if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).VSCoilType == HVAC::CoilDX_HeatPumpWaterHeaterVariableSpeed) {
4411 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).InletWaterTemp = state.dataLoopNodes->Node(WaterInletNode).Temp;
4412 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).InletWaterEnthalpy = state.dataLoopNodes->Node(WaterInletNode).Enthalpy;
4413 : };
4414 :
4415 67679 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).InletAirDBTemp = state.dataLoopNodes->Node(AirInletNode).Temp;
4416 67679 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).InletAirHumRat = state.dataLoopNodes->Node(AirInletNode).HumRat;
4417 67679 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).InletAirEnthalpy = state.dataLoopNodes->Node(AirInletNode).Enthalpy;
4418 :
4419 67679 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).InletAirPressure = state.dataEnvrn->OutBaroPress; // temporary
4420 : // Outlet variables
4421 67679 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Power = 0.0;
4422 67679 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).QLoadTotal = 0.0;
4423 67679 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).QSensible = 0.0;
4424 67679 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).QLatent = 0.0;
4425 67679 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).QSource = 0.0;
4426 67679 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).QWasteHeat = 0.0;
4427 67679 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Energy = 0.0;
4428 67679 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).EnergyLoadTotal = 0.0;
4429 67679 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).EnergySensible = 0.0;
4430 67679 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).EnergyLatent = 0.0;
4431 67679 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).EnergySource = 0.0;
4432 67679 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).COP = 0.0;
4433 :
4434 67679 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).OutletAirDBTemp = 0.0;
4435 67679 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).OutletWaterTemp = 0.0;
4436 67679 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).OutletAirHumRat = 0.0;
4437 67679 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).OutletAirEnthalpy = 0.0;
4438 67679 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).OutletWaterEnthalpy = 0.0;
4439 :
4440 : // bug fix, must set zeros to the variables below, otherwise can't pass switch DD test
4441 67679 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).CrankcaseHeaterConsumption = 0.0;
4442 67679 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).EvapWaterConsump = 0.0;
4443 67679 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).BasinHeaterConsumption = 0.0;
4444 67679 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).EvapCondPumpElecConsumption = 0.0;
4445 67679 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).CrankcaseHeaterPower = 0.0;
4446 67679 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).DefrostPower = 0.0;
4447 67679 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).DefrostConsumption = 0.0;
4448 67679 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).CondensateVdot = 0.0;
4449 67679 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).CondensateVol = 0.0;
4450 67679 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).QWasteHeat = 0.0;
4451 :
4452 : // clear zeros to HPWH variables
4453 67679 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).ElecWaterHeatingPower =
4454 : 0.0; // Total electric power consumed by compressor and condenser pump [W]
4455 67679 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).ElecWaterHeatingConsumption =
4456 : 0.0; // Total electric consumption by compressor and condenser pump [J]
4457 67679 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).TotalHeatingEnergy = 0.0; // total water heating energy
4458 67679 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).TotalHeatingEnergyRate = 0.0; // total WH energy rate
4459 67679 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).HPWHCondPumpElecNomPower = 0.0; // power power
4460 :
4461 67679 : state.dataVariableSpeedCoils->VSHPWHHeatingCapacity = 0.0; // Used by Heat Pump:Water Heater object as total water heating capacity [W]
4462 67679 : state.dataVariableSpeedCoils->VSHPWHHeatingCOP = 0.0; // Used by Heat Pump:Water Heater object as water heating COP [W/W]
4463 67679 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).OutletWaterTemp = state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).InletWaterTemp;
4464 67679 : state.dataHeatBal->HeatReclaimVS_Coil(DXCoilNum).AvailCapacity = 0.0;
4465 67679 : }
4466 :
4467 18 : void SizeVarSpeedCoil(EnergyPlusData &state, int const DXCoilNum, bool &ErrorsFound)
4468 : {
4469 :
4470 : // SUBROUTINE INFORMATION:
4471 : // AUTHOR Bo Shen, based on WaterToAirHeatPumpSimple:SizeHVACWaterToAir
4472 : // DATE WRITTEN March, 2012
4473 : // MODIFIED August 2013 Daeho Kang, add component sizing table entries
4474 : // MODIFIED Bo Shen, 12/2014, add variable-speed HPWH
4475 :
4476 : // PURPOSE OF THIS SUBROUTINE:
4477 : // This subroutine is for sizing WSHP Components for which nominal capacities
4478 : // and flow rates have not been specified in the input
4479 :
4480 : // METHODOLOGY EMPLOYED:
4481 : // Obtains heating capacities and flow rates from the zone or system sizing arrays.
4482 : // NOTE: For WSHP's we are sizing the heating capacity to be
4483 : // equal to the cooling capacity. Thus the cooling and
4484 : // and heating capacities of a DX heat pump system will be identical. In real life the ARI
4485 : // heating and cooling capacities are close but not identical.
4486 :
4487 : // SUBROUTINE PARAMETER DEFINITIONS:
4488 : static constexpr std::string_view RoutineName("SizeVarSpeedCoil");
4489 : static constexpr std::string_view RoutineNameAlt("SizeHVACWaterToAir");
4490 :
4491 18 : auto &varSpeedCoil = state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum);
4492 :
4493 : // SUBROUTINE LOCAL VARIABLE DECLARATIONS:
4494 18 : Real64 rhoair = state.dataEnvrn->StdRhoAir;
4495 18 : Real64 MixTemp = -999.0;
4496 18 : Real64 MixHumRat = -999.0;
4497 18 : Real64 MixEnth = -999.0;
4498 18 : Real64 MixWetBulb = -999.0;
4499 18 : Real64 SupTemp = -999.0;
4500 18 : Real64 SupHumRat = -999.0;
4501 18 : Real64 SupEnth = -999.0;
4502 18 : Real64 OutTemp = -999.0;
4503 18 : Real64 OutAirFrac = -999.0;
4504 18 : Real64 VolFlowRate = -999.0;
4505 18 : Real64 CoolCapAtPeak = -999.0;
4506 18 : Real64 TotCapTempModFac = -999.0;
4507 : int TimeStepNumAtMax;
4508 : int DDNum;
4509 : bool RatedCapCoolTotalAutoSized;
4510 : bool RatedCapCoolSensAutoSized;
4511 : Real64 SystemCapacity;
4512 : Real64 rho;
4513 : Real64 cp;
4514 : int Mode; // speed level
4515 : Real64 rhoW; // water density
4516 : Real64 SHR; // sensible heat transfer ratio
4517 : Real64 RatedAirMassFlowRate; // rated air mass flow rate
4518 : Real64 CBFRated; // bypass factor at the rated condition, considering difference in flow rates
4519 : Real64 RatedInletEnth; // rated inlet air enthalpy
4520 : Real64 QLoadTotal1; // placeholder for calculating SHR
4521 : Real64 QLoadTotal2; // placeholder for calculating SHR
4522 : Real64 QLoadTotal; // placeholder for calculating SHR
4523 : Real64 AirMassFlowRatio; // air mass flow ratio
4524 : Real64 WaterMassFlowRatio; // water mass flow rate
4525 : Real64 RatedSourceTempCool; // rated source temperature, space cooling mode
4526 18 : std::string CurrentObjSubfix; // Object subfix type for printing
4527 : bool HardSizeNoDesRun; // Indicator to hardsize withouth sizing runs
4528 : bool SizingDesRunThisAirSys; // true if a particular air system had a Sizing:System object and system sizing done
4529 : bool SizingDesRunThisZone; // true if a particular zone had a Sizing:Zone object and zone sizing was done
4530 : Real64 HPInletAirHumRat; // Rated inlet air humidity ratio for heat pump water heater [kgWater/kgDryAir]
4531 : Real64 HPWHCoolCapacity; // estimate cooling capacity in HPWH
4532 :
4533 18 : int UpperSpeed = varSpeedCoil.NumOfSpeeds;
4534 18 : int NormSpeed = varSpeedCoil.NormSpedLevel;
4535 18 : int PltSizNum = 0;
4536 18 : bool RatedAirFlowAutoSized = false;
4537 18 : bool RatedWaterFlowAutoSized = false;
4538 18 : bool RatedCapHeatAutoSized = false;
4539 18 : bool IsAutoSize = false;
4540 :
4541 18 : if (state.dataSize->SysSizingRunDone || state.dataSize->ZoneSizingRunDone) {
4542 10 : HardSizeNoDesRun = false;
4543 : } else {
4544 8 : HardSizeNoDesRun = true;
4545 : }
4546 18 : if (state.dataSize->CurSysNum > 0) {
4547 1 : CheckThisAirSystemForSizing(state, state.dataSize->CurSysNum, SizingDesRunThisAirSys);
4548 : } else {
4549 17 : SizingDesRunThisAirSys = false;
4550 : }
4551 18 : if (state.dataSize->CurZoneEqNum > 0) {
4552 12 : CheckThisZoneForSizing(state, state.dataSize->CurZoneEqNum, SizingDesRunThisZone);
4553 : } else {
4554 6 : SizingDesRunThisZone = false;
4555 : }
4556 18 : bool HardSizeNoDesRunAirFlow = false;
4557 18 : Real64 RatedAirVolFlowRateDes = 0.0;
4558 18 : Real64 RatedAirVolFlowRateUser = 0.0;
4559 18 : Real64 RatedCapCoolTotalDes = 0.0;
4560 18 : Real64 RatedCapCoolTotalUser = 0.0;
4561 18 : Real64 RatedCapHeatDes = 0.0;
4562 18 : Real64 RatedCapHeatUser = 0.0;
4563 18 : Real64 RatedWaterVolFlowRateDes = 0.0;
4564 18 : Real64 RatedWaterVolFlowRateUser = 0.0;
4565 18 : Real64 RatedCapCoolSensDes = 0.0;
4566 18 : Real64 EvapCondPumpElecNomPowerDes = 0.0;
4567 18 : Real64 EvapCondPumpElecNomPowerUser = 0.0;
4568 18 : Real64 DefrostCapacityDes = 0.0;
4569 18 : Real64 DefrostCapacityUser = 0.0;
4570 :
4571 18 : if (varSpeedCoil.VSCoilType == HVAC::Coil_CoolingWaterToAirHPVSEquationFit ||
4572 16 : varSpeedCoil.VSCoilType == HVAC::Coil_HeatingWaterToAirHPVSEquationFit) {
4573 3 : CurrentObjSubfix = ":WATERTOAIRHEATPUMP:VARIABLESPEEDEQUATIONFIT";
4574 15 : } else if (varSpeedCoil.VSCoilType == HVAC::CoilDX_HeatPumpWaterHeaterVariableSpeed) {
4575 0 : CurrentObjSubfix = ":WATERHEATING:AIRTOWATERHEATPUMP:VARIABLESPEED";
4576 : } else {
4577 15 : CurrentObjSubfix = ":DX:VARIABLESPEED";
4578 : }
4579 :
4580 18 : if (varSpeedCoil.VSCoilType == HVAC::CoilDX_HeatPumpWaterHeaterVariableSpeed) {
4581 0 : if (varSpeedCoil.RatedAirVolFlowRate == Constant::AutoCalculate) {
4582 0 : varSpeedCoil.RatedAirVolFlowRate =
4583 0 : varSpeedCoil.RatedCapWH * varSpeedCoil.MSRatedAirVolFlowRate(NormSpeed) / varSpeedCoil.MSRatedTotCap(NormSpeed); // 0.00005035;
4584 0 : varSpeedCoil.AirVolFlowAutoSized = true;
4585 : }
4586 0 : state.dataRptCoilSelection->coilSelectionReportObj->setCoilAirFlow(
4587 0 : state, varSpeedCoil.Name, varSpeedCoil.VarSpeedCoilType, varSpeedCoil.RatedAirVolFlowRate, varSpeedCoil.AirVolFlowAutoSized);
4588 :
4589 0 : if (varSpeedCoil.RatedWaterVolFlowRate == Constant::AutoCalculate) {
4590 0 : varSpeedCoil.RatedHPWHCondWaterFlow = varSpeedCoil.RatedCapWH * varSpeedCoil.MSRatedWaterVolFlowRate(NormSpeed) /
4591 0 : varSpeedCoil.MSRatedTotCap(NormSpeed); // 0.00000004487;
4592 0 : varSpeedCoil.RatedWaterVolFlowRate = varSpeedCoil.RatedHPWHCondWaterFlow;
4593 0 : varSpeedCoil.WaterVolFlowAutoSized = true;
4594 : }
4595 0 : state.dataRptCoilSelection->coilSelectionReportObj->setCoilWaterFlowPltSizNum(state,
4596 0 : varSpeedCoil.Name,
4597 0 : varSpeedCoil.VarSpeedCoilType,
4598 : varSpeedCoil.RatedWaterVolFlowRate,
4599 0 : varSpeedCoil.WaterVolFlowAutoSized,
4600 : -999,
4601 : varSpeedCoil.plantLoc.loopNum);
4602 : }
4603 :
4604 18 : if (varSpeedCoil.RatedAirVolFlowRate == DataSizing::AutoSize) {
4605 8 : RatedAirFlowAutoSized = true;
4606 : }
4607 :
4608 18 : if (state.dataSize->CurSysNum > 0) {
4609 1 : if (!RatedAirFlowAutoSized && !SizingDesRunThisAirSys) { // Simulation continue
4610 0 : HardSizeNoDesRunAirFlow = true;
4611 0 : if (varSpeedCoil.RatedAirVolFlowRate > 0.0) {
4612 0 : BaseSizer::reportSizerOutput(state,
4613 0 : format("COIL:{}{}", varSpeedCoil.CoolHeatType, CurrentObjSubfix),
4614 : varSpeedCoil.Name,
4615 : "User-Specified Rated Air Flow Rate [m3/s]",
4616 : varSpeedCoil.RatedAirVolFlowRate);
4617 : }
4618 : } else {
4619 1 : CheckSysSizing(state, format("COIL:{}{}", varSpeedCoil.CoolHeatType, CurrentObjSubfix), varSpeedCoil.Name);
4620 1 : if (state.dataSize->CurOASysNum > 0 && state.dataAirLoop->OutsideAirSys(state.dataSize->CurOASysNum).AirLoopDOASNum > -1) {
4621 : auto const &thisAirloopDOAS =
4622 0 : state.dataAirLoopHVACDOAS->airloopDOAS[state.dataAirLoop->OutsideAirSys(state.dataSize->CurOASysNum).AirLoopDOASNum];
4623 0 : RatedAirVolFlowRateDes = thisAirloopDOAS.SizingMassFlow / state.dataEnvrn->StdRhoAir;
4624 : } else {
4625 1 : if (state.dataSize->FinalSysSizing(state.dataSize->CurSysNum).DesMainVolFlow >= HVAC::SmallAirVolFlow) {
4626 1 : RatedAirVolFlowRateDes = state.dataSize->FinalSysSizing(state.dataSize->CurSysNum).DesMainVolFlow;
4627 : } else {
4628 0 : RatedAirVolFlowRateDes = 0.0;
4629 : }
4630 : }
4631 : }
4632 : }
4633 :
4634 18 : if (state.dataSize->CurZoneEqNum > 0) {
4635 12 : if (!RatedAirFlowAutoSized && !SizingDesRunThisZone) { // Simulation continue
4636 5 : HardSizeNoDesRunAirFlow = true;
4637 5 : if (varSpeedCoil.RatedAirVolFlowRate > 0.0) {
4638 15 : BaseSizer::reportSizerOutput(state,
4639 10 : format("COIL:{}{}", varSpeedCoil.CoolHeatType, CurrentObjSubfix),
4640 : varSpeedCoil.Name,
4641 : "User-Specified Rated Air Flow Rate [m3/s]",
4642 : varSpeedCoil.RatedAirVolFlowRate);
4643 : }
4644 : } else {
4645 7 : CheckZoneSizing(state, format("COIL:{}{}", varSpeedCoil.CoolHeatType, CurrentObjSubfix), varSpeedCoil.Name);
4646 7 : RatedAirVolFlowRateDes = max(state.dataSize->FinalZoneSizing(state.dataSize->CurZoneEqNum).DesCoolVolFlow,
4647 7 : state.dataSize->FinalZoneSizing(state.dataSize->CurZoneEqNum).DesHeatVolFlow);
4648 7 : if (RatedAirVolFlowRateDes < HVAC::SmallAirVolFlow) {
4649 0 : RatedAirVolFlowRateDes = 0.0;
4650 : }
4651 : }
4652 : }
4653 :
4654 18 : if (RatedAirFlowAutoSized) {
4655 8 : varSpeedCoil.RatedAirVolFlowRate = RatedAirVolFlowRateDes;
4656 : }
4657 :
4658 18 : RatedCapCoolTotalAutoSized = false;
4659 18 : RatedCapCoolSensAutoSized = false;
4660 :
4661 : // size rated total cooling capacity
4662 18 : IsAutoSize = false;
4663 18 : if (varSpeedCoil.RatedCapCoolTotal == DataSizing::AutoSize && (varSpeedCoil.VSCoilType == HVAC::Coil_CoolingWaterToAirHPVSEquationFit ||
4664 9 : varSpeedCoil.VSCoilType == HVAC::Coil_CoolingAirToAirVariableSpeed)) {
4665 6 : RatedCapCoolTotalAutoSized = true;
4666 : }
4667 18 : if (SizingDesRunThisZone || SizingDesRunThisAirSys) {
4668 5 : HardSizeNoDesRun = false;
4669 : }
4670 18 : if (state.dataSize->CurSysNum > 0) {
4671 1 : if (!RatedCapCoolTotalAutoSized && !SizingDesRunThisAirSys) { // Simulation continue
4672 0 : HardSizeNoDesRun = true;
4673 0 : if (varSpeedCoil.RatedCapCoolTotal > 0.0) {
4674 0 : BaseSizer::reportSizerOutput(state,
4675 0 : format("COIL:{}{}", varSpeedCoil.CoolHeatType, CurrentObjSubfix),
4676 : varSpeedCoil.Name,
4677 : "User-Specified Rated Total Cooling Capacity [W]",
4678 : varSpeedCoil.RatedCapCoolTotal);
4679 : }
4680 : } else {
4681 1 : CheckSysSizing(state, format("COIL:{}{}", varSpeedCoil.CoolHeatType, CurrentObjSubfix), varSpeedCoil.Name);
4682 1 : if (state.dataSize->CurOASysNum > 0 && state.dataAirLoop->OutsideAirSys(state.dataSize->CurOASysNum).AirLoopDOASNum > -1) {
4683 : auto const &thisAirloopDOAS =
4684 0 : state.dataAirLoopHVACDOAS->airloopDOAS[state.dataAirLoop->OutsideAirSys(state.dataSize->CurOASysNum).AirLoopDOASNum];
4685 0 : VolFlowRate = varSpeedCoil.RatedAirVolFlowRate;
4686 0 : MixTemp = thisAirloopDOAS.SizingCoolOATemp;
4687 0 : SupTemp = thisAirloopDOAS.PrecoolTemp;
4688 0 : MixHumRat = thisAirloopDOAS.SizingCoolOAHumRat;
4689 0 : SupHumRat = thisAirloopDOAS.PrecoolHumRat;
4690 0 : RatedCapCoolTotalDes = VolFlowRate * state.dataEnvrn->StdRhoAir *
4691 0 : (Psychrometrics::PsyHFnTdbW(MixTemp, MixHumRat) - Psychrometrics::PsyHFnTdbW(SupTemp, SupHumRat));
4692 0 : if (varSpeedCoil.MSCCapFTemp(varSpeedCoil.NormSpedLevel) > 0) {
4693 0 : MixWetBulb = Psychrometrics::PsyTwbFnTdbWPb(state, MixTemp, MixHumRat, state.dataEnvrn->StdBaroPress, RoutineName);
4694 0 : if (varSpeedCoil.CondenserType == DataHeatBalance::RefrigCondenserType::Air) {
4695 0 : RatedSourceTempCool = thisAirloopDOAS.SizingCoolOATemp;
4696 : } else {
4697 0 : RatedSourceTempCool = GetVSCoilRatedSourceTemp(state, DXCoilNum);
4698 : }
4699 0 : TotCapTempModFac =
4700 0 : Curve::CurveValue(state, varSpeedCoil.MSCCapFTemp(varSpeedCoil.NormSpedLevel), MixWetBulb, RatedSourceTempCool);
4701 0 : RatedCapCoolTotalDes /= TotCapTempModFac;
4702 : }
4703 : } else {
4704 1 : auto const &finalSysSizing = state.dataSize->FinalSysSizing(state.dataSize->CurSysNum);
4705 1 : VolFlowRate = varSpeedCoil.RatedAirVolFlowRate;
4706 1 : if (VolFlowRate >= HVAC::SmallAirVolFlow) {
4707 1 : if (state.dataSize->CurOASysNum > 0) { // coil is in the OA stream
4708 0 : MixTemp = finalSysSizing.OutTempAtCoolPeak;
4709 0 : MixHumRat = finalSysSizing.OutHumRatAtCoolPeak;
4710 0 : SupTemp = finalSysSizing.PrecoolTemp;
4711 0 : SupHumRat = finalSysSizing.PrecoolHumRat;
4712 : } else { // coil is on the main air loop
4713 1 : SupTemp = finalSysSizing.CoolSupTemp;
4714 1 : SupHumRat = finalSysSizing.CoolSupHumRat;
4715 1 : if (state.dataAirSystemsData->PrimaryAirSystems(state.dataSize->CurSysNum).NumOACoolCoils ==
4716 : 0) { // there is no precooling of the OA stream
4717 1 : MixTemp = finalSysSizing.MixTempAtCoolPeak;
4718 1 : MixHumRat = finalSysSizing.MixHumRatAtCoolPeak;
4719 : } else { // there is precooling of OA stream
4720 0 : if (VolFlowRate > 0.0) {
4721 0 : OutAirFrac = finalSysSizing.DesOutAirVolFlow / VolFlowRate;
4722 : } else {
4723 0 : OutAirFrac = 1.0;
4724 : }
4725 0 : OutAirFrac = min(1.0, max(0.0, OutAirFrac));
4726 0 : MixTemp = OutAirFrac * finalSysSizing.PrecoolTemp + (1.0 - OutAirFrac) * finalSysSizing.RetTempAtCoolPeak;
4727 0 : MixHumRat = OutAirFrac * finalSysSizing.PrecoolHumRat + (1.0 - OutAirFrac) * finalSysSizing.RetHumRatAtCoolPeak;
4728 : }
4729 : }
4730 1 : OutTemp = finalSysSizing.OutTempAtCoolPeak;
4731 1 : MixEnth = Psychrometrics::PsyHFnTdbW(MixTemp, MixHumRat);
4732 1 : SupEnth = Psychrometrics::PsyHFnTdbW(SupTemp, SupHumRat);
4733 :
4734 : // design fan heat will be added to coil load
4735 1 : Real64 FanCoolLoad = DataAirSystems::calcFanDesignHeatGain(state, state.dataSize->DataFanIndex, VolFlowRate);
4736 : // inlet/outlet temp is adjusted after enthalpy is calculcated so fan heat is not double counted
4737 1 : Real64 CpAir = Psychrometrics::PsyCpAirFnW(MixHumRat);
4738 1 : if (state.dataAirSystemsData->PrimaryAirSystems(state.dataSize->CurSysNum).supFanPlace == HVAC::FanPlace::BlowThru) {
4739 0 : MixTemp += FanCoolLoad / (CpAir * rhoair * VolFlowRate);
4740 1 : } else if (state.dataAirSystemsData->PrimaryAirSystems(state.dataSize->CurSysNum).supFanPlace == HVAC::FanPlace::DrawThru) {
4741 0 : SupTemp -= FanCoolLoad / (CpAir * rhoair * VolFlowRate);
4742 : }
4743 1 : MixWetBulb = Psychrometrics::PsyTwbFnTdbWPb(state, MixTemp, MixHumRat, state.dataEnvrn->StdBaroPress, RoutineName);
4744 1 : if (varSpeedCoil.CondenserType == DataHeatBalance::RefrigCondenserType::Air) {
4745 0 : RatedSourceTempCool = OutTemp;
4746 : } else {
4747 1 : RatedSourceTempCool = GetVSCoilRatedSourceTemp(state, DXCoilNum);
4748 : }
4749 1 : TotCapTempModFac =
4750 1 : Curve::CurveValue(state, varSpeedCoil.MSCCapFTemp(varSpeedCoil.NormSpedLevel), MixWetBulb, RatedSourceTempCool);
4751 :
4752 : // The mixed air temp for zone equipment without an OA mixer is 0.
4753 : // This test avoids a negative capacity until a solution can be found.
4754 1 : if (MixEnth > SupEnth) {
4755 1 : CoolCapAtPeak = (rhoair * VolFlowRate * (MixEnth - SupEnth)) + FanCoolLoad;
4756 : } else {
4757 0 : CoolCapAtPeak = (rhoair * VolFlowRate * (48000.0 - SupEnth)) + FanCoolLoad;
4758 : }
4759 1 : CoolCapAtPeak = max(0.0, CoolCapAtPeak);
4760 1 : if (TotCapTempModFac > 0.0) {
4761 1 : RatedCapCoolTotalDes = CoolCapAtPeak / TotCapTempModFac;
4762 : } else {
4763 0 : RatedCapCoolTotalDes = CoolCapAtPeak;
4764 : }
4765 : } else {
4766 0 : RatedCapCoolTotalDes = 0.0;
4767 : }
4768 : }
4769 : }
4770 :
4771 17 : } else if (state.dataSize->CurZoneEqNum > 0) {
4772 12 : if (!RatedCapCoolTotalAutoSized && !SizingDesRunThisZone) { // Simulation continue
4773 5 : HardSizeNoDesRun = true;
4774 5 : if (varSpeedCoil.RatedCapCoolTotal > 0.0) {
4775 9 : BaseSizer::reportSizerOutput(state,
4776 6 : format("COIL:{}{}", varSpeedCoil.CoolHeatType, CurrentObjSubfix),
4777 : varSpeedCoil.Name,
4778 : "User-Specified Rated Total Cooling Capacity [W]",
4779 : varSpeedCoil.RatedCapCoolTotal);
4780 : }
4781 : } else {
4782 7 : CheckZoneSizing(state, format("COIL:{}{}", varSpeedCoil.CoolHeatType, CurrentObjSubfix), varSpeedCoil.Name);
4783 7 : auto const &finalZoneSizing = state.dataSize->FinalZoneSizing(state.dataSize->CurZoneEqNum);
4784 7 : VolFlowRate = varSpeedCoil.RatedAirVolFlowRate;
4785 7 : if (VolFlowRate >= HVAC::SmallAirVolFlow) {
4786 7 : if (state.dataSize->ZoneEqDXCoil) {
4787 4 : if (state.dataSize->ZoneEqSizing(state.dataSize->CurZoneEqNum).OAVolFlow > 0.0) {
4788 0 : MixTemp = finalZoneSizing.DesCoolCoilInTemp;
4789 0 : MixHumRat = finalZoneSizing.DesCoolCoilInHumRat;
4790 : } else {
4791 4 : MixTemp = finalZoneSizing.ZoneTempAtCoolPeak;
4792 4 : MixHumRat = finalZoneSizing.ZoneHumRatAtCoolPeak;
4793 : }
4794 : } else {
4795 3 : MixTemp = finalZoneSizing.DesCoolCoilInTemp;
4796 3 : MixHumRat = finalZoneSizing.DesCoolCoilInHumRat;
4797 : }
4798 7 : SupTemp = finalZoneSizing.CoolDesTemp;
4799 7 : SupHumRat = finalZoneSizing.CoolDesHumRat;
4800 7 : TimeStepNumAtMax = finalZoneSizing.TimeStepNumAtCoolMax;
4801 7 : DDNum = finalZoneSizing.CoolDDNum;
4802 7 : if (DDNum > 0 && TimeStepNumAtMax > 0) {
4803 7 : OutTemp = state.dataSize->DesDayWeath(DDNum).Temp(TimeStepNumAtMax);
4804 : } else {
4805 0 : OutTemp = 0.0;
4806 : }
4807 7 : MixEnth = Psychrometrics::PsyHFnTdbW(MixTemp, MixHumRat);
4808 7 : SupEnth = Psychrometrics::PsyHFnTdbW(SupTemp, SupHumRat);
4809 :
4810 : // design fan heat will be added to coil load
4811 7 : Real64 FanCoolLoad = DataAirSystems::calcFanDesignHeatGain(state, state.dataSize->DataFanIndex, VolFlowRate);
4812 : // inlet/outlet temp is adjusted after enthalpy is calculcated so fan heat is not double counted
4813 7 : Real64 CpAir = Psychrometrics::PsyCpAirFnW(MixHumRat);
4814 :
4815 7 : if (state.dataSize->DataFanPlacement == HVAC::FanPlace::BlowThru) {
4816 7 : MixTemp += FanCoolLoad / (CpAir * rhoair * VolFlowRate);
4817 : } else {
4818 0 : SupTemp -= FanCoolLoad / (CpAir * rhoair * VolFlowRate);
4819 : }
4820 :
4821 7 : MixWetBulb = Psychrometrics::PsyTwbFnTdbWPb(state, MixTemp, MixHumRat, state.dataEnvrn->StdBaroPress, RoutineName);
4822 7 : if (varSpeedCoil.CondenserType == DataHeatBalance::RefrigCondenserType::Air) {
4823 5 : RatedSourceTempCool = OutTemp;
4824 : } else {
4825 2 : RatedSourceTempCool = GetVSCoilRatedSourceTemp(state, DXCoilNum);
4826 : }
4827 7 : TotCapTempModFac =
4828 7 : Curve::CurveValue(state, varSpeedCoil.MSCCapFTemp(varSpeedCoil.NormSpedLevel), MixWetBulb, RatedSourceTempCool);
4829 :
4830 : // The mixed air temp for zone equipment without an OA mixer is 0.
4831 : // This test avoids a negative capacity until a solution can be found.
4832 7 : if (MixEnth > SupEnth) {
4833 7 : CoolCapAtPeak = (rhoair * VolFlowRate * (MixEnth - SupEnth)) + FanCoolLoad;
4834 : } else {
4835 0 : CoolCapAtPeak = (rhoair * VolFlowRate * (48000.0 - SupEnth)) + FanCoolLoad;
4836 : }
4837 7 : CoolCapAtPeak = max(0.0, CoolCapAtPeak);
4838 7 : if (TotCapTempModFac > 0.0) {
4839 7 : RatedCapCoolTotalDes = CoolCapAtPeak / TotCapTempModFac;
4840 : } else {
4841 0 : RatedCapCoolTotalDes = CoolCapAtPeak;
4842 : }
4843 : } else {
4844 0 : RatedCapCoolTotalDes = 0.0;
4845 : }
4846 : }
4847 : }
4848 18 : if (RatedCapCoolTotalDes < HVAC::SmallLoad) {
4849 10 : RatedCapCoolTotalDes = 0.0;
4850 : }
4851 18 : if (!HardSizeNoDesRun) {
4852 8 : if (RatedCapCoolTotalAutoSized) {
4853 6 : varSpeedCoil.RatedCapCoolTotal = RatedCapCoolTotalDes;
4854 18 : BaseSizer::reportSizerOutput(state,
4855 12 : format("COIL:{}{}", varSpeedCoil.CoolHeatType, CurrentObjSubfix),
4856 : varSpeedCoil.Name,
4857 : "Design Size Rated Total Cooling Capacity [W]",
4858 : varSpeedCoil.RatedCapCoolTotal);
4859 12 : OutputReportPredefined::PreDefTableEntry(
4860 6 : state, state.dataOutRptPredefined->pdchCoolCoilTotCap, varSpeedCoil.Name, varSpeedCoil.RatedCapCoolTotal);
4861 12 : OutputReportPredefined::PreDefTableEntry(state,
4862 6 : state.dataOutRptPredefined->pdchCoolCoilLatCap,
4863 : varSpeedCoil.Name,
4864 6 : varSpeedCoil.RatedCapCoolTotal - varSpeedCoil.RatedCapCoolSens);
4865 6 : if (varSpeedCoil.RatedCapCoolTotal != 0.0) {
4866 12 : OutputReportPredefined::PreDefTableEntry(state,
4867 6 : state.dataOutRptPredefined->pdchCoolCoilSHR,
4868 : varSpeedCoil.Name,
4869 6 : varSpeedCoil.RatedCapCoolSens / varSpeedCoil.RatedCapCoolTotal);
4870 12 : OutputReportPredefined::PreDefTableEntry(
4871 6 : state, state.dataOutRptPredefined->pdchCoolCoilNomEff, varSpeedCoil.Name, varSpeedCoil.MSRatedCOP(NormSpeed));
4872 : } else {
4873 0 : OutputReportPredefined::PreDefTableEntry(state, state.dataOutRptPredefined->pdchCoolCoilSHR, varSpeedCoil.Name, 0.0);
4874 0 : OutputReportPredefined::PreDefTableEntry(state, state.dataOutRptPredefined->pdchCoolCoilNomEff, varSpeedCoil.Name, 0.0);
4875 : }
4876 12 : OutputReportPredefined::addFootNoteSubTable(
4877 : state,
4878 6 : state.dataOutRptPredefined->pdstCoolCoil,
4879 : "Nominal values are gross at rated conditions, i.e., the supply air fan heat and electric power NOT accounted for.");
4880 : } else {
4881 2 : if (varSpeedCoil.RatedCapCoolTotal > 0.0 && RatedCapCoolTotalDes > 0.0) {
4882 0 : RatedCapCoolTotalUser = varSpeedCoil.RatedCapCoolTotal;
4883 0 : BaseSizer::reportSizerOutput(state,
4884 0 : format("COIL:{}{}", varSpeedCoil.CoolHeatType, CurrentObjSubfix),
4885 : varSpeedCoil.Name,
4886 : "Design Size Rated Total Cooling Capacity [W]",
4887 : RatedCapCoolTotalDes,
4888 : "User-Specified Rated Total Cooling Capacity [W]",
4889 : RatedCapCoolTotalUser);
4890 0 : if (state.dataGlobal->DisplayExtraWarnings) {
4891 0 : if ((std::abs(RatedCapCoolTotalDes - RatedCapCoolTotalUser) / RatedCapCoolTotalUser) >
4892 0 : state.dataSize->AutoVsHardSizingThreshold) {
4893 0 : ShowMessage(state,
4894 0 : format("SizeVarSpeedCoil: Potential issue with equipment sizing for {} {}",
4895 0 : varSpeedCoil.CoolHeatType,
4896 : CurrentObjSubfix));
4897 0 : ShowContinueError(state, format("Coil Name = {}", varSpeedCoil.Name));
4898 0 : ShowContinueError(state, format("User-Specified Rated Total Cooling Capacity of {:.2R} [W]", RatedCapCoolTotalUser));
4899 0 : ShowContinueError(state,
4900 0 : format("differs from Design Size Rated Total Cooling Capacity of {:.2R} [W]", RatedCapCoolTotalDes));
4901 0 : ShowContinueError(state, "This may, or may not, indicate mismatched component sizes.");
4902 0 : ShowContinueError(state, "Verify that the value entered is intended and is consistent with other components.");
4903 : }
4904 : }
4905 : }
4906 : }
4907 :
4908 8 : state.dataRptCoilSelection->coilSelectionReportObj->setCoilEntAirTemp(
4909 8 : state, varSpeedCoil.Name, varSpeedCoil.VarSpeedCoilType, MixTemp, state.dataSize->CurSysNum, state.dataSize->CurZoneEqNum);
4910 8 : state.dataRptCoilSelection->coilSelectionReportObj->setCoilEntAirHumRat(
4911 8 : state, varSpeedCoil.Name, varSpeedCoil.VarSpeedCoilType, MixHumRat);
4912 8 : state.dataRptCoilSelection->coilSelectionReportObj->setCoilLvgAirTemp(state, varSpeedCoil.Name, varSpeedCoil.VarSpeedCoilType, SupTemp);
4913 8 : state.dataRptCoilSelection->coilSelectionReportObj->setCoilLvgAirHumRat(
4914 8 : state, varSpeedCoil.Name, varSpeedCoil.VarSpeedCoilType, SupHumRat);
4915 8 : state.dataRptCoilSelection->coilSelectionReportObj->setCoilAirFlow(
4916 8 : state, varSpeedCoil.Name, varSpeedCoil.VarSpeedCoilType, varSpeedCoil.RatedAirVolFlowRate, RatedAirFlowAutoSized);
4917 8 : state.dataRptCoilSelection->coilSelectionReportObj->setCoilCoolingCapacity(state,
4918 8 : varSpeedCoil.Name,
4919 8 : varSpeedCoil.VarSpeedCoilType,
4920 : RatedCapCoolTotalDes,
4921 : RatedCapCoolTotalAutoSized,
4922 8 : state.dataSize->CurSysNum,
4923 8 : state.dataSize->CurZoneEqNum,
4924 8 : state.dataSize->CurOASysNum,
4925 : 0.0, // no fan load included in sizing
4926 : TotCapTempModFac,
4927 : -999.0,
4928 : -999.0); // VS model doesn't limit, double check
4929 : }
4930 :
4931 : // Set the global DX cooling coil capacity variable for use by other objects
4932 18 : if (varSpeedCoil.VSCoilType == HVAC::Coil_CoolingWaterToAirHPVSEquationFit ||
4933 16 : varSpeedCoil.VSCoilType == HVAC::Coil_CoolingAirToAirVariableSpeed) {
4934 13 : state.dataSize->DXCoolCap = varSpeedCoil.RatedCapCoolTotal;
4935 : }
4936 :
4937 : // size rated heating capacity
4938 18 : if (varSpeedCoil.RatedCapHeat == DataSizing::AutoSize && (varSpeedCoil.VSCoilType == HVAC::Coil_HeatingWaterToAirHPVSEquationFit ||
4939 16 : varSpeedCoil.VSCoilType == HVAC::Coil_HeatingAirToAirVariableSpeed)) {
4940 4 : RatedCapHeatAutoSized = true;
4941 : }
4942 : // simply set heating capacity equal to the cooling capacity
4943 : // VarSpeedCoil(DXCoilNum)%RatedCapHeat = DXCoolCap
4944 18 : if (varSpeedCoil.VSCoilType == HVAC::Coil_HeatingWaterToAirHPVSEquationFit ||
4945 17 : varSpeedCoil.VSCoilType == HVAC::Coil_HeatingAirToAirVariableSpeed) {
4946 5 : if (varSpeedCoil.CompanionCoolingCoilNum > 0) {
4947 1 : RatedCapHeatDes = state.dataVariableSpeedCoils->VarSpeedCoil(varSpeedCoil.CompanionCoolingCoilNum).RatedCapCoolTotal;
4948 1 : varSpeedCoil.RatedCapCoolTotal = RatedCapHeatDes; // AVOID BEING ZERO
4949 : } else {
4950 4 : RatedCapHeatDes = state.dataSize->DXCoolCap; // previous code, can be risky
4951 : }
4952 : // END IF
4953 5 : if (RatedCapHeatAutoSized) {
4954 4 : if (RatedCapHeatDes == DataSizing::AutoSize) {
4955 0 : ShowWarningError(
4956 0 : state, format("COIL:{}:WATERTOAIRHEATPUMP:VARIABLESPEEDEQUATIONFIT \"{}\"", varSpeedCoil.CoolHeatType, varSpeedCoil.Name));
4957 0 : ShowContinueError(state,
4958 0 : format("{}: Heating coil could not be autosized since cooling coil was not previously sized.", RoutineName));
4959 0 : ShowContinueError(state, "... Cooling coil must be upstream of heating coil.");
4960 0 : ShowContinueError(state, "... Manually sizing this heating coil will be required.");
4961 : }
4962 : }
4963 5 : if (RatedCapHeatDes < HVAC::SmallLoad) {
4964 1 : RatedCapHeatDes = 0.0;
4965 : }
4966 5 : state.dataRptCoilSelection->coilSelectionReportObj->setCoilHeatingCapacity(state,
4967 5 : varSpeedCoil.Name,
4968 5 : varSpeedCoil.VarSpeedCoilType,
4969 : RatedCapHeatDes,
4970 : RatedCapHeatAutoSized,
4971 5 : state.dataSize->CurSysNum,
4972 5 : state.dataSize->CurZoneEqNum,
4973 5 : state.dataSize->CurOASysNum,
4974 : 0.0,
4975 : 1.0,
4976 : -999.0,
4977 : -999.0);
4978 : }
4979 18 : if (RatedCapHeatAutoSized) {
4980 4 : varSpeedCoil.RatedCapHeat = RatedCapHeatDes;
4981 12 : BaseSizer::reportSizerOutput(state,
4982 8 : format("COIL:{}{}", varSpeedCoil.CoolHeatType, CurrentObjSubfix),
4983 : varSpeedCoil.Name,
4984 : "Design Size Nominal Heating Capacity [W]",
4985 : RatedCapHeatDes);
4986 8 : OutputReportPredefined::PreDefTableEntry(
4987 4 : state, state.dataOutRptPredefined->pdchHeatCoilNomCap, varSpeedCoil.Name, varSpeedCoil.RatedCapHeat);
4988 4 : if (varSpeedCoil.RatedCapHeat != 0.0) {
4989 8 : OutputReportPredefined::PreDefTableEntry(
4990 4 : state, state.dataOutRptPredefined->pdchHeatCoilNomEff, varSpeedCoil.Name, varSpeedCoil.MSRatedCOP(NormSpeed));
4991 : } else {
4992 0 : OutputReportPredefined::PreDefTableEntry(state, state.dataOutRptPredefined->pdchHeatCoilNomEff, varSpeedCoil.Name, 0.0);
4993 : }
4994 8 : OutputReportPredefined::addFootNoteSubTable(
4995 : state,
4996 4 : state.dataOutRptPredefined->pdstHeatCoil,
4997 : "Nominal values are gross at rated conditions, i.e., the supply air fan heat and electric power NOT accounted for.");
4998 : } else {
4999 14 : if (varSpeedCoil.RatedCapHeat > 0.0 && RatedCapHeatDes > 0.0) {
5000 0 : RatedCapHeatUser = varSpeedCoil.RatedCapHeat;
5001 0 : BaseSizer::reportSizerOutput(state,
5002 0 : format("COIL:{}{}", varSpeedCoil.CoolHeatType, CurrentObjSubfix),
5003 : varSpeedCoil.Name,
5004 : "Design Size Nominal Heating Capacity [W]",
5005 : RatedCapHeatDes,
5006 : "User-Specified Nominal Heating Capacity [W]",
5007 : RatedCapHeatUser);
5008 0 : if (state.dataGlobal->DisplayExtraWarnings) {
5009 0 : if ((std::abs(RatedCapHeatDes - RatedCapHeatUser) / RatedCapHeatUser) > state.dataSize->AutoVsHardSizingThreshold) {
5010 0 : ShowMessage(
5011 : state,
5012 0 : format("SizeVarSpeedCoil: Potential issue with equipment sizing for {} {}", varSpeedCoil.CoolHeatType, CurrentObjSubfix));
5013 0 : ShowContinueError(state, format("Coil Name = {}", varSpeedCoil.Name));
5014 0 : ShowContinueError(state, format("User-Specified Rated Total Heating Capacity of {:.2R} [W]", RatedCapHeatUser));
5015 0 : ShowContinueError(state, format("differs from Design Size Rated Total Heating Capacity of {:.2R} [W]", RatedCapHeatDes));
5016 0 : ShowContinueError(state, "This may, or may not, indicate mismatched component sizes.");
5017 0 : ShowContinueError(state, "Verify that the value entered is intended and is consistent with other components.");
5018 : }
5019 : }
5020 : }
5021 : }
5022 :
5023 : // FORCE BACK TO THE RATED AIR FLOW RATE WITH THE SAME RATIO DEFINED BY THE CATALOG DATA
5024 18 : if (!HardSizeNoDesRunAirFlow) {
5025 13 : if ((RatedCapCoolTotalAutoSized) && (RatedAirFlowAutoSized)) {
5026 6 : RatedAirVolFlowRateDes = varSpeedCoil.RatedCapCoolTotal * varSpeedCoil.MSRatedAirVolFlowPerRatedTotCap(NormSpeed);
5027 7 : } else if ((RatedCapHeatAutoSized) && (RatedAirFlowAutoSized)) {
5028 2 : RatedAirVolFlowRateDes = varSpeedCoil.RatedCapHeat * varSpeedCoil.MSRatedAirVolFlowPerRatedTotCap(NormSpeed);
5029 : }
5030 :
5031 : // write the air flow sizing output
5032 13 : if (RatedAirFlowAutoSized) {
5033 8 : varSpeedCoil.RatedAirVolFlowRate = RatedAirVolFlowRateDes;
5034 24 : BaseSizer::reportSizerOutput(state,
5035 16 : format("COIL:{}{}", varSpeedCoil.CoolHeatType, CurrentObjSubfix),
5036 : varSpeedCoil.Name,
5037 : "Design Size Rated Air Flow Rate [m3/s]",
5038 : RatedAirVolFlowRateDes);
5039 : } else {
5040 5 : if (varSpeedCoil.RatedAirVolFlowRate > 0.0 && RatedAirVolFlowRateDes > 0.0) {
5041 0 : RatedAirVolFlowRateUser = varSpeedCoil.RatedAirVolFlowRate;
5042 0 : BaseSizer::reportSizerOutput(state,
5043 0 : format("COIL:{}{}", varSpeedCoil.CoolHeatType, CurrentObjSubfix),
5044 : varSpeedCoil.Name,
5045 : "Design Size Rated Air Flow Rate [m3/s]",
5046 : RatedAirVolFlowRateDes,
5047 : "User-Specified Rated Air Flow Rate [m3/s]",
5048 : RatedAirVolFlowRateUser);
5049 0 : if (state.dataGlobal->DisplayExtraWarnings) {
5050 0 : if ((std::abs(RatedAirVolFlowRateDes - RatedAirVolFlowRateUser) / RatedAirVolFlowRateUser) >
5051 0 : state.dataSize->AutoVsHardSizingThreshold) {
5052 0 : ShowMessage(state,
5053 0 : format("SizeVarSpeedCoil: Potential issue with equipment sizing for {} {}",
5054 0 : varSpeedCoil.CoolHeatType,
5055 : CurrentObjSubfix));
5056 0 : ShowContinueError(state, format("Coil Name = {}", varSpeedCoil.Name));
5057 0 : ShowContinueError(state, format("User-Specified Rated Air Flow Rate of {:.5R} [m3/s]", RatedAirVolFlowRateUser));
5058 0 : ShowContinueError(state, format("differs from Design Size Rated Air Flow Rate of {:.5R} [m3/s]", RatedAirVolFlowRateDes));
5059 0 : ShowContinueError(state, "This may, or may not, indicate mismatched component sizes.");
5060 0 : ShowContinueError(state, "Verify that the value entered is intended and is consistent with other components.");
5061 : }
5062 : }
5063 : }
5064 : }
5065 13 : state.dataRptCoilSelection->coilSelectionReportObj->setCoilAirFlow(
5066 13 : state, varSpeedCoil.Name, varSpeedCoil.VarSpeedCoilType, RatedAirVolFlowRateDes, RatedAirFlowAutoSized);
5067 : }
5068 :
5069 : // Check that heat pump heating capacity is within 20% of cooling capacity. Check only for heating coil and report both.
5070 18 : if ((varSpeedCoil.VSCoilType == HVAC::Coil_HeatingWaterToAirHPVSEquationFit ||
5071 17 : varSpeedCoil.VSCoilType == HVAC::Coil_HeatingAirToAirVariableSpeed) &&
5072 5 : varSpeedCoil.CompanionCoolingCoilNum > 0) {
5073 :
5074 1 : if (state.dataVariableSpeedCoils->VarSpeedCoil(varSpeedCoil.CompanionCoolingCoilNum).RatedCapCoolTotal > 0.0) {
5075 :
5076 1 : if (std::abs(state.dataVariableSpeedCoils->VarSpeedCoil(varSpeedCoil.CompanionCoolingCoilNum).RatedCapCoolTotal -
5077 1 : varSpeedCoil.RatedCapHeat) /
5078 1 : state.dataVariableSpeedCoils->VarSpeedCoil(varSpeedCoil.CompanionCoolingCoilNum).RatedCapCoolTotal >
5079 : 0.2) {
5080 :
5081 0 : ShowWarningError(
5082 0 : state, format("COIL:{}:WATERTOAIRHEATPUMP:VARIABLESPEEDEQUATIONFIT \"{}\"", varSpeedCoil.CoolHeatType, varSpeedCoil.Name));
5083 0 : ShowContinueError(state,
5084 0 : format("...used with COIL:{}:WATERTOAIRHEATPUMP:VARIABLESPEEDEQUATIONFIT \"{}\"",
5085 0 : state.dataVariableSpeedCoils->VarSpeedCoil(varSpeedCoil.CompanionCoolingCoilNum).CoolHeatType,
5086 0 : state.dataVariableSpeedCoils->VarSpeedCoil(varSpeedCoil.CompanionCoolingCoilNum).Name));
5087 0 : ShowContinueError(state, "...heating capacity is disproportionate (> 20% different) to total cooling capacity");
5088 0 : ShowContinueError(state, format("...heating capacity = {:.3T} W", varSpeedCoil.RatedCapHeat));
5089 0 : ShowContinueError(state,
5090 0 : format("...cooling capacity = {:.3T} W",
5091 0 : state.dataVariableSpeedCoils->VarSpeedCoil(varSpeedCoil.CompanionCoolingCoilNum).RatedCapCoolTotal));
5092 : }
5093 : }
5094 : }
5095 :
5096 : // ASSIGN CAPACITY
5097 18 : switch (varSpeedCoil.VSCoilType) {
5098 13 : case HVAC::Coil_CoolingWaterToAirHPVSEquationFit:
5099 : case HVAC::Coil_CoolingAirToAirVariableSpeed: {
5100 13 : varSpeedCoil.MSRatedTotCap(UpperSpeed) = varSpeedCoil.RatedCapCoolTotal / varSpeedCoil.MSRatedPercentTotCap(NormSpeed);
5101 13 : } break;
5102 5 : case HVAC::Coil_HeatingWaterToAirHPVSEquationFit:
5103 : case HVAC::Coil_HeatingAirToAirVariableSpeed: {
5104 5 : varSpeedCoil.MSRatedTotCap(UpperSpeed) = varSpeedCoil.RatedCapHeat / varSpeedCoil.MSRatedPercentTotCap(NormSpeed);
5105 5 : } break;
5106 0 : case HVAC::CoilDX_HeatPumpWaterHeaterVariableSpeed: {
5107 0 : varSpeedCoil.MSRatedTotCap(UpperSpeed) = varSpeedCoil.RatedCapWH / varSpeedCoil.MSRatedPercentTotCap(NormSpeed);
5108 0 : } break;
5109 : }
5110 :
5111 18 : if (varSpeedCoil.VSCoilType == HVAC::CoilDX_HeatPumpWaterHeaterVariableSpeed) {
5112 0 : HPInletAirHumRat = Psychrometrics::PsyWFnTdbTwbPb(
5113 0 : state, varSpeedCoil.WHRatedInletDBTemp, varSpeedCoil.WHRatedInletWBTemp, state.dataEnvrn->StdBaroPress, RoutineName);
5114 :
5115 0 : for (Mode = varSpeedCoil.NumOfSpeeds; Mode >= 1; --Mode) {
5116 0 : varSpeedCoil.MSRatedTotCap(Mode) = varSpeedCoil.MSRatedTotCap(UpperSpeed) * varSpeedCoil.MSRatedPercentTotCap(Mode);
5117 0 : varSpeedCoil.MSRatedAirVolFlowRate(Mode) = varSpeedCoil.MSRatedTotCap(Mode) * varSpeedCoil.MSRatedAirVolFlowPerRatedTotCap(Mode);
5118 0 : varSpeedCoil.MSRatedAirMassFlowRate(Mode) = varSpeedCoil.MSRatedAirVolFlowRate(Mode) * rhoair;
5119 : // EVAPORATIVE PRECOOLING CONDENSER AIR FLOW RATE
5120 0 : varSpeedCoil.EvapCondAirFlow(Mode) = 0.0;
5121 : }
5122 : } else {
5123 : // HPWH, the mass flow rate will be updated by a revised entering air density
5124 :
5125 18 : if (varSpeedCoil.MSHPDesignSpecIndex > -1 && state.dataUnitarySystems->designSpecMSHP.size() > 0) {
5126 3 : if (varSpeedCoil.VSCoilType == HVAC::Coil_CoolingWaterToAirHPVSEquationFit ||
5127 3 : varSpeedCoil.VSCoilType == HVAC::Coil_CoolingAirToAirVariableSpeed) {
5128 2 : if (state.dataUnitarySystems->designSpecMSHP[varSpeedCoil.MSHPDesignSpecIndex].numOfSpeedCooling != varSpeedCoil.NumOfSpeeds) {
5129 0 : ShowFatalError(state,
5130 0 : format("COIL:{} = {}{} number of speeds not equal to number of speed specified in "
5131 : "UnitarySystemPerformance:Multispeed object.",
5132 0 : varSpeedCoil.CoolHeatType,
5133 : CurrentObjSubfix,
5134 0 : varSpeedCoil.Name));
5135 : } else {
5136 11 : for (Mode = varSpeedCoil.NumOfSpeeds; Mode >= 1; --Mode) {
5137 20 : varSpeedCoil.MSRatedAirVolFlowRate(Mode) =
5138 10 : varSpeedCoil.RatedAirVolFlowRate *
5139 10 : state.dataUnitarySystems->designSpecMSHP[varSpeedCoil.MSHPDesignSpecIndex].coolingVolFlowRatio[Mode - 1];
5140 20 : varSpeedCoil.MSRatedTotCap(Mode) =
5141 10 : varSpeedCoil.MSRatedAirVolFlowRate(Mode) / varSpeedCoil.MSRatedAirVolFlowPerRatedTotCap(Mode);
5142 10 : varSpeedCoil.MSRatedAirMassFlowRate(Mode) = varSpeedCoil.MSRatedAirVolFlowRate(Mode) * rhoair;
5143 : // EVAPORATIVE PRECOOLING CONDENSER AIR FLOW RATE
5144 10 : varSpeedCoil.EvapCondAirFlow(Mode) =
5145 10 : varSpeedCoil.MSRatedTotCap(Mode) * varSpeedCoil.MSRatedEvapCondVolFlowPerRatedTotCap(Mode);
5146 : }
5147 : }
5148 2 : } else if (varSpeedCoil.VSCoilType == HVAC::Coil_HeatingWaterToAirHPVSEquationFit ||
5149 2 : varSpeedCoil.VSCoilType == HVAC::Coil_HeatingAirToAirVariableSpeed) {
5150 2 : if (state.dataUnitarySystems->designSpecMSHP[varSpeedCoil.MSHPDesignSpecIndex].numOfSpeedHeating != varSpeedCoil.NumOfSpeeds) {
5151 0 : ShowFatalError(state,
5152 0 : format("COIL:{}{} = \"{}\" number of speeds not equal to number of speed specified in "
5153 : "UnitarySystemPerformance:Multispeed object.",
5154 0 : varSpeedCoil.CoolHeatType,
5155 : CurrentObjSubfix,
5156 0 : varSpeedCoil.Name));
5157 : } else {
5158 22 : for (Mode = varSpeedCoil.NumOfSpeeds; Mode >= 1; --Mode) {
5159 40 : varSpeedCoil.MSRatedAirVolFlowRate(Mode) =
5160 20 : varSpeedCoil.RatedAirVolFlowRate *
5161 20 : state.dataUnitarySystems->designSpecMSHP[varSpeedCoil.MSHPDesignSpecIndex].heatingVolFlowRatio[Mode - 1];
5162 40 : varSpeedCoil.MSRatedTotCap(Mode) =
5163 20 : varSpeedCoil.MSRatedAirVolFlowRate(Mode) / varSpeedCoil.MSRatedAirVolFlowPerRatedTotCap(Mode);
5164 20 : varSpeedCoil.MSRatedAirMassFlowRate(Mode) = varSpeedCoil.MSRatedAirVolFlowRate(Mode) * rhoair;
5165 : // EVAPORATIVE PRECOOLING CONDENSER AIR FLOW RATE
5166 20 : varSpeedCoil.EvapCondAirFlow(Mode) =
5167 20 : varSpeedCoil.MSRatedTotCap(Mode) * varSpeedCoil.MSRatedEvapCondVolFlowPerRatedTotCap(Mode);
5168 : }
5169 : }
5170 : }
5171 : } else {
5172 108 : for (Mode = varSpeedCoil.NumOfSpeeds; Mode >= 1; --Mode) {
5173 93 : varSpeedCoil.MSRatedTotCap(Mode) = varSpeedCoil.MSRatedTotCap(UpperSpeed) * varSpeedCoil.MSRatedPercentTotCap(Mode);
5174 93 : varSpeedCoil.MSRatedAirVolFlowRate(Mode) = varSpeedCoil.MSRatedTotCap(Mode) * varSpeedCoil.MSRatedAirVolFlowPerRatedTotCap(Mode);
5175 93 : varSpeedCoil.MSRatedAirMassFlowRate(Mode) = varSpeedCoil.MSRatedAirVolFlowRate(Mode) * rhoair;
5176 : // EVAPORATIVE PRECOOLING CONDENSER AIR FLOW RATE
5177 93 : varSpeedCoil.EvapCondAirFlow(Mode) = varSpeedCoil.MSRatedTotCap(Mode) * varSpeedCoil.MSRatedEvapCondVolFlowPerRatedTotCap(Mode);
5178 : }
5179 : }
5180 : }
5181 :
5182 : // size rated power
5183 18 : switch (varSpeedCoil.VSCoilType) {
5184 13 : case HVAC::Coil_CoolingWaterToAirHPVSEquationFit:
5185 : case HVAC::Coil_CoolingAirToAirVariableSpeed: {
5186 13 : varSpeedCoil.RatedCOPCool = varSpeedCoil.MSRatedCOP(varSpeedCoil.NormSpedLevel);
5187 13 : varSpeedCoil.RatedPowerCool = varSpeedCoil.RatedCapCoolTotal / varSpeedCoil.RatedCOPCool;
5188 13 : } break;
5189 5 : case HVAC::Coil_HeatingWaterToAirHPVSEquationFit:
5190 : case HVAC::Coil_HeatingAirToAirVariableSpeed: {
5191 5 : varSpeedCoil.RatedCOPHeat = varSpeedCoil.MSRatedCOP(varSpeedCoil.NormSpedLevel);
5192 5 : varSpeedCoil.RatedPowerHeat = varSpeedCoil.RatedCapHeat / varSpeedCoil.RatedCOPHeat;
5193 5 : varSpeedCoil.RatedCapCoolTotal = varSpeedCoil.RatedCapHeat;
5194 5 : } break;
5195 0 : case HVAC::CoilDX_HeatPumpWaterHeaterVariableSpeed: {
5196 0 : varSpeedCoil.RatedCOPHeat = varSpeedCoil.MSRatedCOP(varSpeedCoil.NormSpedLevel);
5197 0 : varSpeedCoil.RatedPowerHeat = varSpeedCoil.RatedCapWH / varSpeedCoil.RatedCOPHeat;
5198 0 : varSpeedCoil.RatedCapCoolTotal = varSpeedCoil.RatedCapWH * (1.0 - 1.0 / varSpeedCoil.RatedCOPHeat);
5199 0 : } break;
5200 : }
5201 :
5202 : // Size water volumetric flow rate
5203 18 : if ((varSpeedCoil.RatedWaterVolFlowRate == DataSizing::AutoSize) &&
5204 18 : (varSpeedCoil.VSCoilType == HVAC::Coil_CoolingWaterToAirHPVSEquationFit ||
5205 16 : varSpeedCoil.VSCoilType == HVAC::Coil_HeatingWaterToAirHPVSEquationFit)) {
5206 3 : RatedWaterFlowAutoSized = true;
5207 : }
5208 :
5209 : // WSHP condenser can be on either a plant loop or condenser loop. Test each to find plant sizing number.
5210 : // first check to see if coil is connected to a plant loop, no warning on this CALL
5211 18 : if (RatedWaterFlowAutoSized) {
5212 3 : if (varSpeedCoil.CondenserType == DataHeatBalance::RefrigCondenserType::Water) {
5213 6 : PltSizNum = PlantUtilities::MyPlantSizingIndex(state,
5214 6 : format("COIL:{}{}", varSpeedCoil.CoolHeatType, CurrentObjSubfix),
5215 : varSpeedCoil.Name,
5216 : varSpeedCoil.WaterInletNodeNum,
5217 : varSpeedCoil.WaterOutletNodeNum,
5218 : ErrorsFound,
5219 : false);
5220 : }
5221 :
5222 3 : if (PltSizNum > 0) {
5223 3 : rho = state.dataPlnt->PlantLoop(varSpeedCoil.plantLoc.loopNum)
5224 3 : .glycol->getDensity(state, state.dataSize->PlantSizData(PltSizNum).ExitTemp, RoutineNameAlt);
5225 3 : cp = state.dataPlnt->PlantLoop(varSpeedCoil.plantLoc.loopNum)
5226 3 : .glycol->getSpecificHeat(state, state.dataSize->PlantSizData(PltSizNum).ExitTemp, RoutineNameAlt);
5227 :
5228 3 : if (varSpeedCoil.VSCoilType == HVAC::Coil_HeatingWaterToAirHPVSEquationFit ||
5229 2 : varSpeedCoil.VSCoilType == HVAC::Coil_HeatingAirToAirVariableSpeed) {
5230 :
5231 1 : RatedWaterVolFlowRateDes = varSpeedCoil.RatedCapHeat / (state.dataSize->PlantSizData(PltSizNum).DeltaT * cp * rho);
5232 :
5233 1 : state.dataRptCoilSelection->coilSelectionReportObj->setCoilLvgWaterTemp(
5234 : state,
5235 1 : varSpeedCoil.Name,
5236 1 : varSpeedCoil.VarSpeedCoilType,
5237 1 : state.dataSize->PlantSizData(PltSizNum).ExitTemp +
5238 1 : state.dataSize->PlantSizData(PltSizNum).DeltaT); // TRACE 3D Plus coil selection report
5239 :
5240 2 : } else if (varSpeedCoil.VSCoilType == HVAC::Coil_CoolingWaterToAirHPVSEquationFit ||
5241 0 : varSpeedCoil.VSCoilType == HVAC::Coil_CoolingAirToAirVariableSpeed) {
5242 :
5243 : // use companion heating coil capacity to calculate volumetric flow rate
5244 2 : if (varSpeedCoil.CompanionCoolingCoilNum > 0) {
5245 0 : SystemCapacity = state.dataVariableSpeedCoils->VarSpeedCoil(varSpeedCoil.CompanionCoolingCoilNum).RatedCapHeat;
5246 : } else {
5247 2 : SystemCapacity = varSpeedCoil.RatedCapCoolTotal;
5248 : }
5249 :
5250 2 : RatedWaterVolFlowRateDes = SystemCapacity / (state.dataSize->PlantSizData(PltSizNum).DeltaT * cp * rho);
5251 :
5252 2 : state.dataRptCoilSelection->coilSelectionReportObj->setCoilLvgWaterTemp(
5253 : state,
5254 2 : varSpeedCoil.Name,
5255 2 : varSpeedCoil.VarSpeedCoilType,
5256 2 : state.dataSize->PlantSizData(PltSizNum).ExitTemp -
5257 2 : state.dataSize->PlantSizData(PltSizNum).DeltaT); // TRACE 3D Plus coil selection report
5258 : }
5259 :
5260 3 : state.dataRptCoilSelection->coilSelectionReportObj->setCoilEntWaterTemp(
5261 : state,
5262 3 : varSpeedCoil.Name,
5263 3 : varSpeedCoil.VarSpeedCoilType,
5264 3 : state.dataSize->PlantSizData(PltSizNum).ExitTemp); // TRACE 3D Plus coil selection report
5265 :
5266 3 : state.dataRptCoilSelection->coilSelectionReportObj->setCoilWaterDeltaT(
5267 : state,
5268 3 : varSpeedCoil.Name,
5269 3 : varSpeedCoil.VarSpeedCoilType,
5270 3 : state.dataSize->PlantSizData(PltSizNum).DeltaT); // TRACE 3D Plus coil selection report
5271 : } else {
5272 0 : ShowSevereError(state, "Autosizing of water flow requires a loop Sizing:Plant object");
5273 0 : ShowContinueError(state, "Autosizing also requires physical connection to a plant or condenser loop.");
5274 0 : ShowContinueError(state, format("Occurs in COIL:{}{} Object = {}", varSpeedCoil.CoolHeatType, CurrentObjSubfix, varSpeedCoil.Name));
5275 0 : ErrorsFound = true;
5276 : }
5277 :
5278 : // WRITE THE WATER SIZING OUTPUT
5279 : // FORCE BACK TO THE RATED WATER FLOW RATE WITH THE SAME RATIO DEFINED BY THE CATLOG DATA
5280 3 : if (RatedCapCoolTotalAutoSized) {
5281 2 : RatedWaterVolFlowRateDes = varSpeedCoil.RatedCapCoolTotal * varSpeedCoil.MSRatedWaterVolFlowPerRatedTotCap(NormSpeed);
5282 1 : } else if (RatedCapHeatAutoSized) {
5283 1 : RatedWaterVolFlowRateDes = varSpeedCoil.RatedCapHeat * varSpeedCoil.MSRatedWaterVolFlowPerRatedTotCap(NormSpeed);
5284 : }
5285 3 : state.dataRptCoilSelection->coilSelectionReportObj->setCoilWaterFlowNodeNums(state,
5286 3 : varSpeedCoil.Name,
5287 3 : varSpeedCoil.VarSpeedCoilType,
5288 : RatedWaterVolFlowRateDes,
5289 : RatedWaterFlowAutoSized,
5290 : varSpeedCoil.WaterInletNodeNum,
5291 : varSpeedCoil.WaterOutletNodeNum,
5292 : varSpeedCoil.plantLoc.loopNum);
5293 3 : varSpeedCoil.RatedWaterVolFlowRate = RatedWaterVolFlowRateDes;
5294 9 : BaseSizer::reportSizerOutput(state,
5295 6 : format("COIL:{}{}", varSpeedCoil.CoolHeatType, CurrentObjSubfix),
5296 : varSpeedCoil.Name,
5297 : "Design Size Rated Water Flow Rate [m3/s]",
5298 : RatedWaterVolFlowRateDes);
5299 : // Ensure water flow rate at lower speed must be lower or
5300 : // equal to the flow rate at higher speed. Otherwise, a severe error is isssued.
5301 30 : for (Mode = 1; Mode <= varSpeedCoil.NumOfSpeeds - 1; ++Mode) {
5302 27 : if (varSpeedCoil.MSRatedWaterVolFlowRate(Mode) > varSpeedCoil.MSRatedWaterVolFlowRate(Mode + 1) * 1.05) {
5303 0 : ShowWarningError(
5304 : state,
5305 0 : format("SizeDXCoil: {} {}, Speed {} Rated Air Flow Rate must be less than or equal to Speed {} Rated Air Flow Rate.",
5306 0 : varSpeedCoil.VarSpeedCoilType,
5307 0 : varSpeedCoil.Name,
5308 : Mode,
5309 0 : Mode + 1));
5310 0 : ShowContinueError(
5311 : state,
5312 0 : format("Instead, {:.2R} > {:.2R}", varSpeedCoil.MSRatedAirVolFlowRate(Mode), varSpeedCoil.MSRatedAirVolFlowRate(Mode + 1)));
5313 0 : ShowFatalError(state, "Preceding conditions cause termination.");
5314 : }
5315 : }
5316 : } else {
5317 15 : if (varSpeedCoil.RatedWaterVolFlowRate > 0.0 && RatedWaterVolFlowRateDes > 0.0) {
5318 0 : RatedWaterVolFlowRateUser = varSpeedCoil.RatedWaterVolFlowRate;
5319 0 : BaseSizer::reportSizerOutput(state,
5320 0 : format("COIL:{}{}", varSpeedCoil.CoolHeatType, CurrentObjSubfix),
5321 : varSpeedCoil.Name,
5322 : "Design Size Rated Water Flow Rate [m3/s]",
5323 : RatedWaterVolFlowRateDes,
5324 : "User-Specified Rated Water Flow Rate [m3/s]",
5325 : RatedWaterVolFlowRateUser);
5326 0 : if (state.dataGlobal->DisplayExtraWarnings) {
5327 0 : if ((std::abs(RatedWaterVolFlowRateDes - RatedWaterVolFlowRateUser) / RatedWaterVolFlowRateUser) >
5328 0 : state.dataSize->AutoVsHardSizingThreshold) {
5329 0 : ShowMessage(
5330 : state,
5331 0 : format("SizeVarSpeedCoil: Potential issue with equipment sizing for {} {}", varSpeedCoil.CoolHeatType, CurrentObjSubfix));
5332 0 : ShowContinueError(state, format("Coil Name = {}", varSpeedCoil.Name));
5333 0 : ShowContinueError(state, format("User-Specified Rated Water Flow Rate of {:.5R} [m3/s]", RatedWaterVolFlowRateUser));
5334 0 : ShowContinueError(state, format("differs from Design Size Rated Water Flow Rate of {:.5R} [m3/s]", RatedWaterVolFlowRateDes));
5335 0 : ShowContinueError(state, "This may, or may not, indicate mismatched component sizes.");
5336 0 : ShowContinueError(state, "Verify that the value entered is intended and is consistent with other components.");
5337 : }
5338 : }
5339 : }
5340 : }
5341 :
5342 : // Save component design water volumetric flow rate.
5343 18 : if (varSpeedCoil.RatedWaterVolFlowRate > 0.0 && varSpeedCoil.VSCoilType == HVAC::CoilDX_HeatPumpWaterHeaterVariableSpeed) {
5344 0 : PlantUtilities::RegisterPlantCompDesignFlow(state, varSpeedCoil.WaterInletNodeNum, varSpeedCoil.RatedWaterVolFlowRate);
5345 : }
5346 : // Use 1/2 flow since both cooling and heating coil will save flow yet only 1 will operate at a time
5347 18 : else if (varSpeedCoil.RatedWaterVolFlowRate > 0.0) {
5348 3 : PlantUtilities::RegisterPlantCompDesignFlow(state, varSpeedCoil.WaterInletNodeNum, 0.5 * varSpeedCoil.RatedWaterVolFlowRate);
5349 : }
5350 :
5351 18 : RatedSourceTempCool = GetVSCoilRatedSourceTemp(state, DXCoilNum);
5352 18 : if (varSpeedCoil.VSCoilType == HVAC::Coil_CoolingWaterToAirHPVSEquationFit ||
5353 16 : varSpeedCoil.VSCoilType == HVAC::Coil_HeatingWaterToAirHPVSEquationFit) {
5354 :
5355 3 : if (PltSizNum > 0) {
5356 3 : rhoW = rho;
5357 : } else {
5358 0 : rhoW = state.dataPlnt->PlantLoop(varSpeedCoil.plantLoc.loopNum).glycol->getDensity(state, RatedSourceTempCool, RoutineName);
5359 : }
5360 :
5361 3 : varSpeedCoil.RatedWaterMassFlowRate = varSpeedCoil.RatedWaterVolFlowRate * rhoW;
5362 33 : for (Mode = varSpeedCoil.NumOfSpeeds; Mode >= 1; --Mode) {
5363 30 : varSpeedCoil.MSRatedWaterVolFlowRate(Mode) = varSpeedCoil.MSRatedTotCap(Mode) * varSpeedCoil.MSRatedWaterVolFlowPerRatedTotCap(Mode);
5364 30 : varSpeedCoil.MSRatedWaterMassFlowRate(Mode) = varSpeedCoil.MSRatedWaterVolFlowRate(Mode) * rhoW;
5365 : }
5366 15 : } else if (varSpeedCoil.VSCoilType == HVAC::CoilDX_HeatPumpWaterHeaterVariableSpeed) {
5367 0 : rhoW = Psychrometrics::RhoH2O(RatedSourceTempCool);
5368 0 : varSpeedCoil.RatedWaterMassFlowRate = varSpeedCoil.RatedWaterVolFlowRate * rhoW;
5369 0 : for (Mode = varSpeedCoil.NumOfSpeeds; Mode >= 1; --Mode) {
5370 0 : varSpeedCoil.MSRatedWaterVolFlowRate(Mode) = varSpeedCoil.MSRatedTotCap(Mode) * varSpeedCoil.MSRatedWaterVolFlowPerRatedTotCap(Mode);
5371 0 : varSpeedCoil.MSWHPumpPower(Mode) = varSpeedCoil.MSRatedTotCap(Mode) * varSpeedCoil.MSWHPumpPowerPerRatedTotCap(Mode);
5372 0 : varSpeedCoil.MSRatedWaterMassFlowRate(Mode) = varSpeedCoil.MSRatedWaterVolFlowRate(Mode) * rhoW;
5373 : }
5374 : }
5375 :
5376 : // Ensure air flow rate at lower speed must be lower or
5377 : // equal to the flow rate at higher speed. Otherwise, a severe error is issued.
5378 123 : for (Mode = 1; Mode <= varSpeedCoil.NumOfSpeeds - 1; ++Mode) {
5379 105 : if (varSpeedCoil.MSRatedAirVolFlowRate(Mode) > varSpeedCoil.MSRatedAirVolFlowRate(Mode + 1)) {
5380 0 : ShowWarningError(state,
5381 0 : format("SizeDXCoil: {} {}, Speed {} Rated Air Flow Rate must be less than or equal to Speed {} Rated Air Flow Rate.",
5382 0 : varSpeedCoil.VarSpeedCoilType,
5383 0 : varSpeedCoil.Name,
5384 : Mode,
5385 0 : Mode + 1));
5386 0 : ShowContinueError(
5387 : state,
5388 0 : format("Instead, {:.2R} > {:.2R}", varSpeedCoil.MSRatedAirVolFlowRate(Mode), varSpeedCoil.MSRatedAirVolFlowRate(Mode + 1)));
5389 0 : ShowFatalError(state, "Preceding conditions cause termination.");
5390 : }
5391 : }
5392 :
5393 : // Ensure capacity at lower speed must be lower or equal to the capacity at higher speed.
5394 123 : for (Mode = 1; Mode <= varSpeedCoil.NumOfSpeeds - 1; ++Mode) {
5395 105 : if (varSpeedCoil.MSRatedTotCap(Mode) > varSpeedCoil.MSRatedTotCap(Mode + 1)) {
5396 0 : ShowWarningError(state,
5397 0 : format("SizeDXCoil: {} {}, Speed {} Rated Total Cooling Capacity must be less than or equal to Speed {} Rated Total "
5398 : "Cooling Capacity.",
5399 0 : varSpeedCoil.VarSpeedCoilType,
5400 0 : varSpeedCoil.Name,
5401 : Mode,
5402 0 : Mode + 1));
5403 0 : ShowContinueError(state, format("Instead, {:.2R} > {:.2R}", varSpeedCoil.MSRatedTotCap(Mode), varSpeedCoil.MSRatedTotCap(Mode + 1)));
5404 0 : ShowFatalError(state, "Preceding conditions cause termination.");
5405 : }
5406 : }
5407 :
5408 : // convert SHR to rated Bypass factor and effective air side surface area
5409 18 : if (varSpeedCoil.VSCoilType == HVAC::Coil_CoolingWaterToAirHPVSEquationFit ||
5410 16 : varSpeedCoil.VSCoilType == HVAC::Coil_CoolingAirToAirVariableSpeed) {
5411 91 : for (Mode = 1; Mode <= varSpeedCoil.NumOfSpeeds; ++Mode) {
5412 78 : varSpeedCoil.MSRatedCBF(Mode) = DXCoils::CalcCBF(state,
5413 78 : varSpeedCoil.VarSpeedCoilType,
5414 78 : varSpeedCoil.Name,
5415 : RatedInletAirTemp,
5416 : RatedInletAirHumRat,
5417 78 : varSpeedCoil.MSRatedTotCap(Mode),
5418 78 : varSpeedCoil.MSRatedAirVolFlowRate(Mode),
5419 78 : varSpeedCoil.MSRatedSHR(Mode),
5420 : true);
5421 78 : if (varSpeedCoil.MSRatedCBF(Mode) > 0.0) {
5422 73 : varSpeedCoil.MSEffectiveAo(Mode) = -std::log(varSpeedCoil.MSRatedCBF(Mode)) * varSpeedCoil.MSRatedAirMassFlowRate(Mode);
5423 : } else {
5424 5 : varSpeedCoil.MSEffectiveAo(Mode) = 0.0;
5425 : }
5426 : }
5427 5 : } else if (varSpeedCoil.VSCoilType == HVAC::CoilDX_HeatPumpWaterHeaterVariableSpeed) {
5428 0 : state.dataHVACGlobal->HPWHInletDBTemp = varSpeedCoil.WHRatedInletDBTemp;
5429 0 : state.dataHVACGlobal->HPWHInletWBTemp = varSpeedCoil.WHRatedInletWBTemp;
5430 :
5431 0 : for (Mode = 1; Mode <= varSpeedCoil.NumOfSpeeds; ++Mode) {
5432 0 : varSpeedCoil.MSRatedAirMassFlowRate(Mode) = varSpeedCoil.MSRatedAirVolFlowRate(Mode) * rhoair;
5433 : }
5434 :
5435 0 : for (Mode = 1; Mode <= varSpeedCoil.NumOfSpeeds; ++Mode) {
5436 : // get cooling capacity, without fan power, i.e. total coil cooling
5437 0 : if (varSpeedCoil.CondPumpPowerInCOP) {
5438 0 : HPWHCoolCapacity = varSpeedCoil.MSRatedTotCap(Mode) * (1.0 - 1.0 / varSpeedCoil.MSRatedCOP(Mode)) +
5439 0 : varSpeedCoil.MSWHPumpPower(Mode) - varSpeedCoil.MSWHPumpPower(Mode) * varSpeedCoil.HPWHCondPumpFracToWater;
5440 : } else {
5441 0 : HPWHCoolCapacity = varSpeedCoil.MSRatedTotCap(Mode) * (1.0 - 1.0 / varSpeedCoil.MSRatedCOP(Mode)) -
5442 0 : varSpeedCoil.MSWHPumpPower(Mode) * varSpeedCoil.HPWHCondPumpFracToWater;
5443 : }
5444 :
5445 0 : varSpeedCoil.MSRatedCBF(Mode) = DXCoils::CalcCBF(state,
5446 0 : varSpeedCoil.VarSpeedCoilType,
5447 0 : varSpeedCoil.Name,
5448 0 : state.dataHVACGlobal->HPWHInletDBTemp,
5449 : HPInletAirHumRat,
5450 : HPWHCoolCapacity,
5451 0 : varSpeedCoil.MSRatedAirVolFlowRate(Mode),
5452 0 : varSpeedCoil.MSRatedSHR(Mode),
5453 : true);
5454 0 : if (varSpeedCoil.MSRatedCBF(Mode) > 0.0) {
5455 0 : varSpeedCoil.MSEffectiveAo(Mode) = -std::log(varSpeedCoil.MSRatedCBF(Mode)) * varSpeedCoil.MSRatedAirMassFlowRate(Mode);
5456 : } else {
5457 0 : varSpeedCoil.MSEffectiveAo(Mode) = 0.0;
5458 : }
5459 : }
5460 :
5461 : // update VarSpeedCoil(DXCoilNum).RatedCapCoolTotal
5462 0 : Mode = varSpeedCoil.NormSpedLevel;
5463 0 : if (varSpeedCoil.CondPumpPowerInCOP) {
5464 0 : varSpeedCoil.RatedCapCoolTotal = varSpeedCoil.MSRatedTotCap(Mode) * (1.0 - 1.0 / varSpeedCoil.MSRatedCOP(Mode)) +
5465 0 : varSpeedCoil.MSWHPumpPower(Mode) -
5466 0 : varSpeedCoil.MSWHPumpPower(Mode) * varSpeedCoil.HPWHCondPumpFracToWater;
5467 : } else {
5468 0 : varSpeedCoil.RatedCapCoolTotal = varSpeedCoil.MSRatedTotCap(Mode) * (1.0 - 1.0 / varSpeedCoil.MSRatedCOP(Mode)) -
5469 0 : varSpeedCoil.MSWHPumpPower(Mode) * varSpeedCoil.HPWHCondPumpFracToWater;
5470 : }
5471 : }
5472 :
5473 : // size rated sensible cooling capacity
5474 18 : RatedCapCoolSensAutoSized = true; // always do that
5475 :
5476 18 : if (varSpeedCoil.RatedAirVolFlowRate >= HVAC::SmallAirVolFlow && (varSpeedCoil.VSCoilType == HVAC::Coil_CoolingWaterToAirHPVSEquationFit ||
5477 16 : varSpeedCoil.VSCoilType == HVAC::Coil_CoolingAirToAirVariableSpeed)) {
5478 13 : RatedAirMassFlowRate =
5479 13 : varSpeedCoil.RatedAirVolFlowRate *
5480 13 : Psychrometrics::PsyRhoAirFnPbTdbW(state, state.dataEnvrn->StdBaroPress, RatedInletAirTemp, RatedInletAirHumRat, RoutineName);
5481 13 : RatedInletEnth = Psychrometrics::PsyHFnTdbW(RatedInletAirTemp, RatedInletAirHumRat);
5482 13 : CBFRated = DXCoils::AdjustCBF(varSpeedCoil.MSRatedCBF(NormSpeed), varSpeedCoil.MSRatedAirMassFlowRate(NormSpeed), RatedAirMassFlowRate);
5483 13 : if (CBFRated > 0.999) {
5484 1 : CBFRated = 0.999;
5485 : }
5486 13 : if (varSpeedCoil.MSRatedAirMassFlowRate(NormSpeed) > 1.0e-10) {
5487 12 : AirMassFlowRatio = RatedAirMassFlowRate / varSpeedCoil.MSRatedAirMassFlowRate(NormSpeed);
5488 : } else {
5489 1 : AirMassFlowRatio = 1.0;
5490 : }
5491 :
5492 13 : if (varSpeedCoil.MSRatedWaterVolFlowRate(NormSpeed) > 1.0e-10) {
5493 2 : WaterMassFlowRatio = varSpeedCoil.RatedWaterVolFlowRate / varSpeedCoil.MSRatedWaterVolFlowRate(NormSpeed);
5494 : } else {
5495 11 : WaterMassFlowRatio = 1.0;
5496 : }
5497 :
5498 13 : Real64 TempInletWetBulb = RatedInletWetBulbTemp;
5499 65 : CalcTotCapSHR_VSWSHP(state,
5500 : RatedInletAirTemp,
5501 : RatedInletAirHumRat,
5502 : RatedInletEnth,
5503 : TempInletWetBulb,
5504 : AirMassFlowRatio,
5505 : WaterMassFlowRatio,
5506 : RatedAirMassFlowRate,
5507 : CBFRated,
5508 13 : varSpeedCoil.MSRatedTotCap(NormSpeed),
5509 13 : varSpeedCoil.MSCCapFTemp(NormSpeed),
5510 13 : varSpeedCoil.MSCCapAirFFlow(NormSpeed),
5511 13 : varSpeedCoil.MSCCapWaterFFlow(NormSpeed),
5512 : 0.0,
5513 : 0,
5514 : 0,
5515 : 0,
5516 : QLoadTotal1,
5517 : QLoadTotal2,
5518 : QLoadTotal,
5519 : SHR,
5520 : RatedSourceTempCool,
5521 13 : state.dataEnvrn->StdBaroPress,
5522 : 0.0,
5523 : 1,
5524 13 : varSpeedCoil.capModFacTotal);
5525 :
5526 13 : RatedCapCoolSensDes = varSpeedCoil.RatedCapCoolTotal * SHR;
5527 18 : } else if (varSpeedCoil.RatedAirVolFlowRate >= HVAC::SmallAirVolFlow &&
5528 5 : varSpeedCoil.VSCoilType == HVAC::CoilDX_HeatPumpWaterHeaterVariableSpeed) {
5529 0 : SHR = varSpeedCoil.MSRatedSHR(NormSpeed);
5530 0 : RatedCapCoolSensDes = varSpeedCoil.RatedCapCoolTotal * SHR;
5531 : } else {
5532 5 : RatedCapCoolSensDes = 0.0;
5533 : }
5534 :
5535 18 : if (RatedCapCoolSensDes < HVAC::SmallLoad) {
5536 6 : RatedCapCoolSensDes = 0.0;
5537 : }
5538 :
5539 18 : if (varSpeedCoil.VSCoilType == HVAC::Coil_CoolingWaterToAirHPVSEquationFit ||
5540 16 : varSpeedCoil.VSCoilType == HVAC::Coil_CoolingAirToAirVariableSpeed) { // always report for cooling mode
5541 13 : if (RatedCapCoolTotalAutoSized) {
5542 6 : varSpeedCoil.RatedCapCoolSens = RatedCapCoolSensDes;
5543 18 : BaseSizer::reportSizerOutput(state,
5544 12 : format("COIL:{}{}", varSpeedCoil.CoolHeatType, CurrentObjSubfix),
5545 : varSpeedCoil.Name,
5546 : "Design Size Rated Sensible Cooling Capacity [W]",
5547 : varSpeedCoil.RatedCapCoolSens);
5548 :
5549 : } else {
5550 : // sensible capacity does not have an input field
5551 7 : if (RatedCapCoolSensDes > 0.0) {
5552 6 : varSpeedCoil.RatedCapCoolSens = RatedCapCoolSensDes;
5553 18 : BaseSizer::reportSizerOutput(state,
5554 12 : format("COIL:{}{}", varSpeedCoil.CoolHeatType, CurrentObjSubfix),
5555 : varSpeedCoil.Name,
5556 : "Design Size Rated Sensible Cooling Capacity [W]",
5557 : RatedCapCoolSensDes); //, &
5558 : }
5559 : }
5560 26 : OutputReportPredefined::PreDefTableEntry(
5561 13 : state, state.dataOutRptPredefined->pdchCoolCoilTotCap, varSpeedCoil.Name, varSpeedCoil.RatedCapCoolTotal);
5562 26 : OutputReportPredefined::PreDefTableEntry(
5563 13 : state, state.dataOutRptPredefined->pdchCoolCoilSensCap, varSpeedCoil.Name, varSpeedCoil.RatedCapCoolSens);
5564 26 : OutputReportPredefined::PreDefTableEntry(state,
5565 13 : state.dataOutRptPredefined->pdchCoolCoilLatCap,
5566 : varSpeedCoil.Name,
5567 13 : varSpeedCoil.RatedCapCoolTotal - varSpeedCoil.RatedCapCoolSens);
5568 13 : if (varSpeedCoil.RatedCapCoolTotal != 0.0) {
5569 24 : OutputReportPredefined::PreDefTableEntry(state,
5570 12 : state.dataOutRptPredefined->pdchCoolCoilSHR,
5571 : varSpeedCoil.Name,
5572 12 : varSpeedCoil.RatedCapCoolSens / varSpeedCoil.RatedCapCoolTotal);
5573 : } else {
5574 1 : OutputReportPredefined::PreDefTableEntry(state, state.dataOutRptPredefined->pdchCoolCoilSHR, varSpeedCoil.Name, 0.0);
5575 : }
5576 26 : OutputReportPredefined::PreDefTableEntry(
5577 13 : state, state.dataOutRptPredefined->pdchCoolCoilNomEff, varSpeedCoil.Name, varSpeedCoil.MSRatedCOP(varSpeedCoil.NormSpedLevel));
5578 26 : OutputReportPredefined::addFootNoteSubTable(
5579 : state,
5580 13 : state.dataOutRptPredefined->pdstCoolCoil,
5581 : "Nominal values are gross at rated conditions, i.e., the supply air fan heat and electric power NOT accounted for.");
5582 : }
5583 :
5584 : // START SIZING EVAP PRECOOLING PUMP POWER
5585 18 : IsAutoSize = false;
5586 18 : if (varSpeedCoil.VSCoilType == HVAC::Coil_CoolingAirToAirVariableSpeed) {
5587 11 : if (varSpeedCoil.EvapCondPumpElecNomPower == DataSizing::AutoSize) {
5588 0 : IsAutoSize = true;
5589 : }
5590 : // Auto size high speed evap condenser pump power to Total Capacity * 0.004266 w/w (15 w/ton)
5591 11 : EvapCondPumpElecNomPowerDes = varSpeedCoil.RatedCapCoolTotal * 0.004266;
5592 11 : if (IsAutoSize) {
5593 0 : varSpeedCoil.EvapCondPumpElecNomPower = EvapCondPumpElecNomPowerDes;
5594 0 : BaseSizer::reportSizerOutput(state,
5595 : "AS VS COOLING COIL",
5596 : varSpeedCoil.Name,
5597 : "Design Size Evaporative Condenser Pump Rated Power Consumption [W]",
5598 : EvapCondPumpElecNomPowerDes);
5599 : } else {
5600 11 : if (varSpeedCoil.EvapCondPumpElecNomPower > 0.0 && EvapCondPumpElecNomPowerDes > 0.0) {
5601 0 : EvapCondPumpElecNomPowerUser = varSpeedCoil.EvapCondPumpElecNomPower;
5602 0 : BaseSizer::reportSizerOutput(state,
5603 : "AS VS COOLING COIL",
5604 : varSpeedCoil.Name,
5605 : "Design Size Evaporative Condenser Pump Rated Power Consumption [W]",
5606 : EvapCondPumpElecNomPowerDes,
5607 : "User-Specified Evaporative Condenser Pump Rated Power Consumption [W]",
5608 : EvapCondPumpElecNomPowerUser);
5609 0 : if (state.dataGlobal->DisplayExtraWarnings) {
5610 0 : if ((std::abs(EvapCondPumpElecNomPowerDes - EvapCondPumpElecNomPowerUser) / EvapCondPumpElecNomPowerUser) >
5611 0 : state.dataSize->AutoVsHardSizingThreshold) {
5612 0 : ShowMessage(state,
5613 0 : format("SizeVarSpeedCoil: Potential issue with equipment sizing for {} {}",
5614 0 : varSpeedCoil.CoolHeatType,
5615 : CurrentObjSubfix));
5616 0 : ShowContinueError(state, format("Coil Name = {}", varSpeedCoil.Name));
5617 0 : ShowContinueError(state,
5618 0 : format("User-Specified Evaporative Condenser Pump Rated Power Consumption of {:.2R} [W]",
5619 : EvapCondPumpElecNomPowerUser));
5620 0 : ShowContinueError(state,
5621 0 : format("differs from Design Size Evaporative Condenser Pump Rated Power Consumption of {:.2R} [W]",
5622 : EvapCondPumpElecNomPowerDes));
5623 0 : ShowContinueError(state, "This may, or may not, indicate mismatched component sizes.");
5624 0 : ShowContinueError(state, "Verify that the value entered is intended and is consistent with other components.");
5625 : }
5626 : }
5627 : }
5628 : }
5629 : }
5630 : // END SIZING EVAP PRE-COOLING PUMP POWER
5631 :
5632 : // SIZE DEFROST HEATER
5633 :
5634 : // Resistive Defrost Heater Capacity = capacity at the first stage
5635 18 : IsAutoSize = false;
5636 18 : if (varSpeedCoil.VSCoilType == HVAC::Coil_HeatingAirToAirVariableSpeed) {
5637 4 : if (varSpeedCoil.DefrostCapacity == DataSizing::AutoSize) {
5638 0 : IsAutoSize = true;
5639 : }
5640 4 : if (varSpeedCoil.DefrostStrategy == Resistive) {
5641 4 : DefrostCapacityDes = varSpeedCoil.RatedCapHeat;
5642 : } else {
5643 0 : DefrostCapacityDes = 0.0;
5644 : }
5645 4 : if (IsAutoSize) {
5646 0 : varSpeedCoil.DefrostCapacity = DefrostCapacityDes;
5647 0 : BaseSizer::reportSizerOutput(
5648 : state, "AS VS HEATING COIL", varSpeedCoil.Name, "Design Size Resistive Defrost Heater Capacity [W]", DefrostCapacityDes);
5649 : } else {
5650 4 : if (varSpeedCoil.DefrostCapacity > 0.0 && DefrostCapacityDes > 0.0 && !HardSizeNoDesRun) {
5651 1 : DefrostCapacityUser = varSpeedCoil.DefrostCapacity;
5652 1 : BaseSizer::reportSizerOutput(state,
5653 : "AS VS HEATING COIL",
5654 : varSpeedCoil.Name,
5655 : "Design Size Resistive Defrost Heater Capacity [W]",
5656 : DefrostCapacityDes,
5657 : "User-Specified Resistive Defrost Heater Capacity [W]",
5658 : DefrostCapacityUser);
5659 1 : if (state.dataGlobal->DisplayExtraWarnings) {
5660 0 : if ((std::abs(DefrostCapacityDes - DefrostCapacityUser) / DefrostCapacityUser) > state.dataSize->AutoVsHardSizingThreshold) {
5661 0 : ShowMessage(state,
5662 0 : format("SizeVarSpeedCoil: Potential issue with equipment sizing for {} {}",
5663 0 : varSpeedCoil.CoolHeatType,
5664 : CurrentObjSubfix));
5665 0 : ShowContinueError(state, format("Coil Name = {}", varSpeedCoil.Name));
5666 0 : ShowContinueError(state, format("User-Specified Resistive Defrost Heater Capacity of {:.2R} [W]", DefrostCapacityUser));
5667 0 : ShowContinueError(state,
5668 0 : format("differs from Design Size Resistive Defrost Heater Capacity of {:.2R} [W]", DefrostCapacityDes));
5669 0 : ShowContinueError(state, "This may, or may not, indicate mismatched component sizes.");
5670 0 : ShowContinueError(state, "Verify that the value entered is intended and is consistent with other components.");
5671 : }
5672 : }
5673 : }
5674 : }
5675 : }
5676 : // END SIZING DEFROST HEATER
5677 :
5678 : // test autosized sensible and total cooling capacity for total > sensible
5679 18 : if (RatedCapCoolSensAutoSized && RatedCapCoolTotalAutoSized) {
5680 6 : if (varSpeedCoil.RatedCapCoolSens > varSpeedCoil.RatedCapCoolTotal) {
5681 0 : ShowWarningError(state,
5682 0 : format("COIL:{}:WATERTOAIRHEATPUMP:VARIABLESPEEDEQUATIONFIT \"{}\"", varSpeedCoil.CoolHeatType, varSpeedCoil.Name));
5683 0 : ShowContinueError(state, format("{}: Rated Sensible Cooling Capacity > Rated Total Cooling Capacity", RoutineName));
5684 0 : ShowContinueError(state, "Each of these capacity inputs have been autosized.");
5685 0 : ShowContinueError(state, format("Rated Sensible Cooling Capacity = {:.2T} W", varSpeedCoil.RatedCapCoolSens));
5686 0 : ShowContinueError(state, format("Rated Total Cooling Capacity = {:.2T} W", varSpeedCoil.RatedCapCoolTotal));
5687 0 : ShowContinueError(state, "See eio file for further details.");
5688 0 : ShowContinueError(state, "Check Total and Sensible Cooling Capacity Coefficients to ensure they are accurate.");
5689 0 : ShowContinueError(state, "Check Zone and System Sizing objects to verify sizing inputs.");
5690 0 : ShowContinueError(state, "Sizing statistics:");
5691 0 : ShowContinueError(state, format("Entering Air Dry-Bulb Temperature = {:.3T} C", MixTemp));
5692 0 : ShowContinueError(state, format("Entering Air Wet-Bulb Temperature = {:.3T} C", MixWetBulb));
5693 0 : ShowContinueError(state, "Entering Condenser Water Temperature used = 24.4444 C");
5694 0 : ShowContinueError(state, "Used design air and water flow rates (i.e., used 1 for ratioVL and ratioVS)");
5695 0 : ShowContinueError(state, format("ratioTDB = {:.3T}", ((MixTemp + 283.15) / 273.15)));
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, format("Total Cooling Capacity Modifier = {:.5T}", TotCapTempModFac));
5700 0 : ShowContinueError(state, "...Rated Total Cooling Capacity = Total Design Load / Total Cooling Capacity Modifier");
5701 0 : ShowContinueError(state, "Carefully review the Load Side Total, Sensible, and Latent heat transfer rates");
5702 0 : ShowContinueError(state, "... to ensure they meet the expected manufacturers performance specifications.");
5703 : }
5704 12 : } else if (RatedCapCoolTotalAutoSized) {
5705 0 : if (varSpeedCoil.RatedCapCoolSens > varSpeedCoil.RatedCapCoolTotal) {
5706 0 : ShowWarningError(state,
5707 0 : format("COIL:{}:WATERTOAIRHEATPUMP:VARIABLESPEEDEQUATIONFIT \"{}\"", varSpeedCoil.CoolHeatType, varSpeedCoil.Name));
5708 0 : ShowContinueError(state, format("{}: Rated Sensible Cooling Capacity > Rated Total Cooling Capacity", RoutineName));
5709 0 : ShowContinueError(state, "Only the rated total capacity input is autosized, consider autosizing both inputs.");
5710 0 : ShowContinueError(state, format("Rated Sensible Cooling Capacity = {:.2T} W", varSpeedCoil.RatedCapCoolSens));
5711 0 : ShowContinueError(state, format("Rated Total Cooling Capacity = {:.2T} W", varSpeedCoil.RatedCapCoolTotal));
5712 0 : ShowContinueError(state, "See eio file for further details.");
5713 0 : ShowContinueError(state, "Check Total and Sensible Cooling Capacity Coefficients to ensure they are accurate.");
5714 0 : ShowContinueError(state, "Check Zone and System Sizing objects to verify sizing inputs.");
5715 0 : ShowContinueError(state, "Sizing statistics for Total Cooling Capacity:");
5716 0 : ShowContinueError(state, format("Entering Air Wet-Bulb Temperature = {:.3T} C", MixWetBulb));
5717 0 : ShowContinueError(state, "Entering Condenser Water Temperature used = 24.4444 C");
5718 0 : ShowContinueError(state, "Used design air and water flow rates (i.e., used 1 for ratioVL and ratioVS)");
5719 0 : ShowContinueError(state, format("ratioTWB = {:.3T}", ((MixWetBulb + 283.15) / 273.15)));
5720 0 : ShowContinueError(state, format("ratioTS = {:.3T}", ((85.0 + 283.15) / 273.15)));
5721 0 : ShowContinueError(state, "Rated Sensible Cooling Capacity = Rated Total Cooling Capacity * Sensible Heat Ratio");
5722 0 : ShowContinueError(state, "Carefully review the Load Side Total, Sensible, and Latent heat transfer rates");
5723 0 : ShowContinueError(state, "... to ensure they meet the expected manufacturers performance specifications.");
5724 : }
5725 : }
5726 :
5727 36 : Array1D<DataHeatBalance::RefrigCondenserType> CondenserType;
5728 : StandardRatings::HPdefrostControl DefrostControl;
5729 18 : switch (varSpeedCoil.VSCoilType) {
5730 11 : case HVAC::Coil_CoolingAirToAirVariableSpeed:
5731 11 : CondenserType.push_back(varSpeedCoil.CondenserType);
5732 11 : switch (varSpeedCoil.DefrostControl) // defrost control; 1=timed, 2=on-demand
5733 : {
5734 0 : case 2:
5735 0 : DefrostControl = StandardRatings::HPdefrostControl::OnDemand;
5736 0 : break;
5737 11 : case 1:
5738 : default:
5739 11 : DefrostControl = StandardRatings::HPdefrostControl::Timed;
5740 11 : break;
5741 : }
5742 11 : if (varSpeedCoil.RatedCapCoolTotal > 0.0) {
5743 60 : StandardRatings::CalcDXCoilStandardRating(state,
5744 10 : varSpeedCoil.Name,
5745 10 : varSpeedCoil.VarSpeedCoilType,
5746 : varSpeedCoil.VSCoilType,
5747 : varSpeedCoil.NumOfSpeeds,
5748 : varSpeedCoil.MSRatedTotCap,
5749 : varSpeedCoil.MSRatedCOP,
5750 : varSpeedCoil.MSCCapAirFFlow,
5751 : varSpeedCoil.MSCCapFTemp,
5752 : varSpeedCoil.MSEIRAirFFlow,
5753 : varSpeedCoil.MSEIRFTemp,
5754 10 : varSpeedCoil.PLFFPLR,
5755 : varSpeedCoil.MSRatedAirVolFlowRate,
5756 : varSpeedCoil.MSRatedEvaporatorFanPowerPerVolumeFlowRate2017,
5757 : varSpeedCoil.MSRatedEvaporatorFanPowerPerVolumeFlowRate2023,
5758 : CondenserType,
5759 20 : 0, // varSpeedCoil.RegionNum, // ??
5760 10 : varSpeedCoil.MinOATCompressor,
5761 10 : varSpeedCoil.OATempCompressorOn,
5762 20 : false, // varSpeedCoil.OATempCompressorOnOffBlank, // ??
5763 : DefrostControl,
5764 20 : ObjexxFCL::Optional_bool_const(),
5765 10 : varSpeedCoil.RatedCapCoolTotal,
5766 10 : varSpeedCoil.RatedAirVolFlowRate);
5767 : }
5768 11 : break;
5769 7 : default:
5770 7 : break;
5771 : }
5772 18 : }
5773 :
5774 34029 : void CalcVarSpeedCoilCooling(EnergyPlusData &state,
5775 : int const DXCoilNum, // Heat Pump Number
5776 : HVAC::FanOp const fanOp, // Fan/Compressor cycling scheme indicator
5777 : [[maybe_unused]] Real64 const SensDemand, // Cooling Sensible Demand [W] !unused1208
5778 : [[maybe_unused]] Real64 const LatentDemand, // Cooling Latent Demand [W]
5779 : HVAC::CompressorOp const compressorOp, // compressor operation flag
5780 : Real64 const PartLoadRatio, // compressor part load ratio
5781 : [[maybe_unused]] Real64 const OnOffAirFlowRatio, // ratio of compressor on flow to average flow over time step
5782 : Real64 const SpeedRatio, // SpeedRatio varies between 1.0 (higher speed) and 0.0 (lower speed)
5783 : int const SpeedNum // Speed number, high bound
5784 : )
5785 : {
5786 :
5787 : // AUTHOR Bo Shen, based on WaterToAirHeatPumpSimple:CalcHPCoolingSimple
5788 : // DATE WRITTEN March 2012
5789 :
5790 : // PURPOSE OF THIS SUBROUTINE:
5791 : // This subroutine is for simulating the cooling mode of the Variable-Speed Water to Air HP Simple
5792 :
5793 : // METHODOLOGY EMPLOYED:
5794 : // Simulate the heat pump performance using the coefficients and rated conditions, interpolating between speed levels
5795 : // If the LatDegradModelSimFlag is enabled, the coil will be simulated twice:
5796 : // (1)first simulation at the rated conditions (2) second simulation at the
5797 : // actual operating conditions. Then call CalcEffectiveSHR and the effective SHR
5798 : // is adjusted.
5799 : // If the LatDegradModelSimFlag is disabled, the cooling coil is only simulated
5800 : // once at the actual operating conditions.
5801 : // Finally, adjust the heat pump outlet conditions based on the PartLoadRatio
5802 : // and RuntimeFrac.
5803 :
5804 : // SUBROUTINE PARAMETER DEFINITIONS:
5805 : static constexpr std::string_view RoutineName("CalcVarSpeedCoilCooling");
5806 : static constexpr std::string_view RoutineNameSourceSideInletTemp("CalcVarSpeedCoilCooling:SourceSideInletTemp");
5807 34029 : Real64 TimeStepSysSec = state.dataHVACGlobal->TimeStepSysSec;
5808 :
5809 : // SUBROUTINE LOCAL VARIABLE DECLARATIONS:
5810 : Real64 Twet_Rated; // Twet at rated conditions (coil air flow rate and air temperatures), sec
5811 : Real64 Gamma_Rated; // Gamma at rated conditions (coil air flow rate and air temperatures)
5812 :
5813 : Real64 SHRss; // Sensible heat ratio at steady state
5814 : Real64 SHReff; // Effective sensible heat ratio at part-load condition
5815 : Real64 CpSource; // Specific heat of water [J/kg_C]
5816 : Real64 CpAir; // Specific heat of air [J/kg_C]
5817 :
5818 : bool LatDegradModelSimFlag; // Latent degradation model simulation flag
5819 : int NumIteration; // Iteration Counter
5820 : Real64 LoadSideInletDBTemp_Unit; // calc conditions for unit
5821 : Real64 LoadSideInletWBTemp_Unit; // calc conditions for unit
5822 : Real64 LoadSideInletHumRat_Unit; // calc conditions for unit
5823 : Real64 LoadSideInletEnth_Unit; // calc conditions for unit
5824 : Real64 CpAir_Unit; // calc conditions for unit
5825 : Real64 AirMassFlowRatio; // airflow ratio at low speed
5826 : Real64 WaterMassFlowRatio; // airflow ratio at high speed
5827 : Real64 EIRAirFFModFac; // air flow fraction modification
5828 : Real64 EIRWaterFFModFac; // water flow fraction modification
5829 : Real64 EIRTempModFac; // total capacity temperature correctio fraction
5830 : Real64 CBFSpeed; // total capacity temperature correctio fraction
5831 : Real64 SHR; // total capacity temperature correctio fraction
5832 : Real64 EIR; // total capacity temperature correctio fraction
5833 : int MaxSpeed; // maximum speed level
5834 : int SpeedCal; // calculated speed level
5835 : Real64 AoEff; // effective air side surface area
5836 : Real64 QLoadTotal1; // total capacity at low speed
5837 : Real64 QLoadTotal2; // total capacity at high speed
5838 : Real64 Winput1; // power consumption at low speed
5839 : Real64 Winput2; // power consumption at high speed
5840 : Real64 QWasteHeat; // recoverable waste heat
5841 : Real64 QWasteHeat1; // recoverable waste heat at low speed
5842 : Real64 QWasteHeat2; // recoverable waste heat at high speed
5843 : Real64 PLF; // part-load function
5844 : Real64 MaxHumRat; // max possible humidity
5845 : Real64 MaxOutletEnth; // max possible outlet enthalpy
5846 :
5847 : // ADDED VARIABLES FOR air source coil
5848 : Real64 CondInletTemp; // Condenser inlet temperature (C). Outdoor dry-bulb temp for air-cooled condenser.
5849 : // Outdoor Wetbulb +(1 - effectiveness)*(outdoor drybulb - outdoor wetbulb) for evap condenser.
5850 : Real64 CondInletHumRat; // Condenser inlet humidity ratio (kg/kg). Zero for air-cooled condenser.
5851 : // For evap condenser, its the humidity ratio of the air leaving the evap cooling pads.
5852 : Real64 CondAirMassFlow; // Condenser air mass flow rate [kg/s]
5853 : Real64 RhoSourceAir; // Density of air [kg/m3]
5854 : Real64 RhoEvapCondWater; // Density of water used for evaporative condenser [kg/m3]
5855 : Real64 EvapCondEffectSped; // condenser evaporative effectiveness at the speed level
5856 : Real64 RhoWater; // condensed water density
5857 : Real64 SpecHumIn; // inlet air specific humidity
5858 : Real64 SpecHumOut; // outlet air specific humidity
5859 34029 : Real64 rhoair(0); // entering air density
5860 :
5861 34029 : if (state.dataVariableSpeedCoils->firstTime) {
5862 : // Set indoor air conditions to the rated condition
5863 16 : state.dataVariableSpeedCoils->LoadSideInletDBTemp_Init = 26.7;
5864 16 : state.dataVariableSpeedCoils->LoadSideInletHumRat_Init = 0.0111;
5865 16 : state.dataVariableSpeedCoils->LoadSideInletEnth_Init = Psychrometrics::PsyHFnTdbW(state.dataVariableSpeedCoils->LoadSideInletDBTemp_Init,
5866 16 : state.dataVariableSpeedCoils->LoadSideInletHumRat_Init);
5867 16 : state.dataVariableSpeedCoils->CpAir_Init = Psychrometrics::PsyCpAirFnW(state.dataVariableSpeedCoils->LoadSideInletHumRat_Init);
5868 16 : state.dataVariableSpeedCoils->firstTime = false;
5869 : }
5870 :
5871 68058 : state.dataVariableSpeedCoils->LoadSideInletWBTemp_Init =
5872 34029 : Psychrometrics::PsyTwbFnTdbWPb(state,
5873 34029 : state.dataVariableSpeedCoils->LoadSideInletDBTemp_Init,
5874 34029 : state.dataVariableSpeedCoils->LoadSideInletHumRat_Init,
5875 34029 : state.dataEnvrn->OutBaroPress,
5876 : RoutineName);
5877 :
5878 34029 : MaxSpeed = state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).NumOfSpeeds;
5879 :
5880 : // must be placed inside the loop, otherwise cause bug in release mode, need to be present at two places
5881 34029 : if (SpeedNum > MaxSpeed) {
5882 0 : SpeedCal = MaxSpeed;
5883 : } else {
5884 34029 : SpeedCal = SpeedNum;
5885 : }
5886 :
5887 : // LOAD LOCAL VARIABLES FROM DATA STRUCTURE (for code readability)
5888 34029 : if (!(fanOp == HVAC::FanOp::Continuous) && PartLoadRatio > 0.0) {
5889 10430 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).AirMassFlowRate =
5890 10430 : state.dataLoopNodes->Node(state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).AirInletNodeNum).MassFlowRate / PartLoadRatio;
5891 : }
5892 :
5893 34029 : Twet_Rated = state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Twet_Rated;
5894 34029 : Gamma_Rated = state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Gamma_Rated;
5895 :
5896 34029 : state.dataVariableSpeedCoils->LoadSideMassFlowRate = state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).AirMassFlowRate;
5897 :
5898 34029 : if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).VSCoilType == HVAC::Coil_CoolingAirToAirVariableSpeed) {
5899 : // Get condenser outdoor node info from DX COOLING Coil
5900 388 : if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).CondenserInletNodeNum != 0) {
5901 0 : state.dataVariableSpeedCoils->OutdoorDryBulb_CalcVarSpeedCoilCooling =
5902 0 : state.dataLoopNodes->Node(state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).CondenserInletNodeNum).Temp;
5903 0 : state.dataVariableSpeedCoils->OutdoorHumRat_CalcVarSpeedCoilCooling =
5904 0 : state.dataLoopNodes->Node(state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).CondenserInletNodeNum).HumRat;
5905 0 : state.dataVariableSpeedCoils->OutdoorPressure_CalcVarSpeedCoilCooling =
5906 0 : state.dataLoopNodes->Node(state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).CondenserInletNodeNum).Press;
5907 0 : state.dataVariableSpeedCoils->OutdoorWetBulb_CalcVarSpeedCoilCooling =
5908 0 : state.dataLoopNodes->Node(state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).CondenserInletNodeNum).OutAirWetBulb;
5909 : } else {
5910 388 : state.dataVariableSpeedCoils->OutdoorDryBulb_CalcVarSpeedCoilCooling = state.dataEnvrn->OutDryBulbTemp;
5911 388 : state.dataVariableSpeedCoils->OutdoorHumRat_CalcVarSpeedCoilCooling = state.dataEnvrn->OutHumRat;
5912 388 : state.dataVariableSpeedCoils->OutdoorPressure_CalcVarSpeedCoilCooling = state.dataEnvrn->OutBaroPress;
5913 388 : state.dataVariableSpeedCoils->OutdoorWetBulb_CalcVarSpeedCoilCooling = state.dataEnvrn->OutWetBulbTemp;
5914 : }
5915 :
5916 776 : RhoSourceAir = Psychrometrics::PsyRhoAirFnPbTdbW(state,
5917 388 : state.dataVariableSpeedCoils->OutdoorPressure_CalcVarSpeedCoilCooling,
5918 388 : state.dataVariableSpeedCoils->OutdoorDryBulb_CalcVarSpeedCoilCooling,
5919 388 : state.dataVariableSpeedCoils->OutdoorHumRat_CalcVarSpeedCoilCooling);
5920 :
5921 388 : if ((SpeedNum == 1) || (SpeedNum > MaxSpeed) || (SpeedRatio == 1.0)) {
5922 365 : CondAirMassFlow = RhoSourceAir * state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).EvapCondAirFlow(SpeedCal);
5923 : } else {
5924 23 : CondAirMassFlow =
5925 23 : RhoSourceAir * (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).EvapCondAirFlow(SpeedCal) * SpeedRatio +
5926 23 : (1.0 - SpeedRatio) * state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).EvapCondAirFlow(SpeedCal - 1));
5927 : }
5928 :
5929 : // AIR COOL OR EVAP COOLED CONDENSER
5930 388 : if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).CondenserType == DataHeatBalance::RefrigCondenserType::Evap) {
5931 0 : if ((SpeedNum == 1) || (SpeedNum > MaxSpeed) || (SpeedRatio == 1.0)) {
5932 0 : EvapCondEffectSped = state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).EvapCondEffect(SpeedCal);
5933 : } else {
5934 0 : EvapCondEffectSped = state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).EvapCondEffect(SpeedCal) * SpeedRatio +
5935 0 : (1.0 - SpeedRatio) * state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).EvapCondEffect(SpeedCal - 1);
5936 : }
5937 : // (Outdoor wet-bulb temp from DataEnvironment) + (1.0-EvapCondEffectiveness) * (drybulb - wetbulb)
5938 0 : CondInletTemp = state.dataVariableSpeedCoils->OutdoorWetBulb_CalcVarSpeedCoilCooling +
5939 0 : (state.dataVariableSpeedCoils->OutdoorDryBulb_CalcVarSpeedCoilCooling -
5940 0 : state.dataVariableSpeedCoils->OutdoorWetBulb_CalcVarSpeedCoilCooling) *
5941 0 : (1.0 - EvapCondEffectSped);
5942 0 : CondInletHumRat = Psychrometrics::PsyWFnTdbTwbPb(state,
5943 : CondInletTemp,
5944 0 : state.dataVariableSpeedCoils->OutdoorWetBulb_CalcVarSpeedCoilCooling,
5945 0 : state.dataVariableSpeedCoils->OutdoorPressure_CalcVarSpeedCoilCooling);
5946 0 : state.dataVariableSpeedCoils->CompAmbTemp_CalcVarSpeedCoilCooling = CondInletTemp;
5947 : } else { // AIR COOLED CONDENSER
5948 388 : CondInletTemp = state.dataVariableSpeedCoils->OutdoorDryBulb_CalcVarSpeedCoilCooling; // Outdoor dry-bulb temp
5949 776 : state.dataVariableSpeedCoils->CompAmbTemp_CalcVarSpeedCoilCooling =
5950 388 : state.dataVariableSpeedCoils->OutdoorDryBulb_CalcVarSpeedCoilCooling;
5951 388 : CondInletHumRat = state.dataEnvrn->OutHumRat;
5952 : }
5953 :
5954 388 : state.dataVariableSpeedCoils->SourceSideMassFlowRate = CondAirMassFlow;
5955 388 : state.dataVariableSpeedCoils->SourceSideInletTemp = CondInletTemp;
5956 388 : state.dataVariableSpeedCoils->SourceSideInletEnth = Psychrometrics::PsyHFnTdbW(CondInletTemp, CondInletHumRat);
5957 388 : CpSource = Psychrometrics::PsyCpAirFnW(CondInletHumRat);
5958 388 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).CondInletTemp = CondInletTemp;
5959 :
5960 : // If used in a heat pump, the value of MaxOAT in the heating coil overrides that in the cooling coil (in GetInput)
5961 : // Initialize crankcase heater, operates below OAT defined in input deck for HP DX heating coil
5962 388 : if (state.dataVariableSpeedCoils->OutdoorDryBulb_CalcVarSpeedCoilCooling <
5963 388 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MaxOATCrankcaseHeater) {
5964 44 : state.dataVariableSpeedCoils->CrankcaseHeatingPower_CalcVarSpeedCoilCooling =
5965 22 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).CrankcaseHeaterCapacity;
5966 22 : if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).CrankcaseHeaterCapacityCurveIndex > 0) {
5967 1 : state.dataVariableSpeedCoils->CrankcaseHeatingPower_CalcVarSpeedCoilCooling *=
5968 1 : Curve::CurveValue(state,
5969 1 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).CrankcaseHeaterCapacityCurveIndex,
5970 1 : state.dataEnvrn->OutDryBulbTemp);
5971 : }
5972 : } else {
5973 366 : state.dataVariableSpeedCoils->CrankcaseHeatingPower_CalcVarSpeedCoilCooling = 0.0;
5974 : }
5975 : } else {
5976 33641 : state.dataVariableSpeedCoils->SourceSideMassFlowRate = state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).WaterMassFlowRate;
5977 33641 : state.dataVariableSpeedCoils->SourceSideInletTemp = state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).InletWaterTemp;
5978 33641 : state.dataVariableSpeedCoils->SourceSideInletEnth = state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).InletWaterEnthalpy;
5979 33641 : CpSource = state.dataPlnt->PlantLoop(state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).plantLoc.loopNum)
5980 33641 : .glycol->getSpecificHeat(state, state.dataVariableSpeedCoils->SourceSideInletTemp, RoutineNameSourceSideInletTemp);
5981 : }
5982 :
5983 : // Check for flows, do not perform simulation if no flow in load side or source side.
5984 34029 : if (state.dataVariableSpeedCoils->SourceSideMassFlowRate <= 0.0 || state.dataVariableSpeedCoils->LoadSideMassFlowRate <= 0.0) {
5985 :
5986 23557 : if ((state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).VSCoilType == HVAC::Coil_CoolingAirToAirVariableSpeed) &&
5987 23702 : (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).CondenserType == DataHeatBalance::RefrigCondenserType::Air) &&
5988 145 : (state.dataVariableSpeedCoils->LoadSideMassFlowRate > 0.0)) {
5989 : // ALLOW SIMULATION IF AIR-COOLED CONDENSER COIL
5990 57 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).SimFlag = true;
5991 : } else {
5992 23500 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).SimFlag = false;
5993 23516 : return;
5994 : }
5995 : } else {
5996 10472 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).SimFlag = true;
5997 : }
5998 :
5999 10529 : if (compressorOp == HVAC::CompressorOp::Off || state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).RatedCapCoolTotal <= 0.0) {
6000 16 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).SimFlag = false;
6001 16 : return;
6002 : }
6003 :
6004 10797 : if ((state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).VSCoilType == HVAC::Coil_CoolingAirToAirVariableSpeed) &&
6005 284 : (CondInletTemp < state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MinOATCompressor)) {
6006 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).SimFlag = false;
6007 0 : return;
6008 : }
6009 :
6010 : // Loop the calculation at least once depending whether the latent degradation model
6011 : // is enabled. 1st iteration to calculate the QLatent(rated) at (TDB,TWB)indoorair=(26.7C,19.4C)
6012 : // and 2nd iteration to calculate the QLatent(actual)
6013 10513 : if ((PartLoadRatio < 1e-10) || (Twet_Rated <= 0.0) || (Gamma_Rated <= 0.0) || (SpeedNum > 1.0)) {
6014 10502 : LatDegradModelSimFlag = false;
6015 : // Set NumIteration=1 so that latent model would quit after 1 simulation with the actual condition
6016 10502 : NumIteration = 1;
6017 : } else {
6018 11 : LatDegradModelSimFlag = true;
6019 : // Set NumIteration=0 so that latent model would simulate twice with rated and actual condition
6020 11 : NumIteration = 0;
6021 : }
6022 :
6023 : // Set indoor air conditions to the actual condition
6024 10513 : LoadSideInletDBTemp_Unit = state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).InletAirDBTemp;
6025 10513 : LoadSideInletHumRat_Unit = state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).InletAirHumRat;
6026 : LoadSideInletWBTemp_Unit =
6027 10513 : Psychrometrics::PsyTwbFnTdbWPb(state, LoadSideInletDBTemp_Unit, LoadSideInletHumRat_Unit, state.dataEnvrn->OutBaroPress, RoutineName);
6028 10513 : LoadSideInletEnth_Unit = state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).InletAirEnthalpy;
6029 10513 : CpAir_Unit = Psychrometrics::PsyCpAirFnW(LoadSideInletHumRat_Unit);
6030 :
6031 10513 : state.dataHVACGlobal->OnOffFanPartLoadFraction = 1.0;
6032 10513 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).RunFrac = 1.0;
6033 10513 : if ((SpeedNum == 1) && (PartLoadRatio < 1.0)) {
6034 671 : PLF = Curve::CurveValue(state, state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).PLFFPLR, PartLoadRatio);
6035 671 : if (PLF < 0.7) {
6036 0 : PLF = 0.7;
6037 : }
6038 671 : if (fanOp == HVAC::FanOp::Cycling) {
6039 650 : state.dataHVACGlobal->OnOffFanPartLoadFraction =
6040 : PLF; // save PLF for fan model, don't change fan power for constant fan mode if coil is off
6041 : }
6042 : // calculate the run time fraction
6043 671 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).RunFrac = PartLoadRatio / PLF;
6044 671 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).PartLoadRatio = PartLoadRatio;
6045 :
6046 671 : if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).RunFrac > 1.0) {
6047 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).RunFrac = 1.0; // Reset coil runtime fraction to 1.0
6048 671 : } else if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).RunFrac < 0.0) {
6049 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).RunFrac = 0.0;
6050 : }
6051 : }
6052 :
6053 : while (true) {
6054 10524 : ++NumIteration;
6055 10524 : if (NumIteration == 1) {
6056 : // Set indoor air conditions to the rated conditions
6057 11 : state.dataVariableSpeedCoils->LoadSideInletDBTemp = state.dataVariableSpeedCoils->LoadSideInletDBTemp_Init;
6058 11 : state.dataVariableSpeedCoils->LoadSideInletHumRat = state.dataVariableSpeedCoils->LoadSideInletHumRat_Init;
6059 11 : state.dataVariableSpeedCoils->LoadSideInletWBTemp = state.dataVariableSpeedCoils->LoadSideInletWBTemp_Init;
6060 11 : state.dataVariableSpeedCoils->LoadSideInletEnth = state.dataVariableSpeedCoils->LoadSideInletEnth_Init;
6061 11 : CpAir = state.dataVariableSpeedCoils->CpAir_Init;
6062 : } else {
6063 : // Set indoor air conditions to the actual condition
6064 10513 : state.dataVariableSpeedCoils->LoadSideInletDBTemp = LoadSideInletDBTemp_Unit;
6065 10513 : state.dataVariableSpeedCoils->LoadSideInletHumRat = LoadSideInletHumRat_Unit;
6066 10513 : state.dataVariableSpeedCoils->LoadSideInletWBTemp = LoadSideInletWBTemp_Unit;
6067 10513 : state.dataVariableSpeedCoils->LoadSideInletEnth = LoadSideInletEnth_Unit;
6068 10513 : CpAir = CpAir_Unit;
6069 : }
6070 :
6071 : // must be placed inside the loop, otherwise cause bug in release mode
6072 10524 : if (SpeedNum > MaxSpeed) {
6073 0 : SpeedCal = MaxSpeed;
6074 : } else {
6075 10524 : SpeedCal = SpeedNum;
6076 : }
6077 :
6078 10524 : if ((SpeedNum == 1) || (SpeedNum > MaxSpeed) || (SpeedRatio == 1.0)) {
6079 7158 : AirMassFlowRatio =
6080 7158 : state.dataVariableSpeedCoils->LoadSideMassFlowRate / state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).DesignAirMassFlowRate;
6081 :
6082 7158 : if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).VSCoilType == HVAC::Coil_CoolingAirToAirVariableSpeed) {
6083 272 : WaterMassFlowRatio = 1.0;
6084 : } else {
6085 6886 : WaterMassFlowRatio = state.dataVariableSpeedCoils->SourceSideMassFlowRate /
6086 6886 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).DesignWaterMassFlowRate;
6087 : }
6088 :
6089 7158 : CBFSpeed = DXCoils::AdjustCBF(state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedCBF(SpeedCal),
6090 7158 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedAirMassFlowRate(SpeedCal),
6091 7158 : state.dataVariableSpeedCoils->LoadSideMassFlowRate);
6092 :
6093 7158 : if (CBFSpeed > 0.999) {
6094 1 : CBFSpeed = 0.999;
6095 : }
6096 :
6097 7158 : CalcTotCapSHR_VSWSHP(state,
6098 7158 : state.dataVariableSpeedCoils->LoadSideInletDBTemp,
6099 7158 : state.dataVariableSpeedCoils->LoadSideInletHumRat,
6100 7158 : state.dataVariableSpeedCoils->LoadSideInletEnth,
6101 7158 : state.dataVariableSpeedCoils->LoadSideInletWBTemp,
6102 : AirMassFlowRatio,
6103 : WaterMassFlowRatio,
6104 7158 : state.dataVariableSpeedCoils->LoadSideMassFlowRate,
6105 : CBFSpeed,
6106 7158 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedTotCap(SpeedCal),
6107 7158 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSCCapFTemp(SpeedCal),
6108 7158 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSCCapAirFFlow(SpeedCal),
6109 7158 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSCCapWaterFFlow(SpeedCal),
6110 : 0.0,
6111 : 0,
6112 : 0,
6113 : 0,
6114 : QLoadTotal1,
6115 : QLoadTotal2,
6116 7158 : state.dataVariableSpeedCoils->QLoadTotal,
6117 : SHR,
6118 7158 : state.dataVariableSpeedCoils->SourceSideInletTemp,
6119 7158 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).InletAirPressure,
6120 : 0.0,
6121 : 1,
6122 7158 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).capModFacTotal);
6123 :
6124 28632 : EIRTempModFac = Curve::CurveValue(state,
6125 7158 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSEIRFTemp(SpeedCal),
6126 7158 : state.dataVariableSpeedCoils->LoadSideInletWBTemp,
6127 7158 : state.dataVariableSpeedCoils->SourceSideInletTemp);
6128 : EIRAirFFModFac =
6129 7158 : Curve::CurveValue(state, state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSEIRAirFFlow(SpeedCal), AirMassFlowRatio);
6130 :
6131 7158 : if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).VSCoilType == HVAC::Coil_CoolingAirToAirVariableSpeed) {
6132 272 : EIRWaterFFModFac = 1.0;
6133 : } else {
6134 : EIRWaterFFModFac =
6135 6886 : Curve::CurveValue(state, state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSEIRWaterFFlow(SpeedCal), WaterMassFlowRatio);
6136 : }
6137 :
6138 7158 : EIR = (1.0 / state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedCOP(SpeedCal)) * EIRTempModFac * EIRAirFFModFac *
6139 : EIRWaterFFModFac;
6140 :
6141 7158 : CBFSpeed = DXCoils::AdjustCBF(state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedCBF(SpeedCal),
6142 7158 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedAirMassFlowRate(SpeedCal),
6143 7158 : state.dataVariableSpeedCoils->LoadSideMassFlowRate);
6144 :
6145 7158 : if (CBFSpeed > 0.999) {
6146 1 : CBFSpeed = 0.999;
6147 : }
6148 :
6149 7158 : CalcTotCapSHR_VSWSHP(state,
6150 7158 : state.dataVariableSpeedCoils->LoadSideInletDBTemp,
6151 7158 : state.dataVariableSpeedCoils->LoadSideInletHumRat,
6152 7158 : state.dataVariableSpeedCoils->LoadSideInletEnth,
6153 7158 : state.dataVariableSpeedCoils->LoadSideInletWBTemp,
6154 : AirMassFlowRatio,
6155 : WaterMassFlowRatio,
6156 7158 : state.dataVariableSpeedCoils->LoadSideMassFlowRate,
6157 : CBFSpeed,
6158 7158 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedTotCap(SpeedCal),
6159 7158 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSCCapFTemp(SpeedCal),
6160 7158 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSCCapAirFFlow(SpeedCal),
6161 7158 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSCCapWaterFFlow(SpeedCal),
6162 : 0.0,
6163 : 0,
6164 : 0,
6165 : 0,
6166 : QLoadTotal1,
6167 : QLoadTotal2,
6168 7158 : state.dataVariableSpeedCoils->QLoadTotal,
6169 : SHR,
6170 7158 : state.dataVariableSpeedCoils->SourceSideInletTemp,
6171 7158 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).InletAirPressure,
6172 : 0.0,
6173 : 1,
6174 7158 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).capModFacTotal);
6175 :
6176 7158 : state.dataVariableSpeedCoils->Winput = state.dataVariableSpeedCoils->QLoadTotal * EIR;
6177 :
6178 14316 : if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).VSCoilType == HVAC::Coil_CoolingAirToAirVariableSpeed) {
6179 272 : QWasteHeat = 0.0;
6180 : } else {
6181 6886 : QWasteHeat =
6182 6886 : state.dataVariableSpeedCoils->Winput * state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSWasteHeatFrac(SpeedCal);
6183 6886 : QWasteHeat *= Curve::CurveValue(state,
6184 6886 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSWasteHeat(SpeedCal),
6185 6886 : state.dataVariableSpeedCoils->LoadSideInletWBTemp,
6186 6886 : state.dataVariableSpeedCoils->SourceSideInletTemp);
6187 : }
6188 : } else {
6189 3366 : AirMassFlowRatio =
6190 3366 : state.dataVariableSpeedCoils->LoadSideMassFlowRate / state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).DesignAirMassFlowRate;
6191 :
6192 3366 : if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).VSCoilType == HVAC::Coil_CoolingAirToAirVariableSpeed) {
6193 23 : WaterMassFlowRatio = 1.0;
6194 : } else {
6195 3343 : WaterMassFlowRatio = state.dataVariableSpeedCoils->SourceSideMassFlowRate /
6196 3343 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).DesignWaterMassFlowRate;
6197 : }
6198 :
6199 3366 : AoEff = state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSEffectiveAo(SpeedCal) * SpeedRatio +
6200 3366 : (1.0 - SpeedRatio) * state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSEffectiveAo(SpeedCal - 1);
6201 :
6202 3366 : CBFSpeed = std::exp(-AoEff / state.dataVariableSpeedCoils->LoadSideMassFlowRate);
6203 :
6204 3366 : if (CBFSpeed > 0.999) {
6205 0 : CBFSpeed = 0.999;
6206 : }
6207 :
6208 3366 : CalcTotCapSHR_VSWSHP(state,
6209 3366 : state.dataVariableSpeedCoils->LoadSideInletDBTemp,
6210 3366 : state.dataVariableSpeedCoils->LoadSideInletHumRat,
6211 3366 : state.dataVariableSpeedCoils->LoadSideInletEnth,
6212 3366 : state.dataVariableSpeedCoils->LoadSideInletWBTemp,
6213 : AirMassFlowRatio,
6214 : WaterMassFlowRatio,
6215 3366 : state.dataVariableSpeedCoils->LoadSideMassFlowRate,
6216 : CBFSpeed,
6217 3366 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedTotCap(SpeedCal - 1),
6218 3366 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSCCapFTemp(SpeedCal - 1),
6219 3366 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSCCapAirFFlow(SpeedCal - 1),
6220 3366 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSCCapWaterFFlow(SpeedCal - 1),
6221 3366 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedTotCap(SpeedCal),
6222 3366 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSCCapFTemp(SpeedCal),
6223 3366 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSCCapAirFFlow(SpeedCal),
6224 3366 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSCCapWaterFFlow(SpeedCal),
6225 : QLoadTotal1,
6226 : QLoadTotal2,
6227 3366 : state.dataVariableSpeedCoils->QLoadTotal,
6228 : SHR,
6229 3366 : state.dataVariableSpeedCoils->SourceSideInletTemp,
6230 3366 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).InletAirPressure,
6231 : SpeedRatio,
6232 : 2,
6233 3366 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).capModFacTotal);
6234 :
6235 3366 : SpeedCal = SpeedNum - 1;
6236 13464 : EIRTempModFac = Curve::CurveValue(state,
6237 3366 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSEIRFTemp(SpeedCal),
6238 3366 : state.dataVariableSpeedCoils->LoadSideInletWBTemp,
6239 3366 : state.dataVariableSpeedCoils->SourceSideInletTemp);
6240 : EIRAirFFModFac =
6241 3366 : Curve::CurveValue(state, state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSEIRAirFFlow(SpeedCal), AirMassFlowRatio);
6242 :
6243 3366 : if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).VSCoilType == HVAC::Coil_CoolingAirToAirVariableSpeed) {
6244 23 : EIRWaterFFModFac = 1.0;
6245 : } else {
6246 : EIRWaterFFModFac =
6247 3343 : Curve::CurveValue(state, state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSEIRWaterFFlow(SpeedCal), WaterMassFlowRatio);
6248 : }
6249 :
6250 3366 : EIR = (1.0 / state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedCOP(SpeedCal)) * EIRTempModFac * EIRAirFFModFac *
6251 : EIRWaterFFModFac;
6252 3366 : Winput1 = QLoadTotal1 * EIR;
6253 :
6254 3366 : if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).VSCoilType == HVAC::Coil_CoolingAirToAirVariableSpeed) {
6255 23 : QWasteHeat1 = 0.0;
6256 : } else {
6257 3343 : QWasteHeat1 = Winput1 * state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSWasteHeatFrac(SpeedCal);
6258 3343 : QWasteHeat1 *= Curve::CurveValue(state,
6259 3343 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSWasteHeat(SpeedCal),
6260 3343 : state.dataVariableSpeedCoils->LoadSideInletWBTemp,
6261 3343 : state.dataVariableSpeedCoils->SourceSideInletTemp);
6262 : }
6263 :
6264 3366 : SpeedCal = SpeedNum;
6265 13464 : EIRTempModFac = Curve::CurveValue(state,
6266 3366 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSEIRFTemp(SpeedCal),
6267 3366 : state.dataVariableSpeedCoils->LoadSideInletWBTemp,
6268 3366 : state.dataVariableSpeedCoils->SourceSideInletTemp);
6269 : EIRAirFFModFac =
6270 3366 : Curve::CurveValue(state, state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSEIRAirFFlow(SpeedCal), AirMassFlowRatio);
6271 :
6272 3366 : if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).VSCoilType == HVAC::Coil_CoolingAirToAirVariableSpeed) {
6273 23 : EIRWaterFFModFac = 1.0;
6274 : } else {
6275 : EIRWaterFFModFac =
6276 3343 : Curve::CurveValue(state, state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSEIRWaterFFlow(SpeedCal), WaterMassFlowRatio);
6277 : }
6278 :
6279 3366 : EIR = (1.0 / state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedCOP(SpeedCal)) * EIRTempModFac * EIRAirFFModFac *
6280 : EIRWaterFFModFac;
6281 3366 : Winput2 = QLoadTotal2 * EIR;
6282 :
6283 3366 : if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).VSCoilType == HVAC::Coil_CoolingAirToAirVariableSpeed) {
6284 23 : QWasteHeat2 = 0.0;
6285 : } else {
6286 3343 : QWasteHeat2 = Winput2 * state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSWasteHeatFrac(SpeedCal);
6287 3343 : QWasteHeat2 *= Curve::CurveValue(state,
6288 3343 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSWasteHeat(SpeedCal),
6289 3343 : state.dataVariableSpeedCoils->LoadSideInletWBTemp,
6290 3343 : state.dataVariableSpeedCoils->SourceSideInletTemp);
6291 : }
6292 :
6293 3366 : state.dataVariableSpeedCoils->Winput = Winput2 * SpeedRatio + (1.0 - SpeedRatio) * Winput1;
6294 3366 : QWasteHeat = QWasteHeat2 * SpeedRatio + (1.0 - SpeedRatio) * QWasteHeat1;
6295 : }
6296 :
6297 10524 : state.dataVariableSpeedCoils->QSensible = state.dataVariableSpeedCoils->QLoadTotal * SHR;
6298 :
6299 10524 : state.dataVariableSpeedCoils->QSource = state.dataVariableSpeedCoils->QLoadTotal + state.dataVariableSpeedCoils->Winput - QWasteHeat;
6300 :
6301 10524 : if (state.dataVariableSpeedCoils->QSource < 0) {
6302 0 : state.dataVariableSpeedCoils->QSource = 0.0;
6303 0 : QWasteHeat = state.dataVariableSpeedCoils->QLoadTotal + state.dataVariableSpeedCoils->Winput;
6304 : }
6305 :
6306 : // Check if the Sensible Load is greater than the Total Cooling Load
6307 10524 : if (state.dataVariableSpeedCoils->QSensible > state.dataVariableSpeedCoils->QLoadTotal) {
6308 0 : state.dataVariableSpeedCoils->QSensible = state.dataVariableSpeedCoils->QLoadTotal;
6309 : }
6310 :
6311 10524 : if (LatDegradModelSimFlag) {
6312 : // Calculate for SHReff using the Latent Degradation Model
6313 22 : if (NumIteration == 1) {
6314 11 : state.dataVariableSpeedCoils->QLatRated = state.dataVariableSpeedCoils->QLoadTotal - state.dataVariableSpeedCoils->QSensible;
6315 11 : } else if (NumIteration == 2) {
6316 11 : state.dataVariableSpeedCoils->QLatActual = state.dataVariableSpeedCoils->QLoadTotal - state.dataVariableSpeedCoils->QSensible;
6317 11 : SHRss = state.dataVariableSpeedCoils->QSensible / state.dataVariableSpeedCoils->QLoadTotal;
6318 66 : SHReff = CalcEffectiveSHR(state,
6319 : DXCoilNum,
6320 : SHRss,
6321 : fanOp,
6322 11 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).RunFrac,
6323 11 : state.dataVariableSpeedCoils->QLatRated,
6324 11 : state.dataVariableSpeedCoils->QLatActual,
6325 11 : state.dataVariableSpeedCoils->LoadSideInletDBTemp,
6326 11 : state.dataVariableSpeedCoils->LoadSideInletWBTemp);
6327 : // Update sensible capacity based on effective SHR
6328 11 : state.dataVariableSpeedCoils->QSensible = state.dataVariableSpeedCoils->QLoadTotal * SHReff;
6329 11 : goto LOOP_exit;
6330 : }
6331 : } else {
6332 : // Assume SHReff=SHRss
6333 10502 : SHReff = state.dataVariableSpeedCoils->QSensible / state.dataVariableSpeedCoils->QLoadTotal;
6334 10502 : goto LOOP_exit;
6335 : }
6336 : }
6337 10513 : LOOP_exit:;
6338 :
6339 : // considering hot gas reheat here
6340 10513 : if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).HOTGASREHEATFLG > 0) {
6341 0 : state.dataVariableSpeedCoils->QLoadTotal -= QWasteHeat;
6342 0 : state.dataVariableSpeedCoils->QSensible -= QWasteHeat;
6343 0 : SHReff = state.dataVariableSpeedCoils->QSensible / state.dataVariableSpeedCoils->QLoadTotal;
6344 : }
6345 :
6346 10513 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).BasinHeaterPower = 0.0;
6347 10513 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).CrankcaseHeaterPower = 0.0;
6348 :
6349 10513 : if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).VSCoilType == HVAC::Coil_CoolingAirToAirVariableSpeed) {
6350 284 : if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).CondenserType == DataHeatBalance::RefrigCondenserType::Evap) {
6351 : //******************
6352 : // WATER CONSUMPTION IN m3 OF WATER FOR DIRECT
6353 : // H2O [m3/s] = Delta W[kgWater/kgDryAir]*Mass Flow Air[kgDryAir/s]
6354 : // /RhoWater [kgWater/m3]
6355 : //******************
6356 0 : RhoEvapCondWater = Psychrometrics::RhoH2O(state.dataVariableSpeedCoils->OutdoorDryBulb_CalcVarSpeedCoilCooling);
6357 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).EvapWaterConsumpRate =
6358 0 : (CondInletHumRat - state.dataVariableSpeedCoils->OutdoorHumRat_CalcVarSpeedCoilCooling) * CondAirMassFlow / RhoEvapCondWater *
6359 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).RunFrac;
6360 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).EvapCondPumpElecPower =
6361 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).EvapCondPumpElecNomPower *
6362 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).RunFrac;
6363 : // Calculate basin heater power
6364 0 : CalcBasinHeaterPower(state,
6365 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).BasinHeaterPowerFTempDiff,
6366 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).basinHeaterSched,
6367 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).BasinHeaterSetPointTemp,
6368 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).BasinHeaterPower);
6369 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).BasinHeaterPower *=
6370 0 : (1.0 - state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).RunFrac);
6371 : }
6372 :
6373 284 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).CrankcaseHeaterPower =
6374 284 : state.dataVariableSpeedCoils->CrankcaseHeatingPower_CalcVarSpeedCoilCooling *
6375 284 : (1.0 - state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).RunFrac);
6376 :
6377 : // set water system demand request (if needed)
6378 284 : if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).EvapWaterSupplyMode == WaterSupplyFromTank) {
6379 0 : state.dataWaterData->WaterStorage(state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).EvapWaterSupTankID)
6380 0 : .VdotRequestDemand(state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).EvapWaterTankDemandARRID) =
6381 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).EvapWaterConsumpRate;
6382 : }
6383 : }
6384 :
6385 10513 : if ((PartLoadRatio > 0.0 && fanOp == HVAC::FanOp::Continuous) || (fanOp == HVAC::FanOp::Cycling)) {
6386 : // calculate coil outlet state variables
6387 21022 : state.dataVariableSpeedCoils->LoadSideOutletEnth =
6388 10511 : state.dataVariableSpeedCoils->LoadSideInletEnth -
6389 10511 : state.dataVariableSpeedCoils->QLoadTotal / state.dataVariableSpeedCoils->LoadSideMassFlowRate;
6390 21022 : state.dataVariableSpeedCoils->LoadSideOutletDBTemp =
6391 10511 : state.dataVariableSpeedCoils->LoadSideInletDBTemp -
6392 10511 : state.dataVariableSpeedCoils->QSensible / (state.dataVariableSpeedCoils->LoadSideMassFlowRate * CpAir);
6393 :
6394 10511 : MaxHumRat = Psychrometrics::PsyWFnTdbRhPb(state,
6395 10511 : state.dataVariableSpeedCoils->LoadSideOutletDBTemp,
6396 : 0.9999,
6397 10511 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).InletAirPressure,
6398 : RoutineName);
6399 10511 : MaxOutletEnth = Psychrometrics::PsyHFnTdbW(state.dataVariableSpeedCoils->LoadSideOutletDBTemp, MaxHumRat);
6400 10511 : if (state.dataVariableSpeedCoils->LoadSideOutletEnth > MaxOutletEnth) {
6401 142 : state.dataVariableSpeedCoils->LoadSideOutletEnth = MaxOutletEnth;
6402 : // QLoadTotal = LoadSideMassFlowRate * (LoadSideInletEnth - LoadSideOutletEnth)
6403 : }
6404 10511 : state.dataVariableSpeedCoils->LoadSideOutletHumRat = Psychrometrics::PsyWFnTdbH(
6405 10511 : state, state.dataVariableSpeedCoils->LoadSideOutletDBTemp, state.dataVariableSpeedCoils->LoadSideOutletEnth, RoutineName);
6406 10511 : if (state.dataVariableSpeedCoils->LoadSideOutletHumRat > MaxHumRat) {
6407 16 : state.dataVariableSpeedCoils->LoadSideOutletHumRat = MaxHumRat;
6408 : }
6409 : }
6410 :
6411 : // Actual outlet conditions are "average" for time step
6412 10513 : if (fanOp == HVAC::FanOp::Continuous) {
6413 : // continuous fan, cycling compressor
6414 83 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).OutletAirEnthalpy =
6415 83 : PartLoadRatio * state.dataVariableSpeedCoils->LoadSideOutletEnth +
6416 83 : (1.0 - PartLoadRatio) * state.dataVariableSpeedCoils->LoadSideInletEnth;
6417 83 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).OutletAirHumRat =
6418 83 : PartLoadRatio * state.dataVariableSpeedCoils->LoadSideOutletHumRat +
6419 83 : (1.0 - PartLoadRatio) * state.dataVariableSpeedCoils->LoadSideInletHumRat;
6420 83 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).OutletAirDBTemp =
6421 83 : Psychrometrics::PsyTdbFnHW(state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).OutletAirEnthalpy,
6422 83 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).OutletAirHumRat);
6423 83 : state.dataVariableSpeedCoils->PLRCorrLoadSideMdot = state.dataVariableSpeedCoils->LoadSideMassFlowRate;
6424 : } else {
6425 : // default to cycling fan, cycling compressor
6426 10430 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).OutletAirEnthalpy = state.dataVariableSpeedCoils->LoadSideOutletEnth;
6427 10430 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).OutletAirHumRat = state.dataVariableSpeedCoils->LoadSideOutletHumRat;
6428 10430 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).OutletAirDBTemp = state.dataVariableSpeedCoils->LoadSideOutletDBTemp;
6429 10430 : state.dataVariableSpeedCoils->PLRCorrLoadSideMdot = state.dataVariableSpeedCoils->LoadSideMassFlowRate * PartLoadRatio;
6430 : }
6431 :
6432 : // scale heat transfer rates to PLR and power to RTF
6433 10513 : state.dataVariableSpeedCoils->QLoadTotal *= PartLoadRatio;
6434 10513 : state.dataVariableSpeedCoils->QSensible *= PartLoadRatio;
6435 : // count the powr separately
6436 10513 : state.dataVariableSpeedCoils->Winput *= state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).RunFrac;
6437 10513 : state.dataVariableSpeedCoils->QSource *= PartLoadRatio;
6438 10513 : QWasteHeat *= PartLoadRatio;
6439 :
6440 : // Update heat pump data structure
6441 10513 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Power = state.dataVariableSpeedCoils->Winput;
6442 10513 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).QLoadTotal = state.dataVariableSpeedCoils->QLoadTotal;
6443 10513 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).QSensible = state.dataVariableSpeedCoils->QSensible;
6444 10513 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).QLatent =
6445 10513 : state.dataVariableSpeedCoils->QLoadTotal - state.dataVariableSpeedCoils->QSensible;
6446 10513 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Energy = state.dataVariableSpeedCoils->Winput * TimeStepSysSec;
6447 10513 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).EnergyLoadTotal = state.dataVariableSpeedCoils->QLoadTotal * TimeStepSysSec;
6448 10513 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).EnergySensible = state.dataVariableSpeedCoils->QSensible * TimeStepSysSec;
6449 10513 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).EnergyLatent =
6450 10513 : (state.dataVariableSpeedCoils->QLoadTotal - state.dataVariableSpeedCoils->QSensible) * TimeStepSysSec;
6451 10513 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).CrankcaseHeaterConsumption =
6452 10513 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).CrankcaseHeaterPower * TimeStepSysSec;
6453 10513 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).EvapWaterConsump =
6454 10513 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).EvapWaterConsumpRate * TimeStepSysSec;
6455 10513 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).BasinHeaterConsumption =
6456 10513 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).BasinHeaterPower * TimeStepSysSec;
6457 10513 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).EvapCondPumpElecConsumption =
6458 10513 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).EvapCondPumpElecPower * TimeStepSysSec;
6459 10513 : if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).RunFrac == 0.0) {
6460 2 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).COP = 0.0;
6461 : } else {
6462 10511 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).COP =
6463 10511 : state.dataVariableSpeedCoils->QLoadTotal / state.dataVariableSpeedCoils->Winput;
6464 : }
6465 10513 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).PartLoadRatio = PartLoadRatio;
6466 10513 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).AirMassFlowRate = state.dataVariableSpeedCoils->PLRCorrLoadSideMdot;
6467 10513 : rhoair = Psychrometrics::PsyRhoAirFnPbTdbW(state,
6468 10513 : state.dataEnvrn->OutBaroPress,
6469 10513 : state.dataVariableSpeedCoils->LoadSideInletDBTemp,
6470 10513 : state.dataVariableSpeedCoils->LoadSideInletHumRat,
6471 : RoutineName);
6472 : // This seems wrong, initializing mass flow rate to StdRhoAir or actual air density,
6473 : // then using that mass flow rate, then back calculating volume using inlet conditions.
6474 : // Volume should be constant through a fan and air mass flow rate should vary based on inlet conditions.
6475 10513 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).AirVolFlowRate =
6476 10513 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).AirMassFlowRate / rhoair;
6477 :
6478 10513 : if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).VSCoilType == HVAC::Coil_CoolingAirToAirVariableSpeed) {
6479 284 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).WaterMassFlowRate = 0.0;
6480 284 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).OutletWaterTemp = 0.0;
6481 284 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).OutletWaterEnthalpy = 0.0;
6482 284 : state.dataHeatBal->HeatReclaimVS_Coil(DXCoilNum).AvailCapacity = state.dataVariableSpeedCoils->QSource;
6483 284 : if (state.dataHeatBal->HeatReclaimVS_Coil(DXCoilNum).WaterHeatingDesuperheaterReclaimedHeatTotal > 0.0) {
6484 0 : state.dataVariableSpeedCoils->QSource -= state.dataHeatBal->HeatReclaimVS_Coil(DXCoilNum).WaterHeatingDesuperheaterReclaimedHeatTotal;
6485 : }
6486 : } else {
6487 10229 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).WaterMassFlowRate = state.dataVariableSpeedCoils->SourceSideMassFlowRate;
6488 10229 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).OutletWaterTemp =
6489 10229 : state.dataVariableSpeedCoils->SourceSideInletTemp +
6490 10229 : state.dataVariableSpeedCoils->QSource / (state.dataVariableSpeedCoils->SourceSideMassFlowRate * CpSource);
6491 10229 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).OutletWaterEnthalpy =
6492 10229 : state.dataVariableSpeedCoils->SourceSideInletEnth +
6493 10229 : state.dataVariableSpeedCoils->QSource / state.dataVariableSpeedCoils->SourceSideMassFlowRate;
6494 10229 : state.dataHeatBal->HeatReclaimVS_Coil(DXCoilNum).AvailCapacity = state.dataVariableSpeedCoils->QSource;
6495 10229 : if (state.dataHeatBal->HeatReclaimVS_Coil(DXCoilNum).WaterHeatingDesuperheaterReclaimedHeatTotal > 0.0) {
6496 1 : state.dataVariableSpeedCoils->QSource -= state.dataHeatBal->HeatReclaimVS_Coil(DXCoilNum).WaterHeatingDesuperheaterReclaimedHeatTotal;
6497 : }
6498 : }
6499 10513 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).QSource = state.dataVariableSpeedCoils->QSource;
6500 10513 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).EnergySource = state.dataVariableSpeedCoils->QSource * TimeStepSysSec;
6501 :
6502 10513 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).QWasteHeat = QWasteHeat;
6503 :
6504 10513 : if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).CondensateCollectMode == CondensateToTank) {
6505 : // calculate and report condensation rates (how much water extracted from the air stream)
6506 : // water flow of water in m3/s for water system interactions
6507 0 : RhoWater = Psychrometrics::RhoH2O((state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).InletAirDBTemp +
6508 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).OutletAirDBTemp) /
6509 : 2.0);
6510 : // CR9155 Remove specific humidity calculations
6511 0 : SpecHumIn = state.dataVariableSpeedCoils->LoadSideInletHumRat;
6512 0 : SpecHumOut = state.dataVariableSpeedCoils->LoadSideOutletHumRat;
6513 : // mdot * del HumRat / rho water
6514 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).CondensateVdot =
6515 0 : max(0.0, (state.dataVariableSpeedCoils->LoadSideMassFlowRate * (SpecHumIn - SpecHumOut) / RhoWater));
6516 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).CondensateVol =
6517 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).CondensateVdot * TimeStepSysSec;
6518 : }
6519 : }
6520 :
6521 0 : void CalcVarSpeedHPWH(EnergyPlusData &state,
6522 : int const DXCoilNum, // the number of the DX coil to be simulated
6523 : Real64 const PartLoadRatio, // sensible water heating load / full load sensible water heating capacity
6524 : Real64 const SpeedRatio, // SpeedRatio varies between 1.0 (higher speed) and 0.0 (lower speed)
6525 : int const SpeedNum, // Speed number, high bound
6526 : HVAC::FanOp const fanOp // Continuous fan OR cycling compressor
6527 : )
6528 : {
6529 :
6530 : // SUBROUTINE INFORMATION:
6531 : // AUTHOR Bo Shen, ORNL
6532 : // DATE WRITTEN 12/2014
6533 :
6534 : // PURPOSE OF THIS SUBROUTINE:
6535 : // Calculates the gross cooling capacity of a variable-speed heat pump water heater evaporator and
6536 : // heating capacity of the condenser coil given the rated heating capacity and COP.
6537 :
6538 : // METHODOLOGY EMPLOYED:
6539 : // The routine requires the user to enter the total heating capacity and COP for the
6540 : // heat pump water heater along with logicals defining if fan and condenser pump are included at numerous speed levels.
6541 : // Since manufacturer's can rate their HPWH equipment with or without including condenser
6542 : // pump heat, this information is required to accurately determine the condenser's leaving
6543 : // water temperature. In addition, knowledge of the fan heat is required to back into
6544 : // a compressor COP.
6545 :
6546 : // SUBROUTINE PARAMETER DEFINITIONS:
6547 : static constexpr std::string_view RoutineName("CalcVarSpeedHPWH");
6548 0 : Real64 TimeStepSysSec = state.dataHVACGlobal->TimeStepSysSec;
6549 :
6550 : // SUBROUTINE LOCAL VARIABLE DECLARATIONS:
6551 : Real64 OperatingHeatingCapacity; // Water heating operating capacity including the impact of capacity and COP curves (W)
6552 : Real64 OperatingHeatingCOP; // Water heating operating COP including the impact of capacity and COP curves (W/W)
6553 : Real64 OperatingHeatingPower; // Water heating operating Power (W)
6554 : Real64 CompressorPower; // Power consumed by compressor only (W)
6555 :
6556 : Real64 TotalTankHeatingCapacity; // Water heating capacity corrected for condenser water pump heat (W)
6557 : Real64 TankHeatingCOP; // Water heating COP corrected for fan and condenser water pump power (W/W)
6558 : // (these previous 2 variables also include the impact of capacity and COP curves)
6559 : Real64 EvapCoolingCapacity; // Air cooling capacity corrected for evap fan and cond water pump heat (W)
6560 : Real64 InletWaterTemp; // Condenser water inlet temperature (C)
6561 : Real64 OutletWaterTemp; // Condenser water outlet temperature (C)
6562 : Real64 EvapInletMassFlowRate; // Evaporator air inlet mass flow rate (m3/s)
6563 : Real64 CondInletMassFlowRate; // Condenser water inlet mass flow rate (m3/s)
6564 : Real64 CpWater; // Specific heat of condenser inlet water (J/Kg/k)
6565 : Real64 InletAirTemp; // HPWH inlet air temperature (dry-bulb or wet-bulb) (C)
6566 : Real64 AirMassFlowRatio; // Ratio of evaporator inlet air mass flow rate to rated mass flow rate
6567 : Real64 WaterMassFlowRatio; // Ratio of evaporator inlet water mass flow rate to rated mass flow rate
6568 : Real64 PumpHeatToWater; // Amount of pump heat attributed to heating water
6569 : Real64 PLF; // part-load function
6570 : Real64 CBFSpeed; // bypass factor as individual speed level
6571 : Real64 COPAirFFModFac; // air flow fraction modification
6572 : Real64 COPWaterFFModFac; // water flow fraction modification
6573 : Real64 COPTempModFac; // total capacity temperature correctio fraction
6574 : Real64 TOTCAPAirFFModFac; // air flow fraction modification
6575 : Real64 TOTCAPWaterFFModFac; // water flow fraction modification
6576 : Real64 TOTCAPTempModFac; // total capacity temperature correctio fraction
6577 : Real64 SHR; // total capacity temperature correctio fraction
6578 : Real64 COP; // total capacity temperature correctio fraction
6579 : Real64 AoEff; // effective air side surface area
6580 : Real64 Winput1; // power consumption at low speed
6581 : Real64 Winput2; // power consumption at high speed
6582 : Real64 LoadPressure; // evaporator inlet pressure
6583 : Real64 hDelta; // Change in air enthalpy across the cooling coil [J/kg]
6584 : Real64 hADP; // Apparatus dew point enthalpy [J/kg]
6585 : Real64 tADP; // Apparatus dew point temperature [C]
6586 : Real64 wADP; // Apparatus dew point humidity ratio [kg/kg]
6587 : Real64 hTinwADP; // Enthalpy at inlet dry-bulb and wADP [J/kg]
6588 : Real64 WHCAP1; // total heating capacity at low speed [W]
6589 : Real64 WHCAP2; // total heating capacity at high speed [W]
6590 : Real64 CpAir; // Specific heat of air [J/kg_C]
6591 : Real64 MaxHumRat; // max possible humidity
6592 : Real64 MaxOutletEnth; // max possible outlet enthalpy
6593 : int EvapInletNode; // Evaporator air inlet node number
6594 : int SpeedCal; // calculated speed level
6595 0 : Real64 rhoair = 0.0; // entering air density
6596 0 : Real64 RhoWater = 0.0; // water density
6597 :
6598 : // note: load side is the evaporator side, and source side is the condenser side
6599 :
6600 0 : int CondInletNode = state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).WaterInletNodeNum;
6601 0 : int CondOutletNode = state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).WaterOutletNodeNum;
6602 : // If heat pump water heater is OFF, set outlet to inlet and RETURN
6603 0 : if (PartLoadRatio == 0.0) {
6604 0 : state.dataLoopNodes->Node(CondOutletNode) = state.dataLoopNodes->Node(CondInletNode);
6605 0 : return;
6606 : } else {
6607 0 : EvapInletNode = state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).AirInletNodeNum;
6608 0 : InletWaterTemp = state.dataLoopNodes->Node(CondInletNode).Temp;
6609 0 : CondInletMassFlowRate = state.dataLoopNodes->Node(CondInletNode).MassFlowRate;
6610 0 : EvapInletMassFlowRate = state.dataLoopNodes->Node(EvapInletNode).MassFlowRate;
6611 0 : CpWater = Psychrometrics::CPHW(InletWaterTemp);
6612 0 : CompressorPower = 0.0;
6613 0 : OperatingHeatingPower = 0.0;
6614 0 : TankHeatingCOP = 0.0;
6615 : }
6616 :
6617 : // LOAD LOCAL VARIABLES FROM DATA STRUCTURE (for code readability)
6618 0 : if (!(fanOp == HVAC::FanOp::Continuous) && PartLoadRatio > 0.0) {
6619 0 : CondInletMassFlowRate = CondInletMassFlowRate / PartLoadRatio;
6620 0 : EvapInletMassFlowRate = EvapInletMassFlowRate / PartLoadRatio;
6621 : }
6622 :
6623 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).AirMassFlowRate = EvapInletMassFlowRate;
6624 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).WaterMassFlowRate = CondInletMassFlowRate;
6625 :
6626 : // determine inlet air temperature type for curve objects
6627 0 : if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).InletAirTemperatureType == HVAC::OATType::WetBulb) {
6628 0 : InletAirTemp = state.dataHVACGlobal->HPWHInletWBTemp;
6629 : } else {
6630 0 : InletAirTemp = state.dataHVACGlobal->HPWHInletDBTemp;
6631 : }
6632 :
6633 : // check if indoor evaporator or outdoor evaporator
6634 0 : Real64 CrankcaseHeatingPower = 0.0;
6635 0 : if (EvapInletNode != 0) {
6636 0 : state.dataVariableSpeedCoils->LoadSideInletDBTemp = state.dataLoopNodes->Node(EvapInletNode).Temp;
6637 0 : state.dataVariableSpeedCoils->LoadSideInletHumRat = state.dataLoopNodes->Node(EvapInletNode).HumRat;
6638 0 : LoadPressure = state.dataLoopNodes->Node(EvapInletNode).Press;
6639 : // prevent the air pressure not given
6640 0 : if (LoadPressure < 10.0) {
6641 0 : LoadPressure = state.dataEnvrn->OutBaroPress;
6642 : }
6643 :
6644 0 : state.dataVariableSpeedCoils->LoadSideInletWBTemp = state.dataLoopNodes->Node(EvapInletNode).OutAirWetBulb;
6645 0 : state.dataVariableSpeedCoils->LoadSideInletEnth = state.dataLoopNodes->Node(EvapInletNode).Enthalpy;
6646 : } else {
6647 0 : state.dataVariableSpeedCoils->LoadSideInletDBTemp = state.dataEnvrn->OutDryBulbTemp;
6648 0 : state.dataVariableSpeedCoils->LoadSideInletHumRat = state.dataEnvrn->OutHumRat;
6649 0 : LoadPressure = state.dataEnvrn->OutBaroPress;
6650 0 : state.dataVariableSpeedCoils->LoadSideInletWBTemp = state.dataEnvrn->OutWetBulbTemp;
6651 0 : state.dataVariableSpeedCoils->LoadSideInletEnth = state.dataEnvrn->OutEnthalpy;
6652 :
6653 : // Initialize crankcase heater, operates below OAT defined in input deck for HP DX heating coil
6654 0 : if (state.dataEnvrn->OutDryBulbTemp < state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MaxOATCrankcaseHeater) {
6655 0 : CrankcaseHeatingPower = state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).CrankcaseHeaterCapacity;
6656 0 : if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).CrankcaseHeaterCapacityCurveIndex > 0) {
6657 0 : CrankcaseHeatingPower *=
6658 0 : Curve::CurveValue(state,
6659 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).CrankcaseHeaterCapacityCurveIndex,
6660 0 : state.dataEnvrn->OutDryBulbTemp);
6661 : }
6662 : };
6663 : }
6664 :
6665 0 : state.dataVariableSpeedCoils->LoadSideMassFlowRate = EvapInletMassFlowRate;
6666 0 : state.dataVariableSpeedCoils->SourceSideMassFlowRate = CondInletMassFlowRate;
6667 0 : state.dataVariableSpeedCoils->SourceSideInletTemp = InletWaterTemp;
6668 0 : state.dataVariableSpeedCoils->SourceSideInletEnth = state.dataLoopNodes->Node(CondInletNode).Enthalpy;
6669 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).InletWaterEnthalpy = state.dataVariableSpeedCoils->SourceSideInletEnth;
6670 :
6671 : // Check for flows, do not perform simulation if no flow in load side or source side.
6672 0 : if ((state.dataVariableSpeedCoils->SourceSideMassFlowRate <= 0.0) || (state.dataVariableSpeedCoils->LoadSideMassFlowRate <= 0.0)) {
6673 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).SimFlag = false;
6674 0 : return;
6675 : } else {
6676 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).SimFlag = true;
6677 : }
6678 :
6679 : // part-load calculation
6680 0 : state.dataHVACGlobal->OnOffFanPartLoadFraction = 1.0;
6681 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).RunFrac = 1.0;
6682 0 : if ((SpeedNum == 1) && (PartLoadRatio < 1.0)) {
6683 0 : PLF = Curve::CurveValue(state, state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).PLFFPLR, PartLoadRatio);
6684 0 : if (PLF < 0.7) {
6685 0 : PLF = 0.7;
6686 : }
6687 0 : if (fanOp == HVAC::FanOp::Cycling) {
6688 0 : state.dataHVACGlobal->OnOffFanPartLoadFraction =
6689 : PLF; // save PLF for fan model, don't change fan power for constant fan mode if coil is off
6690 : }
6691 : // calculate the run time fraction
6692 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).RunFrac = PartLoadRatio / PLF;
6693 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).PartLoadRatio = PartLoadRatio;
6694 :
6695 0 : if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).RunFrac > 1.0) {
6696 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).RunFrac = 1.0; // Reset coil runtime fraction to 1.0
6697 0 : } else if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).RunFrac < 0.0) {
6698 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).RunFrac = 0.0;
6699 : }
6700 : }
6701 :
6702 0 : int MaxSpeed = state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).NumOfSpeeds;
6703 :
6704 : // interpolate between speeds
6705 : // must be placed inside the loop, otherwise cause bug in release mode
6706 0 : if (SpeedNum > MaxSpeed) {
6707 0 : SpeedCal = MaxSpeed;
6708 : } else {
6709 0 : SpeedCal = SpeedNum;
6710 : }
6711 :
6712 0 : Real64 locFanElecPower = 0.0; // local for fan electric power
6713 0 : if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).SupplyFanIndex > 0) {
6714 0 : locFanElecPower = state.dataFans->fans(state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).SupplyFanIndex)->totalPower;
6715 : }
6716 0 : if ((SpeedNum == 1) || (SpeedNum > MaxSpeed) || (SpeedRatio == 1.0)) {
6717 0 : AirMassFlowRatio =
6718 0 : state.dataVariableSpeedCoils->LoadSideMassFlowRate / state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).DesignAirMassFlowRate;
6719 0 : WaterMassFlowRatio =
6720 0 : state.dataVariableSpeedCoils->SourceSideMassFlowRate / state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).DesignWaterMassFlowRate;
6721 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).HPWHCondPumpElecNomPower =
6722 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSWHPumpPower(SpeedCal);
6723 :
6724 0 : COPTempModFac = Curve::CurveValue(state,
6725 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSEIRFTemp(SpeedCal),
6726 : InletAirTemp,
6727 0 : state.dataVariableSpeedCoils->SourceSideInletTemp);
6728 : COPAirFFModFac =
6729 0 : Curve::CurveValue(state, state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSEIRAirFFlow(SpeedCal), AirMassFlowRatio);
6730 : COPWaterFFModFac =
6731 0 : Curve::CurveValue(state, state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSEIRWaterFFlow(SpeedCal), WaterMassFlowRatio);
6732 :
6733 0 : COP = state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedCOP(SpeedCal) * COPTempModFac * COPAirFFModFac * COPWaterFFModFac;
6734 :
6735 0 : TOTCAPTempModFac = Curve::CurveValue(state,
6736 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSCCapFTemp(SpeedCal),
6737 : InletAirTemp,
6738 0 : state.dataVariableSpeedCoils->SourceSideInletTemp);
6739 : // Get capacity modifying factor (function of mass flow) for off-rated conditions
6740 : TOTCAPAirFFModFac =
6741 0 : Curve::CurveValue(state, state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSCCapAirFFlow(SpeedCal), AirMassFlowRatio);
6742 : // Get capacity modifying factor (function of mass flow) for off-rated conditions
6743 : TOTCAPWaterFFModFac =
6744 0 : Curve::CurveValue(state, state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSCCapWaterFFlow(SpeedCal), WaterMassFlowRatio);
6745 :
6746 0 : OperatingHeatingCapacity = state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedTotCap(SpeedCal) * TOTCAPTempModFac *
6747 : TOTCAPAirFFModFac * TOTCAPWaterFFModFac;
6748 :
6749 0 : state.dataVariableSpeedCoils->Winput = OperatingHeatingCapacity / COP;
6750 0 : OperatingHeatingPower = state.dataVariableSpeedCoils->Winput;
6751 :
6752 0 : OperatingHeatingCOP = COP;
6753 0 : PumpHeatToWater = state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).HPWHCondPumpElecNomPower *
6754 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).HPWHCondPumpFracToWater;
6755 0 : TankHeatingCOP = OperatingHeatingCOP;
6756 :
6757 : // account for pump heat if not included in total water heating capacity
6758 0 : if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).CondPumpHeatInCapacity) {
6759 0 : TotalTankHeatingCapacity = OperatingHeatingCapacity;
6760 : } else {
6761 0 : TotalTankHeatingCapacity = OperatingHeatingCapacity + PumpHeatToWater;
6762 : }
6763 :
6764 : // calculate evaporator total cooling capacity
6765 0 : if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).FanPowerIncludedInCOP) {
6766 0 : if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).CondPumpPowerInCOP) {
6767 : // make sure fan power is full load fan power, it isn't though,
6768 0 : CompressorPower = OperatingHeatingPower - locFanElecPower / state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).RunFrac -
6769 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).HPWHCondPumpElecNomPower;
6770 0 : if (OperatingHeatingPower > 0.0) {
6771 0 : TankHeatingCOP = TotalTankHeatingCapacity / OperatingHeatingPower;
6772 : }
6773 : } else {
6774 0 : CompressorPower = OperatingHeatingPower - locFanElecPower / state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).RunFrac;
6775 0 : if ((OperatingHeatingPower + state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).HPWHCondPumpElecNomPower) > 0.0) {
6776 0 : TankHeatingCOP = TotalTankHeatingCapacity /
6777 0 : (OperatingHeatingPower + state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).HPWHCondPumpElecNomPower);
6778 : }
6779 : }
6780 : } else {
6781 0 : if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).CondPumpPowerInCOP) {
6782 : // make sure fan power is full load fan power
6783 0 : CompressorPower = OperatingHeatingPower - state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).HPWHCondPumpElecNomPower;
6784 0 : if ((OperatingHeatingPower + locFanElecPower / state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).RunFrac) > 0.0) {
6785 0 : TankHeatingCOP = TotalTankHeatingCapacity /
6786 0 : (OperatingHeatingPower + locFanElecPower / state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).RunFrac);
6787 : }
6788 : } else {
6789 0 : CompressorPower = OperatingHeatingPower;
6790 0 : if ((OperatingHeatingPower + locFanElecPower / state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).RunFrac +
6791 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).HPWHCondPumpElecNomPower) > 0.0) {
6792 0 : TankHeatingCOP = TotalTankHeatingCapacity /
6793 0 : (OperatingHeatingPower + locFanElecPower / state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).RunFrac +
6794 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).HPWHCondPumpElecNomPower);
6795 : }
6796 : }
6797 : }
6798 :
6799 0 : if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).CondPumpHeatInCapacity) {
6800 0 : EvapCoolingCapacity = TotalTankHeatingCapacity - PumpHeatToWater - CompressorPower;
6801 : } else {
6802 0 : EvapCoolingCapacity = TotalTankHeatingCapacity - CompressorPower;
6803 : }
6804 :
6805 0 : CBFSpeed = DXCoils::AdjustCBF(state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedCBF(SpeedCal),
6806 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedAirMassFlowRate(SpeedCal),
6807 0 : state.dataVariableSpeedCoils->LoadSideMassFlowRate);
6808 :
6809 : } else {
6810 0 : AirMassFlowRatio =
6811 0 : state.dataVariableSpeedCoils->LoadSideMassFlowRate / state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).DesignAirMassFlowRate;
6812 0 : WaterMassFlowRatio =
6813 0 : state.dataVariableSpeedCoils->SourceSideMassFlowRate / state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).DesignWaterMassFlowRate;
6814 0 : AoEff = state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSEffectiveAo(SpeedCal) * SpeedRatio +
6815 0 : (1.0 - SpeedRatio) * state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSEffectiveAo(SpeedCal - 1);
6816 0 : CBFSpeed = std::exp(-AoEff / state.dataVariableSpeedCoils->LoadSideMassFlowRate);
6817 :
6818 : // calculate low speed
6819 0 : SpeedCal = SpeedNum - 1;
6820 :
6821 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).HPWHCondPumpElecNomPower =
6822 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSWHPumpPower(SpeedCal);
6823 0 : COPTempModFac = Curve::CurveValue(state,
6824 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSEIRFTemp(SpeedCal),
6825 : InletAirTemp,
6826 0 : state.dataVariableSpeedCoils->SourceSideInletTemp);
6827 : COPAirFFModFac =
6828 0 : Curve::CurveValue(state, state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSEIRAirFFlow(SpeedCal), AirMassFlowRatio);
6829 : COPWaterFFModFac =
6830 0 : Curve::CurveValue(state, state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSEIRWaterFFlow(SpeedCal), WaterMassFlowRatio);
6831 :
6832 0 : COP = state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedCOP(SpeedCal) * COPTempModFac * COPAirFFModFac * COPWaterFFModFac;
6833 :
6834 0 : TOTCAPTempModFac = Curve::CurveValue(state,
6835 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSCCapFTemp(SpeedCal),
6836 : InletAirTemp,
6837 0 : state.dataVariableSpeedCoils->SourceSideInletTemp);
6838 : // Get capacity modifying factor (function of mass flow) for off-rated conditions
6839 : TOTCAPAirFFModFac =
6840 0 : Curve::CurveValue(state, state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSCCapAirFFlow(SpeedCal), AirMassFlowRatio);
6841 : // Get capacity modifying factor (function of mass flow) for off-rated conditions
6842 : TOTCAPWaterFFModFac =
6843 0 : Curve::CurveValue(state, state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSCCapWaterFFlow(SpeedCal), WaterMassFlowRatio);
6844 :
6845 0 : OperatingHeatingCapacity = state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedTotCap(SpeedCal) * TOTCAPTempModFac *
6846 : TOTCAPAirFFModFac * TOTCAPWaterFFModFac;
6847 :
6848 0 : state.dataVariableSpeedCoils->Winput = OperatingHeatingCapacity / COP;
6849 0 : Winput1 = state.dataVariableSpeedCoils->Winput;
6850 0 : WHCAP1 = OperatingHeatingCapacity;
6851 :
6852 : // calculate upper speed
6853 0 : SpeedCal = SpeedNum;
6854 :
6855 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).HPWHCondPumpElecNomPower =
6856 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSWHPumpPower(SpeedCal);
6857 0 : COPTempModFac = Curve::CurveValue(state,
6858 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSEIRFTemp(SpeedCal),
6859 : InletAirTemp,
6860 0 : state.dataVariableSpeedCoils->SourceSideInletTemp);
6861 : COPAirFFModFac =
6862 0 : Curve::CurveValue(state, state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSEIRAirFFlow(SpeedCal), AirMassFlowRatio);
6863 : COPWaterFFModFac =
6864 0 : Curve::CurveValue(state, state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSEIRWaterFFlow(SpeedCal), WaterMassFlowRatio);
6865 :
6866 0 : COP = state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedCOP(SpeedCal) * COPTempModFac * COPAirFFModFac * COPWaterFFModFac;
6867 :
6868 0 : TOTCAPTempModFac = Curve::CurveValue(state,
6869 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSCCapFTemp(SpeedCal),
6870 : InletAirTemp,
6871 0 : state.dataVariableSpeedCoils->SourceSideInletTemp);
6872 : // Get capacity modifying factor (function of mass flow) for off-rated conditions
6873 : TOTCAPAirFFModFac =
6874 0 : Curve::CurveValue(state, state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSCCapAirFFlow(SpeedCal), AirMassFlowRatio);
6875 : // Get capacity modifying factor (function of mass flow) for off-rated conditions
6876 : TOTCAPWaterFFModFac =
6877 0 : Curve::CurveValue(state, state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSCCapWaterFFlow(SpeedCal), WaterMassFlowRatio);
6878 :
6879 0 : OperatingHeatingCapacity = state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedTotCap(SpeedCal) * TOTCAPTempModFac *
6880 : TOTCAPAirFFModFac * TOTCAPWaterFFModFac;
6881 :
6882 0 : Winput2 = OperatingHeatingCapacity / COP;
6883 0 : WHCAP2 = OperatingHeatingCapacity;
6884 :
6885 : // interpolation
6886 0 : state.dataVariableSpeedCoils->Winput = Winput2 * SpeedRatio + (1.0 - SpeedRatio) * Winput1;
6887 0 : OperatingHeatingPower = state.dataVariableSpeedCoils->Winput;
6888 0 : OperatingHeatingCapacity = WHCAP2 * SpeedRatio + (1.0 - SpeedRatio) * WHCAP1;
6889 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).HPWHCondPumpElecNomPower =
6890 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSWHPumpPower(SpeedNum) * SpeedRatio +
6891 0 : (1.0 - SpeedRatio) * state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSWHPumpPower(SpeedNum - 1);
6892 :
6893 0 : OperatingHeatingCOP = OperatingHeatingCapacity / OperatingHeatingPower;
6894 0 : TankHeatingCOP = OperatingHeatingCOP;
6895 :
6896 0 : PumpHeatToWater = state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).HPWHCondPumpElecNomPower *
6897 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).HPWHCondPumpFracToWater;
6898 :
6899 : // account for pump heat if not included in total water heating capacity
6900 0 : if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).CondPumpHeatInCapacity) {
6901 0 : TotalTankHeatingCapacity = OperatingHeatingCapacity;
6902 : } else {
6903 0 : TotalTankHeatingCapacity = OperatingHeatingCapacity + PumpHeatToWater;
6904 : }
6905 :
6906 0 : Real64 HPRTF = state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).RunFrac;
6907 : // calculate evaporator total cooling capacity
6908 0 : if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).FanPowerIncludedInCOP) {
6909 0 : if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).CondPumpPowerInCOP) {
6910 : // make sure fan power is full load fan power
6911 0 : CompressorPower = OperatingHeatingPower - locFanElecPower / HPRTF -
6912 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).HPWHCondPumpElecNomPower;
6913 0 : if (OperatingHeatingPower > 0.0) {
6914 0 : TankHeatingCOP = TotalTankHeatingCapacity / OperatingHeatingPower;
6915 : }
6916 : } else {
6917 0 : CompressorPower = OperatingHeatingPower - locFanElecPower / HPRTF;
6918 0 : if ((OperatingHeatingPower + state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).HPWHCondPumpElecNomPower) > 0.0) {
6919 0 : TankHeatingCOP = TotalTankHeatingCapacity /
6920 0 : (OperatingHeatingPower + state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).HPWHCondPumpElecNomPower);
6921 : }
6922 : }
6923 : } else {
6924 0 : if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).CondPumpPowerInCOP) {
6925 : // make sure fan power is full load fan power
6926 0 : CompressorPower = OperatingHeatingPower - state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).HPWHCondPumpElecNomPower;
6927 0 : if ((OperatingHeatingPower + locFanElecPower / HPRTF) > 0.0) {
6928 0 : TankHeatingCOP = TotalTankHeatingCapacity / (OperatingHeatingPower + locFanElecPower / HPRTF);
6929 : }
6930 : } else {
6931 0 : CompressorPower = OperatingHeatingPower;
6932 0 : if ((OperatingHeatingPower + locFanElecPower / HPRTF +
6933 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).HPWHCondPumpElecNomPower) > 0.0) {
6934 0 : TankHeatingCOP = TotalTankHeatingCapacity / (OperatingHeatingPower + locFanElecPower / HPRTF +
6935 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).HPWHCondPumpElecNomPower);
6936 : }
6937 : }
6938 : }
6939 :
6940 0 : if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).CondPumpHeatInCapacity) {
6941 0 : EvapCoolingCapacity = TotalTankHeatingCapacity - PumpHeatToWater - CompressorPower;
6942 : } else {
6943 0 : EvapCoolingCapacity = TotalTankHeatingCapacity - CompressorPower;
6944 : }
6945 : }
6946 :
6947 0 : state.dataVariableSpeedCoils->QSource = TotalTankHeatingCapacity;
6948 0 : state.dataVariableSpeedCoils->QLoadTotal = EvapCoolingCapacity;
6949 0 : state.dataHVACGlobal->DXCoilTotalCapacity = EvapCoolingCapacity; // for standard rating calculation
6950 0 : SHR = 1.0;
6951 : // if indoor, calculate SHR
6952 0 : if (EvapInletNode != 0) {
6953 0 : if (CBFSpeed > 0.999) {
6954 0 : CBFSpeed = 0.999;
6955 : }
6956 :
6957 0 : if (CBFSpeed < 0.001) {
6958 0 : SHR = 1.0;
6959 : } else {
6960 0 : hDelta = state.dataVariableSpeedCoils->QLoadTotal / state.dataVariableSpeedCoils->LoadSideMassFlowRate;
6961 0 : hADP = state.dataVariableSpeedCoils->LoadSideInletEnth - hDelta / (1.0 - CBFSpeed);
6962 0 : tADP = Psychrometrics::PsyTsatFnHPb(state, hADP, LoadPressure, RoutineName);
6963 0 : wADP = Psychrometrics::PsyWFnTdbH(state, tADP, hADP, RoutineName);
6964 0 : hTinwADP = Psychrometrics::PsyHFnTdbW(state.dataVariableSpeedCoils->LoadSideInletDBTemp, wADP);
6965 0 : if ((state.dataVariableSpeedCoils->LoadSideInletEnth - hADP) > 1.e-10) {
6966 0 : SHR = min((hTinwADP - hADP) / (state.dataVariableSpeedCoils->LoadSideInletEnth - hADP), 1.0);
6967 : } else {
6968 0 : SHR = 1.0;
6969 : }
6970 : }
6971 : }
6972 :
6973 0 : state.dataVariableSpeedCoils->QSensible = state.dataVariableSpeedCoils->QLoadTotal * SHR;
6974 :
6975 : // determine condenser water inlet/outlet condition at full capacity
6976 0 : if (CondInletMassFlowRate == 0.0) {
6977 0 : OutletWaterTemp = InletWaterTemp;
6978 : } else {
6979 0 : OutletWaterTemp = InletWaterTemp + TotalTankHeatingCapacity / (CpWater * CondInletMassFlowRate);
6980 : }
6981 :
6982 0 : state.dataLoopNodes->Node(CondOutletNode).Temp = OutletWaterTemp;
6983 :
6984 0 : state.dataLoopNodes->Node(CondOutletNode).MassFlowRate = state.dataLoopNodes->Node(CondInletNode).MassFlowRate;
6985 :
6986 : // send heating capacity and COP to water heater module for standards rating calculation
6987 : // total heating capacity including condenser pump
6988 0 : state.dataVariableSpeedCoils->VSHPWHHeatingCapacity = TotalTankHeatingCapacity;
6989 : // total heating COP including compressor, fan, and condenser pump
6990 0 : state.dataVariableSpeedCoils->VSHPWHHeatingCOP = TankHeatingCOP;
6991 :
6992 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).TotalHeatingEnergyRate = TotalTankHeatingCapacity * PartLoadRatio;
6993 : // calculate total compressor plus condenser pump power, fan power reported in fan module
6994 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).ElecWaterHeatingPower =
6995 0 : (CompressorPower + state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).HPWHCondPumpElecNomPower) *
6996 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).RunFrac;
6997 :
6998 : // pass the outputs for the cooling coil section
6999 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).BasinHeaterPower = 0.0;
7000 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).CrankcaseHeaterPower =
7001 0 : CrankcaseHeatingPower * (1.0 - state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).RunFrac);
7002 :
7003 : // calculate coil outlet state variables
7004 0 : state.dataVariableSpeedCoils->LoadSideOutletEnth =
7005 0 : state.dataVariableSpeedCoils->LoadSideInletEnth -
7006 0 : state.dataVariableSpeedCoils->QLoadTotal / state.dataVariableSpeedCoils->LoadSideMassFlowRate;
7007 0 : CpAir = Psychrometrics::PsyCpAirFnW(state.dataVariableSpeedCoils->LoadSideInletHumRat);
7008 0 : state.dataVariableSpeedCoils->LoadSideOutletDBTemp =
7009 0 : state.dataVariableSpeedCoils->LoadSideInletDBTemp -
7010 0 : state.dataVariableSpeedCoils->QSensible / (state.dataVariableSpeedCoils->LoadSideMassFlowRate * CpAir);
7011 :
7012 0 : MaxHumRat = Psychrometrics::PsyWFnTdbRhPb(state,
7013 0 : state.dataVariableSpeedCoils->LoadSideOutletDBTemp,
7014 : 0.9999,
7015 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).InletAirPressure,
7016 : RoutineName);
7017 0 : MaxOutletEnth = Psychrometrics::PsyHFnTdbW(state.dataVariableSpeedCoils->LoadSideOutletDBTemp, MaxHumRat);
7018 0 : if (state.dataVariableSpeedCoils->LoadSideOutletEnth > MaxOutletEnth) {
7019 0 : state.dataVariableSpeedCoils->LoadSideOutletEnth = MaxOutletEnth;
7020 : }
7021 0 : state.dataVariableSpeedCoils->LoadSideOutletHumRat = Psychrometrics::PsyWFnTdbH(
7022 0 : state, state.dataVariableSpeedCoils->LoadSideOutletDBTemp, state.dataVariableSpeedCoils->LoadSideOutletEnth, RoutineName);
7023 0 : if (state.dataVariableSpeedCoils->LoadSideOutletHumRat > MaxHumRat) {
7024 0 : state.dataVariableSpeedCoils->LoadSideOutletHumRat = MaxHumRat;
7025 : }
7026 :
7027 : // Actual outlet conditions are "average" for time step
7028 0 : if (fanOp == HVAC::FanOp::Continuous) {
7029 : // continuous fan, cycling compressor
7030 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).OutletAirEnthalpy =
7031 0 : PartLoadRatio * state.dataVariableSpeedCoils->LoadSideOutletEnth +
7032 0 : (1.0 - PartLoadRatio) * state.dataVariableSpeedCoils->LoadSideInletEnth;
7033 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).OutletAirHumRat =
7034 0 : PartLoadRatio * state.dataVariableSpeedCoils->LoadSideOutletHumRat +
7035 0 : (1.0 - PartLoadRatio) * state.dataVariableSpeedCoils->LoadSideInletHumRat;
7036 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).OutletAirDBTemp =
7037 0 : Psychrometrics::PsyTdbFnHW(state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).OutletAirEnthalpy,
7038 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).OutletAirHumRat);
7039 0 : state.dataVariableSpeedCoils->PLRCorrLoadSideMdot = state.dataVariableSpeedCoils->LoadSideMassFlowRate;
7040 : } else {
7041 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).OutletAirEnthalpy = state.dataVariableSpeedCoils->LoadSideOutletEnth;
7042 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).OutletAirHumRat = state.dataVariableSpeedCoils->LoadSideOutletHumRat;
7043 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).OutletAirDBTemp = state.dataVariableSpeedCoils->LoadSideOutletDBTemp;
7044 0 : state.dataVariableSpeedCoils->PLRCorrLoadSideMdot = state.dataVariableSpeedCoils->LoadSideMassFlowRate * PartLoadRatio;
7045 : }
7046 :
7047 : // scale heat transfer rates to PLR and power to RTF
7048 0 : state.dataVariableSpeedCoils->QLoadTotal *= PartLoadRatio;
7049 0 : state.dataVariableSpeedCoils->QSensible *= PartLoadRatio;
7050 : // count the powr separately
7051 0 : state.dataVariableSpeedCoils->Winput *=
7052 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).RunFrac; //+ VarSpeedCoil(DXCoilNum)%CrankcaseHeaterPower &
7053 : //+ VarSpeedCoil(DXCoilNum)%BasinHeaterPower + VarSpeedCoil(DXCoilNum)%EvapCondPumpElecPower
7054 0 : state.dataVariableSpeedCoils->QSource *= PartLoadRatio;
7055 :
7056 : // Update heat pump data structure
7057 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).HPWHCondPumpElecNomPower =
7058 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).HPWHCondPumpElecNomPower *
7059 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).RunFrac; // water heating pump power
7060 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Power = state.dataVariableSpeedCoils->Winput;
7061 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).QLoadTotal = state.dataVariableSpeedCoils->QLoadTotal;
7062 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).QSensible = state.dataVariableSpeedCoils->QSensible;
7063 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).QLatent =
7064 0 : state.dataVariableSpeedCoils->QLoadTotal - state.dataVariableSpeedCoils->QSensible;
7065 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).QSource = state.dataVariableSpeedCoils->QSource;
7066 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Energy = state.dataVariableSpeedCoils->Winput * TimeStepSysSec;
7067 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).EnergyLoadTotal = state.dataVariableSpeedCoils->QLoadTotal * TimeStepSysSec;
7068 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).EnergySensible = state.dataVariableSpeedCoils->QSensible * TimeStepSysSec;
7069 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).EnergyLatent =
7070 0 : (state.dataVariableSpeedCoils->QLoadTotal - state.dataVariableSpeedCoils->QSensible) * TimeStepSysSec;
7071 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).EnergySource = state.dataVariableSpeedCoils->QSource * TimeStepSysSec;
7072 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).CrankcaseHeaterConsumption =
7073 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).CrankcaseHeaterPower * TimeStepSysSec;
7074 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).EvapWaterConsump = 0.0;
7075 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).BasinHeaterConsumption = 0.0;
7076 : // re-use EvapCondPumpElecConsumption to store WH pump energy consumption
7077 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).EvapCondPumpElecConsumption =
7078 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).HPWHCondPumpElecNomPower * TimeStepSysSec;
7079 0 : if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).RunFrac == 0.0) {
7080 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).COP = 0.0;
7081 : } else {
7082 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).COP =
7083 0 : state.dataVariableSpeedCoils->QLoadTotal / state.dataVariableSpeedCoils->Winput;
7084 : }
7085 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).PartLoadRatio = PartLoadRatio;
7086 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).AirMassFlowRate = state.dataVariableSpeedCoils->PLRCorrLoadSideMdot;
7087 0 : rhoair = Psychrometrics::PsyRhoAirFnPbTdbW(state,
7088 0 : state.dataEnvrn->OutBaroPress,
7089 0 : state.dataVariableSpeedCoils->LoadSideInletDBTemp,
7090 0 : state.dataVariableSpeedCoils->LoadSideInletHumRat,
7091 : RoutineName);
7092 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).AirVolFlowRate =
7093 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).AirMassFlowRate / rhoair;
7094 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).WaterMassFlowRate = state.dataVariableSpeedCoils->SourceSideMassFlowRate;
7095 0 : RhoWater = Psychrometrics::RhoH2O(InletWaterTemp); // initialize
7096 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).WaterVolFlowRate =
7097 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).WaterMassFlowRate / RhoWater;
7098 :
7099 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).OutletWaterTemp =
7100 0 : state.dataVariableSpeedCoils->SourceSideInletTemp +
7101 0 : state.dataVariableSpeedCoils->QSource / (state.dataVariableSpeedCoils->SourceSideMassFlowRate * CpWater);
7102 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).OutletWaterEnthalpy =
7103 0 : state.dataVariableSpeedCoils->SourceSideInletEnth +
7104 0 : state.dataVariableSpeedCoils->QSource / state.dataVariableSpeedCoils->SourceSideMassFlowRate;
7105 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).QWasteHeat = 0.0;
7106 :
7107 0 : if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).bIsDesuperheater) // desuperheater doesn't save power and cooling energy variables
7108 : {
7109 : // source side is the water side; load side is the air side
7110 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Power = 0.0;
7111 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).QLoadTotal = 0.0;
7112 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).QSensible = 0.0;
7113 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).QLatent = 0.0;
7114 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Energy = 0.0;
7115 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).EnergyLoadTotal = 0.0;
7116 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).EnergySensible = 0.0;
7117 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).EnergyLatent = 0.0;
7118 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).CrankcaseHeaterConsumption = 0.0;
7119 : }
7120 : }
7121 :
7122 0 : void setVarSpeedHPWHFanType(EnergyPlusData &state, int const dXCoilNum, HVAC::FanType fanType)
7123 : {
7124 0 : state.dataVariableSpeedCoils->VarSpeedCoil(dXCoilNum).supplyFanType = fanType;
7125 0 : }
7126 :
7127 0 : void setVarSpeedHPWHFanIndex(EnergyPlusData &state, int const dXCoilNum, int const fanIndex)
7128 : {
7129 0 : state.dataVariableSpeedCoils->VarSpeedCoil(dXCoilNum).SupplyFanIndex = fanIndex;
7130 0 : }
7131 :
7132 33673 : void CalcVarSpeedCoilHeating(EnergyPlusData &state,
7133 : int const DXCoilNum, // Heat Pump Number
7134 : HVAC::FanOp const fanOp, // Fan/Compressor cycling scheme indicator
7135 : [[maybe_unused]] Real64 const SensDemand, // Cooling Sensible Demand [W] !unused1208
7136 : HVAC::CompressorOp const compressorOp, // compressor operation flag
7137 : Real64 const PartLoadRatio, // compressor part load ratio
7138 : [[maybe_unused]] Real64 const OnOffAirFlowRatio, // ratio of compressor on flow to average flow over time step
7139 : Real64 const SpeedRatio, // SpeedRatio varies between 1.0 (higher speed) and 0.0 (lower speed)
7140 : int const SpeedNum // Speed number, high bound, i.e. SpeedNum - 1 is the other side
7141 : )
7142 : {
7143 :
7144 : // AUTHOR Bo Shen, based on WaterToAirHeatPumpSimple:CalcHPHeatingSimple
7145 : // DATE WRITTEN March 2012
7146 :
7147 : // PURPOSE OF THIS SUBROUTINE:
7148 : // This subroutine is for simulating the heating mode of the Variable Speed Water to Air HP Simple
7149 :
7150 : // METHODOLOGY EMPLOYED:
7151 : // Simulate the heat pump performance using the coefficients and rated conditions
7152 : // Finally, adjust the heat pump outlet conditions based on the PartLoadRatio
7153 : // and RuntimeFrac.
7154 :
7155 : // SUBROUTINE PARAMETER DEFINITIONS:
7156 : static constexpr std::string_view RoutineName("CalcVarSpeedCoilHeating");
7157 : static constexpr std::string_view RoutineNameSourceSideInletTemp("CalcVarSpeedCoilHeating:SourceSideInletTemp");
7158 33673 : Real64 TimeStepSysSec = state.dataHVACGlobal->TimeStepSysSec;
7159 :
7160 : // SUBROUTINE LOCAL VARIABLE DECLARATIONS:
7161 : Real64 CpSource; // Specific heat of water [J/kg_C]
7162 : Real64 AirMassFlowRatio; // airflow ratio at low speed
7163 : Real64 WaterMassFlowRatio; // airflow ratio at high speed
7164 : Real64 TotCapAirFFModFac; // air flow fraction modification
7165 : Real64 TotCapWaterFFModFac; // water flow fraction modification
7166 : Real64 TotCapTempModFac; // total capacity temperature correction fraction
7167 : Real64 EIRAirFFModFac; // air flow fraction modification
7168 : Real64 EIRWaterFFModFac; // water flow fraction modification
7169 : Real64 EIRTempModFac; // total capacity temperature correction fraction
7170 : Real64 EIR; // total capacity temperature correction fraction
7171 : int SpeedCal; // calculated speed level
7172 : Real64 QLoadTotal1; // heating capacity at low speed
7173 : Real64 QLoadTotal2; // heating capacity at high speed
7174 : Real64 Winput1; // power consumption at low speed
7175 : Real64 Winput2; // power consumption at high speed
7176 : Real64 QWasteHeat; // recoverable waste heat
7177 : Real64 QWasteHeat1; // recoverable waste heat at low speed
7178 : Real64 QWasteHeat2; // recoverable waste heat at high speed
7179 : Real64 PLF; // part-load function
7180 33673 : Real64 rhoair(0.0); // entering air density
7181 :
7182 : // ADDED VARIABLES FOR air source coil
7183 33673 : int MaxSpeed = state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).NumOfSpeeds;
7184 :
7185 : // LOAD LOCAL VARIABLES FROM DATA STRUCTURE (for code readability)
7186 33673 : if (!(fanOp == HVAC::FanOp::Continuous) && PartLoadRatio > 0.0) {
7187 17652 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).AirMassFlowRate =
7188 17652 : state.dataLoopNodes->Node(state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).AirInletNodeNum).MassFlowRate / PartLoadRatio;
7189 : }
7190 :
7191 33673 : state.dataVariableSpeedCoils->LoadSideMassFlowRate = state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).AirMassFlowRate;
7192 33673 : state.dataVariableSpeedCoils->LoadSideInletDBTemp = state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).InletAirDBTemp;
7193 33673 : state.dataVariableSpeedCoils->LoadSideInletHumRat = state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).InletAirHumRat;
7194 :
7195 33673 : state.dataVariableSpeedCoils->LoadSideInletWBTemp = Psychrometrics::PsyTwbFnTdbWPb(state,
7196 33673 : state.dataVariableSpeedCoils->LoadSideInletDBTemp,
7197 33673 : state.dataVariableSpeedCoils->LoadSideInletHumRat,
7198 33673 : state.dataEnvrn->OutBaroPress,
7199 : RoutineName);
7200 33673 : state.dataVariableSpeedCoils->LoadSideInletEnth = state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).InletAirEnthalpy;
7201 33673 : Real64 CpAir = Psychrometrics::PsyCpAirFnW(state.dataVariableSpeedCoils->LoadSideInletHumRat); // Specific heat of air [J/kg_C]
7202 :
7203 33673 : if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).VSCoilType == HVAC::Coil_HeatingAirToAirVariableSpeed) {
7204 : // Get condenser outdoor node info from DX Heating Coil
7205 36 : if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).CondenserInletNodeNum != 0) {
7206 0 : state.dataVariableSpeedCoils->OutdoorDryBulb =
7207 0 : state.dataLoopNodes->Node(state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).CondenserInletNodeNum).Temp;
7208 0 : state.dataVariableSpeedCoils->OutdoorHumRat =
7209 0 : state.dataLoopNodes->Node(state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).CondenserInletNodeNum).HumRat;
7210 0 : state.dataVariableSpeedCoils->OutdoorPressure =
7211 0 : state.dataLoopNodes->Node(state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).CondenserInletNodeNum).Press;
7212 0 : state.dataVariableSpeedCoils->OutdoorWetBulb =
7213 0 : state.dataLoopNodes->Node(state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).CondenserInletNodeNum).OutAirWetBulb;
7214 : } else {
7215 36 : state.dataVariableSpeedCoils->OutdoorDryBulb = state.dataEnvrn->OutDryBulbTemp;
7216 36 : state.dataVariableSpeedCoils->OutdoorHumRat = state.dataEnvrn->OutHumRat;
7217 36 : state.dataVariableSpeedCoils->OutdoorPressure = state.dataEnvrn->OutBaroPress;
7218 36 : state.dataVariableSpeedCoils->OutdoorWetBulb = state.dataEnvrn->OutWetBulbTemp;
7219 : }
7220 36 : state.dataVariableSpeedCoils->SourceSideMassFlowRate = 1.0; // not used and avoid divided by zero
7221 36 : state.dataVariableSpeedCoils->SourceSideInletTemp = state.dataVariableSpeedCoils->OutdoorDryBulb;
7222 36 : state.dataVariableSpeedCoils->SourceSideInletEnth =
7223 36 : Psychrometrics::PsyHFnTdbW(state.dataVariableSpeedCoils->OutdoorDryBulb, state.dataVariableSpeedCoils->OutdoorHumRat);
7224 36 : CpSource = Psychrometrics::PsyCpAirFnW(state.dataEnvrn->OutHumRat);
7225 :
7226 : // Initialize crankcase heater, operates below OAT defined in input deck for HP DX heating coil
7227 36 : if (state.dataVariableSpeedCoils->OutdoorDryBulb < state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MaxOATCrankcaseHeater) {
7228 33 : state.dataVariableSpeedCoils->CrankcaseHeatingPower = state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).CrankcaseHeaterCapacity;
7229 33 : if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).CrankcaseHeaterCapacityCurveIndex > 0) {
7230 1 : state.dataVariableSpeedCoils->CrankcaseHeatingPower *=
7231 1 : Curve::CurveValue(state,
7232 1 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).CrankcaseHeaterCapacityCurveIndex,
7233 1 : state.dataEnvrn->OutDryBulbTemp);
7234 : }
7235 : } else {
7236 3 : state.dataVariableSpeedCoils->CrankcaseHeatingPower = 0.0;
7237 : }
7238 : } else {
7239 33637 : state.dataVariableSpeedCoils->SourceSideMassFlowRate = state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).WaterMassFlowRate;
7240 33637 : state.dataVariableSpeedCoils->SourceSideInletTemp = state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).InletWaterTemp;
7241 33637 : state.dataVariableSpeedCoils->SourceSideInletEnth = state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).InletWaterEnthalpy;
7242 33637 : CpSource = state.dataPlnt->PlantLoop(state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).plantLoc.loopNum)
7243 33637 : .glycol->getSpecificHeat(state, state.dataVariableSpeedCoils->SourceSideInletTemp, RoutineNameSourceSideInletTemp);
7244 : }
7245 :
7246 : // Check for flows, do not perform simulation if no flow in load side or source side.
7247 33673 : if ((state.dataVariableSpeedCoils->SourceSideMassFlowRate <= 0.0) || (state.dataVariableSpeedCoils->LoadSideMassFlowRate <= 0.0)) {
7248 16038 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).SimFlag = false;
7249 16038 : return;
7250 : } else {
7251 17635 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).SimFlag = true;
7252 : }
7253 :
7254 17659 : if ((state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).VSCoilType == HVAC::Coil_HeatingAirToAirVariableSpeed) &&
7255 24 : (state.dataVariableSpeedCoils->OutdoorDryBulb < state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MinOATCompressor)) {
7256 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).SimFlag = false;
7257 0 : return;
7258 : }
7259 :
7260 17635 : if (compressorOp == HVAC::CompressorOp::Off) {
7261 1 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).SimFlag = false;
7262 1 : return;
7263 : }
7264 :
7265 17634 : if (SpeedNum > MaxSpeed) {
7266 0 : SpeedCal = MaxSpeed;
7267 : } else {
7268 17634 : SpeedCal = SpeedNum;
7269 : }
7270 :
7271 17634 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).RunFrac = 1.0;
7272 17634 : state.dataHVACGlobal->OnOffFanPartLoadFraction = 1.0;
7273 17634 : if ((SpeedNum == 1) && (PartLoadRatio < 1.0)) {
7274 39 : PLF = Curve::CurveValue(state, state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).PLFFPLR, PartLoadRatio);
7275 39 : if (PLF < 0.7) {
7276 0 : PLF = 0.7;
7277 : }
7278 39 : if (fanOp == HVAC::FanOp::Cycling) {
7279 32 : state.dataHVACGlobal->OnOffFanPartLoadFraction =
7280 : PLF; // save PLF for fan model, don't change fan power for constant fan mode if coil is off
7281 : }
7282 : // calculate the run time fraction
7283 39 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).RunFrac = PartLoadRatio / PLF;
7284 39 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).PartLoadRatio = PartLoadRatio;
7285 :
7286 39 : if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).RunFrac > 1.0) {
7287 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).RunFrac = 1.0; // Reset coil runtime fraction to 1.0
7288 39 : } else if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).RunFrac < 0.0) {
7289 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).RunFrac = 0.0;
7290 : }
7291 : }
7292 :
7293 17634 : if ((SpeedNum == 1) || (SpeedNum > MaxSpeed) || (SpeedRatio == 1.0)) {
7294 12217 : AirMassFlowRatio =
7295 12217 : state.dataVariableSpeedCoils->LoadSideMassFlowRate / state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).DesignAirMassFlowRate;
7296 :
7297 12217 : if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).VSCoilType == HVAC::Coil_HeatingAirToAirVariableSpeed) {
7298 18 : WaterMassFlowRatio = 1.0;
7299 : } else {
7300 12199 : WaterMassFlowRatio = state.dataVariableSpeedCoils->SourceSideMassFlowRate /
7301 12199 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).DesignWaterMassFlowRate;
7302 : }
7303 :
7304 48868 : TotCapTempModFac = Curve::CurveValue(state,
7305 12217 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSCCapFTemp(SpeedCal),
7306 12217 : state.dataVariableSpeedCoils->LoadSideInletDBTemp,
7307 12217 : state.dataVariableSpeedCoils->SourceSideInletTemp);
7308 : TotCapAirFFModFac =
7309 12217 : Curve::CurveValue(state, state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSCCapAirFFlow(SpeedCal), AirMassFlowRatio);
7310 :
7311 12217 : if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).VSCoilType == HVAC::Coil_HeatingAirToAirVariableSpeed) {
7312 18 : TotCapWaterFFModFac = 1.0;
7313 : } else {
7314 : TotCapWaterFFModFac =
7315 12199 : Curve::CurveValue(state, state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSCCapWaterFFlow(SpeedCal), WaterMassFlowRatio);
7316 : }
7317 :
7318 12217 : state.dataVariableSpeedCoils->QLoadTotal = state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedTotCap(SpeedCal) *
7319 12217 : TotCapTempModFac * TotCapAirFFModFac * TotCapWaterFFModFac;
7320 12217 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).capModFacTotal = TotCapTempModFac * TotCapAirFFModFac * TotCapWaterFFModFac;
7321 24434 : state.dataVariableSpeedCoils->TotRatedCapacity =
7322 12217 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedTotCap(SpeedCal); // for defrosting power cal
7323 :
7324 48868 : EIRTempModFac = Curve::CurveValue(state,
7325 12217 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSEIRFTemp(SpeedCal),
7326 12217 : state.dataVariableSpeedCoils->LoadSideInletDBTemp,
7327 12217 : state.dataVariableSpeedCoils->SourceSideInletTemp);
7328 : EIRAirFFModFac =
7329 12217 : Curve::CurveValue(state, state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSEIRAirFFlow(SpeedCal), AirMassFlowRatio);
7330 :
7331 12217 : if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).VSCoilType == HVAC::Coil_HeatingAirToAirVariableSpeed) {
7332 18 : EIRWaterFFModFac = 1.0;
7333 : } else {
7334 : EIRWaterFFModFac =
7335 12199 : Curve::CurveValue(state, state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSEIRWaterFFlow(SpeedCal), WaterMassFlowRatio);
7336 : }
7337 :
7338 12217 : EIR = (1.0 / state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedCOP(SpeedCal)) * EIRTempModFac * EIRAirFFModFac *
7339 : EIRWaterFFModFac;
7340 12217 : state.dataVariableSpeedCoils->Winput = state.dataVariableSpeedCoils->QLoadTotal * EIR;
7341 :
7342 24434 : if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).VSCoilType == HVAC::Coil_HeatingAirToAirVariableSpeed) {
7343 18 : QWasteHeat = 0.0;
7344 : } else {
7345 12199 : QWasteHeat = state.dataVariableSpeedCoils->Winput * state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSWasteHeatFrac(SpeedCal);
7346 12199 : QWasteHeat *= Curve::CurveValue(state,
7347 12199 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSWasteHeat(SpeedCal),
7348 12199 : state.dataVariableSpeedCoils->LoadSideInletDBTemp,
7349 12199 : state.dataVariableSpeedCoils->SourceSideInletTemp);
7350 : }
7351 :
7352 : } else {
7353 5417 : AirMassFlowRatio =
7354 5417 : state.dataVariableSpeedCoils->LoadSideMassFlowRate / state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).DesignAirMassFlowRate;
7355 :
7356 5417 : if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).VSCoilType == HVAC::Coil_HeatingAirToAirVariableSpeed) {
7357 5 : WaterMassFlowRatio = 1.0;
7358 : } else {
7359 5412 : WaterMassFlowRatio = state.dataVariableSpeedCoils->SourceSideMassFlowRate /
7360 5412 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).DesignWaterMassFlowRate;
7361 : }
7362 :
7363 5417 : SpeedCal = SpeedNum - 1;
7364 21668 : TotCapTempModFac = Curve::CurveValue(state,
7365 5417 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSCCapFTemp(SpeedCal),
7366 5417 : state.dataVariableSpeedCoils->LoadSideInletDBTemp,
7367 5417 : state.dataVariableSpeedCoils->SourceSideInletTemp);
7368 : TotCapAirFFModFac =
7369 5417 : Curve::CurveValue(state, state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSCCapAirFFlow(SpeedCal), AirMassFlowRatio);
7370 :
7371 5417 : if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).VSCoilType == HVAC::Coil_HeatingAirToAirVariableSpeed) {
7372 5 : TotCapWaterFFModFac = 1.0;
7373 : } else {
7374 : TotCapWaterFFModFac =
7375 5412 : Curve::CurveValue(state, state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSCCapWaterFFlow(SpeedCal), WaterMassFlowRatio);
7376 : }
7377 :
7378 5417 : QLoadTotal1 = state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedTotCap(SpeedCal) * TotCapTempModFac * TotCapAirFFModFac *
7379 : TotCapWaterFFModFac;
7380 :
7381 21668 : EIRTempModFac = Curve::CurveValue(state,
7382 5417 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSEIRFTemp(SpeedCal),
7383 5417 : state.dataVariableSpeedCoils->LoadSideInletDBTemp,
7384 5417 : state.dataVariableSpeedCoils->SourceSideInletTemp);
7385 : EIRAirFFModFac =
7386 5417 : Curve::CurveValue(state, state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSEIRAirFFlow(SpeedCal), AirMassFlowRatio);
7387 :
7388 5417 : if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).VSCoilType == HVAC::Coil_HeatingAirToAirVariableSpeed) {
7389 5 : EIRWaterFFModFac = 1.0;
7390 : } else {
7391 : EIRWaterFFModFac =
7392 5412 : Curve::CurveValue(state, state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSEIRWaterFFlow(SpeedCal), WaterMassFlowRatio);
7393 : }
7394 :
7395 5417 : EIR = (1.0 / state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedCOP(SpeedCal)) * EIRTempModFac * EIRAirFFModFac *
7396 : EIRWaterFFModFac;
7397 5417 : Winput1 = QLoadTotal1 * EIR;
7398 :
7399 5417 : if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).VSCoilType == HVAC::Coil_HeatingAirToAirVariableSpeed) {
7400 5 : QWasteHeat1 = 0.0;
7401 : } else {
7402 5412 : QWasteHeat1 = Winput1 * state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSWasteHeatFrac(SpeedCal);
7403 5412 : QWasteHeat1 *= Curve::CurveValue(state,
7404 5412 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSWasteHeat(SpeedCal),
7405 5412 : state.dataVariableSpeedCoils->LoadSideInletDBTemp,
7406 5412 : state.dataVariableSpeedCoils->SourceSideInletTemp);
7407 : }
7408 :
7409 5417 : SpeedCal = SpeedNum;
7410 21668 : TotCapTempModFac = Curve::CurveValue(state,
7411 5417 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSCCapFTemp(SpeedCal),
7412 5417 : state.dataVariableSpeedCoils->LoadSideInletDBTemp,
7413 5417 : state.dataVariableSpeedCoils->SourceSideInletTemp);
7414 : TotCapAirFFModFac =
7415 5417 : Curve::CurveValue(state, state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSCCapAirFFlow(SpeedCal), AirMassFlowRatio);
7416 :
7417 5417 : if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).VSCoilType == HVAC::Coil_HeatingAirToAirVariableSpeed) {
7418 5 : TotCapWaterFFModFac = 1.0;
7419 : } else {
7420 : TotCapWaterFFModFac =
7421 5412 : Curve::CurveValue(state, state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSCCapWaterFFlow(SpeedCal), WaterMassFlowRatio);
7422 : }
7423 :
7424 5417 : QLoadTotal2 = state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedTotCap(SpeedCal) * TotCapTempModFac * TotCapAirFFModFac *
7425 : TotCapWaterFFModFac;
7426 :
7427 21668 : EIRTempModFac = Curve::CurveValue(state,
7428 5417 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSEIRFTemp(SpeedCal),
7429 5417 : state.dataVariableSpeedCoils->LoadSideInletDBTemp,
7430 5417 : state.dataVariableSpeedCoils->SourceSideInletTemp);
7431 : EIRAirFFModFac =
7432 5417 : Curve::CurveValue(state, state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSEIRAirFFlow(SpeedCal), AirMassFlowRatio);
7433 :
7434 5417 : if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).VSCoilType == HVAC::Coil_HeatingAirToAirVariableSpeed) {
7435 5 : EIRWaterFFModFac = 1.0;
7436 : } else {
7437 : EIRWaterFFModFac =
7438 5412 : Curve::CurveValue(state, state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSEIRWaterFFlow(SpeedCal), WaterMassFlowRatio);
7439 : }
7440 :
7441 5417 : EIR = (1.0 / state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedCOP(SpeedCal)) * EIRTempModFac * EIRAirFFModFac *
7442 : EIRWaterFFModFac;
7443 5417 : Winput2 = QLoadTotal2 * EIR;
7444 :
7445 5417 : if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).VSCoilType == HVAC::Coil_HeatingAirToAirVariableSpeed) {
7446 5 : QWasteHeat2 = 0.0;
7447 : } else {
7448 5412 : QWasteHeat2 = Winput2 * state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSWasteHeatFrac(SpeedCal);
7449 5412 : QWasteHeat2 *= Curve::CurveValue(state,
7450 5412 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSWasteHeat(SpeedCal),
7451 5412 : state.dataVariableSpeedCoils->LoadSideInletDBTemp,
7452 5412 : state.dataVariableSpeedCoils->SourceSideInletTemp);
7453 : }
7454 :
7455 5417 : state.dataVariableSpeedCoils->QLoadTotal = QLoadTotal2 * SpeedRatio + (1.0 - SpeedRatio) * QLoadTotal1;
7456 5417 : state.dataVariableSpeedCoils->Winput = Winput2 * SpeedRatio + (1.0 - SpeedRatio) * Winput1;
7457 5417 : QWasteHeat = QWasteHeat2 * SpeedRatio + (1.0 - SpeedRatio) * QWasteHeat1;
7458 5417 : state.dataVariableSpeedCoils->TotRatedCapacity =
7459 5417 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedTotCap(SpeedCal) * SpeedRatio +
7460 5417 : (1.0 - SpeedRatio) * state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedTotCap(SpeedCal - 1);
7461 : }
7462 :
7463 17634 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).CrankcaseHeaterPower = 0.0; // necessary to clear zero for water source coils
7464 17634 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).DefrostPower = 0.0; // clear the defrost power
7465 17634 : if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).VSCoilType == HVAC::Coil_HeatingAirToAirVariableSpeed) {
7466 : // Calculating adjustment factors for defrost
7467 : // Calculate delta w through outdoor coil by assuming a coil temp of 0.82*DBT-9.7(F) per DOE2.1E
7468 23 : state.dataVariableSpeedCoils->OutdoorCoilT = 0.82 * state.dataVariableSpeedCoils->OutdoorDryBulb - 8.589;
7469 23 : state.dataVariableSpeedCoils->OutdoorCoildw =
7470 23 : max(1.0e-6,
7471 23 : (state.dataVariableSpeedCoils->OutdoorHumRat -
7472 23 : Psychrometrics::PsyWFnTdpPb(state, state.dataVariableSpeedCoils->OutdoorCoilT, state.dataVariableSpeedCoils->OutdoorPressure)));
7473 :
7474 : // Initializing defrost adjustment factors
7475 23 : state.dataVariableSpeedCoils->LoadDueToDefrost = 0.0;
7476 23 : state.dataVariableSpeedCoils->HeatingCapacityMultiplier = 1.0;
7477 23 : state.dataVariableSpeedCoils->FractionalDefrostTime = 0.0;
7478 23 : state.dataVariableSpeedCoils->InputPowerMultiplier = 1.0;
7479 : // Check outdoor temperature to determine of defrost is active
7480 23 : if (state.dataVariableSpeedCoils->OutdoorDryBulb <= state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MaxOATDefrost) {
7481 : // Calculate defrost adjustment factors depending on defrost control type
7482 19 : if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).DefrostControl == Timed) {
7483 12 : state.dataVariableSpeedCoils->FractionalDefrostTime = state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).DefrostTime;
7484 12 : if (state.dataVariableSpeedCoils->FractionalDefrostTime > 0.0) {
7485 11 : if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).FrostHeatingCapacityMultiplierEMSOverrideOn &&
7486 1 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).FrostHeatingInputPowerMultiplierEMSOverrideOn) {
7487 2 : state.dataVariableSpeedCoils->HeatingCapacityMultiplier =
7488 1 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).FrostHeatingCapacityMultiplierEMSOverrideValue;
7489 1 : state.dataVariableSpeedCoils->InputPowerMultiplier =
7490 1 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).FrostHeatingInputPowerMultiplierEMSOverrideValue;
7491 : } else {
7492 9 : state.dataVariableSpeedCoils->HeatingCapacityMultiplier = 0.909 - 107.33 * state.dataVariableSpeedCoils->OutdoorCoildw;
7493 9 : state.dataVariableSpeedCoils->InputPowerMultiplier = 0.90 - 36.45 * state.dataVariableSpeedCoils->OutdoorCoildw;
7494 18 : if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).FrostHeatingCapacityMultiplierEMSOverrideOn ||
7495 9 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).FrostHeatingInputPowerMultiplierEMSOverrideOn) {
7496 0 : ShowWarningMessage(
7497 : state,
7498 0 : format("The Frost Heating Capacity Multiplier actuator and the Frost Heating Input Power Multiplier "
7499 : "actuator must be both provided for DX heating coil {}",
7500 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name));
7501 0 : ShowContinueError(state, "EMS actuators are ignored. Simulation is continuing.");
7502 : }
7503 : }
7504 : }
7505 : } else { // else defrost control is on-demand
7506 7 : state.dataVariableSpeedCoils->FractionalDefrostTime = 1.0 / (1.0 + 0.01446 / state.dataVariableSpeedCoils->OutdoorCoildw);
7507 7 : if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).FrostHeatingCapacityMultiplierEMSOverrideOn &&
7508 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).FrostHeatingInputPowerMultiplierEMSOverrideOn) {
7509 0 : state.dataVariableSpeedCoils->HeatingCapacityMultiplier =
7510 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).FrostHeatingCapacityMultiplierEMSOverrideValue;
7511 0 : state.dataVariableSpeedCoils->InputPowerMultiplier =
7512 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).FrostHeatingInputPowerMultiplierEMSOverrideValue;
7513 : } else {
7514 7 : state.dataVariableSpeedCoils->HeatingCapacityMultiplier = 0.875 * (1.0 - state.dataVariableSpeedCoils->FractionalDefrostTime);
7515 7 : state.dataVariableSpeedCoils->InputPowerMultiplier = 0.954 * (1.0 - state.dataVariableSpeedCoils->FractionalDefrostTime);
7516 14 : if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).FrostHeatingCapacityMultiplierEMSOverrideOn ||
7517 7 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).FrostHeatingInputPowerMultiplierEMSOverrideOn) {
7518 0 : ShowWarningMessage(state,
7519 0 : format("The Frost Heating Capacity Multiplier actuator and the Frost Heating Input Power Multiplier "
7520 : "actuator must be both provided for DX heating coil {}",
7521 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name));
7522 0 : ShowContinueError(state, "EMS actuators are ignored. Simulation is continuing.");
7523 : }
7524 : }
7525 : }
7526 : // correction fractional defrost time shorten by runtime fraction
7527 19 : state.dataVariableSpeedCoils->FractionalDefrostTime *= state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).RunFrac;
7528 :
7529 19 : if (state.dataVariableSpeedCoils->FractionalDefrostTime > 0.0) {
7530 : // Calculate defrost adjustment factors depending on defrost control strategy
7531 17 : if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).DefrostStrategy == ReverseCycle) {
7532 0 : state.dataVariableSpeedCoils->LoadDueToDefrost = (0.01 * state.dataVariableSpeedCoils->FractionalDefrostTime) *
7533 0 : (7.222 - state.dataVariableSpeedCoils->OutdoorDryBulb) *
7534 0 : (state.dataVariableSpeedCoils->TotRatedCapacity / 1.01667);
7535 0 : state.dataVariableSpeedCoils->DefrostEIRTempModFac =
7536 0 : Curve::CurveValue(state,
7537 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).DefrostEIRFT,
7538 0 : max(15.555, state.dataVariableSpeedCoils->LoadSideInletWBTemp),
7539 0 : max(15.555, state.dataVariableSpeedCoils->OutdoorDryBulb));
7540 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).DefrostPower =
7541 0 : state.dataVariableSpeedCoils->DefrostEIRTempModFac * (state.dataVariableSpeedCoils->TotRatedCapacity / 1.01667) *
7542 0 : state.dataVariableSpeedCoils->FractionalDefrostTime;
7543 : } else { // Defrost strategy is resistive
7544 17 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).DefrostPower =
7545 17 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).DefrostCapacity *
7546 17 : state.dataVariableSpeedCoils->FractionalDefrostTime;
7547 : }
7548 : } else { // Defrost is not active because (OutDryBulbTemp > VarSpeedCoil(DXCoilNum).MaxOATDefrost)
7549 2 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).DefrostPower = 0.0;
7550 : }
7551 : }
7552 :
7553 23 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).CrankcaseHeaterPower =
7554 23 : state.dataVariableSpeedCoils->CrankcaseHeatingPower * (1.0 - state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).RunFrac);
7555 : //! Modify total heating capacity based on defrost heating capacity multiplier
7556 : //! MaxHeatCap passed from parent object VRF Condenser and is used to limit capacity of TU's to that available from condenser
7557 : // IF(PRESENT(MaxHeatCap))THEN
7558 : // TotCap = MIN(MaxHeatCap,TotCap * HeatingCapacityMultiplier)
7559 : // ELSE
7560 : // TotCap = TotCap * HeatingCapacityMultiplier
7561 : // END IF
7562 46 : state.dataVariableSpeedCoils->QLoadTotal =
7563 23 : state.dataVariableSpeedCoils->QLoadTotal * state.dataVariableSpeedCoils->HeatingCapacityMultiplier -
7564 23 : state.dataVariableSpeedCoils->LoadDueToDefrost;
7565 : // count the powr separately
7566 23 : state.dataVariableSpeedCoils->Winput *= state.dataVariableSpeedCoils->InputPowerMultiplier; //+ VarSpeedCoil(DXCoilNum)%DefrostPower
7567 : }
7568 :
7569 17634 : state.dataVariableSpeedCoils->QSource = state.dataVariableSpeedCoils->QLoadTotal + QWasteHeat - state.dataVariableSpeedCoils->Winput;
7570 17634 : state.dataVariableSpeedCoils->QSensible = state.dataVariableSpeedCoils->QLoadTotal;
7571 :
7572 17634 : if (state.dataVariableSpeedCoils->QSource < 0) {
7573 1 : state.dataVariableSpeedCoils->QSource = 0.0;
7574 1 : QWasteHeat = state.dataVariableSpeedCoils->Winput - state.dataVariableSpeedCoils->QLoadTotal;
7575 : }
7576 :
7577 : // calculate coil outlet state variables
7578 35268 : state.dataVariableSpeedCoils->LoadSideOutletEnth =
7579 17634 : state.dataVariableSpeedCoils->LoadSideInletEnth +
7580 17634 : state.dataVariableSpeedCoils->QLoadTotal / state.dataVariableSpeedCoils->LoadSideMassFlowRate;
7581 35268 : state.dataVariableSpeedCoils->LoadSideOutletDBTemp =
7582 17634 : state.dataVariableSpeedCoils->LoadSideInletDBTemp +
7583 17634 : state.dataVariableSpeedCoils->QSensible / (state.dataVariableSpeedCoils->LoadSideMassFlowRate * CpAir);
7584 17634 : state.dataVariableSpeedCoils->LoadSideOutletHumRat = Psychrometrics::PsyWFnTdbH(
7585 17634 : state, state.dataVariableSpeedCoils->LoadSideOutletDBTemp, state.dataVariableSpeedCoils->LoadSideOutletEnth, RoutineName);
7586 :
7587 : // Actual outlet conditions are "average" for time step
7588 17634 : if (fanOp == HVAC::FanOp::Continuous) {
7589 : // continuous fan, cycling compressor
7590 24 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).OutletAirEnthalpy =
7591 24 : PartLoadRatio * state.dataVariableSpeedCoils->LoadSideOutletEnth +
7592 24 : (1.0 - PartLoadRatio) * state.dataVariableSpeedCoils->LoadSideInletEnth;
7593 24 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).OutletAirHumRat =
7594 24 : PartLoadRatio * state.dataVariableSpeedCoils->LoadSideOutletHumRat +
7595 24 : (1.0 - PartLoadRatio) * state.dataVariableSpeedCoils->LoadSideInletHumRat;
7596 24 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).OutletAirDBTemp =
7597 24 : Psychrometrics::PsyTdbFnHW(state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).OutletAirEnthalpy,
7598 24 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).OutletAirHumRat);
7599 24 : state.dataVariableSpeedCoils->PLRCorrLoadSideMdot = state.dataVariableSpeedCoils->LoadSideMassFlowRate;
7600 : } else {
7601 : // default to cycling fan, cycling compressor
7602 17610 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).OutletAirEnthalpy = state.dataVariableSpeedCoils->LoadSideOutletEnth;
7603 17610 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).OutletAirHumRat = state.dataVariableSpeedCoils->LoadSideOutletHumRat;
7604 17610 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).OutletAirDBTemp = state.dataVariableSpeedCoils->LoadSideOutletDBTemp;
7605 17610 : state.dataVariableSpeedCoils->PLRCorrLoadSideMdot = state.dataVariableSpeedCoils->LoadSideMassFlowRate * PartLoadRatio;
7606 : }
7607 :
7608 : // scale heat transfer rates to PLR and power to RTF
7609 17634 : state.dataVariableSpeedCoils->QLoadTotal *= PartLoadRatio;
7610 17634 : state.dataVariableSpeedCoils->QSensible *= PartLoadRatio;
7611 : // count the powr separately
7612 35268 : state.dataVariableSpeedCoils->Winput *=
7613 17634 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).RunFrac; //+ VarSpeedCoil(DXCoilNum)%CrankcaseHeaterPower
7614 17634 : state.dataVariableSpeedCoils->QSource *= PartLoadRatio;
7615 17634 : QWasteHeat *= PartLoadRatio;
7616 :
7617 : // Update heat pump data structure
7618 17634 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Power = state.dataVariableSpeedCoils->Winput;
7619 17634 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).QLoadTotal = state.dataVariableSpeedCoils->QLoadTotal;
7620 17634 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).QSensible = state.dataVariableSpeedCoils->QSensible;
7621 17634 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).QSource = state.dataVariableSpeedCoils->QSource;
7622 17634 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Energy = state.dataVariableSpeedCoils->Winput * TimeStepSysSec;
7623 17634 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).EnergyLoadTotal = state.dataVariableSpeedCoils->QLoadTotal * TimeStepSysSec;
7624 17634 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).EnergySensible = state.dataVariableSpeedCoils->QSensible * TimeStepSysSec;
7625 17634 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).EnergyLatent = 0.0;
7626 17634 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).EnergySource = state.dataVariableSpeedCoils->QSource * TimeStepSysSec;
7627 17634 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).CrankcaseHeaterConsumption =
7628 17634 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).CrankcaseHeaterPower * TimeStepSysSec;
7629 17634 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).DefrostConsumption =
7630 17634 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).DefrostPower * TimeStepSysSec;
7631 17634 : if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).RunFrac == 0.0) {
7632 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).COP = 0.0;
7633 : } else {
7634 17634 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).COP =
7635 17634 : state.dataVariableSpeedCoils->QLoadTotal / state.dataVariableSpeedCoils->Winput;
7636 : }
7637 17634 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).PartLoadRatio = PartLoadRatio;
7638 17634 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).AirMassFlowRate = state.dataVariableSpeedCoils->PLRCorrLoadSideMdot;
7639 17634 : rhoair = Psychrometrics::PsyRhoAirFnPbTdbW(state,
7640 17634 : state.dataEnvrn->OutBaroPress,
7641 17634 : state.dataVariableSpeedCoils->LoadSideInletDBTemp,
7642 17634 : state.dataVariableSpeedCoils->LoadSideInletHumRat,
7643 : RoutineName);
7644 17634 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).AirVolFlowRate =
7645 17634 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).AirMassFlowRate / rhoair;
7646 :
7647 17634 : if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).VSCoilType == HVAC::Coil_HeatingAirToAirVariableSpeed) {
7648 23 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).WaterMassFlowRate = 0.0;
7649 23 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).OutletWaterTemp = 0.0;
7650 23 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).OutletWaterEnthalpy = 0.0;
7651 : } else {
7652 17611 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).WaterMassFlowRate = state.dataVariableSpeedCoils->SourceSideMassFlowRate;
7653 17611 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).OutletWaterTemp =
7654 17611 : state.dataVariableSpeedCoils->SourceSideInletTemp -
7655 17611 : state.dataVariableSpeedCoils->QSource / (state.dataVariableSpeedCoils->SourceSideMassFlowRate * CpSource);
7656 17611 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).OutletWaterEnthalpy =
7657 17611 : state.dataVariableSpeedCoils->SourceSideInletEnth -
7658 17611 : state.dataVariableSpeedCoils->QSource / state.dataVariableSpeedCoils->SourceSideMassFlowRate;
7659 : }
7660 :
7661 17634 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).QWasteHeat = QWasteHeat;
7662 : }
7663 :
7664 8 : Real64 GetCoilCapacityVariableSpeed(EnergyPlusData &state,
7665 : std::string const &CoilType, // must match coil types in this module
7666 : std::string const &CoilName, // must match coil names for the coil type
7667 : bool &ErrorsFound // set to true if problem
7668 : )
7669 : {
7670 :
7671 : // FUNCTION INFORMATION:
7672 : // AUTHOR Bo Shen, based on WaterToAirHeatPumpSimple:GetCoilCapacity
7673 : // DATE WRITTEN March 2012
7674 :
7675 : // PURPOSE OF THIS FUNCTION:
7676 : // This function looks up the rated coil capacity at the nominal speed level for the given coil and returns it. If
7677 : // incorrect coil type or name is given, ErrorsFound is returned as true and capacity is returned
7678 : // as negative.
7679 :
7680 : // Return value
7681 : Real64 CoilCapacity; // returned capacity of matched coil
7682 :
7683 : // FUNCTION LOCAL VARIABLE DECLARATIONS:
7684 : int WhichCoil;
7685 :
7686 : // Obtains and Allocates WatertoAirHP related parameters from input file
7687 8 : if (state.dataVariableSpeedCoils->GetCoilsInputFlag) { // First time subroutine has been entered
7688 0 : GetVarSpeedCoilInput(state);
7689 0 : state.dataVariableSpeedCoils->GetCoilsInputFlag = false;
7690 : }
7691 :
7692 14 : if (Util::SameString(CoilType, "COIL:COOLING:WATERTOAIRHEATPUMP:VARIABLESPEEDEQUATIONFIT") ||
7693 12 : Util::SameString(CoilType, "COIL:HEATING:WATERTOAIRHEATPUMP:VARIABLESPEEDEQUATIONFIT") ||
7694 20 : Util::SameString(CoilType, "COIL:COOLING:DX:VARIABLESPEED") || Util::SameString(CoilType, "COIL:HEATING:DX:VARIABLESPEED") ||
7695 8 : Util::SameString(CoilType, "COIL:WATERHEATING:AIRTOWATERHEATPUMP:VARIABLESPEED")) {
7696 8 : WhichCoil = Util::FindItemInList(CoilName, state.dataVariableSpeedCoils->VarSpeedCoil);
7697 8 : if (WhichCoil != 0) {
7698 16 : if (Util::SameString(CoilType, "COIL:HEATING:WATERTOAIRHEATPUMP:VARIABLESPEEDEQUATIONFIT") ||
7699 16 : Util::SameString(CoilType, "COIL:HEATING:DX:VARIABLESPEED")) {
7700 0 : CoilCapacity = state.dataVariableSpeedCoils->VarSpeedCoil(WhichCoil).RatedCapHeat;
7701 8 : } else if (Util::SameString(CoilType, "COIL:WATERHEATING:AIRTOWATERHEATPUMP:VARIABLESPEED")) {
7702 0 : CoilCapacity = state.dataVariableSpeedCoils->VarSpeedCoil(WhichCoil).RatedCapWH;
7703 : } else {
7704 8 : CoilCapacity = state.dataVariableSpeedCoils->VarSpeedCoil(WhichCoil).RatedCapCoolTotal;
7705 : }
7706 : }
7707 : } else {
7708 0 : WhichCoil = 0;
7709 : }
7710 :
7711 8 : if (WhichCoil == 0) {
7712 0 : ShowSevereError(state, format("GetCoilCapacityVariableSpeed: Could not find CoilType=\"{}\" with Name=\"{}\"", CoilType, CoilName));
7713 0 : ErrorsFound = true;
7714 0 : CoilCapacity = -1000.0;
7715 : }
7716 :
7717 8 : return CoilCapacity;
7718 : }
7719 :
7720 27 : int GetCoilIndexVariableSpeed(EnergyPlusData &state,
7721 : std::string const &CoilType, // must match coil types in this module
7722 : std::string const &CoilName, // must match coil names for the coil type
7723 : bool &ErrorsFound // set to true if problem
7724 : )
7725 : {
7726 :
7727 : // FUNCTION INFORMATION:
7728 : // AUTHOR Bo Shen, based on WaterToAirHeatPumpSimple:GetCoilIndex
7729 : // DATE WRITTEN March 2012
7730 :
7731 : // PURPOSE OF THIS FUNCTION:
7732 : // This function looks up the coil index for the given coil and returns it. If incorrect
7733 : // coil type or name is given, ErrorsFound is returned as true and index is returned as zero.
7734 :
7735 : // Return value
7736 : int IndexNum; // returned index of matched coil
7737 :
7738 : // Obtains and Allocates WatertoAirHP related parameters from input file
7739 27 : if (state.dataVariableSpeedCoils->GetCoilsInputFlag) { // First time subroutine has been entered
7740 13 : GetVarSpeedCoilInput(state);
7741 13 : state.dataVariableSpeedCoils->GetCoilsInputFlag = false;
7742 : }
7743 :
7744 27 : IndexNum = Util::FindItemInList(CoilName, state.dataVariableSpeedCoils->VarSpeedCoil);
7745 :
7746 27 : if (IndexNum == 0) {
7747 0 : ShowSevereError(state, format("GetCoilIndexVariableSpeed: Could not find CoilType=\"{}\" with Name=\"{}\"", CoilType, CoilName));
7748 0 : ErrorsFound = true;
7749 : }
7750 :
7751 27 : return IndexNum;
7752 : }
7753 :
7754 1 : Real64 GetCoilAirFlowRateVariableSpeed(EnergyPlusData &state,
7755 : std::string const &CoilType, // must match coil types in this module
7756 : std::string const &CoilName, // must match coil names for the coil type
7757 : bool &ErrorsFound // set to true if problem
7758 : )
7759 : {
7760 :
7761 : // FUNCTION INFORMATION:
7762 : // AUTHOR Bo Shen, based on WaterToAirHeatPumpSimple:GetCoilAirFlowRate
7763 : // DATE WRITTEN March 2012
7764 :
7765 : // PURPOSE OF THIS FUNCTION:
7766 : // This function looks up the max coil air flow rate for the given coil and returns it. If incorrect
7767 : // coil type or name is given, ErrorsFound is returned as true and capacity is returned as negative.
7768 :
7769 : // Return value
7770 : Real64 CoilAirFlowRate; // returned air volume flow rate of matched coil
7771 :
7772 : // FUNCTION LOCAL VARIABLE DECLARATIONS:
7773 : int WhichCoil;
7774 :
7775 : // Obtains and Allocates WatertoAirHP related parameters from input file
7776 1 : if (state.dataVariableSpeedCoils->GetCoilsInputFlag) { // First time subroutine has been entered
7777 0 : GetVarSpeedCoilInput(state);
7778 0 : state.dataVariableSpeedCoils->GetCoilsInputFlag = false;
7779 : }
7780 :
7781 2 : if (Util::SameString(CoilType, "COIL:COOLING:WATERTOAIRHEATPUMP:VARIABLESPEEDEQUATIONFIT") ||
7782 2 : Util::SameString(CoilType, "COIL:HEATING:WATERTOAIRHEATPUMP:VARIABLESPEEDEQUATIONFIT") ||
7783 3 : Util::SameString(CoilType, "COIL:COOLING:DX:VARIABLESPEED") || Util::SameString(CoilType, "COIL:HEATING:DX:VARIABLESPEED") ||
7784 1 : Util::SameString(CoilType, "COIL:WATERHEATING:AIRTOWATERHEATPUMP:VARIABLESPEED")) {
7785 1 : WhichCoil = Util::FindItemInList(CoilName, state.dataVariableSpeedCoils->VarSpeedCoil);
7786 1 : if (WhichCoil != 0) {
7787 1 : if (state.dataVariableSpeedCoils->VarSpeedCoil(WhichCoil).RatedAirVolFlowRate == DataSizing::AutoSize) { // means autosize
7788 0 : CoilAirFlowRate = state.dataVariableSpeedCoils->VarSpeedCoil(WhichCoil).RatedAirVolFlowRate;
7789 : } else {
7790 1 : CoilAirFlowRate = state.dataVariableSpeedCoils->VarSpeedCoil(WhichCoil).MSRatedAirVolFlowRate(
7791 1 : state.dataVariableSpeedCoils->VarSpeedCoil(WhichCoil).NumOfSpeeds) /
7792 1 : state.dataVariableSpeedCoils->VarSpeedCoil(WhichCoil).MSRatedAirVolFlowRate(
7793 1 : state.dataVariableSpeedCoils->VarSpeedCoil(WhichCoil).NormSpedLevel) *
7794 1 : state.dataVariableSpeedCoils->VarSpeedCoil(WhichCoil).RatedAirVolFlowRate;
7795 : } // use largest air flow rate
7796 : }
7797 : } else {
7798 0 : WhichCoil = 0;
7799 : }
7800 :
7801 1 : if (WhichCoil == 0) {
7802 0 : ShowSevereError(state, format("GetCoilAirFlowRateVariableSpeed: Could not find CoilType=\"{}\" with Name=\"{}\"", CoilType, CoilName));
7803 0 : ErrorsFound = true;
7804 0 : CoilAirFlowRate = -1000.0;
7805 : }
7806 :
7807 1 : return CoilAirFlowRate;
7808 : }
7809 :
7810 0 : int GetVSCoilPLFFPLR(EnergyPlusData &state,
7811 : std::string const &CoilType, // must match coil types in this module
7812 : std::string const &CoilName, // must match coil names for the coil type
7813 : bool &ErrorsFound // set to true if problem
7814 : )
7815 : {
7816 :
7817 : // FUNCTION INFORMATION:
7818 : // AUTHOR Bo Shen
7819 : // DATE WRITTEN 12/2014
7820 :
7821 : // PURPOSE OF THIS FUNCTION:
7822 : // This function looks up the given coil and returns PLR curve index. If incorrect
7823 : // coil type or name is given, ErrorsFound is returned as true and value is returned as zero.
7824 :
7825 : // Return value
7826 : int PLRNumber; // returned outlet node of matched coil
7827 :
7828 : // FUNCTION LOCAL VARIABLE DECLARATIONS:
7829 : int WhichCoil;
7830 :
7831 : // Obtains and Allocates WatertoAirHP related parameters from input file
7832 0 : if (state.dataVariableSpeedCoils->GetCoilsInputFlag) { // First time subroutine has been entered
7833 0 : GetVarSpeedCoilInput(state);
7834 0 : state.dataVariableSpeedCoils->GetCoilsInputFlag = false;
7835 : }
7836 :
7837 0 : WhichCoil = Util::FindItemInList(CoilName, state.dataVariableSpeedCoils->VarSpeedCoil);
7838 0 : if (WhichCoil != 0) {
7839 0 : PLRNumber = state.dataVariableSpeedCoils->VarSpeedCoil(WhichCoil).PLFFPLR;
7840 : }
7841 :
7842 0 : if (WhichCoil == 0) {
7843 0 : ShowSevereError(state, format("GetVSCoilPLFFPLR: Could not find CoilType=\"{}\" with Name=\"{}\"", CoilType, CoilName));
7844 0 : ErrorsFound = true;
7845 0 : PLRNumber = 0;
7846 : }
7847 :
7848 0 : return PLRNumber;
7849 : }
7850 :
7851 5 : int GetVSCoilCapFTCurveIndex(EnergyPlusData &state,
7852 : int const CoilIndex, // must match coil names for the coil type
7853 : bool &ErrorsFound // set to true if problem
7854 : )
7855 : {
7856 :
7857 : // FUNCTION INFORMATION:
7858 : // AUTHOR Richard Raustad
7859 : // DATE WRITTEN 7/2017
7860 :
7861 : // PURPOSE OF THIS FUNCTION:
7862 : // This function looks up the given coil and returns CapFT curve index. If incorrect
7863 : // coil index is given, ErrorsFound is returned as true and value is returned as zero.
7864 :
7865 : // Return value
7866 : int CapFTIndex; // returned CapFT curve index of matched coil
7867 :
7868 : // Obtains and Allocates WatertoAirHP related parameters from input file
7869 5 : if (state.dataVariableSpeedCoils->GetCoilsInputFlag) { // First time subroutine has been entered
7870 0 : GetVarSpeedCoilInput(state);
7871 0 : state.dataVariableSpeedCoils->GetCoilsInputFlag = false;
7872 : }
7873 :
7874 5 : if (CoilIndex == 0) {
7875 0 : ShowSevereError(state, "GetVSCoilCapFTCurveIndex: Could not find Coil");
7876 0 : ErrorsFound = true;
7877 0 : CapFTIndex = 0;
7878 : } else {
7879 5 : CapFTIndex =
7880 5 : state.dataVariableSpeedCoils->VarSpeedCoil(CoilIndex).MSCCapFTemp(state.dataVariableSpeedCoils->VarSpeedCoil(CoilIndex).NumOfSpeeds);
7881 : }
7882 :
7883 5 : return CapFTIndex;
7884 : }
7885 :
7886 1 : int GetCoilInletNodeVariableSpeed(EnergyPlusData &state,
7887 : std::string const &CoilType, // must match coil types in this module
7888 : std::string const &CoilName, // must match coil names for the coil type
7889 : bool &ErrorsFound // set to true if problem
7890 : )
7891 : {
7892 :
7893 : // FUNCTION INFORMATION:
7894 : // AUTHOR Bo Shen, based on WaterToAirHeatPumpSimple:GetCoilInletNode
7895 : // DATE WRITTEN March 2012
7896 :
7897 : // PURPOSE OF THIS FUNCTION:
7898 : // This function looks up the given coil and returns the inlet node. If incorrect
7899 : // coil type or name is given, ErrorsFound is returned as true and value is returned as zero.
7900 :
7901 : // Return value
7902 : int NodeNumber; // returned outlet node of matched coil
7903 :
7904 : // FUNCTION LOCAL VARIABLE DECLARATIONS:
7905 : int WhichCoil;
7906 :
7907 : // Obtains and Allocates WatertoAirHP related parameters from input file
7908 1 : if (state.dataVariableSpeedCoils->GetCoilsInputFlag) { // First time subroutine has been entered
7909 0 : GetVarSpeedCoilInput(state);
7910 0 : state.dataVariableSpeedCoils->GetCoilsInputFlag = false;
7911 : }
7912 :
7913 1 : WhichCoil = Util::FindItemInList(CoilName, state.dataVariableSpeedCoils->VarSpeedCoil);
7914 1 : if (WhichCoil != 0) {
7915 1 : NodeNumber = state.dataVariableSpeedCoils->VarSpeedCoil(WhichCoil).AirInletNodeNum;
7916 : }
7917 :
7918 1 : if (WhichCoil == 0) {
7919 0 : ShowSevereError(state, format("GetCoilInletNodeVariableSpeed: Could not find CoilType=\"{}\" with Name=\"{}\"", CoilType, CoilName));
7920 0 : ErrorsFound = true;
7921 0 : NodeNumber = 0;
7922 : }
7923 :
7924 1 : return NodeNumber;
7925 : }
7926 :
7927 4 : int GetCoilOutletNodeVariableSpeed(EnergyPlusData &state,
7928 : std::string const &CoilType, // must match coil types in this module
7929 : std::string const &CoilName, // must match coil names for the coil type
7930 : bool &ErrorsFound // set to true if problem
7931 : )
7932 : {
7933 :
7934 : // FUNCTION INFORMATION:
7935 : // AUTHOR Bo Shen, based on WaterToAirHeatPumpSimple:GetCoilOutletNode
7936 : // DATE WRITTEN March 2012
7937 :
7938 : // PURPOSE OF THIS FUNCTION:
7939 : // This function looks up the given coil and returns the outlet node. If incorrect
7940 : // coil type or name is given, ErrorsFound is returned as true and value is returned as zero.
7941 :
7942 : // Return value
7943 : int NodeNumber; // returned outlet node of matched coil
7944 :
7945 : // FUNCTION LOCAL VARIABLE DECLARATIONS:
7946 : int WhichCoil;
7947 :
7948 : // Obtains and Allocates WatertoAirHP related parameters from input file
7949 4 : if (state.dataVariableSpeedCoils->GetCoilsInputFlag) { // First time subroutine has been entered
7950 3 : GetVarSpeedCoilInput(state);
7951 3 : state.dataVariableSpeedCoils->GetCoilsInputFlag = false;
7952 : }
7953 :
7954 4 : WhichCoil = Util::FindItemInList(CoilName, state.dataVariableSpeedCoils->VarSpeedCoil);
7955 4 : if (WhichCoil != 0) {
7956 4 : NodeNumber = state.dataVariableSpeedCoils->VarSpeedCoil(WhichCoil).AirOutletNodeNum;
7957 : }
7958 :
7959 4 : if (WhichCoil == 0) {
7960 0 : ShowSevereError(state, format("GetCoilOutletNodeVariableSpeed: Could not find CoilType=\"{}\" with Name=\"{}\"", CoilType, CoilName));
7961 0 : ErrorsFound = true;
7962 0 : NodeNumber = 0;
7963 : }
7964 :
7965 4 : return NodeNumber;
7966 : }
7967 :
7968 8 : int GetVSCoilCondenserInletNode(EnergyPlusData &state,
7969 : std::string const &CoilName, // must match coil names for the coil type
7970 : bool &ErrorsFound // set to true if problem
7971 : )
7972 : {
7973 :
7974 : // FUNCTION INFORMATION:
7975 : // AUTHOR Bo Shen, based on DXCoil:GetCoilCondenserInletNode
7976 : // DATE WRITTEN July 2012
7977 :
7978 : // PURPOSE OF THIS FUNCTION:
7979 : // This function looks up the given coil and returns the condenser inlet node. If
7980 : // incorrect coil name is given, ErrorsFound is returned as true.
7981 :
7982 : // Return value
7983 : int CondNode; // returned condenser node number of matched coil
7984 :
7985 : // FUNCTION LOCAL VARIABLE DECLARATIONS:
7986 : int WhichCoil;
7987 :
7988 : // Obtains and Allocates WatertoAirHP related parameters from input file
7989 8 : if (state.dataVariableSpeedCoils->GetCoilsInputFlag) { // First time subroutine has been entered
7990 0 : GetVarSpeedCoilInput(state);
7991 0 : state.dataVariableSpeedCoils->GetCoilsInputFlag = false;
7992 : }
7993 :
7994 8 : WhichCoil = Util::FindItemInList(CoilName, state.dataVariableSpeedCoils->VarSpeedCoil);
7995 8 : if (WhichCoil != 0) {
7996 8 : CondNode = state.dataVariableSpeedCoils->VarSpeedCoil(WhichCoil).CondenserInletNodeNum;
7997 : } else {
7998 0 : ShowSevereError(state, format("GetCoilCondenserInletNode: Invalid VS DX Coil, Type= VS DX Cooling Name=\"{}\"", CoilName));
7999 0 : ErrorsFound = true;
8000 0 : CondNode = 0;
8001 : }
8002 :
8003 8 : return CondNode;
8004 : }
8005 :
8006 13 : Real64 GetVSCoilMinOATCompressor(EnergyPlusData &state,
8007 : int const CoilIndex, // index to cooling coil
8008 : bool &ErrorsFound // set to true if problem
8009 : )
8010 : {
8011 : // Obtains and Allocates WatertoAirHP related parameters from input file
8012 13 : if (state.dataVariableSpeedCoils->GetCoilsInputFlag) { // First time subroutine has been entered
8013 0 : GetVarSpeedCoilInput(state);
8014 0 : state.dataVariableSpeedCoils->GetCoilsInputFlag = false;
8015 : }
8016 :
8017 13 : if (CoilIndex == 0) {
8018 0 : ShowSevereError(state, "GetVSCoilMinOATCompressor: Index passed = 0");
8019 0 : ShowContinueError(state, "... returning Min OAT as -1000.");
8020 0 : ErrorsFound = true;
8021 0 : return -1000.0;
8022 : } else {
8023 13 : return state.dataVariableSpeedCoils->VarSpeedCoil(CoilIndex).MinOATCompressor;
8024 : }
8025 : }
8026 :
8027 7 : int GetVSCoilNumOfSpeeds(EnergyPlusData &state,
8028 : std::string const &CoilName, // must match coil names for the coil type
8029 : bool &ErrorsFound // set to true if problem
8030 : )
8031 : {
8032 :
8033 : // FUNCTION INFORMATION:
8034 : // AUTHOR Richard Raustad, FSEC
8035 : // DATE WRITTEN March 2013
8036 :
8037 : // PURPOSE OF THIS FUNCTION:
8038 : // This function looks up the given coil and returns number of speeds. If
8039 : // incorrect coil name is given, ErrorsFound is returned as true.
8040 :
8041 : // Return value
8042 : int Speeds; // returned number of speeds
8043 :
8044 : // Obtains and Allocates WatertoAirHP related parameters from input file
8045 7 : if (state.dataVariableSpeedCoils->GetCoilsInputFlag) { // First time subroutine has been entered
8046 0 : GetVarSpeedCoilInput(state);
8047 0 : state.dataVariableSpeedCoils->GetCoilsInputFlag = false;
8048 : }
8049 :
8050 7 : int WhichCoil = Util::FindItemInList(CoilName, state.dataVariableSpeedCoils->VarSpeedCoil);
8051 7 : if (WhichCoil != 0) {
8052 7 : Speeds = state.dataVariableSpeedCoils->VarSpeedCoil(WhichCoil).NumOfSpeeds;
8053 : } else {
8054 0 : ShowSevereError(state, format("GetVSCoilNumOfSpeeds: Invalid VS DX Coil, Type= VS DX Coil Name=\"{}\"", CoilName));
8055 0 : ErrorsFound = true;
8056 0 : Speeds = 0;
8057 : }
8058 :
8059 7 : return Speeds;
8060 : }
8061 :
8062 28 : Real64 GetVSCoilRatedSourceTemp(EnergyPlusData &state, int const CoilIndex)
8063 : {
8064 28 : Real64 RatedSourceTemp = 0.0;
8065 28 : switch (state.dataVariableSpeedCoils->VarSpeedCoil(CoilIndex).VSCoilType) {
8066 7 : case HVAC::Coil_CoolingWaterToAirHPVSEquationFit: {
8067 7 : RatedSourceTemp = RatedInletWaterTemp;
8068 7 : } break;
8069 3 : case HVAC::Coil_HeatingWaterToAirHPVSEquationFit: {
8070 3 : RatedSourceTemp = RatedInletWaterTempHeat;
8071 3 : } break;
8072 1 : case HVAC::CoilDX_HeatPumpWaterHeaterVariableSpeed: {
8073 1 : RatedSourceTemp = state.dataVariableSpeedCoils->VarSpeedCoil(CoilIndex).WHRatedInletWaterTemp;
8074 1 : } break;
8075 12 : case HVAC::Coil_CoolingAirToAirVariableSpeed: {
8076 12 : RatedSourceTemp = RatedAmbAirTemp;
8077 12 : } break;
8078 5 : case HVAC::Coil_HeatingAirToAirVariableSpeed: {
8079 5 : RatedSourceTemp = RatedAmbAirTempHeat;
8080 5 : } break;
8081 0 : default: {
8082 0 : assert(false);
8083 : } break;
8084 : }
8085 28 : return RatedSourceTemp;
8086 : }
8087 :
8088 12 : void SetVarSpeedCoilData(EnergyPlusData &state,
8089 : int const WSHPNum, // Number of OA Controller
8090 : bool &ErrorsFound, // Set to true if certain errors found
8091 : ObjexxFCL::Optional_int CompanionCoolingCoilNum, // Index to cooling coil for heating coil = SimpleWSHPNum
8092 : ObjexxFCL::Optional_int CompanionHeatingCoilNum, // Index to heating coil for cooling coil = SimpleWSHPNum
8093 : ObjexxFCL::Optional_int MSHPDesignSpecIndex // index to UnitarySystemPerformance:Multispeed object
8094 : )
8095 : {
8096 :
8097 : // SUBROUTINE INFORMATION:
8098 : // AUTHOR Bo Shen, based on WaterToAirHeatPumpSimple:SetWSHPData
8099 : // DATE WRITTEN March 2012
8100 :
8101 : // PURPOSE OF THIS SUBROUTINE:
8102 : // This routine was designed to "push" information from a parent object to this WSHP coil object.
8103 :
8104 : // Obtains and Allocates WatertoAirHP related parameters from input file
8105 12 : if (state.dataVariableSpeedCoils->GetCoilsInputFlag) { // First time subroutine has been entered
8106 0 : GetVarSpeedCoilInput(state);
8107 0 : state.dataVariableSpeedCoils->GetCoilsInputFlag = false;
8108 : }
8109 :
8110 12 : if (WSHPNum <= 0 || WSHPNum > state.dataVariableSpeedCoils->NumVarSpeedCoils) {
8111 0 : ShowSevereError(state,
8112 0 : format("SetVarSpeedCoilData: called with VS WSHP Coil Number out of range={} should be >0 and <{}",
8113 : WSHPNum,
8114 0 : state.dataVariableSpeedCoils->NumVarSpeedCoils));
8115 0 : ErrorsFound = true;
8116 0 : return;
8117 : }
8118 :
8119 12 : if (present(CompanionCoolingCoilNum)) {
8120 0 : state.dataVariableSpeedCoils->VarSpeedCoil(WSHPNum).CompanionCoolingCoilNum = CompanionCoolingCoilNum;
8121 0 : state.dataVariableSpeedCoils->VarSpeedCoil(WSHPNum).FindCompanionUpStreamCoil = true;
8122 0 : state.dataVariableSpeedCoils->VarSpeedCoil(CompanionCoolingCoilNum).CompanionHeatingCoilNum = WSHPNum;
8123 : }
8124 :
8125 12 : if (present(CompanionHeatingCoilNum)) {
8126 1 : state.dataVariableSpeedCoils->VarSpeedCoil(WSHPNum).CompanionHeatingCoilNum = CompanionHeatingCoilNum;
8127 1 : state.dataVariableSpeedCoils->VarSpeedCoil(CompanionHeatingCoilNum).CompanionCoolingCoilNum = WSHPNum;
8128 : }
8129 :
8130 12 : if (present(MSHPDesignSpecIndex)) {
8131 11 : state.dataVariableSpeedCoils->VarSpeedCoil(WSHPNum).MSHPDesignSpecIndex = MSHPDesignSpecIndex;
8132 : }
8133 : }
8134 :
8135 67679 : void UpdateVarSpeedCoil(EnergyPlusData &state, int const DXCoilNum)
8136 : {
8137 : // SUBROUTINE INFORMATION:
8138 : // AUTHOR Bo Shen, based on WaterToAirHeatPumpSimple:UpdateSimpleWSHP
8139 : // DATE WRITTEN March 2012
8140 :
8141 : // PURPOSE OF THIS SUBROUTINE:
8142 : // This subroutine updates the Water to Air Heat Pump outlet nodes.
8143 :
8144 : // METHODOLOGY EMPLOYED:
8145 : // Data is moved from the HP data structure to the HP outlet nodes.
8146 :
8147 : // Using/Aliasing
8148 67679 : Real64 TimeStepSysSec = state.dataHVACGlobal->TimeStepSysSec;
8149 :
8150 67679 : auto &varSpeedCoil = state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum);
8151 :
8152 : // WatertoAirHP(DXCoilNum)%SimFlag=.FALSE.
8153 67679 : if (!varSpeedCoil.SimFlag) {
8154 : // Heatpump is off; just pass through conditions
8155 39555 : varSpeedCoil.Power = 0.0;
8156 39555 : varSpeedCoil.QLoadTotal = 0.0;
8157 39555 : varSpeedCoil.QSensible = 0.0;
8158 39555 : varSpeedCoil.QLatent = 0.0;
8159 39555 : varSpeedCoil.QSource = 0.0;
8160 39555 : varSpeedCoil.Energy = 0.0;
8161 39555 : varSpeedCoil.EnergyLoadTotal = 0.0;
8162 39555 : varSpeedCoil.EnergySensible = 0.0;
8163 39555 : varSpeedCoil.EnergyLatent = 0.0;
8164 39555 : varSpeedCoil.EnergySource = 0.0;
8165 39555 : varSpeedCoil.COP = 0.0;
8166 39555 : varSpeedCoil.RunFrac = 0.0;
8167 39555 : varSpeedCoil.PartLoadRatio = 0.0;
8168 :
8169 39555 : varSpeedCoil.OutletAirDBTemp = varSpeedCoil.InletAirDBTemp;
8170 39555 : varSpeedCoil.OutletAirHumRat = varSpeedCoil.InletAirHumRat;
8171 39555 : varSpeedCoil.OutletAirEnthalpy = varSpeedCoil.InletAirEnthalpy;
8172 39555 : varSpeedCoil.OutletWaterTemp = varSpeedCoil.InletWaterTemp;
8173 39555 : varSpeedCoil.OutletWaterEnthalpy = varSpeedCoil.InletWaterEnthalpy;
8174 : }
8175 :
8176 67679 : int AirInletNode = varSpeedCoil.AirInletNodeNum;
8177 67679 : int WaterInletNode = varSpeedCoil.WaterInletNodeNum;
8178 67679 : int AirOutletNode = varSpeedCoil.AirOutletNodeNum;
8179 67679 : int WaterOutletNode = varSpeedCoil.WaterOutletNodeNum;
8180 :
8181 : // Set the air outlet nodes of the WatertoAirHPSimple
8182 67679 : state.dataLoopNodes->Node(AirOutletNode).MassFlowRate = state.dataLoopNodes->Node(AirInletNode).MassFlowRate; // LoadSideMassFlowRate
8183 67679 : state.dataLoopNodes->Node(AirOutletNode).Temp = varSpeedCoil.OutletAirDBTemp;
8184 67679 : state.dataLoopNodes->Node(AirOutletNode).HumRat = varSpeedCoil.OutletAirHumRat;
8185 67679 : state.dataLoopNodes->Node(AirOutletNode).Enthalpy = varSpeedCoil.OutletAirEnthalpy;
8186 :
8187 : // Set the air outlet nodes for properties that just pass through & not used
8188 67679 : state.dataLoopNodes->Node(AirOutletNode).Quality = state.dataLoopNodes->Node(AirInletNode).Quality;
8189 67679 : state.dataLoopNodes->Node(AirOutletNode).Press = state.dataLoopNodes->Node(AirInletNode).Press;
8190 67679 : state.dataLoopNodes->Node(AirOutletNode).MassFlowRateMin = state.dataLoopNodes->Node(AirInletNode).MassFlowRateMin;
8191 67679 : state.dataLoopNodes->Node(AirOutletNode).MassFlowRateMax = state.dataLoopNodes->Node(AirInletNode).MassFlowRateMax; // LoadSideMassFlowRate
8192 67679 : state.dataLoopNodes->Node(AirOutletNode).MassFlowRateMinAvail = state.dataLoopNodes->Node(AirInletNode).MassFlowRateMinAvail;
8193 67679 : state.dataLoopNodes->Node(AirOutletNode).MassFlowRateMaxAvail =
8194 67679 : state.dataLoopNodes->Node(AirInletNode).MassFlowRateMaxAvail; // LoadSideMassFlowRate
8195 :
8196 : // Set the water outlet node of the WatertoAirHPSimple
8197 : // Set the water outlet nodes for properties that just pass through & not used
8198 67679 : if (WaterInletNode != 0 && WaterOutletNode != 0) {
8199 67273 : PlantUtilities::SafeCopyPlantNode(state, WaterInletNode, WaterOutletNode);
8200 67273 : state.dataLoopNodes->Node(WaterOutletNode).Temp = varSpeedCoil.OutletWaterTemp;
8201 67273 : state.dataLoopNodes->Node(WaterOutletNode).Enthalpy = varSpeedCoil.OutletWaterEnthalpy;
8202 : }
8203 :
8204 67679 : varSpeedCoil.Energy = varSpeedCoil.Power * TimeStepSysSec;
8205 67679 : varSpeedCoil.EnergyLoadTotal = varSpeedCoil.QLoadTotal * TimeStepSysSec;
8206 67679 : varSpeedCoil.EnergySensible = varSpeedCoil.QSensible * TimeStepSysSec;
8207 67679 : varSpeedCoil.EnergyLatent = varSpeedCoil.QLatent * TimeStepSysSec;
8208 67679 : varSpeedCoil.EnergySource = varSpeedCoil.QSource * TimeStepSysSec;
8209 :
8210 67679 : if (state.dataContaminantBalance->Contaminant.CO2Simulation) {
8211 1 : state.dataLoopNodes->Node(AirOutletNode).CO2 = state.dataLoopNodes->Node(AirInletNode).CO2;
8212 : }
8213 :
8214 67679 : if (state.dataContaminantBalance->Contaminant.GenericContamSimulation) {
8215 1 : state.dataLoopNodes->Node(AirOutletNode).GenContam = state.dataLoopNodes->Node(AirInletNode).GenContam;
8216 : }
8217 :
8218 67679 : if (varSpeedCoil.reportCoilFinalSizes) {
8219 23 : if (!state.dataGlobal->WarmupFlag && !state.dataGlobal->DoingHVACSizingSimulations && !state.dataGlobal->DoingSizing) {
8220 19 : if (varSpeedCoil.VSCoilType == HVAC::Coil_CoolingWaterToAirHPVSEquationFit ||
8221 17 : varSpeedCoil.VSCoilType == HVAC::Coil_CoolingAirToAirVariableSpeed) { // cooling coil
8222 13 : state.dataRptCoilSelection->coilSelectionReportObj->setCoilFinalSizes(state,
8223 13 : varSpeedCoil.Name,
8224 13 : varSpeedCoil.VarSpeedCoilType,
8225 : varSpeedCoil.RatedCapCoolTotal,
8226 : varSpeedCoil.RatedCapCoolSens,
8227 : varSpeedCoil.RatedAirVolFlowRate,
8228 : varSpeedCoil.RatedWaterMassFlowRate);
8229 6 : } else if (varSpeedCoil.VSCoilType == HVAC::Coil_HeatingWaterToAirHPVSEquationFit ||
8230 5 : varSpeedCoil.VSCoilType == HVAC::Coil_HeatingAirToAirVariableSpeed) { // heating coil
8231 6 : state.dataRptCoilSelection->coilSelectionReportObj->setCoilFinalSizes(state,
8232 6 : varSpeedCoil.Name,
8233 6 : varSpeedCoil.VarSpeedCoilType,
8234 : varSpeedCoil.RatedCapHeat,
8235 : varSpeedCoil.RatedCapHeat,
8236 : varSpeedCoil.RatedAirVolFlowRate,
8237 : varSpeedCoil.RatedWaterMassFlowRate);
8238 : }
8239 19 : varSpeedCoil.reportCoilFinalSizes = false;
8240 : }
8241 : }
8242 67679 : if (varSpeedCoil.VSCoilType == HVAC::Coil_CoolingWaterToAirHPVSEquationFit ||
8243 34042 : varSpeedCoil.VSCoilType == HVAC::Coil_CoolingAirToAirVariableSpeed) {
8244 : // Add power to global variable so power can be summed by parent object
8245 34011 : state.dataHVACGlobal->DXElecCoolingPower = varSpeedCoil.Power;
8246 33668 : } else if (varSpeedCoil.VSCoilType == HVAC::Coil_HeatingWaterToAirHPVSEquationFit) {
8247 : // Add power to global variable so power can be summed by parent object
8248 33636 : state.dataHVACGlobal->DXElecHeatingPower = varSpeedCoil.Power;
8249 32 : } else if (varSpeedCoil.VSCoilType == HVAC::Coil_HeatingAirToAirVariableSpeed) {
8250 : // Add power to global variable so power can be summed by parent object
8251 31 : state.dataHVACGlobal->DXElecHeatingPower = varSpeedCoil.Power + varSpeedCoil.CrankcaseHeaterPower;
8252 31 : state.dataHVACGlobal->DefrostElecPower = varSpeedCoil.DefrostPower;
8253 : }
8254 67679 : }
8255 :
8256 11 : Real64 CalcEffectiveSHR(EnergyPlusData &state,
8257 : int const DXCoilNum, // Index number for cooling coil
8258 : Real64 const SHRss, // Steady-state sensible heat ratio
8259 : HVAC::FanOp const fanOp, // Fan/compressor cycling scheme indicator
8260 : Real64 const RTF, // Compressor run-time fraction
8261 : Real64 const QLatRated, // Rated latent capacity
8262 : Real64 const QLatActual, // Actual latent capacity
8263 : Real64 const EnteringDB, // Entering air dry-bulb temperature
8264 : Real64 const EnteringWB // Entering air wet-bulb temperature
8265 : )
8266 : {
8267 :
8268 : // FUNCTION INFORMATION:
8269 : // AUTHOR Bo Shen, based on WaterToAirHeatPumpSimple:CalcEffectiveSHR
8270 : // DATE WRITTEN March 2012
8271 :
8272 : // PURPOSE OF THIS FUNCTION:
8273 : // Adjust sensible heat ratio to account for degradation of DX coil latent
8274 : // capacity at part-load (cycling) conditions.
8275 :
8276 : // METHODOLOGY EMPLOYED:
8277 : // With model parameters entered by the user, the part-load latent performance
8278 : // of a DX cooling coil is determined for a constant air flow system with
8279 : // a cooling coil that cycles on/off. The model calculates the time
8280 : // required for condensate to begin falling from the cooling coil.
8281 : // Runtimes greater than this are integrated to a "part-load" latent
8282 : // capacity which is used to determine the "part-load" sensible heat ratio.
8283 : // See reference below for additional details (linear decay model, Eq. 8b).
8284 :
8285 : // For cycling fan operation, a modified version of Henderson and Rengarajan (1996)
8286 : // model is used by ultilizing the fan delay time as the time-off (or time duration
8287 : // for the re-evaporation of moisture from time coil). Refer to Tang, C.C. (2005)
8288 :
8289 : // Return value
8290 : Real64 SHReff; // Effective sensible heat ratio, includes degradation due to cycling effects
8291 :
8292 : // FUNCTION LOCAL VARIABLE DECLARATIONS:
8293 : Real64 Twet; // Nominal time for condensate to begin leaving the coil's condensate drain line
8294 : // at the current operating conditions (sec)
8295 : Real64 Gamma; // Initial moisture evaporation rate divided by steady-state AC latent capacity
8296 : // at the current operating conditions
8297 : Real64 Twet_max; // Maximum allowed value for Twet
8298 : Real64 Ton; // Coil on time (sec)
8299 : Real64 Toff; // Coil off time (sec)
8300 : Real64 Toffa; // Actual coil off time (sec). Equations valid for Toff <= (2.0 * Twet/Gamma)
8301 : Real64 aa; // Intermediate variable
8302 : Real64 To1; // Intermediate variable (first guess at To). To = time to the start of moisture removal
8303 : Real64 To2; // Intermediate variable (second guess at To). To = time to the start of moisture removal
8304 : Real64 Error; // Error for iteration (DO) loop
8305 : Real64 LHRmult; // Latent Heat Ratio (LHR) multiplier. The effective latent heat ratio LHR = (1-SHRss)*LHRmult
8306 :
8307 11 : Real64 Twet_Rated = state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Twet_Rated; // [s]
8308 11 : Real64 Gamma_Rated = state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Gamma_Rated;
8309 11 : Real64 MaxONOFFCyclesperHour = state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MaxONOFFCyclesperHour; // [cycles/hr]
8310 11 : Real64 LatentCapacityTimeConstant = state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).LatentCapacityTimeConstant; // [s]
8311 11 : Real64 FanDelayTime = state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).FanDelayTime; // [s]
8312 :
8313 : // No moisture evaporation (latent degradation) occurs for runtime fraction of 1.0
8314 : // All latent degradation model parameters cause divide by 0.0 if not greater than 0.0
8315 : // Latent degradation model parameters initialize to 0.0 meaning no evaporation model used.
8316 11 : if ((RTF >= 1.0) || (QLatRated == 0.0) || (QLatActual == 0.0) || (Twet_Rated <= 0.0) || (Gamma_Rated <= 0.0) ||
8317 7 : (MaxONOFFCyclesperHour <= 0.0) || (LatentCapacityTimeConstant <= 0.0) || (RTF <= 0.0)) {
8318 4 : SHReff = SHRss;
8319 4 : return SHReff;
8320 : }
8321 :
8322 7 : Twet_max = 9999.0; // high limit for Twet
8323 :
8324 : // Calculate the model parameters at the actual operating conditions
8325 7 : Twet = min(Twet_Rated * QLatRated / (QLatActual + 1.e-10), Twet_max);
8326 7 : Gamma = Gamma_Rated * QLatRated * (EnteringDB - EnteringWB) / ((26.7 - 19.4) * QLatActual + 1.e-10);
8327 :
8328 : // Calculate the compressor on and off times using a converntional thermostat curve
8329 7 : Ton = 3600.0 / (4.0 * MaxONOFFCyclesperHour * (1.0 - RTF)); // duration of cooling coil on-cycle (sec)
8330 :
8331 7 : if ((fanOp == HVAC::FanOp::Cycling) && (FanDelayTime != 0.0)) {
8332 : // For FanOp::Cycling, moisture is evaporated from the cooling coil back to the air stream
8333 : // until the fan cycle off. Assume no evaporation from the coil after the fan shuts off.
8334 0 : Toff = FanDelayTime;
8335 : } else {
8336 : // For FanOp::Continuous, moisture is evaporated from the cooling coil back to the air stream
8337 : // for the entire heat pump off-cycle.
8338 7 : Toff = 3600.0 / (4.0 * MaxONOFFCyclesperHour * RTF); // duration of cooling coil off-cycle (sec)
8339 : }
8340 :
8341 : // Cap Toff to meet the equation restriction
8342 7 : if (Gamma > 0.0) {
8343 7 : Toffa = min(Toff, 2.0 * Twet / Gamma);
8344 : } else {
8345 0 : Toffa = Toff;
8346 : }
8347 :
8348 : // Use sucessive substitution to solve for To
8349 7 : aa = (Gamma * Toffa) - (0.25 / Twet) * pow_2(Gamma) * pow_2(Toffa);
8350 :
8351 7 : To1 = aa + LatentCapacityTimeConstant;
8352 7 : Error = 1.0;
8353 14 : while (Error > 0.001) {
8354 7 : To2 = aa - LatentCapacityTimeConstant * (std::exp(-To1 / LatentCapacityTimeConstant) - 1.0);
8355 7 : Error = std::abs((To2 - To1) / To1);
8356 7 : To1 = To2;
8357 : }
8358 :
8359 : // Adjust Sensible Heat Ratio (SHR) using Latent Heat Ratio (LHR) multiplier
8360 : // Floating underflow errors occur when -Ton/LatentCapacityTimeConstant is a large negative number.
8361 : // Cap lower limit at -700 to avoid the underflow errors.
8362 7 : aa = std::exp(max(-700.0, -Ton / LatentCapacityTimeConstant));
8363 : // Calculate latent heat ratio multiplier
8364 7 : LHRmult = max(((Ton - To2) / (Ton + LatentCapacityTimeConstant * (aa - 1.0))), 0.0);
8365 :
8366 : // Calculate part-load or "effective" sensible heat ratio
8367 7 : SHReff = 1.0 - (1.0 - SHRss) * LHRmult;
8368 :
8369 7 : if (SHReff < SHRss) {
8370 0 : SHReff = SHRss; // Effective SHR can be less than the steady-state SHR
8371 : }
8372 7 : if (SHReff > 1.0) {
8373 0 : SHReff = 1.0; // Effective sensible heat ratio can't be greater than 1.0
8374 : }
8375 :
8376 7 : return SHReff;
8377 : }
8378 :
8379 17696 : void CalcTotCapSHR_VSWSHP(EnergyPlusData &state,
8380 : Real64 const InletDryBulb, // inlet air dry bulb temperature [C]
8381 : Real64 const InletHumRat, // inlet air humidity ratio [kg water / kg dry air]
8382 : Real64 const InletEnthalpy, // inlet air specific enthalpy [J/kg]
8383 : Real64 &InletWetBulb, // inlet air wet bulb temperature [C]
8384 : Real64 const AirMassFlowRatio, // Ratio of actual air mass flow to nominal air mass flow
8385 : Real64 const WaterMassFlowRatio, // Ratio of actual water mass flow to nominal water mass flow
8386 : Real64 const AirMassFlow, // actual mass flow for capacity and SHR calculation
8387 : Real64 const CBF, // coil bypass factor
8388 : Real64 const TotCapNom1, // nominal total capacity at low speed [W]
8389 : int const CCapFTemp1, // capacity modifier curve index, function of entering wetbulb at low speed
8390 : int const CCapAirFFlow1, // capacity modifier curve, function of actual air flow vs rated flow at low speed
8391 : int const CCapWaterFFlow1, // capacity modifier curve, function of actual water flow vs rated flow at low speed
8392 : Real64 const TotCapNom2, // nominal total capacity at high speed [W]
8393 : int const CCapFTemp2, // capacity modifier curve index, function of entering wetbulb at high speed
8394 : int const CCapAirFFlow2, // capacity modifier curve, function of actual air flow vs rated flow at high speed
8395 : int const CCapWaterFFlow2, // capacity modifier curve, function of actual water flow vs rated flow at high speed
8396 : Real64 &TotCap1, // total capacity at the given conditions [W] at low speed
8397 : Real64 &TotCap2, // total capacity at the given conditions [W] at high speed
8398 : Real64 &TotCapSpeed, // integrated total capacity corresponding to the speed ratio
8399 : Real64 &SHR, // sensible heat ratio at the given conditions
8400 : Real64 const CondInletTemp, // Condenser inlet temperature [C]
8401 : Real64 const Pressure, // air pressure [Pa]
8402 : Real64 const SpeedRatio, // from 0.0 to 1.0
8403 : int const NumSpeeds, // number of speeds for input
8404 : Real64 &TotCapModFac // capacity modification factor, func of temp and func of flow
8405 : )
8406 : {
8407 :
8408 : // SUBROUTINE INFORMATION:
8409 : // AUTHOR Bo Shen, , based on DX:CalcTotCapSHR, introducing two speed levels
8410 : // DATE WRITTEN March 2012
8411 :
8412 : // PURPOSE OF THIS SUBROUTINE:
8413 : // Calculates total capacity and sensible heat ratio of a DX coil at the specified conditions
8414 :
8415 : // METHODOLOGY EMPLOYED:
8416 : // With the rated performance data entered by the user, the model employs some of the
8417 : // DOE-2.1E curve fits to adjust the capacity and SHR of the unit as a function
8418 : // of entering air temperatures and supply air flow rate (actual vs rated flow). The model
8419 : // does NOT employ the exact same methodology to calculate performance as DOE-2, although
8420 : // some of the DOE-2 curve fits are employed by this model.
8421 :
8422 : // The model checks for coil dryout conditions, and adjusts the calculated performance appropriately.
8423 :
8424 : // REFERENCES:
8425 : // ASHRAE HVAC 2 Toolkit page 4-81.
8426 : // Henderson, H.I. Jr., K. Rengarajan and D.B. Shirey, III. 1992.The impact of comfort
8427 : // control on air conditioner energy use in humid climates. ASHRAE Transactions 98(2):
8428 : // 104-113.
8429 : // Henderson, H.I. Jr., Danny Parker and Y.J. Huang. 2000.Improving DOE-2's RESYS routine:
8430 : // User Defined Functions to Provide More Accurate Part Load Energy Use and Humidity
8431 : // Predictions. Proceedings of ACEEE Conference.
8432 :
8433 : // SUBROUTINE PARAMETER DEFINITIONS:
8434 : static constexpr std::string_view RoutineName("CalcTotCapSHR_VSWSHP");
8435 17696 : constexpr int MaxIter = 30; // Maximum number of iterations for dry evaporator calculations
8436 17696 : constexpr Real64 Tolerance = 0.01; // Error tolerance for dry evaporator iterations
8437 :
8438 : // SUBROUTINE LOCAL VARIABLE DECLARATIONS:
8439 : Real64 TotCapWaterFlowModFac1; // Total capacity modifier (function of actual supply water flow vs nominal flow) at low speed
8440 : Real64 TotCapTempModFac2; // Total capacity modifier (function of entering wetbulb, outside water inlet temp) at high speed
8441 : Real64 TotCapAirFlowModFac2; // Total capacity modifier (function of actual supply air flow vs nominal flow) at high speed
8442 : Real64 TotCapWaterFlowModFac2; // Total capacity modifier (function of actual supply water flow vs nominal flow) at high speed
8443 : Real64 TotCapCalc; // temporary calculated value of total capacity [W]
8444 : Real64 TotCapCalc1; // temporary calculated value of total capacity [W] at low speed
8445 : Real64 TotCapCalc2; // temporary calculated value of total capacity [W] at high speed
8446 :
8447 17696 : int Counter = 0; // Error tolerance for dry evaporator iterations
8448 17696 : Real64 RF = 0.4; // Relaxation factor for dry evaporator iterations
8449 17696 : Real64 werror = 0.0; // Deviation of humidity ratio in dry evaporator iteration loop
8450 17696 : Real64 SHRCalc = SHR; // initialize temporary calculated value of SHR
8451 17696 : Real64 InletWetBulbCalc = InletWetBulb; // calculated inlet wetbulb temperature used for finding dry coil point [C]
8452 17696 : Real64 InletHumRatCalc = InletHumRat; // calculated inlet humidity ratio used for finding dry coil point [kg water / kg dry air]
8453 17696 : bool LoopOn = true; // flag to control the loop iteration
8454 :
8455 : // LOOP WHILE (ABS(werror) .gt. Tolerance .OR. Counter == 0)
8456 35402 : while (LoopOn) {
8457 : // Get capacity modifying factor (function of inlet wetbulb & condenser inlet temp) for off-rated conditions
8458 17706 : Real64 TotCapTempModFac1 = Curve::CurveValue(state, CCapFTemp1, InletWetBulbCalc, CondInletTemp);
8459 : // Get capacity modifying factor (function of mass flow) for off-rated conditions
8460 17706 : Real64 TotCapAirFlowModFac1 = Curve::CurveValue(state, CCapAirFFlow1, AirMassFlowRatio);
8461 : // Get capacity modifying factor (function of mass flow) for off-rated conditions
8462 17706 : if (CCapWaterFFlow1 == 0) {
8463 589 : TotCapWaterFlowModFac1 = 1.0;
8464 : } else {
8465 17117 : TotCapWaterFlowModFac1 = Curve::CurveValue(state, CCapWaterFFlow1, WaterMassFlowRatio);
8466 : }
8467 :
8468 : // Get total capacity
8469 17706 : if (NumSpeeds < 2) { // ONLY ONE SPEED
8470 14340 : TotCapCalc = TotCapNom1 * TotCapAirFlowModFac1 * TotCapWaterFlowModFac1 * TotCapTempModFac1;
8471 14340 : TotCapCalc1 = TotCapCalc;
8472 14340 : TotCapCalc2 = 0.0;
8473 14340 : TotCapModFac = TotCapAirFlowModFac1 * TotCapWaterFlowModFac1 * TotCapTempModFac1;
8474 : } else {
8475 3366 : TotCapTempModFac2 = Curve::CurveValue(state, CCapFTemp2, InletWetBulbCalc, CondInletTemp);
8476 3366 : TotCapAirFlowModFac2 = Curve::CurveValue(state, CCapAirFFlow2, AirMassFlowRatio);
8477 :
8478 3366 : if (CCapWaterFFlow2 == 0) {
8479 23 : TotCapWaterFlowModFac2 = 1.0;
8480 : } else {
8481 3343 : TotCapWaterFlowModFac2 = Curve::CurveValue(state, CCapWaterFFlow2, WaterMassFlowRatio);
8482 : }
8483 :
8484 3366 : TotCapCalc1 = TotCapNom1 * TotCapAirFlowModFac1 * TotCapWaterFlowModFac1 * TotCapTempModFac1;
8485 3366 : TotCapCalc2 = TotCapNom2 * TotCapAirFlowModFac2 * TotCapWaterFlowModFac2 * TotCapTempModFac2;
8486 :
8487 3366 : TotCapCalc = TotCapCalc2 * SpeedRatio + (1.0 - SpeedRatio) * TotCapCalc1;
8488 3366 : TotCapModFac = (TotCapAirFlowModFac2 * TotCapWaterFlowModFac2 * TotCapTempModFac2) * SpeedRatio +
8489 3366 : (1.0 - SpeedRatio) * (TotCapAirFlowModFac1 * TotCapWaterFlowModFac1 * TotCapTempModFac1);
8490 : }
8491 :
8492 17706 : Real64 localCBF = max(0.0, CBF); // negative coil bypass factor is physically impossible
8493 :
8494 : // Calculate apparatus dew point conditions using TotCap and CBF
8495 17706 : Real64 hDelta = TotCapCalc / AirMassFlow; // Change in air enthalpy across the cooling coil [J/kg]
8496 17706 : Real64 hADP = InletEnthalpy - hDelta / (1.0 - localCBF); // Apparatus dew point enthalpy [J/kg]
8497 17706 : Real64 tADP = Psychrometrics::PsyTsatFnHPb(state, hADP, Pressure, RoutineName); // Apparatus dew point temperature [C]
8498 17706 : Real64 wADP = Psychrometrics::PsyWFnTdbH(state, tADP, hADP, RoutineName); // Apparatus dew point humidity ratio [kg/kg]
8499 17706 : Real64 hTinwADP = Psychrometrics::PsyHFnTdbW(InletDryBulb, wADP); // Enthalpy at inlet dry-bulb and wADP [J/kg]
8500 17706 : if (TotCapCalc > 1.0e-10) {
8501 17699 : SHRCalc = min((hTinwADP - hADP) / (InletEnthalpy - hADP), 1.0); // temporary calculated value of SHR
8502 : } else {
8503 7 : SHRCalc = 1.0;
8504 : }
8505 :
8506 : // Check for dry evaporator conditions (win < wadp)
8507 17706 : if (wADP > InletHumRatCalc || (Counter >= 1 && Counter < MaxIter)) {
8508 17 : if (InletHumRatCalc == 0.0) {
8509 2 : InletHumRatCalc = 0.00001;
8510 : }
8511 17 : werror = (InletHumRatCalc - wADP) / InletHumRatCalc;
8512 : // Increase InletHumRatCalc at constant inlet air temp to find coil dry-out point. Then use the
8513 : // capacity at the dry-out point to determine exiting conditions from coil. This is required
8514 : // since the TotCapTempModFac doesn't work properly with dry-coil conditions.
8515 17 : InletHumRatCalc = RF * wADP + (1.0 - RF) * InletHumRatCalc;
8516 17 : InletWetBulbCalc = Psychrometrics::PsyTwbFnTdbWPb(state, InletDryBulb, InletHumRatCalc, Pressure);
8517 17 : ++Counter;
8518 34 : if (std::abs(werror) > Tolerance) {
8519 10 : LoopOn = true; // Recalculate with modified inlet conditions
8520 : } else {
8521 7 : LoopOn = false;
8522 : }
8523 : } else {
8524 17689 : LoopOn = false;
8525 : }
8526 : } // END LOOP
8527 :
8528 : // Calculate full load output conditions
8529 17696 : if (SHRCalc > 1.0 || Counter > 0) {
8530 7 : SHRCalc = 1.0; // if Counter > 0 means a dry coil so SHR = 1
8531 : }
8532 :
8533 17696 : SHR = SHRCalc;
8534 17696 : TotCap1 = TotCapCalc1;
8535 17696 : TotCap2 = TotCapCalc2;
8536 17696 : TotCapSpeed = TotCapCalc;
8537 17696 : InletWetBulb = InletWetBulbCalc;
8538 17696 : }
8539 :
8540 2 : Real64 getVarSpeedPartLoadRatio(EnergyPlusData &state, int const DXCoilNum)
8541 : {
8542 2 : return state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).PartLoadRatio;
8543 : }
8544 :
8545 : } // namespace VariableSpeedCoils
8546 :
8547 : } // namespace EnergyPlus
|
