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 45014786 : 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 45014786 : if (state.dataVariableSpeedCoils->GetCoilsInputFlag) { // First time subroutine has been entered
139 0 : GetVarSpeedCoilInput(state);
140 0 : state.dataVariableSpeedCoils->GetCoilsInputFlag = false;
141 : }
142 :
143 45014786 : if (CompIndex == 0) {
144 4 : DXCoilNum = Util::FindItemInList(CompName, state.dataVariableSpeedCoils->VarSpeedCoil);
145 4 : if (DXCoilNum == 0) {
146 0 : ShowFatalError(state, format("WaterToAirHPVSWEquationFit not found={}", CompName));
147 : }
148 4 : CompIndex = DXCoilNum;
149 : } else {
150 45014782 : DXCoilNum = CompIndex;
151 45014782 : 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 45014782 : 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 45014786 : if (SpeedNum < 1) {
170 1456498 : SpeedCal = 1;
171 : } else {
172 43558288 : SpeedCal = SpeedNum;
173 : }
174 :
175 85507779 : if ((state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).VSCoilType == HVAC::Coil_CoolingWaterToAirHPVSEquationFit) ||
176 40492993 : (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).VSCoilType == HVAC::Coil_CoolingAirToAirVariableSpeed)) {
177 : // Cooling mode
178 37952531 : InitVarSpeedCoil(state, DXCoilNum, SensLoad, LatentLoad, fanOp, OnOffAirFlowRatio, SpeedRatio, SpeedCal);
179 37952531 : CalcVarSpeedCoilCooling(
180 : state, DXCoilNum, fanOp, SensLoad, LatentLoad, compressorOp, PartLoadFrac, OnOffAirFlowRatio, SpeedRatio, SpeedCal);
181 37952531 : UpdateVarSpeedCoil(state, DXCoilNum);
182 9602717 : } else if ((state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).VSCoilType == HVAC::Coil_HeatingWaterToAirHPVSEquationFit) ||
183 2540462 : (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).VSCoilType == HVAC::Coil_HeatingAirToAirVariableSpeed)) {
184 : // Heating mode
185 5463079 : InitVarSpeedCoil(state, DXCoilNum, SensLoad, LatentLoad, fanOp, OnOffAirFlowRatio, SpeedRatio, SpeedCal);
186 5463079 : CalcVarSpeedCoilHeating(state, DXCoilNum, fanOp, SensLoad, compressorOp, PartLoadFrac, OnOffAirFlowRatio, SpeedRatio, SpeedCal);
187 5463079 : UpdateVarSpeedCoil(state, DXCoilNum);
188 1599176 : } else if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).VSCoilType == HVAC::CoilDX_HeatPumpWaterHeaterVariableSpeed) {
189 : // Heating mode
190 1599176 : InitVarSpeedCoil(state, DXCoilNum, SensLoad, LatentLoad, fanOp, OnOffAirFlowRatio, SpeedRatio, SpeedCal);
191 1599176 : CalcVarSpeedHPWH(state, DXCoilNum, PartLoadFrac, SpeedRatio, SpeedNum, fanOp);
192 1599176 : 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 45014786 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).SpeedNumReport = SpeedCal;
199 45014786 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).SpeedRatioReport = SpeedRatio;
200 45014786 : }
201 :
202 22 : 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 22 : int MaxNums(0); // Maximum number of numeric input fields
225 22 : int MaxAlphas(0); // Maximum number of alpha input fields
226 : int IOStat;
227 : int AlfaFieldIncre; // increment number of Alfa field
228 22 : 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 22 : std::string CurrentModuleObject; // for ease in getting objects
233 22 : Array1D_string AlphArray; // Alpha input items for object
234 22 : Array1D_string cAlphaFields; // Alpha field names
235 22 : Array1D_string cNumericFields; // Numeric field names
236 22 : Array1D<Real64> NumArray; // Numeric input items for object
237 22 : Array1D_bool lAlphaBlanks; // Logical array, alpha field input BLANK = .TRUE.
238 22 : Array1D_bool lNumericBlanks; // Logical array, numeric field input BLANK = .TRUE.
239 :
240 : int NumCool =
241 22 : state.dataInputProcessing->inputProcessor->getNumObjectsFound(state, "COIL:COOLING:WATERTOAIRHEATPUMP:VARIABLESPEEDEQUATIONFIT");
242 : int NumHeat =
243 22 : state.dataInputProcessing->inputProcessor->getNumObjectsFound(state, "COIL:HEATING:WATERTOAIRHEATPUMP:VARIABLESPEEDEQUATIONFIT");
244 22 : int NumCoolAS = state.dataInputProcessing->inputProcessor->getNumObjectsFound(state, "COIL:COOLING:DX:VARIABLESPEED");
245 22 : int NumHeatAS = state.dataInputProcessing->inputProcessor->getNumObjectsFound(state, "COIL:HEATING:DX:VARIABLESPEED");
246 : int NumHPWHAirToWater =
247 22 : state.dataInputProcessing->inputProcessor->getNumObjectsFound(state, "COIL:WATERHEATING:AIRTOWATERHEATPUMP:VARIABLESPEED");
248 22 : state.dataVariableSpeedCoils->NumVarSpeedCoils = NumCool + NumHeat + NumCoolAS + NumHeatAS + NumHPWHAirToWater;
249 22 : int DXCoilNum = 0;
250 :
251 22 : if (state.dataVariableSpeedCoils->NumVarSpeedCoils <= 0) {
252 0 : ShowSevereError(state, "No Equipment found in GetVarSpeedCoilInput");
253 0 : ErrorsFound = true;
254 : }
255 :
256 : // Allocate Arrays
257 22 : if (state.dataVariableSpeedCoils->NumVarSpeedCoils > 0) {
258 22 : state.dataVariableSpeedCoils->VarSpeedCoil.allocate(state.dataVariableSpeedCoils->NumVarSpeedCoils);
259 22 : state.dataHeatBal->HeatReclaimVS_Coil.allocate(state.dataVariableSpeedCoils->NumVarSpeedCoils);
260 : }
261 :
262 22 : state.dataInputProcessing->inputProcessor->getObjectDefMaxArgs(
263 : state, "COIL:COOLING:WATERTOAIRHEATPUMP:VARIABLESPEEDEQUATIONFIT", NumParams, NumAlphas, NumNums);
264 22 : MaxNums = max(MaxNums, NumNums);
265 22 : MaxAlphas = max(MaxAlphas, NumAlphas);
266 22 : state.dataInputProcessing->inputProcessor->getObjectDefMaxArgs(
267 : state, "COIL:HEATING:WATERTOAIRHEATPUMP:VARIABLESPEEDEQUATIONFIT", NumParams, NumAlphas, NumNums);
268 22 : MaxNums = max(MaxNums, NumNums);
269 22 : MaxAlphas = max(MaxAlphas, NumAlphas);
270 :
271 22 : state.dataInputProcessing->inputProcessor->getObjectDefMaxArgs(state, "COIL:COOLING:DX:VARIABLESPEED", NumParams, NumAlphas, NumNums);
272 22 : MaxNums = max(MaxNums, NumNums);
273 22 : MaxAlphas = max(MaxAlphas, NumAlphas);
274 22 : state.dataInputProcessing->inputProcessor->getObjectDefMaxArgs(state, "COIL:HEATING:DX:VARIABLESPEED", NumParams, NumAlphas, NumNums);
275 22 : MaxNums = max(MaxNums, NumNums);
276 22 : MaxAlphas = max(MaxAlphas, NumAlphas);
277 :
278 : // variable speed air-source HPWH
279 22 : state.dataInputProcessing->inputProcessor->getObjectDefMaxArgs(
280 : state, "COIL:WATERHEATING:AIRTOWATERHEATPUMP:VARIABLESPEED", NumParams, NumAlphas, NumNums);
281 22 : MaxNums = max(MaxNums, NumNums);
282 22 : MaxAlphas = max(MaxAlphas, NumAlphas);
283 :
284 22 : AlphArray.allocate(MaxAlphas);
285 22 : cAlphaFields.allocate(MaxAlphas);
286 22 : lAlphaBlanks.dimension(MaxAlphas, true);
287 22 : cNumericFields.allocate(MaxNums);
288 22 : lNumericBlanks.dimension(MaxNums, true);
289 22 : NumArray.dimension(MaxNums, 0.0);
290 :
291 : // Get the data for cooling coil, WATER SOURCE
292 22 : CurrentModuleObject = "Coil:Cooling:WaterToAirHeatPump:VariableSpeedEquationFit"; // for reporting
293 :
294 40 : for (int CoilCounter = 1; CoilCounter <= NumCool; ++CoilCounter) {
295 :
296 18 : ++DXCoilNum;
297 18 : AlfaFieldIncre = 1;
298 :
299 18 : 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 18 : GlobalNames::VerifyUniqueCoilName(state, CurrentModuleObject, AlphArray(1), ErrorsFound, CurrentModuleObject + " Name");
314 :
315 18 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).bIsDesuperheater = false;
316 18 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name = AlphArray(1);
317 18 : state.dataHeatBal->HeatReclaimVS_Coil(DXCoilNum).Name = state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name;
318 18 : state.dataHeatBal->HeatReclaimVS_Coil(DXCoilNum).SourceType = CurrentModuleObject;
319 18 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).CoolHeatType = "COOLING";
320 18 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).VSCoilType = HVAC::Coil_CoolingWaterToAirHPVSEquationFit;
321 18 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).VarSpeedCoilType =
322 36 : HVAC::cAllCoilTypes(state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).VSCoilType);
323 18 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).NumOfSpeeds = int(NumArray(1));
324 18 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).NormSpedLevel = int(NumArray(2));
325 18 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).RatedCapCoolTotal = NumArray(3);
326 18 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).RatedAirVolFlowRate = NumArray(4);
327 18 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).RatedWaterVolFlowRate = NumArray(5);
328 18 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Twet_Rated = NumArray(6);
329 18 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Gamma_Rated = NumArray(7);
330 18 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MaxONOFFCyclesperHour = NumArray(8);
331 18 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).LatentCapacityTimeConstant = NumArray(9);
332 18 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).FanDelayTime = NumArray(10);
333 18 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).HOTGASREHEATFLG = int(NumArray(11));
334 18 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).CondenserType = DataHeatBalance::RefrigCondenserType::Water;
335 :
336 18 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).WaterInletNodeNum =
337 36 : GetOnlySingleNode(state,
338 18 : AlphArray(2),
339 : ErrorsFound,
340 : DataLoopNode::ConnectionObjectType::CoilCoolingWaterToAirHeatPumpVariableSpeedEquationFit,
341 18 : AlphArray(1),
342 : DataLoopNode::NodeFluidType::Water,
343 : DataLoopNode::ConnectionType::Inlet,
344 : NodeInputManager::CompFluidStream::Secondary,
345 : DataLoopNode::ObjectIsNotParent);
346 18 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).WaterOutletNodeNum =
347 36 : GetOnlySingleNode(state,
348 18 : AlphArray(3),
349 : ErrorsFound,
350 : DataLoopNode::ConnectionObjectType::CoilCoolingWaterToAirHeatPumpVariableSpeedEquationFit,
351 18 : AlphArray(1),
352 : DataLoopNode::NodeFluidType::Water,
353 : DataLoopNode::ConnectionType::Outlet,
354 : NodeInputManager::CompFluidStream::Secondary,
355 : DataLoopNode::ObjectIsNotParent);
356 18 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).AirInletNodeNum =
357 36 : GetOnlySingleNode(state,
358 18 : AlphArray(4),
359 : ErrorsFound,
360 : DataLoopNode::ConnectionObjectType::CoilCoolingWaterToAirHeatPumpVariableSpeedEquationFit,
361 18 : AlphArray(1),
362 : DataLoopNode::NodeFluidType::Air,
363 : DataLoopNode::ConnectionType::Inlet,
364 : NodeInputManager::CompFluidStream::Primary,
365 : DataLoopNode::ObjectIsNotParent);
366 18 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).AirOutletNodeNum =
367 54 : GetOnlySingleNode(state,
368 18 : AlphArray(5),
369 : ErrorsFound,
370 : DataLoopNode::ConnectionObjectType::CoilCoolingWaterToAirHeatPumpVariableSpeedEquationFit,
371 18 : AlphArray(1),
372 : DataLoopNode::NodeFluidType::Air,
373 : DataLoopNode::ConnectionType::Outlet,
374 : NodeInputManager::CompFluidStream::Primary,
375 : DataLoopNode::ObjectIsNotParent);
376 :
377 36 : BranchNodeConnections::TestCompSet(state, CurrentModuleObject, AlphArray(1), AlphArray(2), AlphArray(3), "Water Nodes");
378 18 : BranchNodeConnections::TestCompSet(state, CurrentModuleObject, AlphArray(1), AlphArray(4), AlphArray(5), "Air Nodes");
379 :
380 : // If (VarSpeedCoil(DXCoilNum)%NumOfSpeeds .LT. 2) Then
381 18 : 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 18 : if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).NormSpedLevel >
390 18 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).NumOfSpeeds) {
391 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).NormSpedLevel =
392 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).NumOfSpeeds;
393 : }
394 :
395 18 : if ((state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).NormSpedLevel >
396 36 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).NumOfSpeeds) ||
397 18 : (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 18 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).PLFFPLR = Curve::GetCurveIndex(state, AlphArray(6)); // convert curve name to number
407 18 : 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 18 : CurveVal = Curve::CurveValue(state, state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).PLFFPLR, 1.0);
422 18 : 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 198 : for (int I = 1; I <= state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).NumOfSpeeds; ++I) {
434 180 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedTotCap(I) = NumArray(12 + (I - 1) * 6);
435 180 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedSHR(I) = NumArray(13 + (I - 1) * 6);
436 180 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedCOP(I) = NumArray(14 + (I - 1) * 6);
437 180 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedAirVolFlowRate(I) = NumArray(15 + (I - 1) * 6);
438 180 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedWaterVolFlowRate(I) = NumArray(16 + (I - 1) * 6);
439 180 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSWasteHeatFrac(I) = NumArray(17 + (I - 1) * 6);
440 :
441 180 : AlfaFieldIncre = 7 + (I - 1) * 7;
442 180 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSCCapFTemp(I) =
443 180 : Curve::GetCurveIndex(state, AlphArray(AlfaFieldIncre)); // convert curve name to number
444 180 : 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 540 : ErrorsFound |= Curve::CheckCurveDims(state,
464 180 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSCCapFTemp(I), // Curve index
465 : {2}, // Valid dimensions
466 : RoutineName, // Routine name
467 : CurrentModuleObject, // Object Type
468 180 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name, // Object Name
469 180 : cAlphaFields(AlfaFieldIncre)); // Field Name
470 :
471 180 : if (!ErrorsFound) {
472 360 : CurveVal = Curve::CurveValue(
473 180 : state, state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSCCapFTemp(I), RatedInletWetBulbTemp, RatedInletWaterTemp);
474 180 : 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 180 : AlfaFieldIncre = 8 + (I - 1) * 7;
488 180 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSCCapAirFFlow(I) =
489 180 : Curve::GetCurveIndex(state, AlphArray(AlfaFieldIncre)); // convert curve name to number
490 180 : 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 540 : ErrorsFound |= Curve::CheckCurveDims(state,
510 180 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSCCapAirFFlow(I), // Curve index
511 : {1}, // Valid dimensions
512 : RoutineName, // Routine name
513 : CurrentModuleObject, // Object Type
514 180 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name, // Object Name
515 180 : cAlphaFields(AlfaFieldIncre)); // Field Name
516 :
517 180 : if (!ErrorsFound) {
518 180 : CurveVal = Curve::CurveValue(state, state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSCCapAirFFlow(I), 1.0);
519 180 : 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 180 : AlfaFieldIncre = 9 + (I - 1) * 7;
533 180 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSCCapWaterFFlow(I) =
534 180 : Curve::GetCurveIndex(state, AlphArray(AlfaFieldIncre)); // convert curve name to number
535 180 : 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 540 : ErrorsFound |= Curve::CheckCurveDims(state,
555 180 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSCCapWaterFFlow(I), // Curve index
556 : {1}, // Valid dimensions
557 : RoutineName, // Routine name
558 : CurrentModuleObject, // Object Type
559 180 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name, // Object Name
560 180 : cAlphaFields(AlfaFieldIncre)); // Field Name
561 :
562 180 : if (!ErrorsFound) {
563 180 : CurveVal = Curve::CurveValue(state, state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSCCapWaterFFlow(I), 1.0);
564 180 : 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 180 : AlfaFieldIncre = 10 + (I - 1) * 7;
578 180 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSEIRFTemp(I) =
579 180 : Curve::GetCurveIndex(state, AlphArray(AlfaFieldIncre)); // convert curve name to number
580 180 : 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 540 : ErrorsFound |= Curve::CheckCurveDims(state,
600 180 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSEIRFTemp(I), // Curve index
601 : {2}, // Valid dimensions
602 : RoutineName, // Routine name
603 : CurrentModuleObject, // Object Type
604 180 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name, // Object Name
605 180 : cAlphaFields(AlfaFieldIncre)); // Field Name
606 :
607 180 : if (!ErrorsFound) {
608 360 : CurveVal = Curve::CurveValue(
609 180 : state, state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSEIRFTemp(I), RatedInletWetBulbTemp, RatedInletWaterTemp);
610 180 : 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 180 : AlfaFieldIncre = 11 + (I - 1) * 7;
624 180 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSEIRAirFFlow(I) =
625 180 : Curve::GetCurveIndex(state, AlphArray(AlfaFieldIncre)); // convert curve name to number
626 180 : 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 540 : ErrorsFound |= Curve::CheckCurveDims(state,
646 180 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSEIRAirFFlow(I), // Curve index
647 : {1}, // Valid dimensions
648 : RoutineName, // Routine name
649 : CurrentModuleObject, // Object Type
650 180 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name, // Object Name
651 180 : cAlphaFields(AlfaFieldIncre)); // Field Name
652 :
653 180 : if (!ErrorsFound) {
654 180 : CurveVal = Curve::CurveValue(state, state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSEIRAirFFlow(I), 1.0);
655 180 : 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 180 : AlfaFieldIncre = 12 + (I - 1) * 7;
669 180 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSEIRWaterFFlow(I) =
670 180 : Curve::GetCurveIndex(state, AlphArray(AlfaFieldIncre)); // convert curve name to number
671 180 : 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 540 : ErrorsFound |= Curve::CheckCurveDims(state,
691 180 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSEIRWaterFFlow(I), // Curve index
692 : {1}, // Valid dimensions
693 : RoutineName, // Routine name
694 : CurrentModuleObject, // Object Type
695 180 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name, // Object Name
696 180 : cAlphaFields(AlfaFieldIncre)); // Field Name
697 :
698 180 : if (!ErrorsFound) {
699 180 : CurveVal = Curve::CurveValue(state, state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSEIRWaterFFlow(I), 1.0);
700 180 : 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 180 : AlfaFieldIncre = 13 + (I - 1) * 7;
714 : // Read waste heat modifier curve name
715 180 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSWasteHeat(I) =
716 180 : Curve::GetCurveIndex(state, AlphArray(AlfaFieldIncre)); // convert curve name to number
717 180 : 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 540 : ErrorsFound |= Curve::CheckCurveDims(state,
737 180 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSWasteHeat(I), // Curve index
738 : {2}, // Valid dimensions
739 : RoutineName, // Routine name
740 : CurrentModuleObject, // Object Type
741 180 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name, // Object Name
742 180 : cAlphaFields(AlfaFieldIncre)); // Field Name
743 :
744 180 : if (!ErrorsFound) {
745 360 : CurveVal = Curve::CurveValue(
746 180 : state, state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSWasteHeat(I), RatedInletWaterTemp, RatedInletAirTemp);
747 180 : 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 198 : for (int I = 1; I <= state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).NumOfSpeeds; ++I) {
762 180 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedPercentTotCap(I) =
763 180 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedTotCap(I) /
764 360 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedTotCap(
765 180 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).NumOfSpeeds);
766 180 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedAirVolFlowPerRatedTotCap(I) =
767 180 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedAirVolFlowRate(I) /
768 180 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedTotCap(I);
769 180 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedWaterVolFlowPerRatedTotCap(I) =
770 180 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedWaterVolFlowRate(I) /
771 180 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedTotCap(I);
772 : }
773 :
774 : // CurrentModuleObject = "Coil:Cooling:WaterToAirHeatPump:VariableSpeedEquationFit"
775 36 : SetupOutputVariable(state,
776 : "Cooling Coil Electricity Energy",
777 : Constant::Units::J,
778 18 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Energy,
779 : OutputProcessor::TimeStepType::System,
780 : OutputProcessor::StoreType::Sum,
781 18 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name,
782 : Constant::eResource::Electricity,
783 : OutputProcessor::Group::HVAC,
784 : OutputProcessor::EndUseCat::Cooling);
785 36 : SetupOutputVariable(state,
786 : "Cooling Coil Total Cooling Energy",
787 : Constant::Units::J,
788 18 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).EnergyLoadTotal,
789 : OutputProcessor::TimeStepType::System,
790 : OutputProcessor::StoreType::Sum,
791 18 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name,
792 : Constant::eResource::EnergyTransfer,
793 : OutputProcessor::Group::HVAC,
794 : OutputProcessor::EndUseCat::CoolingCoils);
795 36 : SetupOutputVariable(state,
796 : "Cooling Coil Sensible Cooling Energy",
797 : Constant::Units::J,
798 18 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).EnergySensible,
799 : OutputProcessor::TimeStepType::System,
800 : OutputProcessor::StoreType::Sum,
801 18 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name);
802 36 : SetupOutputVariable(state,
803 : "Cooling Coil Latent Cooling Energy",
804 : Constant::Units::J,
805 18 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).EnergyLatent,
806 : OutputProcessor::TimeStepType::System,
807 : OutputProcessor::StoreType::Sum,
808 18 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name);
809 36 : SetupOutputVariable(state,
810 : "Cooling Coil Source Side Heat Transfer Energy",
811 : Constant::Units::J,
812 18 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).EnergySource,
813 : OutputProcessor::TimeStepType::System,
814 : OutputProcessor::StoreType::Sum,
815 18 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name,
816 : Constant::eResource::PlantLoopCoolingDemand,
817 : OutputProcessor::Group::HVAC,
818 : OutputProcessor::EndUseCat::CoolingCoils);
819 :
820 18 : 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 22 : CurrentModuleObject = "Coil:Cooling:DX:VariableSpeed"; // for reporting
827 :
828 44 : for (int CoilCounter = 1; CoilCounter <= NumCoolAS; ++CoilCounter) {
829 :
830 22 : ++DXCoilNum;
831 22 : AlfaFieldIncre = 1;
832 :
833 22 : 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 22 : ErrorObjectHeader eoh{routineName, CurrentModuleObject, AlphArray(1)};
847 :
848 : // ErrorsFound will be set to True if problem was found, left untouched otherwise
849 22 : GlobalNames::VerifyUniqueCoilName(state, CurrentModuleObject, AlphArray(1), ErrorsFound, CurrentModuleObject + " Name");
850 :
851 22 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).bIsDesuperheater = false;
852 22 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name = AlphArray(1);
853 : // Initialize DataHeatBalance heat reclaim variable name for use by heat reclaim coils
854 22 : state.dataHeatBal->HeatReclaimVS_Coil(DXCoilNum).Name = state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name;
855 22 : state.dataHeatBal->HeatReclaimVS_Coil(DXCoilNum).SourceType = CurrentModuleObject;
856 22 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).CoolHeatType = "COOLING";
857 22 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).VSCoilType = HVAC::Coil_CoolingAirToAirVariableSpeed;
858 22 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).VarSpeedCoilType = HVAC::cAllCoilTypes(HVAC::Coil_CoolingAirToAirVariableSpeed);
859 22 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).NumOfSpeeds = int(NumArray(1));
860 22 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).NormSpedLevel = int(NumArray(2));
861 22 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).RatedCapCoolTotal = NumArray(3);
862 22 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).RatedAirVolFlowRate = NumArray(4);
863 22 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Twet_Rated = NumArray(5);
864 22 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Gamma_Rated = NumArray(6);
865 22 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MaxONOFFCyclesperHour = NumArray(7);
866 22 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).LatentCapacityTimeConstant = NumArray(8);
867 22 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).FanDelayTime = NumArray(9);
868 :
869 22 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).AirInletNodeNum =
870 44 : GetOnlySingleNode(state,
871 22 : AlphArray(2),
872 : ErrorsFound,
873 : DataLoopNode::ConnectionObjectType::CoilCoolingDXVariableSpeed,
874 22 : AlphArray(1),
875 : DataLoopNode::NodeFluidType::Air,
876 : DataLoopNode::ConnectionType::Inlet,
877 : NodeInputManager::CompFluidStream::Primary,
878 : DataLoopNode::ObjectIsNotParent);
879 22 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).AirOutletNodeNum =
880 66 : GetOnlySingleNode(state,
881 22 : AlphArray(3),
882 : ErrorsFound,
883 : DataLoopNode::ConnectionObjectType::CoilCoolingDXVariableSpeed,
884 22 : AlphArray(1),
885 : DataLoopNode::NodeFluidType::Air,
886 : DataLoopNode::ConnectionType::Outlet,
887 : NodeInputManager::CompFluidStream::Primary,
888 : DataLoopNode::ObjectIsNotParent);
889 :
890 22 : BranchNodeConnections::TestCompSet(state, CurrentModuleObject, AlphArray(1), AlphArray(2), AlphArray(3), "Air Nodes");
891 :
892 22 : 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 22 : if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).NormSpedLevel >
901 22 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).NumOfSpeeds) {
902 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).NormSpedLevel =
903 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).NumOfSpeeds;
904 : }
905 :
906 22 : if ((state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).NormSpedLevel >
907 44 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).NumOfSpeeds) ||
908 22 : (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 22 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).PLFFPLR = Curve::GetCurveIndex(state, AlphArray(4)); // convert curve name to number
918 22 : 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 22 : CurveVal = Curve::CurveValue(state, state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).PLFFPLR, 1.0);
933 22 : 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 22 : if (lAlphaBlanks(5)) {
946 21 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).CondenserInletNodeNum = 0;
947 : } else {
948 1 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).CondenserInletNodeNum =
949 2 : GetOnlySingleNode(state,
950 1 : AlphArray(5),
951 : ErrorsFound,
952 : DataLoopNode::ConnectionObjectType::CoilCoolingDXVariableSpeed,
953 1 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name,
954 : DataLoopNode::NodeFluidType::Air,
955 : DataLoopNode::ConnectionType::OutsideAirReference,
956 : NodeInputManager::CompFluidStream::Primary,
957 : DataLoopNode::ObjectIsNotParent);
958 :
959 1 : if (!OutAirNodeManager::CheckOutAirNodeNumber(state, state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).CondenserInletNodeNum)) {
960 0 : ShowWarningError(state,
961 0 : format("{}{}=\"{}\", may be invalid",
962 : RoutineName,
963 : CurrentModuleObject,
964 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name));
965 0 : ShowContinueError(state,
966 0 : format("{}=\"{}\", node does not appear in an OutdoorAir:NodeList or as an OutdoorAir:Node.",
967 : cAlphaFields(10),
968 : AlphArray(5)));
969 0 : 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 22 : if ((Util::SameString(AlphArray(6), "AirCooled")) || lAlphaBlanks(6)) {
975 22 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).CondenserType = DataHeatBalance::RefrigCondenserType::Air;
976 0 : } else if (Util::SameString(AlphArray(6), "EvaporativelyCooled")) {
977 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).CondenserType = DataHeatBalance::RefrigCondenserType::Evap;
978 0 : 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 22 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).EvapCondPumpElecNomPower = NumArray(10);
989 :
990 22 : if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).EvapCondPumpElecNomPower != DataSizing::AutoSize) {
991 22 : 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 22 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).CrankcaseHeaterCapacity = NumArray(11);
1003 22 : 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 22 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MaxOATCrankcaseHeater = NumArray(12);
1014 :
1015 : // Set crankcase heater cutout temperature
1016 22 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MinOATCompressor = NumArray(13);
1017 :
1018 : // A7; \field Crankcase Heater Capacity Function of Outdoor Temperature Curve Name
1019 22 : if (!lAlphaBlanks(7)) {
1020 1 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).CrankcaseHeaterCapacityCurveIndex = Curve::GetCurveIndex(state, AlphArray(7));
1021 1 : 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 1 : ErrorsFound |=
1031 4 : Curve::CheckCurveDims(state,
1032 1 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).CrankcaseHeaterCapacityCurveIndex, // Curve index
1033 : {1}, // Valid dimensions
1034 : RoutineName, // Routine name
1035 : CurrentModuleObject, // Object Type
1036 1 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name, // Object Name
1037 1 : cAlphaFields(7)); // Field Name
1038 : }
1039 : }
1040 :
1041 : // Get Water System tank connections
1042 : // A8, \field Name of Water Storage Tank for Supply
1043 22 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).EvapWaterSupplyName = AlphArray(8);
1044 22 : if (lAlphaBlanks(8)) {
1045 22 : 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 22 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).CondensateCollectName = AlphArray(9);
1059 22 : if (lAlphaBlanks(9)) {
1060 22 : 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 22 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).BasinHeaterPowerFTempDiff = NumArray(14);
1074 22 : 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 22 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).BasinHeaterSetPointTemp = NumArray(15);
1084 22 : 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 22 : 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 182 : for (int I = 1; I <= state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).NumOfSpeeds; ++I) {
1105 160 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedTotCap(I) = NumArray(16 + (I - 1) * 8);
1106 160 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedSHR(I) = NumArray(17 + (I - 1) * 8);
1107 160 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedCOP(I) = NumArray(18 + (I - 1) * 8);
1108 160 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedAirVolFlowRate(I) = NumArray(19 + (I - 1) * 8);
1109 160 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedEvaporatorFanPowerPerVolumeFlowRate2017(I) = NumArray(20 + (I - 1) * 8);
1110 160 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedEvaporatorFanPowerPerVolumeFlowRate2023(I) = NumArray(21 + (I - 1) * 8);
1111 160 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).EvapCondAirFlow(I) = NumArray(22 + (I - 1) * 8);
1112 160 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).EvapCondEffect(I) = NumArray(23 + (I - 1) * 8);
1113 320 : if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).EvapCondEffect(I) < 0.0 ||
1114 160 : 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 160 : AlfaFieldIncre = 11 + (I - 1) * 4;
1124 160 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSCCapFTemp(I) =
1125 160 : Curve::GetCurveIndex(state, AlphArray(AlfaFieldIncre)); // convert curve name to number
1126 160 : 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 480 : ErrorsFound |= Curve::CheckCurveDims(state,
1146 160 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSCCapFTemp(I), // Curve index
1147 : {2}, // Valid dimensions
1148 : RoutineName, // Routine name
1149 : CurrentModuleObject, // Object Type
1150 160 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name, // Object Name
1151 160 : cAlphaFields(AlfaFieldIncre)); // Field Name
1152 :
1153 160 : if (!ErrorsFound) {
1154 320 : CurveVal = Curve::CurveValue(
1155 160 : state, state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSCCapFTemp(I), RatedInletWetBulbTemp, RatedAmbAirTemp);
1156 160 : if (CurveVal > 1.10 || CurveVal < 0.90) {
1157 0 : ShowWarningError(state,
1158 0 : format("{}{}=\"{}\", curve values",
1159 : RoutineName,
1160 : CurrentModuleObject,
1161 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name));
1162 0 : ShowContinueError(
1163 0 : state, format("...{} output is not equal to 1.0 (+ or - 10%) at rated conditions.", cAlphaFields(AlfaFieldIncre)));
1164 0 : ShowContinueError(state, format("...Curve output at rated conditions = {:.3T}", CurveVal));
1165 : }
1166 : }
1167 : }
1168 :
1169 160 : AlfaFieldIncre = 12 + (I - 1) * 4;
1170 160 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSCCapAirFFlow(I) =
1171 160 : Curve::GetCurveIndex(state, AlphArray(AlfaFieldIncre)); // convert curve name to number
1172 160 : 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 480 : ErrorsFound |= Curve::CheckCurveDims(state,
1192 160 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSCCapAirFFlow(I), // Curve index
1193 : {1}, // Valid dimensions
1194 : RoutineName, // Routine name
1195 : CurrentModuleObject, // Object Type
1196 160 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name, // Object Name
1197 160 : cAlphaFields(AlfaFieldIncre)); // Field Name
1198 :
1199 160 : if (!ErrorsFound) {
1200 160 : CurveVal = Curve::CurveValue(state, state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSCCapAirFFlow(I), 1.0);
1201 160 : 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 160 : AlfaFieldIncre = 13 + (I - 1) * 4;
1215 160 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSEIRFTemp(I) =
1216 160 : Curve::GetCurveIndex(state, AlphArray(AlfaFieldIncre)); // convert curve name to number
1217 160 : 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 480 : ErrorsFound |= Curve::CheckCurveDims(state,
1237 160 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSEIRFTemp(I), // Curve index
1238 : {2}, // Valid dimensions
1239 : RoutineName, // Routine name
1240 : CurrentModuleObject, // Object Type
1241 160 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name, // Object Name
1242 160 : cAlphaFields(AlfaFieldIncre)); // Field Name
1243 :
1244 160 : if (!ErrorsFound) {
1245 320 : CurveVal = Curve::CurveValue(
1246 160 : state, state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSEIRFTemp(I), RatedInletWetBulbTemp, RatedAmbAirTemp);
1247 160 : if (CurveVal > 1.10 || CurveVal < 0.90) {
1248 0 : ShowWarningError(state,
1249 0 : format("{}{}=\"{}\", curve values",
1250 : RoutineName,
1251 : CurrentModuleObject,
1252 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name));
1253 0 : ShowContinueError(
1254 0 : state, format("...{} output is not equal to 1.0 (+ or - 10%) at rated conditions.", cAlphaFields(AlfaFieldIncre)));
1255 0 : ShowContinueError(state, format("...Curve output at rated conditions = {:.3T}", CurveVal));
1256 : }
1257 : }
1258 : }
1259 :
1260 160 : AlfaFieldIncre = 14 + (I - 1) * 4;
1261 160 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSEIRAirFFlow(I) =
1262 160 : Curve::GetCurveIndex(state, AlphArray(AlfaFieldIncre)); // convert curve name to number
1263 160 : 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 480 : ErrorsFound |= Curve::CheckCurveDims(state,
1283 160 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSEIRAirFFlow(I), // Curve index
1284 : {1}, // Valid dimensions
1285 : RoutineName, // Routine name
1286 : CurrentModuleObject, // Object Type
1287 160 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name, // Object Name
1288 160 : cAlphaFields(AlfaFieldIncre)); // Field Name
1289 :
1290 160 : if (!ErrorsFound) {
1291 160 : CurveVal = Curve::CurveValue(state, state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSEIRAirFFlow(I), 1.0);
1292 160 : 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 182 : for (int I = 1; I <= state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).NumOfSpeeds; ++I) {
1307 160 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedPercentTotCap(I) =
1308 160 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedTotCap(I) /
1309 320 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedTotCap(
1310 160 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).NumOfSpeeds);
1311 160 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedAirVolFlowPerRatedTotCap(I) =
1312 160 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedAirVolFlowRate(I) /
1313 160 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedTotCap(I);
1314 160 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedEvapCondVolFlowPerRatedTotCap(I) =
1315 160 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).EvapCondAirFlow(I) /
1316 160 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedTotCap(I);
1317 : }
1318 :
1319 : // CurrentModuleObject = "Coil:Cooling:DX:VariableSpeed"
1320 44 : SetupOutputVariable(state,
1321 : "Cooling Coil Electricity Energy",
1322 : Constant::Units::J,
1323 22 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Energy,
1324 : OutputProcessor::TimeStepType::System,
1325 : OutputProcessor::StoreType::Sum,
1326 22 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name,
1327 : Constant::eResource::Electricity,
1328 : OutputProcessor::Group::HVAC,
1329 : OutputProcessor::EndUseCat::Cooling);
1330 44 : SetupOutputVariable(state,
1331 : "Cooling Coil Total Cooling Energy",
1332 : Constant::Units::J,
1333 22 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).EnergyLoadTotal,
1334 : OutputProcessor::TimeStepType::System,
1335 : OutputProcessor::StoreType::Sum,
1336 22 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name,
1337 : Constant::eResource::EnergyTransfer,
1338 : OutputProcessor::Group::HVAC,
1339 : OutputProcessor::EndUseCat::CoolingCoils);
1340 44 : SetupOutputVariable(state,
1341 : "Cooling Coil Sensible Cooling Energy",
1342 : Constant::Units::J,
1343 22 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).EnergySensible,
1344 : OutputProcessor::TimeStepType::System,
1345 : OutputProcessor::StoreType::Sum,
1346 22 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name);
1347 44 : SetupOutputVariable(state,
1348 : "Cooling Coil Latent Cooling Energy",
1349 : Constant::Units::J,
1350 22 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).EnergyLatent,
1351 : OutputProcessor::TimeStepType::System,
1352 : OutputProcessor::StoreType::Sum,
1353 22 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name);
1354 44 : SetupOutputVariable(state,
1355 : "Cooling Coil Source Side Heat Transfer Energy",
1356 : Constant::Units::J,
1357 22 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).EnergySource,
1358 : OutputProcessor::TimeStepType::System,
1359 : OutputProcessor::StoreType::Sum,
1360 22 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name);
1361 :
1362 22 : 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 22 : CurrentModuleObject = "Coil:Heating:WaterToAirHeatPump:VariableSpeedEquationFit";
1370 :
1371 40 : for (int CoilCounter = 1; CoilCounter <= NumHeat; ++CoilCounter) {
1372 :
1373 18 : ++DXCoilNum;
1374 :
1375 18 : 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 18 : GlobalNames::VerifyUniqueCoilName(state, CurrentModuleObject, AlphArray(1), ErrorsFound, CurrentModuleObject + " Name");
1389 :
1390 18 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).bIsDesuperheater = false;
1391 18 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name = AlphArray(1);
1392 18 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).CoolHeatType = "HEATING";
1393 18 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).VSCoilType = HVAC::Coil_HeatingWaterToAirHPVSEquationFit; // fix coil type
1394 :
1395 18 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).VarSpeedCoilType =
1396 36 : HVAC::cAllCoilTypes(state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).VSCoilType);
1397 18 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).NumOfSpeeds = int(NumArray(1));
1398 18 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).NormSpedLevel = int(NumArray(2));
1399 18 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).RatedCapHeat = NumArray(3);
1400 18 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).RatedAirVolFlowRate = NumArray(4);
1401 18 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).RatedWaterVolFlowRate = NumArray(5);
1402 18 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).CondenserType = DataHeatBalance::RefrigCondenserType::Water;
1403 :
1404 : // Previously set by parent objects, but not user-definable
1405 18 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MaxONOFFCyclesperHour = 4;
1406 18 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).LatentCapacityTimeConstant = 0.;
1407 18 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).FanDelayTime = 0.;
1408 :
1409 18 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).WaterInletNodeNum =
1410 36 : GetOnlySingleNode(state,
1411 18 : AlphArray(2),
1412 : ErrorsFound,
1413 : DataLoopNode::ConnectionObjectType::CoilHeatingWaterToAirHeatPumpVariableSpeedEquationFit,
1414 18 : AlphArray(1),
1415 : DataLoopNode::NodeFluidType::Water,
1416 : DataLoopNode::ConnectionType::Inlet,
1417 : NodeInputManager::CompFluidStream::Secondary,
1418 : DataLoopNode::ObjectIsNotParent);
1419 18 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).WaterOutletNodeNum =
1420 36 : GetOnlySingleNode(state,
1421 18 : AlphArray(3),
1422 : ErrorsFound,
1423 : DataLoopNode::ConnectionObjectType::CoilHeatingWaterToAirHeatPumpVariableSpeedEquationFit,
1424 18 : AlphArray(1),
1425 : DataLoopNode::NodeFluidType::Water,
1426 : DataLoopNode::ConnectionType::Outlet,
1427 : NodeInputManager::CompFluidStream::Secondary,
1428 : DataLoopNode::ObjectIsNotParent);
1429 18 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).AirInletNodeNum =
1430 36 : GetOnlySingleNode(state,
1431 18 : AlphArray(4),
1432 : ErrorsFound,
1433 : DataLoopNode::ConnectionObjectType::CoilHeatingWaterToAirHeatPumpVariableSpeedEquationFit,
1434 18 : AlphArray(1),
1435 : DataLoopNode::NodeFluidType::Air,
1436 : DataLoopNode::ConnectionType::Inlet,
1437 : NodeInputManager::CompFluidStream::Primary,
1438 : DataLoopNode::ObjectIsNotParent);
1439 18 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).AirOutletNodeNum =
1440 54 : GetOnlySingleNode(state,
1441 18 : AlphArray(5),
1442 : ErrorsFound,
1443 : DataLoopNode::ConnectionObjectType::CoilHeatingWaterToAirHeatPumpVariableSpeedEquationFit,
1444 18 : AlphArray(1),
1445 : DataLoopNode::NodeFluidType::Air,
1446 : DataLoopNode::ConnectionType::Outlet,
1447 : NodeInputManager::CompFluidStream::Primary,
1448 : DataLoopNode::ObjectIsNotParent);
1449 :
1450 36 : BranchNodeConnections::TestCompSet(state, CurrentModuleObject, AlphArray(1), AlphArray(2), AlphArray(3), "Water Nodes");
1451 18 : BranchNodeConnections::TestCompSet(state, CurrentModuleObject, AlphArray(1), AlphArray(4), AlphArray(5), "Air Nodes");
1452 :
1453 : // If (VarSpeedCoil(DXCoilNum)%NumOfSpeeds .LT. 2) Then
1454 18 : 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 18 : if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).NormSpedLevel >
1463 18 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).NumOfSpeeds) {
1464 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).NormSpedLevel =
1465 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).NumOfSpeeds;
1466 : }
1467 :
1468 18 : if ((state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).NormSpedLevel >
1469 36 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).NumOfSpeeds) ||
1470 18 : (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 18 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).PLFFPLR = Curve::GetCurveIndex(state, AlphArray(6)); // convert curve name to number
1480 18 : 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 18 : CurveVal = Curve::CurveValue(state, state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).PLFFPLR, 1.0);
1495 18 : 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 198 : for (int I = 1; I <= state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).NumOfSpeeds; ++I) {
1507 180 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedTotCap(I) = NumArray(6 + (I - 1) * 5);
1508 180 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedCOP(I) = NumArray(7 + (I - 1) * 5);
1509 180 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedAirVolFlowRate(I) = NumArray(8 + (I - 1) * 5);
1510 180 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedWaterVolFlowRate(I) = NumArray(9 + (I - 1) * 5);
1511 180 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSWasteHeatFrac(I) = NumArray(10 + (I - 1) * 5);
1512 :
1513 180 : AlfaFieldIncre = 7 + (I - 1) * 7;
1514 180 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSCCapFTemp(I) =
1515 180 : Curve::GetCurveIndex(state, AlphArray(AlfaFieldIncre)); // convert curve name to number
1516 180 : 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 540 : ErrorsFound |= Curve::CheckCurveDims(state,
1536 180 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSCCapFTemp(I), // Curve index
1537 : {2}, // Valid dimensions
1538 : RoutineName, // Routine name
1539 : CurrentModuleObject, // Object Type
1540 180 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name, // Object Name
1541 180 : cAlphaFields(AlfaFieldIncre)); // Field Name
1542 :
1543 180 : if (!ErrorsFound) {
1544 360 : CurveVal = Curve::CurveValue(state,
1545 180 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSCCapFTemp(I),
1546 : RatedInletAirTempHeat,
1547 : RatedInletWaterTempHeat);
1548 180 : 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 180 : AlfaFieldIncre = 8 + (I - 1) * 7;
1562 180 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSCCapAirFFlow(I) =
1563 180 : Curve::GetCurveIndex(state, AlphArray(AlfaFieldIncre)); // convert curve name to number
1564 180 : 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 540 : ErrorsFound |= Curve::CheckCurveDims(state,
1584 180 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSCCapAirFFlow(I), // Curve index
1585 : {1}, // Valid dimensions
1586 : RoutineName, // Routine name
1587 : CurrentModuleObject, // Object Type
1588 180 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name, // Object Name
1589 180 : cAlphaFields(AlfaFieldIncre)); // Field Name
1590 :
1591 180 : if (!ErrorsFound) {
1592 180 : CurveVal = Curve::CurveValue(state, state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSCCapAirFFlow(I), 1.0);
1593 180 : 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 180 : AlfaFieldIncre = 9 + (I - 1) * 7;
1607 180 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSCCapWaterFFlow(I) =
1608 180 : Curve::GetCurveIndex(state, AlphArray(AlfaFieldIncre)); // convert curve name to number
1609 180 : 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 540 : ErrorsFound |= Curve::CheckCurveDims(state,
1629 180 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSCCapWaterFFlow(I), // Curve index
1630 : {1}, // Valid dimensions
1631 : RoutineName, // Routine name
1632 : CurrentModuleObject, // Object Type
1633 180 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name, // Object Name
1634 180 : cAlphaFields(AlfaFieldIncre)); // Field Name
1635 :
1636 180 : if (!ErrorsFound) {
1637 180 : CurveVal = Curve::CurveValue(state, state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSCCapWaterFFlow(I), 1.0);
1638 180 : 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 180 : AlfaFieldIncre = 10 + (I - 1) * 7;
1652 180 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSEIRFTemp(I) =
1653 180 : Curve::GetCurveIndex(state, AlphArray(AlfaFieldIncre)); // convert curve name to number
1654 180 : 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 540 : ErrorsFound |= Curve::CheckCurveDims(state,
1674 180 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSEIRFTemp(I), // Curve index
1675 : {2}, // Valid dimensions
1676 : RoutineName, // Routine name
1677 : CurrentModuleObject, // Object Type
1678 180 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name, // Object Name
1679 180 : cAlphaFields(AlfaFieldIncre)); // Field Name
1680 :
1681 180 : if (!ErrorsFound) {
1682 360 : CurveVal = Curve::CurveValue(state,
1683 180 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSEIRFTemp(I),
1684 : RatedInletAirTempHeat,
1685 : RatedInletWaterTempHeat);
1686 180 : 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 180 : AlfaFieldIncre = 11 + (I - 1) * 7;
1700 180 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSEIRAirFFlow(I) =
1701 180 : Curve::GetCurveIndex(state, AlphArray(AlfaFieldIncre)); // convert curve name to number
1702 180 : 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 540 : ErrorsFound |= Curve::CheckCurveDims(state,
1722 180 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSEIRAirFFlow(I), // Curve index
1723 : {1}, // Valid dimensions
1724 : RoutineName, // Routine name
1725 : CurrentModuleObject, // Object Type
1726 180 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name, // Object Name
1727 180 : cAlphaFields(AlfaFieldIncre)); // Field Name
1728 :
1729 180 : if (!ErrorsFound) {
1730 180 : CurveVal = Curve::CurveValue(state, state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSEIRAirFFlow(I), 1.0);
1731 180 : 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 180 : AlfaFieldIncre = 12 + (I - 1) * 7;
1745 180 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSEIRWaterFFlow(I) =
1746 180 : Curve::GetCurveIndex(state, AlphArray(AlfaFieldIncre)); // convert curve name to number
1747 180 : 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 540 : ErrorsFound |= Curve::CheckCurveDims(state,
1767 180 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSEIRWaterFFlow(I), // Curve index
1768 : {1}, // Valid dimensions
1769 : RoutineName, // Routine name
1770 : CurrentModuleObject, // Object Type
1771 180 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name, // Object Name
1772 180 : cAlphaFields(AlfaFieldIncre)); // Field Name
1773 :
1774 180 : if (!ErrorsFound) {
1775 180 : CurveVal = Curve::CurveValue(state, state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSEIRWaterFFlow(I), 1.0);
1776 180 : 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 180 : AlfaFieldIncre = 13 + (I - 1) * 7;
1790 : // Read waste heat modifier curve name
1791 180 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSWasteHeat(I) =
1792 180 : Curve::GetCurveIndex(state, AlphArray(AlfaFieldIncre)); // convert curve name to number
1793 180 : 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 540 : ErrorsFound |= Curve::CheckCurveDims(state,
1813 180 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSWasteHeat(I), // Curve index
1814 : {2}, // Valid dimensions
1815 : RoutineName, // Routine name
1816 : CurrentModuleObject, // Object Type
1817 180 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name, // Object Name
1818 180 : cAlphaFields(AlfaFieldIncre)); // Field Name
1819 :
1820 180 : if (!ErrorsFound) {
1821 360 : CurveVal = Curve::CurveValue(state,
1822 180 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSWasteHeat(I),
1823 : RatedInletAirTempHeat,
1824 : RatedInletWaterTempHeat);
1825 180 : 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 198 : for (int I = 1; I <= state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).NumOfSpeeds; ++I) {
1840 180 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedPercentTotCap(I) =
1841 180 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedTotCap(I) /
1842 360 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedTotCap(
1843 180 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).NumOfSpeeds);
1844 180 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedAirVolFlowPerRatedTotCap(I) =
1845 180 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedAirVolFlowRate(I) /
1846 180 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedTotCap(I);
1847 180 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedWaterVolFlowPerRatedTotCap(I) =
1848 180 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedWaterVolFlowRate(I) /
1849 180 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedTotCap(I);
1850 : }
1851 :
1852 : // CurrentModuleObject = "Coil:Heating:WaterToAirHeatPump:VariableSpeedEquationFit"
1853 36 : SetupOutputVariable(state,
1854 : "Heating Coil Electricity Energy",
1855 : Constant::Units::J,
1856 18 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Energy,
1857 : OutputProcessor::TimeStepType::System,
1858 : OutputProcessor::StoreType::Sum,
1859 18 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name,
1860 : Constant::eResource::Electricity,
1861 : OutputProcessor::Group::HVAC,
1862 : OutputProcessor::EndUseCat::Heating);
1863 36 : SetupOutputVariable(state,
1864 : "Heating Coil Heating Energy",
1865 : Constant::Units::J,
1866 18 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).EnergyLoadTotal,
1867 : OutputProcessor::TimeStepType::System,
1868 : OutputProcessor::StoreType::Sum,
1869 18 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name,
1870 : Constant::eResource::EnergyTransfer,
1871 : OutputProcessor::Group::HVAC,
1872 : OutputProcessor::EndUseCat::HeatingCoils);
1873 36 : SetupOutputVariable(state,
1874 : "Heating Coil Source Side Heat Transfer Energy",
1875 : Constant::Units::J,
1876 18 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).EnergySource,
1877 : OutputProcessor::TimeStepType::System,
1878 : OutputProcessor::StoreType::Sum,
1879 18 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name,
1880 : Constant::eResource::PlantLoopHeatingDemand,
1881 : OutputProcessor::Group::HVAC,
1882 : OutputProcessor::EndUseCat::HeatingCoils);
1883 :
1884 : // create predefined report entries
1885 36 : OutputReportPredefined::PreDefTableEntry(
1886 18 : state, state.dataOutRptPredefined->pdchHeatCoilType, state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name, CurrentModuleObject);
1887 36 : OutputReportPredefined::PreDefTableEntry(state,
1888 18 : state.dataOutRptPredefined->pdchHeatCoilNomCap,
1889 18 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name,
1890 18 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).RatedCapHeat);
1891 36 : OutputReportPredefined::PreDefTableEntry(state,
1892 18 : state.dataOutRptPredefined->pdchHeatCoilNomEff,
1893 18 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name,
1894 36 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedCOP(
1895 18 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).NormSpedLevel));
1896 : }
1897 :
1898 : //-------------------------AIR SOURCE, HEATING---BEGIN
1899 : // Get the data for heating coil, AIR SOURCE
1900 22 : CurrentModuleObject = "COIL:HEATING:DX:VARIABLESPEED";
1901 :
1902 31 : for (int CoilCounter = 1; CoilCounter <= NumHeatAS; ++CoilCounter) {
1903 :
1904 9 : ++DXCoilNum;
1905 :
1906 9 : 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 9 : GlobalNames::VerifyUniqueCoilName(state, CurrentModuleObject, AlphArray(1), ErrorsFound, CurrentModuleObject + " Name");
1920 :
1921 9 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).bIsDesuperheater = false;
1922 9 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name = AlphArray(1);
1923 9 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).CoolHeatType = "HEATING";
1924 9 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).VSCoilType = HVAC::Coil_HeatingAirToAirVariableSpeed;
1925 9 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).VarSpeedCoilType = HVAC::cAllCoilTypes(HVAC::Coil_HeatingAirToAirVariableSpeed);
1926 9 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).NumOfSpeeds = int(NumArray(1));
1927 9 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).NormSpedLevel = int(NumArray(2));
1928 9 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).RatedCapHeat = NumArray(3);
1929 9 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).RatedAirVolFlowRate = NumArray(4);
1930 :
1931 : // Previously set by parent objects, but not user-definable
1932 9 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MaxONOFFCyclesperHour = 4;
1933 9 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).LatentCapacityTimeConstant = 0.;
1934 9 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).FanDelayTime = 0.;
1935 :
1936 9 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).AirInletNodeNum =
1937 18 : GetOnlySingleNode(state,
1938 9 : AlphArray(2),
1939 : ErrorsFound,
1940 : DataLoopNode::ConnectionObjectType::CoilHeatingDXVariableSpeed,
1941 9 : AlphArray(1),
1942 : DataLoopNode::NodeFluidType::Air,
1943 : DataLoopNode::ConnectionType::Inlet,
1944 : NodeInputManager::CompFluidStream::Primary,
1945 : DataLoopNode::ObjectIsNotParent);
1946 9 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).AirOutletNodeNum =
1947 27 : GetOnlySingleNode(state,
1948 9 : AlphArray(3),
1949 : ErrorsFound,
1950 : DataLoopNode::ConnectionObjectType::CoilHeatingDXVariableSpeed,
1951 9 : AlphArray(1),
1952 : DataLoopNode::NodeFluidType::Air,
1953 : DataLoopNode::ConnectionType::Outlet,
1954 : NodeInputManager::CompFluidStream::Primary,
1955 : DataLoopNode::ObjectIsNotParent);
1956 :
1957 9 : BranchNodeConnections::TestCompSet(state, CurrentModuleObject, AlphArray(1), AlphArray(2), AlphArray(3), "Air Nodes");
1958 :
1959 9 : 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 9 : if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).NormSpedLevel >
1968 9 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).NumOfSpeeds) {
1969 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).NormSpedLevel =
1970 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).NumOfSpeeds;
1971 : }
1972 :
1973 9 : if ((state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).NormSpedLevel >
1974 18 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).NumOfSpeeds) ||
1975 9 : (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 9 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).PLFFPLR = Curve::GetCurveIndex(state, AlphArray(4)); // convert curve name to number
1985 9 : 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 9 : CurveVal = Curve::CurveValue(state, state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).PLFFPLR, 1.0);
2000 9 : if (CurveVal > 1.10 || CurveVal < 0.90) {
2001 0 : ShowWarningError(state,
2002 0 : format("{}{}=\"{}\", curve values",
2003 : RoutineName,
2004 : CurrentModuleObject,
2005 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name));
2006 0 : ShowContinueError(state, format("...{} output is not equal to 1.0 (+ or - 10%) at rated conditions.", cAlphaFields(4)));
2007 0 : ShowContinueError(state, format("...Curve output at rated conditions = {:.3T}", CurveVal));
2008 : }
2009 : }
2010 :
2011 9 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).DefrostEIRFT =
2012 9 : Curve::GetCurveIndex(state, AlphArray(5)); // convert curve name to number
2013 :
2014 9 : if (!lAlphaBlanks(6)) {
2015 1 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).CrankcaseHeaterCapacityCurveIndex = Curve::GetCurveIndex(state, AlphArray(6));
2016 :
2017 1 : 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 1 : ErrorsFound |=
2027 4 : Curve::CheckCurveDims(state,
2028 1 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).CrankcaseHeaterCapacityCurveIndex, // Curve index
2029 : {1}, // Valid dimensions
2030 : RoutineName, // Routine name
2031 : CurrentModuleObject, // Object Type
2032 1 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name, // Object Name
2033 1 : cAlphaFields(6)); // Field Name
2034 : }
2035 : }
2036 :
2037 9 : 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 9 : if (Util::SameString(AlphArray(7), "ReverseCycle")) {
2069 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).DefrostStrategy = ReverseCycle;
2070 : }
2071 9 : if (Util::SameString(AlphArray(7), "Resistive")) {
2072 9 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).DefrostStrategy = Resistive;
2073 : }
2074 9 : 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 9 : if (Util::SameString(AlphArray(8), "Timed")) {
2084 7 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).DefrostControl = Timed;
2085 : }
2086 9 : if (Util::SameString(AlphArray(8), "OnDemand")) {
2087 2 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).DefrostControl = OnDemand;
2088 : }
2089 9 : 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 9 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MinOATCompressor = NumArray(5);
2100 :
2101 : // reserved for HSPF calculation
2102 9 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).OATempCompressorOn = NumArray(6);
2103 :
2104 : // Set maximum outdoor temp for defrost to occur
2105 9 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MaxOATDefrost = NumArray(7);
2106 :
2107 : // Set crankcase heater capacity
2108 9 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).CrankcaseHeaterCapacity = NumArray(8);
2109 9 : 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 9 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MaxOATCrankcaseHeater = NumArray(9);
2120 :
2121 : // Set defrost time period
2122 9 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).DefrostTime = NumArray(10);
2123 9 : 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 9 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).DefrostCapacity = NumArray(11);
2132 9 : 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 89 : for (int I = 1; I <= state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).NumOfSpeeds; ++I) {
2140 80 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedTotCap(I) = NumArray(12 + (I - 1) * 5);
2141 80 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedCOP(I) = NumArray(13 + (I - 1) * 5);
2142 80 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedAirVolFlowRate(I) = NumArray(14 + (I - 1) * 5);
2143 80 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedEvaporatorFanPowerPerVolumeFlowRate2017(I) = NumArray(15 + (I - 1) * 5);
2144 80 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedEvaporatorFanPowerPerVolumeFlowRate2023(I) = NumArray(16 + (I - 1) * 5);
2145 :
2146 80 : 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 80 : AlfaFieldIncre = 9 + (I - 1) * 4;
2160 80 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSCCapFTemp(I) =
2161 80 : Curve::GetCurveIndex(state, AlphArray(AlfaFieldIncre)); // convert curve name to number
2162 80 : 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 240 : ErrorsFound |= Curve::CheckCurveDims(state,
2182 80 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSCCapFTemp(I), // Curve index
2183 : {2}, // Valid dimensions
2184 : RoutineName, // Routine name
2185 : CurrentModuleObject, // Object Type
2186 80 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name, // Object Name
2187 80 : cAlphaFields(AlfaFieldIncre)); // Field Name
2188 :
2189 80 : if (!ErrorsFound) {
2190 160 : CurveVal = Curve::CurveValue(
2191 80 : state, state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSCCapFTemp(I), RatedInletAirTempHeat, RatedAmbAirTempHeat);
2192 80 : if (CurveVal > 1.10 || CurveVal < 0.90) {
2193 0 : ShowWarningError(state,
2194 0 : format("{}{}=\"{}\", curve values",
2195 : RoutineName,
2196 : CurrentModuleObject,
2197 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name));
2198 0 : ShowContinueError(
2199 0 : state, format("...{} output is not equal to 1.0 (+ or - 10%) at rated conditions.", cAlphaFields(AlfaFieldIncre)));
2200 0 : ShowContinueError(state, format("...Curve output at rated conditions = {:.3T}", CurveVal));
2201 : }
2202 : }
2203 : }
2204 :
2205 80 : AlfaFieldIncre = 10 + (I - 1) * 4;
2206 80 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSCCapAirFFlow(I) =
2207 80 : Curve::GetCurveIndex(state, AlphArray(AlfaFieldIncre)); // convert curve name to number
2208 80 : 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 240 : ErrorsFound |= Curve::CheckCurveDims(state,
2228 80 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSCCapAirFFlow(I), // Curve index
2229 : {1}, // Valid dimensions
2230 : RoutineName, // Routine name
2231 : CurrentModuleObject, // Object Type
2232 80 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name, // Object Name
2233 80 : cAlphaFields(AlfaFieldIncre)); // Field Name
2234 :
2235 80 : if (!ErrorsFound) {
2236 80 : CurveVal = Curve::CurveValue(state, state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSCCapAirFFlow(I), 1.0);
2237 80 : 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 80 : AlfaFieldIncre = 11 + (I - 1) * 4;
2251 80 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSEIRFTemp(I) =
2252 80 : Curve::GetCurveIndex(state, AlphArray(AlfaFieldIncre)); // convert curve name to number
2253 80 : 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 240 : ErrorsFound |= Curve::CheckCurveDims(state,
2273 80 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSEIRFTemp(I), // Curve index
2274 : {2}, // Valid dimensions
2275 : RoutineName, // Routine name
2276 : CurrentModuleObject, // Object Type
2277 80 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name, // Object Name
2278 80 : cAlphaFields(AlfaFieldIncre)); // Field Name
2279 :
2280 80 : if (!ErrorsFound) {
2281 160 : CurveVal = Curve::CurveValue(
2282 80 : state, state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSEIRFTemp(I), RatedInletAirTempHeat, RatedAmbAirTempHeat);
2283 80 : if (CurveVal > 1.10 || CurveVal < 0.90) {
2284 0 : ShowWarningError(state,
2285 0 : format("{}{}=\"{}\", curve values",
2286 : RoutineName,
2287 : CurrentModuleObject,
2288 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name));
2289 0 : ShowContinueError(
2290 0 : state, format("...{} output is not equal to 1.0 (+ or - 10%) at rated conditions.", cAlphaFields(AlfaFieldIncre)));
2291 0 : ShowContinueError(state, format("...Curve output at rated conditions = {:.3T}", CurveVal));
2292 : }
2293 : }
2294 : }
2295 :
2296 80 : AlfaFieldIncre = 12 + (I - 1) * 4;
2297 80 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSEIRAirFFlow(I) =
2298 80 : Curve::GetCurveIndex(state, AlphArray(AlfaFieldIncre)); // convert curve name to number
2299 80 : 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 240 : ErrorsFound |= Curve::CheckCurveDims(state,
2319 80 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSEIRAirFFlow(I), // Curve index
2320 : {1}, // Valid dimensions
2321 : RoutineName, // Routine name
2322 : CurrentModuleObject, // Object Type
2323 80 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name, // Object Name
2324 80 : cAlphaFields(AlfaFieldIncre)); // Field Name
2325 :
2326 80 : if (!ErrorsFound) {
2327 80 : CurveVal = Curve::CurveValue(state, state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSEIRAirFFlow(I), 1.0);
2328 80 : 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 9 : if (ErrorsFound) {
2343 0 : continue;
2344 : }
2345 :
2346 89 : for (int I = 1; I <= state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).NumOfSpeeds; ++I) {
2347 80 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedPercentTotCap(I) =
2348 80 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedTotCap(I) /
2349 160 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedTotCap(
2350 80 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).NumOfSpeeds);
2351 80 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedAirVolFlowPerRatedTotCap(I) =
2352 80 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedAirVolFlowRate(I) /
2353 80 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedTotCap(I);
2354 : }
2355 :
2356 : // CurrentModuleObject = "Coil:Heating:DX:Variablespeed "
2357 18 : SetupOutputVariable(state,
2358 : "Heating Coil Electricity Energy",
2359 : Constant::Units::J,
2360 9 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Energy,
2361 : OutputProcessor::TimeStepType::System,
2362 : OutputProcessor::StoreType::Sum,
2363 9 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name,
2364 : Constant::eResource::Electricity,
2365 : OutputProcessor::Group::HVAC,
2366 : OutputProcessor::EndUseCat::Heating);
2367 18 : SetupOutputVariable(state,
2368 : "Heating Coil Heating Energy",
2369 : Constant::Units::J,
2370 9 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).EnergyLoadTotal,
2371 : OutputProcessor::TimeStepType::System,
2372 : OutputProcessor::StoreType::Sum,
2373 9 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name,
2374 : Constant::eResource::EnergyTransfer,
2375 : OutputProcessor::Group::HVAC,
2376 : OutputProcessor::EndUseCat::HeatingCoils);
2377 18 : SetupOutputVariable(state,
2378 : "Heating Coil Source Side Heat Transfer Energy",
2379 : Constant::Units::J,
2380 9 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).EnergySource,
2381 : OutputProcessor::TimeStepType::System,
2382 : OutputProcessor::StoreType::Sum,
2383 9 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name);
2384 :
2385 : // create predefined report entries
2386 18 : OutputReportPredefined::PreDefTableEntry(
2387 9 : state, state.dataOutRptPredefined->pdchHeatCoilType, state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name, CurrentModuleObject);
2388 18 : OutputReportPredefined::PreDefTableEntry(state,
2389 9 : state.dataOutRptPredefined->pdchHeatCoilNomCap,
2390 9 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name,
2391 9 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).RatedCapHeat);
2392 18 : OutputReportPredefined::PreDefTableEntry(state,
2393 9 : state.dataOutRptPredefined->pdchHeatCoilNomEff,
2394 9 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name,
2395 18 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedCOP(
2396 9 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).NormSpedLevel));
2397 : }
2398 :
2399 : //-------------------------AIR SOURCE HEATING---END
2400 :
2401 : //------------------------VARIABLE-SPEED AIR SOURCE HPWH---BEGIN
2402 22 : CurrentModuleObject = "COIL:WATERHEATING:AIRTOWATERHEATPUMP:VARIABLESPEED"; // for reporting
2403 :
2404 32 : for (int CoilCounter = 1; CoilCounter <= NumHPWHAirToWater; ++CoilCounter) {
2405 :
2406 10 : ++DXCoilNum;
2407 :
2408 10 : 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 10 : GlobalNames::VerifyUniqueCoilName(state, CurrentModuleObject, AlphArray(1), ErrorsFound, CurrentModuleObject + " Name");
2422 :
2423 10 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).bIsDesuperheater = false;
2424 10 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).CondenserType = DataHeatBalance::RefrigCondenserType::WaterHeater;
2425 10 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).CoolHeatType = "WATERHEATING";
2426 10 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).VSCoilType = HVAC::CoilDX_HeatPumpWaterHeaterVariableSpeed;
2427 10 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).VarSpeedCoilType =
2428 20 : HVAC::cAllCoilTypes(HVAC::CoilDX_HeatPumpWaterHeaterVariableSpeed);
2429 :
2430 10 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name = AlphArray(1);
2431 10 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).NumOfSpeeds = int(NumArray(1));
2432 10 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).NormSpedLevel = int(NumArray(2));
2433 :
2434 10 : 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 10 : if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).NormSpedLevel >
2443 10 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).NumOfSpeeds) {
2444 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).NormSpedLevel =
2445 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).NumOfSpeeds;
2446 : }
2447 :
2448 10 : if ((state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).NormSpedLevel >
2449 20 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).NumOfSpeeds) ||
2450 10 : (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 10 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).RatedCapWH = NumArray(3);
2459 10 : 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 10 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).WHRatedInletDBTemp = NumArray(4);
2468 10 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).WHRatedInletWBTemp = NumArray(5);
2469 10 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).WHRatedInletWaterTemp = NumArray(6);
2470 :
2471 10 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).RatedAirVolFlowRate = NumArray(7);
2472 10 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).RatedWaterVolFlowRate = NumArray(8);
2473 :
2474 10 : if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).RatedAirVolFlowRate != Constant::AutoCalculate) {
2475 6 : 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 10 : if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).RatedWaterVolFlowRate != Constant::AutoCalculate) {
2485 6 : 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 10 : if (Util::SameString(AlphArray(2), "Yes") || Util::SameString(AlphArray(2), "No")) {
2495 : // initialized to TRUE on allocate
2496 10 : if (Util::SameString(AlphArray(2), "No")) {
2497 9 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).FanPowerIncludedInCOP = false;
2498 : } else {
2499 1 : 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 10 : if (Util::SameString(AlphArray(3), "Yes") || Util::SameString(AlphArray(3), "No")) {
2511 : // initialized to FALSE on allocate
2512 10 : if (Util::SameString(AlphArray(3), "Yes")) {
2513 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).CondPumpPowerInCOP = true;
2514 : } else {
2515 10 : 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 10 : if (Util::SameString(AlphArray(4), "Yes") || Util::SameString(AlphArray(4), "No")) {
2527 : // initialized to FALSE on allocate
2528 10 : if (Util::SameString(AlphArray(4), "Yes")) {
2529 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).CondPumpHeatInCapacity = true;
2530 : } else {
2531 10 : 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 10 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).HPWHCondPumpFracToWater = NumArray(9);
2543 20 : if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).HPWHCondPumpFracToWater <= 0.0 ||
2544 10 : 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 10 : if (!state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).CondPumpHeatInCapacity) {
2553 10 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).HPWHCondPumpFracToWater = 0.0;
2554 : }
2555 :
2556 : // Air nodes
2557 10 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).AirInletNodeNum =
2558 20 : GetOnlySingleNode(state,
2559 10 : AlphArray(5),
2560 : ErrorsFound,
2561 : DataLoopNode::ConnectionObjectType::CoilWaterHeatingAirToWaterHeatPumpVariableSpeed,
2562 10 : AlphArray(1),
2563 : DataLoopNode::NodeFluidType::Air,
2564 : DataLoopNode::ConnectionType::Inlet,
2565 : NodeInputManager::CompFluidStream::Primary,
2566 : DataLoopNode::ObjectIsNotParent);
2567 :
2568 10 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).AirOutletNodeNum =
2569 30 : GetOnlySingleNode(state,
2570 10 : AlphArray(6),
2571 : ErrorsFound,
2572 : DataLoopNode::ConnectionObjectType::CoilWaterHeatingAirToWaterHeatPumpVariableSpeed,
2573 10 : AlphArray(1),
2574 : DataLoopNode::NodeFluidType::Air,
2575 : DataLoopNode::ConnectionType::Outlet,
2576 : NodeInputManager::CompFluidStream::Primary,
2577 : DataLoopNode::ObjectIsNotParent);
2578 :
2579 10 : 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 10 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).IsDXCoilInZone =
2583 10 : !OutAirNodeManager::CheckOutAirNodeNumber(state, state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).AirInletNodeNum);
2584 :
2585 : // Water nodes
2586 10 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).WaterInletNodeNum =
2587 20 : GetOnlySingleNode(state,
2588 10 : AlphArray(7),
2589 : ErrorsFound,
2590 : DataLoopNode::ConnectionObjectType::CoilWaterHeatingAirToWaterHeatPumpVariableSpeed,
2591 10 : AlphArray(1),
2592 : DataLoopNode::NodeFluidType::Water,
2593 : DataLoopNode::ConnectionType::Inlet,
2594 : NodeInputManager::CompFluidStream::Secondary,
2595 : DataLoopNode::ObjectIsNotParent);
2596 :
2597 10 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).WaterOutletNodeNum =
2598 30 : GetOnlySingleNode(state,
2599 10 : AlphArray(8),
2600 : ErrorsFound,
2601 : DataLoopNode::ConnectionObjectType::CoilWaterHeatingAirToWaterHeatPumpVariableSpeed,
2602 10 : AlphArray(1),
2603 : DataLoopNode::NodeFluidType::Water,
2604 : DataLoopNode::ConnectionType::Outlet,
2605 : NodeInputManager::CompFluidStream::Secondary,
2606 : DataLoopNode::ObjectIsNotParent);
2607 :
2608 10 : BranchNodeConnections::TestCompSet(state, CurrentModuleObject, AlphArray(1), AlphArray(7), AlphArray(8), "Water Nodes");
2609 :
2610 10 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).CrankcaseHeaterCapacity = NumArray(10);
2611 10 : 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 10 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MaxOATCrankcaseHeater = NumArray(11);
2620 10 : 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 10 : if (!lAlphaBlanks(9)) {
2629 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).CrankcaseHeaterCapacityCurveIndex = Curve::GetCurveIndex(state, AlphArray(9));
2630 0 : 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 0 : ErrorsFound |=
2640 0 : Curve::CheckCurveDims(state,
2641 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).CrankcaseHeaterCapacityCurveIndex, // Curve index
2642 : {1}, // Valid dimensions
2643 : RoutineName, // Routine name
2644 : CurrentModuleObject, // Object Type
2645 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name, // Object Name
2646 0 : cAlphaFields(9)); // Field Name
2647 : }
2648 : }
2649 :
2650 10 : if (Util::SameString(AlphArray(10), "DryBulbTemperature")) {
2651 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).InletAirTemperatureType = HVAC::OATType::DryBulb;
2652 10 : } else if (Util::SameString(AlphArray(10), "WetBulbTemperature")) {
2653 10 : 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 10 : if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).InletAirTemperatureType == HVAC::OATType::WetBulb) {
2666 10 : 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 10 : WHInletWaterTemp = state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).WHRatedInletWaterTemp;
2672 :
2673 : // part load curve
2674 10 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).PLFFPLR =
2675 10 : Curve::GetCurveIndex(state, AlphArray(11)); // convert curve name to number
2676 10 : 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 10 : CurveVal = Curve::CurveValue(state, state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).PLFFPLR, 1.0);
2691 10 : if (CurveVal > 1.10 || CurveVal < 0.90) {
2692 0 : ShowWarningError(state,
2693 0 : format("{}{}=\"{}\", curve values",
2694 : RoutineName,
2695 : CurrentModuleObject,
2696 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name));
2697 0 : ShowContinueError(state, format("...{} output is not equal to 1.0 (+ or - 10%) at rated conditions.", cAlphaFields(11)));
2698 0 : ShowContinueError(state, format("...Curve output at rated conditions = {:.3T}", CurveVal));
2699 : }
2700 : }
2701 :
2702 110 : for (int I = 1; I <= state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).NumOfSpeeds; ++I) {
2703 100 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedTotCap(I) = NumArray(12 + (I - 1) * 6);
2704 100 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedCOP(I) = NumArray(13 + (I - 1) * 6);
2705 100 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedSHR(I) = NumArray(14 + (I - 1) * 6);
2706 100 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedAirVolFlowRate(I) = NumArray(15 + (I - 1) * 6);
2707 100 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedWaterVolFlowRate(I) = NumArray(16 + (I - 1) * 6);
2708 100 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSWHPumpPower(I) = NumArray(17 + (I - 1) * 6);
2709 :
2710 100 : AlfaFieldIncre = 12 + (I - 1) * 6;
2711 100 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSCCapFTemp(I) =
2712 100 : Curve::GetCurveIndex(state, AlphArray(AlfaFieldIncre)); // convert curve name to number
2713 100 : 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 300 : ErrorsFound |= Curve::CheckCurveDims(state,
2733 100 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSCCapFTemp(I), // Curve index
2734 : {2}, // Valid dimensions
2735 : RoutineName, // Routine name
2736 : CurrentModuleObject, // Object Type
2737 100 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name, // Object Name
2738 100 : cAlphaFields(AlfaFieldIncre)); // Field Name
2739 :
2740 100 : if (!ErrorsFound) {
2741 200 : CurveVal = Curve::CurveValue(
2742 100 : state, state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSCCapFTemp(I), WHInletAirTemp, WHInletWaterTemp);
2743 100 : if (CurveVal > 1.10 || CurveVal < 0.90) {
2744 0 : ShowWarningError(state,
2745 0 : format("{}{}=\"{}\", curve values",
2746 : RoutineName,
2747 : CurrentModuleObject,
2748 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name));
2749 0 : ShowContinueError(
2750 0 : state, format("...{} output is not equal to 1.0 (+ or - 10%) at rated conditions.", cAlphaFields(AlfaFieldIncre)));
2751 0 : ShowContinueError(state, format("...Curve output at rated conditions = {:.3T}", CurveVal));
2752 : }
2753 : }
2754 : }
2755 :
2756 100 : AlfaFieldIncre = 13 + (I - 1) * 6;
2757 100 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSCCapAirFFlow(I) =
2758 100 : Curve::GetCurveIndex(state, AlphArray(AlfaFieldIncre)); // convert curve name to number
2759 100 : 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 300 : ErrorsFound |= Curve::CheckCurveDims(state,
2779 100 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSCCapAirFFlow(I), // Curve index
2780 : {1}, // Valid dimensions
2781 : RoutineName, // Routine name
2782 : CurrentModuleObject, // Object Type
2783 100 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name, // Object Name
2784 100 : cAlphaFields(AlfaFieldIncre)); // Field Name
2785 :
2786 100 : if (!ErrorsFound) {
2787 100 : CurveVal = Curve::CurveValue(state, state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSCCapAirFFlow(I), 1.0);
2788 100 : 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 100 : AlfaFieldIncre = 14 + (I - 1) * 6;
2802 100 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSCCapWaterFFlow(I) =
2803 100 : Curve::GetCurveIndex(state, AlphArray(AlfaFieldIncre)); // convert curve name to number
2804 100 : 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 300 : ErrorsFound |= Curve::CheckCurveDims(state,
2824 100 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSCCapWaterFFlow(I), // Curve index
2825 : {1}, // Valid dimensions
2826 : RoutineName, // Routine name
2827 : CurrentModuleObject, // Object Type
2828 100 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name, // Object Name
2829 100 : cAlphaFields(AlfaFieldIncre)); // Field Name
2830 :
2831 100 : if (!ErrorsFound) {
2832 100 : CurveVal = Curve::CurveValue(state, state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSCCapWaterFFlow(I), 1.0);
2833 100 : 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 100 : AlfaFieldIncre = 15 + (I - 1) * 6;
2847 100 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSEIRFTemp(I) =
2848 100 : Curve::GetCurveIndex(state, AlphArray(AlfaFieldIncre)); // convert curve name to number
2849 100 : 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 300 : ErrorsFound |= Curve::CheckCurveDims(state,
2869 100 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSEIRFTemp(I), // Curve index
2870 : {2}, // Valid dimensions
2871 : RoutineName, // Routine name
2872 : CurrentModuleObject, // Object Type
2873 100 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name, // Object Name
2874 100 : cAlphaFields(AlfaFieldIncre)); // Field Name
2875 :
2876 100 : if (!ErrorsFound) {
2877 200 : CurveVal = Curve::CurveValue(
2878 100 : state, state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSEIRFTemp(I), WHInletAirTemp, WHInletWaterTemp);
2879 100 : if (CurveVal > 1.10 || CurveVal < 0.90) {
2880 0 : ShowWarningError(state,
2881 0 : format("{}{}=\"{}\", curve values",
2882 : RoutineName,
2883 : CurrentModuleObject,
2884 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name));
2885 0 : ShowContinueError(
2886 0 : state, format("...{} output is not equal to 1.0 (+ or - 10%) at rated conditions.", cAlphaFields(AlfaFieldIncre)));
2887 0 : ShowContinueError(state, format("...Curve output at rated conditions = {:.3T}", CurveVal));
2888 : }
2889 : }
2890 : }
2891 :
2892 100 : AlfaFieldIncre = 16 + (I - 1) * 6;
2893 100 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSEIRAirFFlow(I) =
2894 100 : Curve::GetCurveIndex(state, AlphArray(AlfaFieldIncre)); // convert curve name to number
2895 100 : 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 300 : ErrorsFound |= Curve::CheckCurveDims(state,
2915 100 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSEIRAirFFlow(I), // Curve index
2916 : {1}, // Valid dimensions
2917 : RoutineName, // Routine name
2918 : CurrentModuleObject, // Object Type
2919 100 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name, // Object Name
2920 100 : cAlphaFields(AlfaFieldIncre)); // Field Name
2921 :
2922 100 : if (!ErrorsFound) {
2923 100 : CurveVal = Curve::CurveValue(state, state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSEIRAirFFlow(I), 1.0);
2924 100 : 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 100 : AlfaFieldIncre = 17 + (I - 1) * 6;
2938 100 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSEIRWaterFFlow(I) =
2939 100 : Curve::GetCurveIndex(state, AlphArray(AlfaFieldIncre)); // convert curve name to number
2940 100 : 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 300 : ErrorsFound |= Curve::CheckCurveDims(state,
2960 100 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSEIRWaterFFlow(I), // Curve index
2961 : {1}, // Valid dimensions
2962 : RoutineName, // Routine name
2963 : CurrentModuleObject, // Object Type
2964 100 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name, // Object Name
2965 100 : cAlphaFields(AlfaFieldIncre)); // Field Name
2966 :
2967 100 : if (!ErrorsFound) {
2968 100 : CurveVal = Curve::CurveValue(state, state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSEIRWaterFFlow(I), 1.0);
2969 100 : 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 110 : for (int I = 1; I <= state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).NumOfSpeeds; ++I) {
2985 100 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedPercentTotCap(I) =
2986 100 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedTotCap(I) /
2987 200 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedTotCap(
2988 100 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).NumOfSpeeds);
2989 100 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedAirVolFlowPerRatedTotCap(I) =
2990 100 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedAirVolFlowRate(I) /
2991 100 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedTotCap(I);
2992 100 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedWaterVolFlowPerRatedTotCap(I) =
2993 100 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedWaterVolFlowRate(I) /
2994 100 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedTotCap(I);
2995 100 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSWHPumpPowerPerRatedTotCap(I) =
2996 100 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSWHPumpPower(I) /
2997 100 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedTotCap(I);
2998 : }
2999 :
3000 : // CurrentModuleObject = "Coil:Waterheating:Airtowaterheatpump:Variablespeed"
3001 20 : SetupOutputVariable(state,
3002 : "Cooling Coil Electricity Energy",
3003 : Constant::Units::J,
3004 10 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Energy,
3005 : OutputProcessor::TimeStepType::System,
3006 : OutputProcessor::StoreType::Sum,
3007 10 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name,
3008 : Constant::eResource::Electricity,
3009 : OutputProcessor::Group::HVAC,
3010 : OutputProcessor::EndUseCat::Heating);
3011 20 : SetupOutputVariable(state,
3012 : "Cooling Coil Sensible Cooling Energy",
3013 : Constant::Units::J,
3014 10 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).EnergySensible,
3015 : OutputProcessor::TimeStepType::System,
3016 : OutputProcessor::StoreType::Sum,
3017 10 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name);
3018 20 : SetupOutputVariable(state,
3019 : "Cooling Coil Latent Cooling Energy",
3020 : Constant::Units::J,
3021 10 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).EnergyLatent,
3022 : OutputProcessor::TimeStepType::System,
3023 : OutputProcessor::StoreType::Sum,
3024 10 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name);
3025 20 : SetupOutputVariable(state,
3026 : "Cooling Coil Water Side Heat Transfer Energy",
3027 : Constant::Units::J,
3028 10 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).EnergySource,
3029 : OutputProcessor::TimeStepType::System,
3030 : OutputProcessor::StoreType::Sum,
3031 10 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name,
3032 : Constant::eResource::PlantLoopHeatingDemand,
3033 : OutputProcessor::Group::HVAC,
3034 : OutputProcessor::EndUseCat::HeatingCoils);
3035 :
3036 10 : if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).IsDXCoilInZone) {
3037 20 : SetupOutputVariable(state,
3038 : "Cooling Coil Cooling Energy",
3039 : Constant::Units::J,
3040 10 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).EnergyLoadTotal,
3041 : OutputProcessor::TimeStepType::System,
3042 : OutputProcessor::StoreType::Sum,
3043 10 : 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 10 : 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 22 : AlphArray.deallocate();
3063 22 : cAlphaFields.deallocate();
3064 22 : lAlphaBlanks.deallocate();
3065 22 : cNumericFields.deallocate();
3066 22 : lNumericBlanks.deallocate();
3067 22 : NumArray.deallocate();
3068 :
3069 22 : if (ErrorsFound) {
3070 0 : ShowFatalError(state, format("{}Errors found getting input. Program terminates.", RoutineName));
3071 : }
3072 :
3073 99 : for (DXCoilNum = 1; DXCoilNum <= state.dataVariableSpeedCoils->NumVarSpeedCoils; ++DXCoilNum) {
3074 132 : if ((state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).VSCoilType == HVAC::Coil_CoolingAirToAirVariableSpeed) ||
3075 55 : (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).VSCoilType == HVAC::Coil_HeatingAirToAirVariableSpeed)) {
3076 : // Setup Report variables for the Heat Pump
3077 :
3078 : // cooling and heating coils separately
3079 31 : if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).VSCoilType == HVAC::Coil_CoolingAirToAirVariableSpeed) {
3080 : // air source cooling coils
3081 44 : SetupOutputVariable(state,
3082 : "Cooling Coil Air Mass Flow Rate",
3083 : Constant::Units::kg_s,
3084 22 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).AirMassFlowRate,
3085 : OutputProcessor::TimeStepType::System,
3086 : OutputProcessor::StoreType::Average,
3087 22 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name);
3088 44 : SetupOutputVariable(state,
3089 : "Cooling Coil Air Inlet Temperature",
3090 : Constant::Units::C,
3091 22 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).InletAirDBTemp,
3092 : OutputProcessor::TimeStepType::System,
3093 : OutputProcessor::StoreType::Average,
3094 22 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name);
3095 44 : SetupOutputVariable(state,
3096 : "Cooling Coil Air Inlet Humidity Ratio",
3097 : Constant::Units::kgWater_kgDryAir,
3098 22 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).InletAirHumRat,
3099 : OutputProcessor::TimeStepType::System,
3100 : OutputProcessor::StoreType::Average,
3101 22 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name);
3102 44 : SetupOutputVariable(state,
3103 : "Cooling Coil Latent Cooling Rate",
3104 : Constant::Units::W,
3105 22 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).QLatent,
3106 : OutputProcessor::TimeStepType::System,
3107 : OutputProcessor::StoreType::Average,
3108 22 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name);
3109 44 : SetupOutputVariable(state,
3110 : "Cooling Coil Air Outlet Temperature",
3111 : Constant::Units::C,
3112 22 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).OutletAirDBTemp,
3113 : OutputProcessor::TimeStepType::System,
3114 : OutputProcessor::StoreType::Average,
3115 22 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name);
3116 44 : SetupOutputVariable(state,
3117 : "Cooling Coil Air Outlet Humidity Ratio",
3118 : Constant::Units::kgWater_kgDryAir,
3119 22 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).OutletAirHumRat,
3120 : OutputProcessor::TimeStepType::System,
3121 : OutputProcessor::StoreType::Average,
3122 22 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name);
3123 44 : SetupOutputVariable(state,
3124 : "Cooling Coil Sensible Cooling Rate",
3125 : Constant::Units::W,
3126 22 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).QSensible,
3127 : OutputProcessor::TimeStepType::System,
3128 : OutputProcessor::StoreType::Average,
3129 22 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name);
3130 44 : SetupOutputVariable(state,
3131 : "Cooling Coil Total Cooling Rate",
3132 : Constant::Units::W,
3133 22 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).QLoadTotal,
3134 : OutputProcessor::TimeStepType::System,
3135 : OutputProcessor::StoreType::Average,
3136 22 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name);
3137 44 : SetupOutputVariable(state,
3138 : "Cooling Coil Part Load Ratio",
3139 : Constant::Units::None,
3140 22 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).PartLoadRatio,
3141 : OutputProcessor::TimeStepType::System,
3142 : OutputProcessor::StoreType::Average,
3143 22 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name);
3144 44 : SetupOutputVariable(state,
3145 : "Cooling Coil Electricity Rate",
3146 : Constant::Units::W,
3147 22 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Power,
3148 : OutputProcessor::TimeStepType::System,
3149 : OutputProcessor::StoreType::Average,
3150 22 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name);
3151 44 : SetupOutputVariable(state,
3152 : "Cooling Coil Runtime Fraction",
3153 : Constant::Units::None,
3154 22 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).RunFrac,
3155 : OutputProcessor::TimeStepType::System,
3156 : OutputProcessor::StoreType::Average,
3157 22 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name);
3158 44 : SetupOutputVariable(state,
3159 : "Cooling Coil Source Side Heat Transfer Rate",
3160 : Constant::Units::W,
3161 22 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).QSource,
3162 : OutputProcessor::TimeStepType::System,
3163 : OutputProcessor::StoreType::Average,
3164 22 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name);
3165 44 : SetupOutputVariable(state,
3166 : "Cooling Coil Upper Speed Level",
3167 : Constant::Units::None,
3168 22 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).SpeedNumReport,
3169 : OutputProcessor::TimeStepType::System,
3170 : OutputProcessor::StoreType::Average,
3171 22 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name);
3172 44 : SetupOutputVariable(state,
3173 : "Cooling Coil Neighboring Speed Levels Ratio",
3174 : Constant::Units::None,
3175 22 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).SpeedRatioReport,
3176 : OutputProcessor::TimeStepType::System,
3177 : OutputProcessor::StoreType::Average,
3178 22 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name);
3179 :
3180 22 : 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 22 : if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).ReportEvapCondVars) {
3201 0 : SetupOutputVariable(state,
3202 : "Cooling Coil Condenser Inlet Temperature",
3203 : Constant::Units::C,
3204 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).CondInletTemp,
3205 : OutputProcessor::TimeStepType::System,
3206 : OutputProcessor::StoreType::Average,
3207 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name);
3208 0 : SetupOutputVariable(state,
3209 : "Cooling Coil Evaporative Condenser Water Volume",
3210 : Constant::Units::m3,
3211 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).EvapWaterConsump,
3212 : OutputProcessor::TimeStepType::System,
3213 : OutputProcessor::StoreType::Sum,
3214 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name,
3215 : Constant::eResource::Water,
3216 : OutputProcessor::Group::HVAC,
3217 : OutputProcessor::EndUseCat::Cooling);
3218 0 : SetupOutputVariable(state,
3219 : "Cooling Coil Evaporative Condenser Mains Water Volume",
3220 : Constant::Units::m3,
3221 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).EvapWaterConsump,
3222 : OutputProcessor::TimeStepType::System,
3223 : OutputProcessor::StoreType::Sum,
3224 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name,
3225 : Constant::eResource::MainsWater,
3226 : OutputProcessor::Group::HVAC,
3227 : OutputProcessor::EndUseCat::Cooling);
3228 0 : SetupOutputVariable(state,
3229 : "Cooling Coil Evaporative Condenser Pump Electricity Rate",
3230 : Constant::Units::W,
3231 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).EvapCondPumpElecPower,
3232 : OutputProcessor::TimeStepType::System,
3233 : OutputProcessor::StoreType::Average,
3234 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name);
3235 0 : SetupOutputVariable(state,
3236 : "Cooling Coil Evaporative Condenser Pump Electricity Energy",
3237 : Constant::Units::J,
3238 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).EvapCondPumpElecConsumption,
3239 : OutputProcessor::TimeStepType::System,
3240 : OutputProcessor::StoreType::Sum,
3241 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name,
3242 : Constant::eResource::Electricity,
3243 : OutputProcessor::Group::HVAC,
3244 : OutputProcessor::EndUseCat::Cooling);
3245 0 : 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 44 : SetupOutputVariable(state,
3267 : "Cooling Coil Crankcase Heater Electricity Rate",
3268 : Constant::Units::W,
3269 22 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).CrankcaseHeaterPower,
3270 : OutputProcessor::TimeStepType::System,
3271 : OutputProcessor::StoreType::Average,
3272 22 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name);
3273 44 : SetupOutputVariable(state,
3274 : "Cooling Coil Crankcase Heater Electricity Energy",
3275 : Constant::Units::J,
3276 22 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).CrankcaseHeaterConsumption,
3277 : OutputProcessor::TimeStepType::System,
3278 : OutputProcessor::StoreType::Sum,
3279 22 : 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 18 : SetupOutputVariable(state,
3286 : "Heating Coil Air Mass Flow Rate",
3287 : Constant::Units::kg_s,
3288 9 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).AirMassFlowRate,
3289 : OutputProcessor::TimeStepType::System,
3290 : OutputProcessor::StoreType::Average,
3291 9 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name);
3292 18 : SetupOutputVariable(state,
3293 : "Heating Coil Air Inlet Temperature",
3294 : Constant::Units::C,
3295 9 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).InletAirDBTemp,
3296 : OutputProcessor::TimeStepType::System,
3297 : OutputProcessor::StoreType::Average,
3298 9 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name);
3299 18 : SetupOutputVariable(state,
3300 : "Heating Coil Air Inlet Humidity Ratio",
3301 : Constant::Units::kgWater_kgDryAir,
3302 9 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).InletAirHumRat,
3303 : OutputProcessor::TimeStepType::System,
3304 : OutputProcessor::StoreType::Average,
3305 9 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name);
3306 18 : SetupOutputVariable(state,
3307 : "Heating Coil Air Outlet Temperature",
3308 : Constant::Units::C,
3309 9 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).OutletAirDBTemp,
3310 : OutputProcessor::TimeStepType::System,
3311 : OutputProcessor::StoreType::Average,
3312 9 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name);
3313 18 : SetupOutputVariable(state,
3314 : "Heating Coil Air Outlet Humidity Ratio",
3315 : Constant::Units::kgWater_kgDryAir,
3316 9 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).OutletAirHumRat,
3317 : OutputProcessor::TimeStepType::System,
3318 : OutputProcessor::StoreType::Average,
3319 9 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name);
3320 18 : SetupOutputVariable(state,
3321 : "Heating Coil Sensible Heating Rate",
3322 : Constant::Units::W,
3323 9 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).QSensible,
3324 : OutputProcessor::TimeStepType::System,
3325 : OutputProcessor::StoreType::Average,
3326 9 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name);
3327 18 : SetupOutputVariable(state,
3328 : "Heating Coil Heating Rate",
3329 : Constant::Units::W,
3330 9 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).QLoadTotal,
3331 : OutputProcessor::TimeStepType::System,
3332 : OutputProcessor::StoreType::Average,
3333 9 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name);
3334 18 : SetupOutputVariable(state,
3335 : "Heating Coil Part Load Ratio",
3336 : Constant::Units::None,
3337 9 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).PartLoadRatio,
3338 : OutputProcessor::TimeStepType::System,
3339 : OutputProcessor::StoreType::Average,
3340 9 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name);
3341 18 : SetupOutputVariable(state,
3342 : "Heating Coil Electricity Rate",
3343 : Constant::Units::W,
3344 9 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Power,
3345 : OutputProcessor::TimeStepType::System,
3346 : OutputProcessor::StoreType::Average,
3347 9 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name);
3348 18 : SetupOutputVariable(state,
3349 : "Heating Coil Runtime Fraction",
3350 : Constant::Units::None,
3351 9 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).RunFrac,
3352 : OutputProcessor::TimeStepType::System,
3353 : OutputProcessor::StoreType::Average,
3354 9 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name);
3355 :
3356 18 : SetupOutputVariable(state,
3357 : "Heating Coil Source Side Heat Transfer Rate",
3358 : Constant::Units::W,
3359 9 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).QSource,
3360 : OutputProcessor::TimeStepType::System,
3361 : OutputProcessor::StoreType::Average,
3362 9 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name);
3363 18 : SetupOutputVariable(state,
3364 : "Heating Coil Upper Speed Level",
3365 : Constant::Units::None,
3366 9 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).SpeedNumReport,
3367 : OutputProcessor::TimeStepType::System,
3368 : OutputProcessor::StoreType::Average,
3369 9 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name);
3370 18 : SetupOutputVariable(state,
3371 : "Heating Coil Neighboring Speed Levels Ratio",
3372 : Constant::Units::None,
3373 9 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).SpeedRatioReport,
3374 : OutputProcessor::TimeStepType::System,
3375 : OutputProcessor::StoreType::Average,
3376 9 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name);
3377 :
3378 18 : SetupOutputVariable(state,
3379 : "Heating Coil Defrost Electricity Rate",
3380 : Constant::Units::W,
3381 9 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).DefrostPower,
3382 : OutputProcessor::TimeStepType::System,
3383 : OutputProcessor::StoreType::Average,
3384 9 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name);
3385 18 : SetupOutputVariable(state,
3386 : "Heating Coil Defrost Electricity Energy",
3387 : Constant::Units::J,
3388 9 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).DefrostConsumption,
3389 : OutputProcessor::TimeStepType::System,
3390 : OutputProcessor::StoreType::Sum,
3391 9 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name,
3392 : Constant::eResource::Electricity,
3393 : OutputProcessor::Group::HVAC,
3394 : OutputProcessor::EndUseCat::Heating);
3395 18 : SetupOutputVariable(state,
3396 : "Heating Coil Crankcase Heater Electricity Rate",
3397 : Constant::Units::W,
3398 9 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).CrankcaseHeaterPower,
3399 : OutputProcessor::TimeStepType::System,
3400 : OutputProcessor::StoreType::Average,
3401 9 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name);
3402 18 : SetupOutputVariable(state,
3403 : "Heating Coil Crankcase Heater Electricity Energy",
3404 : Constant::Units::J,
3405 9 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).CrankcaseHeaterConsumption,
3406 : OutputProcessor::TimeStepType::System,
3407 : OutputProcessor::StoreType::Sum,
3408 9 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name,
3409 : Constant::eResource::Electricity,
3410 : OutputProcessor::Group::HVAC,
3411 : OutputProcessor::EndUseCat::Heating);
3412 :
3413 9 : 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 46 : 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 36 : SetupOutputVariable(state,
3438 : "Cooling Coil Electricity Rate",
3439 : Constant::Units::W,
3440 18 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Power,
3441 : OutputProcessor::TimeStepType::System,
3442 : OutputProcessor::StoreType::Average,
3443 18 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name);
3444 36 : SetupOutputVariable(state,
3445 : "Cooling Coil Total Cooling Rate",
3446 : Constant::Units::W,
3447 18 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).QLoadTotal,
3448 : OutputProcessor::TimeStepType::System,
3449 : OutputProcessor::StoreType::Average,
3450 18 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name);
3451 36 : SetupOutputVariable(state,
3452 : "Cooling Coil Sensible Cooling Rate",
3453 : Constant::Units::W,
3454 18 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).QSensible,
3455 : OutputProcessor::TimeStepType::System,
3456 : OutputProcessor::StoreType::Average,
3457 18 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name);
3458 36 : SetupOutputVariable(state,
3459 : "Cooling Coil Latent Cooling Rate",
3460 : Constant::Units::W,
3461 18 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).QLatent,
3462 : OutputProcessor::TimeStepType::System,
3463 : OutputProcessor::StoreType::Average,
3464 18 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name);
3465 36 : SetupOutputVariable(state,
3466 : "Cooling Coil Source Side Heat Transfer Rate",
3467 : Constant::Units::W,
3468 18 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).QSource,
3469 : OutputProcessor::TimeStepType::System,
3470 : OutputProcessor::StoreType::Average,
3471 18 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name);
3472 36 : SetupOutputVariable(state,
3473 : "Cooling Coil Part Load Ratio",
3474 : Constant::Units::None,
3475 18 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).PartLoadRatio,
3476 : OutputProcessor::TimeStepType::System,
3477 : OutputProcessor::StoreType::Average,
3478 18 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name);
3479 36 : SetupOutputVariable(state,
3480 : "Cooling Coil Runtime Fraction",
3481 : Constant::Units::None,
3482 18 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).RunFrac,
3483 : OutputProcessor::TimeStepType::System,
3484 : OutputProcessor::StoreType::Average,
3485 18 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name);
3486 :
3487 36 : SetupOutputVariable(state,
3488 : "Cooling Coil Air Mass Flow Rate",
3489 : Constant::Units::kg_s,
3490 18 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).AirMassFlowRate,
3491 : OutputProcessor::TimeStepType::System,
3492 : OutputProcessor::StoreType::Average,
3493 18 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name);
3494 36 : SetupOutputVariable(state,
3495 : "Cooling Coil Air Inlet Temperature",
3496 : Constant::Units::C,
3497 18 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).InletAirDBTemp,
3498 : OutputProcessor::TimeStepType::System,
3499 : OutputProcessor::StoreType::Average,
3500 18 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name);
3501 36 : SetupOutputVariable(state,
3502 : "Cooling Coil Air Inlet Humidity Ratio",
3503 : Constant::Units::kgWater_kgDryAir,
3504 18 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).InletAirHumRat,
3505 : OutputProcessor::TimeStepType::System,
3506 : OutputProcessor::StoreType::Average,
3507 18 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name);
3508 36 : SetupOutputVariable(state,
3509 : "Cooling Coil Air Outlet Temperature",
3510 : Constant::Units::C,
3511 18 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).OutletAirDBTemp,
3512 : OutputProcessor::TimeStepType::System,
3513 : OutputProcessor::StoreType::Average,
3514 18 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name);
3515 36 : SetupOutputVariable(state,
3516 : "Cooling Coil Air Outlet Humidity Ratio",
3517 : Constant::Units::kgWater_kgDryAir,
3518 18 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).OutletAirHumRat,
3519 : OutputProcessor::TimeStepType::System,
3520 : OutputProcessor::StoreType::Average,
3521 18 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name);
3522 36 : SetupOutputVariable(state,
3523 : "Cooling Coil Source Side Mass Flow Rate",
3524 : Constant::Units::kg_s,
3525 18 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).WaterMassFlowRate,
3526 : OutputProcessor::TimeStepType::System,
3527 : OutputProcessor::StoreType::Average,
3528 18 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name);
3529 36 : SetupOutputVariable(state,
3530 : "Cooling Coil Source Side Inlet Temperature",
3531 : Constant::Units::C,
3532 18 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).InletWaterTemp,
3533 : OutputProcessor::TimeStepType::System,
3534 : OutputProcessor::StoreType::Average,
3535 18 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name);
3536 36 : SetupOutputVariable(state,
3537 : "Cooling Coil Source Side Outlet Temperature",
3538 : Constant::Units::C,
3539 18 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).OutletWaterTemp,
3540 : OutputProcessor::TimeStepType::System,
3541 : OutputProcessor::StoreType::Average,
3542 18 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name);
3543 :
3544 36 : SetupOutputVariable(state,
3545 : "Cooling Coil Upper Speed Level",
3546 : Constant::Units::None,
3547 18 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).SpeedNumReport,
3548 : OutputProcessor::TimeStepType::System,
3549 : OutputProcessor::StoreType::Average,
3550 18 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name);
3551 36 : SetupOutputVariable(state,
3552 : "Cooling Coil Neighboring Speed Levels Ratio",
3553 : Constant::Units::None,
3554 18 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).SpeedRatioReport,
3555 : OutputProcessor::TimeStepType::System,
3556 : OutputProcessor::StoreType::Average,
3557 18 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name);
3558 36 : SetupOutputVariable(state,
3559 : "Cooling Coil Recoverable Heat Transfer Rate",
3560 : Constant::Units::W,
3561 18 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).QWasteHeat,
3562 : OutputProcessor::TimeStepType::System,
3563 : OutputProcessor::StoreType::Average,
3564 18 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name);
3565 28 : } 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 36 : SetupOutputVariable(state,
3570 : "Heating Coil Electricity Rate",
3571 : Constant::Units::W,
3572 18 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Power,
3573 : OutputProcessor::TimeStepType::System,
3574 : OutputProcessor::StoreType::Average,
3575 18 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name);
3576 36 : SetupOutputVariable(state,
3577 : "Heating Coil Heating Rate",
3578 : Constant::Units::W,
3579 18 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).QLoadTotal,
3580 : OutputProcessor::TimeStepType::System,
3581 : OutputProcessor::StoreType::Average,
3582 18 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name);
3583 36 : SetupOutputVariable(state,
3584 : "Heating Coil Sensible Heating Rate",
3585 : Constant::Units::W,
3586 18 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).QSensible,
3587 : OutputProcessor::TimeStepType::System,
3588 : OutputProcessor::StoreType::Average,
3589 18 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name);
3590 :
3591 36 : SetupOutputVariable(state,
3592 : "Heating Coil Source Side Heat Transfer Rate",
3593 : Constant::Units::W,
3594 18 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).QSource,
3595 : OutputProcessor::TimeStepType::System,
3596 : OutputProcessor::StoreType::Average,
3597 18 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name);
3598 36 : SetupOutputVariable(state,
3599 : "Heating Coil Part Load Ratio",
3600 : Constant::Units::None,
3601 18 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).PartLoadRatio,
3602 : OutputProcessor::TimeStepType::System,
3603 : OutputProcessor::StoreType::Average,
3604 18 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name);
3605 36 : SetupOutputVariable(state,
3606 : "Heating Coil Runtime Fraction",
3607 : Constant::Units::None,
3608 18 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).RunFrac,
3609 : OutputProcessor::TimeStepType::System,
3610 : OutputProcessor::StoreType::Average,
3611 18 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name);
3612 :
3613 36 : SetupOutputVariable(state,
3614 : "Heating Coil Air Mass Flow Rate",
3615 : Constant::Units::kg_s,
3616 18 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).AirMassFlowRate,
3617 : OutputProcessor::TimeStepType::System,
3618 : OutputProcessor::StoreType::Average,
3619 18 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name);
3620 36 : SetupOutputVariable(state,
3621 : "Heating Coil Air Inlet Temperature",
3622 : Constant::Units::C,
3623 18 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).InletAirDBTemp,
3624 : OutputProcessor::TimeStepType::System,
3625 : OutputProcessor::StoreType::Average,
3626 18 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name);
3627 36 : SetupOutputVariable(state,
3628 : "Heating Coil Air Inlet Humidity Ratio",
3629 : Constant::Units::kgWater_kgDryAir,
3630 18 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).InletAirHumRat,
3631 : OutputProcessor::TimeStepType::System,
3632 : OutputProcessor::StoreType::Average,
3633 18 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name);
3634 36 : SetupOutputVariable(state,
3635 : "Heating Coil Air Outlet Temperature",
3636 : Constant::Units::C,
3637 18 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).OutletAirDBTemp,
3638 : OutputProcessor::TimeStepType::System,
3639 : OutputProcessor::StoreType::Average,
3640 18 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name);
3641 36 : SetupOutputVariable(state,
3642 : "Heating Coil Air Outlet Humidity Ratio",
3643 : Constant::Units::kgWater_kgDryAir,
3644 18 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).OutletAirHumRat,
3645 : OutputProcessor::TimeStepType::System,
3646 : OutputProcessor::StoreType::Average,
3647 18 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name);
3648 36 : SetupOutputVariable(state,
3649 : "Heating Coil Source Side Mass Flow Rate",
3650 : Constant::Units::kg_s,
3651 18 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).WaterMassFlowRate,
3652 : OutputProcessor::TimeStepType::System,
3653 : OutputProcessor::StoreType::Average,
3654 18 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name);
3655 36 : SetupOutputVariable(state,
3656 : "Heating Coil Source Side Inlet Temperature",
3657 : Constant::Units::C,
3658 18 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).InletWaterTemp,
3659 : OutputProcessor::TimeStepType::System,
3660 : OutputProcessor::StoreType::Average,
3661 18 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name);
3662 36 : SetupOutputVariable(state,
3663 : "Heating Coil Source Side Outlet Temperature",
3664 : Constant::Units::C,
3665 18 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).OutletWaterTemp,
3666 : OutputProcessor::TimeStepType::System,
3667 : OutputProcessor::StoreType::Average,
3668 18 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name);
3669 :
3670 36 : SetupOutputVariable(state,
3671 : "Heating Coil Upper Speed Level",
3672 : Constant::Units::None,
3673 18 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).SpeedNumReport,
3674 : OutputProcessor::TimeStepType::System,
3675 : OutputProcessor::StoreType::Average,
3676 18 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name);
3677 36 : SetupOutputVariable(state,
3678 : "Heating Coil Neighboring Speed Levels Ratio",
3679 : Constant::Units::None,
3680 18 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).SpeedRatioReport,
3681 : OutputProcessor::TimeStepType::System,
3682 : OutputProcessor::StoreType::Average,
3683 18 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name);
3684 36 : SetupOutputVariable(state,
3685 : "Heating Coil Recoverable Heat Transfer Rate",
3686 : Constant::Units::W,
3687 18 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).QWasteHeat,
3688 : OutputProcessor::TimeStepType::System,
3689 : OutputProcessor::StoreType::Average,
3690 18 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name);
3691 10 : } else if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).VSCoilType == HVAC::CoilDX_HeatPumpWaterHeaterVariableSpeed) {
3692 : // air source water heating coil
3693 20 : SetupOutputVariable(state,
3694 : "Cooling Coil Water Heating Electricity Rate",
3695 : Constant::Units::W,
3696 10 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Power,
3697 : OutputProcessor::TimeStepType::System,
3698 : OutputProcessor::StoreType::Average,
3699 10 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name);
3700 20 : SetupOutputVariable(state,
3701 : "Cooling Coil Total Cooling Rate",
3702 : Constant::Units::W,
3703 10 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).QLoadTotal,
3704 : OutputProcessor::TimeStepType::System,
3705 : OutputProcessor::StoreType::Average,
3706 10 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name);
3707 20 : SetupOutputVariable(state,
3708 : "Cooling Coil Sensible Cooling Rate",
3709 : Constant::Units::W,
3710 10 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).QSensible,
3711 : OutputProcessor::TimeStepType::System,
3712 : OutputProcessor::StoreType::Average,
3713 10 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name);
3714 20 : SetupOutputVariable(state,
3715 : "Cooling Coil Latent Cooling Rate",
3716 : Constant::Units::W,
3717 10 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).QLatent,
3718 : OutputProcessor::TimeStepType::System,
3719 : OutputProcessor::StoreType::Average,
3720 10 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name);
3721 20 : SetupOutputVariable(state,
3722 : "Cooling Coil Total Water Heating Rate",
3723 : Constant::Units::W,
3724 10 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).TotalHeatingEnergyRate,
3725 : OutputProcessor::TimeStepType::System,
3726 : OutputProcessor::StoreType::Average,
3727 10 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name);
3728 20 : SetupOutputVariable(state,
3729 : "Cooling Coil Part Load Ratio",
3730 : Constant::Units::None,
3731 10 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).PartLoadRatio,
3732 : OutputProcessor::TimeStepType::System,
3733 : OutputProcessor::StoreType::Average,
3734 10 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name);
3735 20 : SetupOutputVariable(state,
3736 : "Cooling Coil Runtime Fraction",
3737 : Constant::Units::None,
3738 10 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).RunFrac,
3739 : OutputProcessor::TimeStepType::System,
3740 : OutputProcessor::StoreType::Average,
3741 10 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name);
3742 :
3743 20 : SetupOutputVariable(state,
3744 : "Cooling Coil Air Mass Flow Rate",
3745 : Constant::Units::kg_s,
3746 10 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).AirMassFlowRate,
3747 : OutputProcessor::TimeStepType::System,
3748 : OutputProcessor::StoreType::Average,
3749 10 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name);
3750 20 : SetupOutputVariable(state,
3751 : "Cooling Coil Air Inlet Temperature",
3752 : Constant::Units::C,
3753 10 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).InletAirDBTemp,
3754 : OutputProcessor::TimeStepType::System,
3755 : OutputProcessor::StoreType::Average,
3756 10 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name);
3757 20 : SetupOutputVariable(state,
3758 : "Cooling Coil Air Inlet Humidity Ratio",
3759 : Constant::Units::kgWater_kgDryAir,
3760 10 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).InletAirHumRat,
3761 : OutputProcessor::TimeStepType::System,
3762 : OutputProcessor::StoreType::Average,
3763 10 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name);
3764 20 : SetupOutputVariable(state,
3765 : "Cooling Coil Air Outlet Temperature",
3766 : Constant::Units::C,
3767 10 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).OutletAirDBTemp,
3768 : OutputProcessor::TimeStepType::System,
3769 : OutputProcessor::StoreType::Average,
3770 10 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name);
3771 20 : SetupOutputVariable(state,
3772 : "Cooling Coil Air Outlet Humidity Ratio",
3773 : Constant::Units::kgWater_kgDryAir,
3774 10 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).OutletAirHumRat,
3775 : OutputProcessor::TimeStepType::System,
3776 : OutputProcessor::StoreType::Average,
3777 10 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name);
3778 20 : SetupOutputVariable(state,
3779 : "Cooling Coil Water Mass Flow Rate",
3780 : Constant::Units::kg_s,
3781 10 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).WaterMassFlowRate,
3782 : OutputProcessor::TimeStepType::System,
3783 : OutputProcessor::StoreType::Average,
3784 10 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name);
3785 20 : SetupOutputVariable(state,
3786 : "Cooling Coil Water Inlet Temperature",
3787 : Constant::Units::C,
3788 10 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).InletWaterTemp,
3789 : OutputProcessor::TimeStepType::System,
3790 : OutputProcessor::StoreType::Average,
3791 10 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name);
3792 20 : SetupOutputVariable(state,
3793 : "Cooling Coil Water Outlet Temperature",
3794 : Constant::Units::C,
3795 10 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).OutletWaterTemp,
3796 : OutputProcessor::TimeStepType::System,
3797 : OutputProcessor::StoreType::Average,
3798 10 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name);
3799 :
3800 20 : SetupOutputVariable(state,
3801 : "Cooling Coil Crankcase Heater Electricity Rate",
3802 : Constant::Units::W,
3803 10 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).CrankcaseHeaterPower,
3804 : OutputProcessor::TimeStepType::System,
3805 : OutputProcessor::StoreType::Average,
3806 10 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name);
3807 20 : SetupOutputVariable(state,
3808 : "Cooling Coil Crankcase Heater Electricity Energy",
3809 : Constant::Units::J,
3810 10 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).CrankcaseHeaterConsumption,
3811 : OutputProcessor::TimeStepType::System,
3812 : OutputProcessor::StoreType::Sum,
3813 10 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name,
3814 : Constant::eResource::Electricity,
3815 : OutputProcessor::Group::HVAC,
3816 : OutputProcessor::EndUseCat::Heating);
3817 :
3818 20 : SetupOutputVariable(state,
3819 : "Cooling Coil Upper Speed Level",
3820 : Constant::Units::None,
3821 10 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).SpeedNumReport,
3822 : OutputProcessor::TimeStepType::System,
3823 : OutputProcessor::StoreType::Average,
3824 10 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name);
3825 20 : SetupOutputVariable(state,
3826 : "Cooling Coil Neighboring Speed Levels Ratio",
3827 : Constant::Units::None,
3828 10 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).SpeedRatioReport,
3829 : OutputProcessor::TimeStepType::System,
3830 : OutputProcessor::StoreType::Average,
3831 10 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name);
3832 :
3833 20 : SetupOutputVariable(state,
3834 : "Cooling Coil Water Heating Pump Electricity Rate",
3835 : Constant::Units::W,
3836 10 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).HPWHCondPumpElecNomPower,
3837 : OutputProcessor::TimeStepType::System,
3838 : OutputProcessor::StoreType::Average,
3839 10 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name);
3840 20 : SetupOutputVariable(state,
3841 : "Cooling Coil Water Heating Pump Electricity Energy",
3842 : Constant::Units::J,
3843 10 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).EvapCondPumpElecConsumption,
3844 : OutputProcessor::TimeStepType::System,
3845 : OutputProcessor::StoreType::Sum,
3846 10 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name,
3847 : Constant::eResource::Electricity,
3848 : OutputProcessor::Group::HVAC,
3849 : OutputProcessor::EndUseCat::Heating);
3850 : }
3851 : }
3852 : }
3853 :
3854 22 : if (ErrorsFound) {
3855 0 : ShowFatalError(
3856 0 : state, format("{}Errors found in getting {} input. Preceding condition(s) causes termination.", RoutineName, CurrentModuleObject));
3857 : }
3858 22 : }
3859 :
3860 : // Beginning Initialization Section of the Module
3861 : //******************************************************************************
3862 :
3863 45014786 : 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 45014786 : int AirInletNode = state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).AirInletNodeNum;
3902 :
3903 45014786 : if (state.dataVariableSpeedCoils->MyOneTimeFlag) {
3904 : // initialize the environment and sizing flags
3905 22 : state.dataVariableSpeedCoils->MySizeFlag.allocate(state.dataVariableSpeedCoils->NumVarSpeedCoils);
3906 22 : state.dataVariableSpeedCoils->MyEnvrnFlag.allocate(state.dataVariableSpeedCoils->NumVarSpeedCoils);
3907 22 : state.dataVariableSpeedCoils->MyPlantScanFlag.allocate(state.dataVariableSpeedCoils->NumVarSpeedCoils);
3908 22 : state.dataVariableSpeedCoils->MySizeFlag = true;
3909 22 : state.dataVariableSpeedCoils->MyEnvrnFlag = true;
3910 22 : state.dataVariableSpeedCoils->MyPlantScanFlag = true;
3911 22 : state.dataVariableSpeedCoils->MyOneTimeFlag = false;
3912 : }
3913 :
3914 45014786 : 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 46613962 : if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).VSCoilType == HVAC::CoilDX_HeatPumpWaterHeaterVariableSpeed &&
3919 1599176 : state.dataVariableSpeedCoils->MySizeFlag(DXCoilNum)) {
3920 :
3921 10 : ErrorsFound = false;
3922 10 : SizeVarSpeedCoil(state, DXCoilNum, ErrorsFound);
3923 10 : 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 10 : state.dataVariableSpeedCoils->MySizeFlag(DXCoilNum) = false;
3930 : }
3931 : // variable-speed heat pump water heating, end
3932 :
3933 : // water source
3934 85507779 : if ((state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).VSCoilType == HVAC::Coil_CoolingWaterToAirHPVSEquationFit) ||
3935 40492993 : (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).VSCoilType == HVAC::Coil_HeatingWaterToAirHPVSEquationFit)) { // fix coil type
3936 9043586 : if (state.dataVariableSpeedCoils->MyPlantScanFlag(DXCoilNum) && allocated(state.dataPlnt->PlantLoop)) {
3937 : // switch from coil type numbers in DataHVACGlobals, to coil type numbers in plant.
3938 36 : DataPlant::PlantEquipmentType CoilVSWAHPType(DataPlant::PlantEquipmentType::Invalid);
3939 36 : if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).VSCoilType == HVAC::Coil_CoolingWaterToAirHPVSEquationFit) {
3940 18 : CoilVSWAHPType = DataPlant::PlantEquipmentType::CoilVSWAHPCoolingEquationFit;
3941 18 : } else if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).VSCoilType == HVAC::Coil_HeatingWaterToAirHPVSEquationFit) {
3942 18 : CoilVSWAHPType = DataPlant::PlantEquipmentType::CoilVSWAHPHeatingEquationFit;
3943 : }
3944 36 : ErrorsFound = false;
3945 72 : PlantUtilities::ScanPlantLoopsForObject(state,
3946 36 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name,
3947 : CoilVSWAHPType,
3948 36 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).plantLoc,
3949 : ErrorsFound,
3950 : _,
3951 : _,
3952 : _,
3953 : _,
3954 : _);
3955 36 : if (ErrorsFound) {
3956 0 : ShowFatalError(state, "InitVarSpeedCoil: Program terminated for previous conditions.");
3957 : }
3958 36 : state.dataVariableSpeedCoils->MyPlantScanFlag(DXCoilNum) = false;
3959 : }
3960 : } else {
3961 35971200 : state.dataVariableSpeedCoils->MyPlantScanFlag(DXCoilNum) = false;
3962 : }
3963 :
3964 45014853 : if (!state.dataGlobal->SysSizingCalc && state.dataVariableSpeedCoils->MySizeFlag(DXCoilNum) &&
3965 67 : !state.dataVariableSpeedCoils->MyPlantScanFlag(DXCoilNum)) {
3966 : // for each furnace, do the sizing once.
3967 67 : ErrorsFound = false;
3968 67 : SizeVarSpeedCoil(state, DXCoilNum, ErrorsFound);
3969 67 : if (ErrorsFound) {
3970 0 : ShowFatalError(state, format("{}: Failed to size variable speed coil.", RoutineName));
3971 : }
3972 :
3973 67 : state.dataVariableSpeedCoils->MySizeFlag(DXCoilNum) = false;
3974 :
3975 : // Multispeed Cooling
3976 116 : if ((state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).VSCoilType == HVAC::Coil_CoolingWaterToAirHPVSEquationFit) ||
3977 49 : (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).VSCoilType == HVAC::Coil_CoolingAirToAirVariableSpeed)) {
3978 380 : for (int Mode = 1; Mode <= state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).NumOfSpeeds; ++Mode) {
3979 340 : if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).RatedCapCoolTotal <= 0.0) {
3980 0 : break;
3981 : }
3982 : // Check for zero capacity or zero max flow rate
3983 340 : 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 340 : 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 340 : 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 340 : RatedVolFlowPerRatedTotCap = state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedAirVolFlowRate(Mode) /
4004 340 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedTotCap(Mode);
4005 : }
4006 : // call coil model with everything set at rating point
4007 40 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).InletAirDBTemp = RatedInletAirTemp;
4008 40 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).InletAirHumRat =
4009 40 : Psychrometrics::PsyWFnTdbTwbPb(state, RatedInletAirTemp, RatedInletWetBulbTemp, DataEnvironment::StdPressureSeaLevel);
4010 40 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).InletAirEnthalpy =
4011 40 : Psychrometrics::PsyHFnTdbW(RatedInletAirTemp, state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).InletAirHumRat);
4012 40 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).InletAirPressure = DataEnvironment::StdPressureSeaLevel;
4013 :
4014 40 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).AirMassFlowRate =
4015 40 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).RatedAirVolFlowRate *
4016 80 : Psychrometrics::PsyRhoAirFnPbTdbW(state,
4017 : DataEnvironment::StdPressureSeaLevel,
4018 : RatedInletAirTemp,
4019 40 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).InletAirHumRat);
4020 : // store environment data fill back in after rating point calc is over
4021 40 : Real64 holdOutDryBulbTemp = state.dataEnvrn->OutDryBulbTemp;
4022 40 : Real64 holdOutHumRat = state.dataEnvrn->OutHumRat;
4023 40 : Real64 holdOutWetBulb = state.dataEnvrn->OutWetBulbTemp;
4024 40 : Real64 holdOutBaroPress = state.dataEnvrn->OutBaroPress;
4025 40 : Real64 ratedOutdoorAirWetBulb = 23.9; // from I/O ref. more precise value?
4026 :
4027 40 : state.dataEnvrn->OutDryBulbTemp = RatedAmbAirTemp;
4028 40 : state.dataEnvrn->OutWetBulbTemp = ratedOutdoorAirWetBulb;
4029 40 : state.dataEnvrn->OutBaroPress = DataEnvironment::StdPressureSeaLevel; // assume rating is for sea level.
4030 80 : state.dataEnvrn->OutHumRat =
4031 40 : Psychrometrics::PsyWFnTdbTwbPb(state, RatedAmbAirTemp, ratedOutdoorAirWetBulb, DataEnvironment::StdPressureSeaLevel, RoutineName);
4032 40 : if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).CondenserInletNodeNum > 0) {
4033 1 : state.dataLoopNodes->Node(state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).CondenserInletNodeNum).Temp = RatedAmbAirTemp;
4034 1 : state.dataLoopNodes->Node(state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).CondenserInletNodeNum).HumRat =
4035 1 : state.dataEnvrn->OutHumRat;
4036 1 : state.dataLoopNodes->Node(state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).CondenserInletNodeNum).Press =
4037 : DataEnvironment::StdPressureSeaLevel;
4038 1 : state.dataLoopNodes->Node(state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).CondenserInletNodeNum).OutAirWetBulb =
4039 : ratedOutdoorAirWetBulb;
4040 : }
4041 40 : if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).VSCoilType ==
4042 : HVAC::Coil_CoolingWaterToAirHPVSEquationFit) { // need to set water info for WSHP
4043 18 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).WaterMassFlowRate =
4044 36 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedWaterMassFlowRate(
4045 18 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).NumOfSpeeds);
4046 18 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).InletWaterTemp = RatedInletWaterTemp; // 85 F cooling mode
4047 18 : Real64 CpSource = state.dataPlnt->PlantLoop(state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).plantLoc.loopNum)
4048 18 : .glycol->getSpecificHeat(state, state.dataVariableSpeedCoils->SourceSideInletTemp, RoutineName);
4049 18 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).InletWaterEnthalpy =
4050 18 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).InletWaterTemp * CpSource;
4051 : }
4052 :
4053 : // calculate coil model at rating point
4054 40 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).RunFrac = 1.0;
4055 40 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).DesignAirMassFlowRate =
4056 80 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedAirMassFlowRate(
4057 40 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).NumOfSpeeds);
4058 40 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).DesignAirVolFlowRate =
4059 80 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedAirVolFlowRate(
4060 40 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).NumOfSpeeds);
4061 40 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).DesignWaterMassFlowRate =
4062 80 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedWaterMassFlowRate(
4063 40 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).NumOfSpeeds);
4064 40 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).DesignWaterVolFlowRate =
4065 80 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedWaterVolFlowRate(
4066 40 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).NumOfSpeeds);
4067 :
4068 40 : 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 40 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).NumOfSpeeds);
4078 : // coil outlets
4079 40 : Real64 RatedOutletWetBulb(0.0);
4080 120 : RatedOutletWetBulb = Psychrometrics::PsyTwbFnTdbWPb(state,
4081 40 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).OutletAirDBTemp,
4082 40 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).OutletAirHumRat,
4083 : DataEnvironment::StdPressureSeaLevel,
4084 : RoutineName);
4085 40 : state.dataRptCoilSelection->coilSelectionReportObj->setRatedCoilConditions(
4086 : state,
4087 40 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name,
4088 40 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).VarSpeedCoilType,
4089 40 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).QLoadTotal, // this is the report variable
4090 40 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).QSensible, // this is the report variable
4091 40 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).AirMassFlowRate,
4092 40 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).InletAirDBTemp,
4093 40 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).InletAirHumRat,
4094 : RatedInletWetBulbTemp,
4095 40 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).OutletAirDBTemp,
4096 40 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).OutletAirHumRat,
4097 : RatedOutletWetBulb,
4098 : RatedAmbAirTemp,
4099 : ratedOutdoorAirWetBulb,
4100 80 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedCBF(
4101 40 : 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 40 : state.dataEnvrn->OutDryBulbTemp = holdOutDryBulbTemp;
4106 40 : state.dataEnvrn->OutHumRat = holdOutHumRat;
4107 40 : state.dataEnvrn->OutWetBulbTemp = holdOutWetBulb;
4108 40 : state.dataEnvrn->OutBaroPress = holdOutBaroPress;
4109 : }
4110 :
4111 : // Multispeed Heating
4112 116 : if ((state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).VSCoilType == HVAC::Coil_HeatingWaterToAirHPVSEquationFit) ||
4113 49 : (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).VSCoilType == HVAC::Coil_HeatingAirToAirVariableSpeed)) {
4114 27 : RatedHeatPumpIndoorAirTemp = 21.11; // 21.11C or 70F
4115 27 : RatedHeatPumpIndoorHumRat = 0.00881; // Humidity ratio corresponding to 70F dry bulb/60F wet bulb
4116 287 : for (int Mode = 1; Mode <= state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).NumOfSpeeds; ++Mode) {
4117 :
4118 260 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedAirMassFlowRate(Mode) =
4119 260 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedAirVolFlowRate(Mode) *
4120 260 : Psychrometrics::PsyRhoAirFnPbTdbW(
4121 260 : state, state.dataEnvrn->OutBaroPress, RatedHeatPumpIndoorAirTemp, RatedHeatPumpIndoorHumRat, RoutineName);
4122 : // Check for valid range of (Rated Air Volume Flow Rate / Rated Total Capacity)
4123 260 : RatedVolFlowPerRatedTotCap = state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedAirVolFlowRate(Mode) /
4124 260 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedTotCap(Mode);
4125 : }
4126 : // call coil model with everthing set at rating point
4127 27 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).InletAirDBTemp = RatedInletAirTempHeat;
4128 27 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).InletAirHumRat =
4129 27 : Psychrometrics::PsyWFnTdbTwbPb(state, RatedInletAirTempHeat, RatedInletWetBulbTemp, DataEnvironment::StdPressureSeaLevel);
4130 27 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).InletAirEnthalpy =
4131 27 : Psychrometrics::PsyHFnTdbW(RatedInletAirTempHeat, state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).InletAirHumRat);
4132 27 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).InletAirPressure = DataEnvironment::StdPressureSeaLevel;
4133 :
4134 27 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).AirMassFlowRate =
4135 27 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).RatedAirVolFlowRate *
4136 54 : Psychrometrics::PsyRhoAirFnPbTdbW(state,
4137 : DataEnvironment::StdPressureSeaLevel,
4138 : RatedInletAirTempHeat,
4139 27 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).InletAirHumRat);
4140 : // store environment data fill back in after rating point calc is over
4141 27 : Real64 holdOutDryBulbTemp = state.dataEnvrn->OutDryBulbTemp;
4142 27 : Real64 holdOutHumRat = state.dataEnvrn->OutHumRat;
4143 27 : Real64 holdOutWetBulb = state.dataEnvrn->OutWetBulbTemp;
4144 27 : Real64 holdOutBaroPress = state.dataEnvrn->OutBaroPress;
4145 :
4146 27 : state.dataEnvrn->OutDryBulbTemp = RatedAmbAirTempHeat;
4147 27 : state.dataEnvrn->OutWetBulbTemp = RatedAmbAirWBHeat;
4148 27 : state.dataEnvrn->OutBaroPress = DataEnvironment::StdPressureSeaLevel; // assume rating is for sea level.
4149 54 : state.dataEnvrn->OutHumRat =
4150 27 : Psychrometrics::PsyWFnTdbTwbPb(state, RatedAmbAirTempHeat, RatedAmbAirWBHeat, DataEnvironment::StdPressureSeaLevel, RoutineName);
4151 27 : 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 27 : if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).VSCoilType ==
4162 : HVAC::Coil_HeatingWaterToAirHPVSEquationFit) { // need to set water info for WSHP
4163 18 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).WaterMassFlowRate =
4164 36 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedWaterMassFlowRate(
4165 18 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).NumOfSpeeds);
4166 18 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).InletWaterTemp = RatedInletWaterTempHeat; // 21.11C or 70F, heating mode
4167 18 : Real64 CpSource = state.dataPlnt->PlantLoop(state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).plantLoc.loopNum)
4168 18 : .glycol->getSpecificHeat(state, state.dataVariableSpeedCoils->SourceSideInletTemp, RoutineName);
4169 18 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).InletWaterEnthalpy =
4170 18 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).InletWaterTemp * CpSource;
4171 : }
4172 :
4173 : // calculate coil model at rating point
4174 27 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).RunFrac = 1.0;
4175 27 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).DesignAirMassFlowRate =
4176 54 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedAirMassFlowRate(
4177 27 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).NumOfSpeeds);
4178 27 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).DesignAirVolFlowRate =
4179 54 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedAirVolFlowRate(
4180 27 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).NumOfSpeeds);
4181 27 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).DesignWaterMassFlowRate =
4182 54 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedWaterMassFlowRate(
4183 27 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).NumOfSpeeds);
4184 27 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).DesignWaterVolFlowRate =
4185 54 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedWaterVolFlowRate(
4186 27 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).NumOfSpeeds);
4187 27 : CalcVarSpeedCoilHeating(state,
4188 : DXCoilNum,
4189 : HVAC::FanOp::Continuous,
4190 : SensLoad,
4191 : HVAC::CompressorOp::On,
4192 : 1.0,
4193 : 1.0,
4194 : 1.0,
4195 27 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).NumOfSpeeds);
4196 : // coil outlets
4197 27 : Real64 RatedOutletWetBulb(0.0);
4198 81 : RatedOutletWetBulb = Psychrometrics::PsyTwbFnTdbWPb(state,
4199 27 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).OutletAirDBTemp,
4200 27 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).OutletAirHumRat,
4201 : DataEnvironment::StdPressureSeaLevel,
4202 : RoutineName);
4203 27 : state.dataRptCoilSelection->coilSelectionReportObj->setRatedCoilConditions(
4204 : state,
4205 27 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name,
4206 27 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).VarSpeedCoilType,
4207 27 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).QLoadTotal, // this is the report variable
4208 27 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).QSensible, // this is the report variable
4209 27 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).AirMassFlowRate,
4210 27 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).InletAirDBTemp,
4211 27 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).InletAirHumRat,
4212 : RatedInletWetBulbTemp,
4213 27 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).OutletAirDBTemp,
4214 27 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).OutletAirHumRat,
4215 : RatedOutletWetBulb,
4216 : RatedAmbAirTempHeat,
4217 : RatedAmbAirWBHeat,
4218 54 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedCBF(
4219 27 : 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 27 : state.dataEnvrn->OutDryBulbTemp = holdOutDryBulbTemp;
4224 27 : state.dataEnvrn->OutHumRat = holdOutHumRat;
4225 27 : state.dataEnvrn->OutWetBulbTemp = holdOutWetBulb;
4226 27 : state.dataEnvrn->OutBaroPress = holdOutBaroPress;
4227 : }
4228 :
4229 : // store fan info for coil
4230 67 : if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).SupplyFanIndex > 0) {
4231 12 : state.dataRptCoilSelection->coilSelectionReportObj->setCoilSupplyFanInfo(
4232 : state,
4233 12 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Name,
4234 12 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).VarSpeedCoilType,
4235 12 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).SupplyFanName,
4236 12 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).supplyFanType,
4237 12 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).SupplyFanIndex);
4238 : }
4239 : }
4240 :
4241 45014786 : if (SpeedNum > state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).NumOfSpeeds) {
4242 0 : SpeedCal = state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).NumOfSpeeds;
4243 45014786 : } else if (SpeedNum < 1) {
4244 0 : SpeedCal = 1;
4245 : } else {
4246 45014786 : SpeedCal = SpeedNum;
4247 : }
4248 45014786 : if ((SpeedNum <= 1) || (SpeedNum > state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).NumOfSpeeds)) {
4249 22442790 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).DesignAirMassFlowRate =
4250 22442790 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedAirMassFlowRate(SpeedCal);
4251 22442790 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).DesignAirVolFlowRate =
4252 22442790 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedAirVolFlowRate(SpeedCal);
4253 22442790 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).DesignWaterMassFlowRate =
4254 22442790 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedWaterMassFlowRate(SpeedCal);
4255 22442790 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).DesignWaterVolFlowRate =
4256 22442790 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedWaterVolFlowRate(SpeedCal);
4257 : } else {
4258 22571996 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).DesignAirMassFlowRate =
4259 22571996 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedAirMassFlowRate(SpeedCal) * SpeedRatio +
4260 22571996 : (1.0 - SpeedRatio) * state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedAirMassFlowRate(SpeedCal - 1);
4261 22571996 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).DesignAirVolFlowRate =
4262 22571996 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedAirVolFlowRate(SpeedCal) * SpeedRatio +
4263 22571996 : (1.0 - SpeedRatio) * state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedAirVolFlowRate(SpeedCal - 1);
4264 22571996 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).DesignWaterMassFlowRate =
4265 22571996 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedWaterMassFlowRate(SpeedCal) * SpeedRatio +
4266 22571996 : (1.0 - SpeedRatio) * state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedWaterMassFlowRate(SpeedCal - 1);
4267 22571996 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).DesignWaterVolFlowRate =
4268 22571996 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedWaterVolFlowRate(SpeedCal) * SpeedRatio +
4269 22571996 : (1.0 - SpeedRatio) * state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedWaterVolFlowRate(SpeedCal - 1);
4270 : }
4271 :
4272 : // Do the Begin Environment initializations
4273 45015235 : if (state.dataGlobal->BeginEnvrnFlag && state.dataVariableSpeedCoils->MyEnvrnFlag(DXCoilNum) &&
4274 449 : !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 449 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).AirVolFlowRate = 0.0;
4279 449 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).InletAirDBTemp = 0.0;
4280 449 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).InletAirHumRat = 0.0;
4281 449 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).OutletAirDBTemp = 0.0;
4282 449 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).OutletAirHumRat = 0.0;
4283 449 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).WaterVolFlowRate = 0.0;
4284 449 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).WaterMassFlowRate = 0.0;
4285 449 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).InletWaterTemp = 0.0;
4286 449 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).InletWaterEnthalpy = 0.0;
4287 449 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).OutletWaterEnthalpy = 0.0;
4288 449 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).OutletWaterTemp = 0.0;
4289 449 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Power = 0.0;
4290 449 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).QLoadTotal = 0.0;
4291 449 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).QSensible = 0.0;
4292 449 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).QLatent = 0.0;
4293 449 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).QSource = 0.0;
4294 449 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Energy = 0.0;
4295 449 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).EnergyLoadTotal = 0.0;
4296 449 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).EnergySensible = 0.0;
4297 449 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).EnergyLatent = 0.0;
4298 449 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).EnergySource = 0.0;
4299 449 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).COP = 0.0;
4300 449 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).RunFrac = 0.0;
4301 449 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).PartLoadRatio = 0.0;
4302 :
4303 792 : if ((state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).VSCoilType == HVAC::Coil_HeatingWaterToAirHPVSEquationFit) ||
4304 343 : (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).VSCoilType == HVAC::Coil_CoolingWaterToAirHPVSEquationFit)) {
4305 212 : WaterInletNode = state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).WaterInletNodeNum;
4306 :
4307 212 : rho = state.dataPlnt->PlantLoop(state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).plantLoc.loopNum)
4308 212 : .glycol->getDensity(state, Constant::CWInitConvTemp, RoutineNameSimpleWatertoAirHP);
4309 212 : Cp = state.dataPlnt->PlantLoop(state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).plantLoc.loopNum)
4310 212 : .glycol->getSpecificHeat(state, Constant::CWInitConvTemp, RoutineNameSimpleWatertoAirHP);
4311 :
4312 : // VarSpeedCoil(DXCoilNum)%DesignWaterMassFlowRate= &
4313 : // rho * VarSpeedCoil(DXCoilNum)%RatedWaterVolFlowRate
4314 :
4315 636 : PlantUtilities::InitComponentNodes(state,
4316 : 0.0,
4317 424 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedWaterMassFlowRate(
4318 212 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).NumOfSpeeds),
4319 212 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).WaterInletNodeNum,
4320 212 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).WaterOutletNodeNum);
4321 :
4322 212 : state.dataLoopNodes->Node(WaterInletNode).Temp = 5.0;
4323 212 : state.dataLoopNodes->Node(WaterInletNode).Enthalpy = Cp * state.dataLoopNodes->Node(WaterInletNode).Temp;
4324 212 : state.dataLoopNodes->Node(WaterInletNode).Quality = 0.0;
4325 212 : state.dataLoopNodes->Node(WaterInletNode).Press = 0.0;
4326 212 : state.dataLoopNodes->Node(WaterInletNode).HumRat = 0.0;
4327 :
4328 212 : state.dataLoopNodes->Node(state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).WaterOutletNodeNum).Temp = 5.0;
4329 212 : state.dataLoopNodes->Node(state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).WaterOutletNodeNum).Enthalpy =
4330 212 : Cp * state.dataLoopNodes->Node(WaterInletNode).Temp;
4331 212 : state.dataLoopNodes->Node(state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).WaterOutletNodeNum).Quality = 0.0;
4332 212 : state.dataLoopNodes->Node(state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).WaterOutletNodeNum).Press = 0.0;
4333 212 : state.dataLoopNodes->Node(state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).WaterOutletNodeNum).HumRat = 0.0;
4334 : }
4335 :
4336 449 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).SimFlag = true;
4337 449 : state.dataHeatBal->HeatReclaimVS_Coil(DXCoilNum).AvailCapacity = 0.0;
4338 :
4339 449 : state.dataVariableSpeedCoils->MyEnvrnFlag(DXCoilNum) = false;
4340 :
4341 : } // End If for the Begin Environment initializations
4342 :
4343 45014786 : if (!state.dataGlobal->BeginEnvrnFlag) {
4344 44970546 : 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 45014786 : WaterInletNode = state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).WaterInletNodeNum;
4354 :
4355 45014786 : if ((SensLoad != 0.0 || LatentLoad != 0.0) && (state.dataLoopNodes->Node(AirInletNode).MassFlowRate > 0.0)) {
4356 30240509 : if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedWaterMassFlowRate(
4357 30240509 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).NormSpedLevel) > 0.0) {
4358 3439666 : WaterFlowScale = state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).RatedWaterMassFlowRate /
4359 3439666 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedWaterMassFlowRate(
4360 3439666 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).NormSpedLevel);
4361 3439666 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).WaterMassFlowRate =
4362 3439666 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).DesignWaterMassFlowRate * WaterFlowScale;
4363 : } else {
4364 26800843 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).WaterMassFlowRate = 0.0;
4365 : }
4366 :
4367 30240509 : if (fanOp == HVAC::FanOp::Continuous) {
4368 : // continuous fan, cycling compressor
4369 29590555 : 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 29590555 : if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).AirMassFlowRate <
4374 29590555 : 0.25 * state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).DesignAirVolFlowRate *
4375 59181110 : Psychrometrics::PsyRhoAirFnPbTdbW(state,
4376 29590555 : state.dataEnvrn->OutBaroPress,
4377 29590555 : state.dataLoopNodes->Node(AirInletNode).Temp,
4378 29590555 : state.dataLoopNodes->Node(AirInletNode).HumRat)) {
4379 102927 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).AirMassFlowRate =
4380 102927 : 0.25 * state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).DesignAirVolFlowRate *
4381 308781 : Psychrometrics::PsyRhoAirFnPbTdbW(state,
4382 102927 : state.dataEnvrn->OutBaroPress,
4383 102927 : state.dataLoopNodes->Node(AirInletNode).Temp,
4384 102927 : state.dataLoopNodes->Node(AirInletNode).HumRat);
4385 : }
4386 : } else { // CYCLIC FAN, NOT CORRECTION, WILL BE PROCESSED IN THE FOLLOWING SUBROUTINES
4387 649954 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).AirMassFlowRate = state.dataLoopNodes->Node(AirInletNode).MassFlowRate;
4388 : }
4389 :
4390 : } else { // heat pump is off
4391 14774277 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).WaterMassFlowRate = 0.0;
4392 14774277 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).AirMassFlowRate = 0.0;
4393 : }
4394 :
4395 85507779 : if ((state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).VSCoilType == HVAC::Coil_HeatingWaterToAirHPVSEquationFit) ||
4396 40492993 : (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).VSCoilType == HVAC::Coil_CoolingWaterToAirHPVSEquationFit)) {
4397 27130758 : PlantUtilities::SetComponentFlowRate(state,
4398 9043586 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).WaterMassFlowRate,
4399 9043586 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).WaterInletNodeNum,
4400 9043586 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).WaterOutletNodeNum,
4401 9043586 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).plantLoc);
4402 :
4403 9043586 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).InletWaterTemp = state.dataLoopNodes->Node(WaterInletNode).Temp;
4404 9043586 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).InletWaterEnthalpy = state.dataLoopNodes->Node(WaterInletNode).Enthalpy;
4405 : } else {
4406 35971200 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).InletWaterTemp = 0.0;
4407 35971200 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).InletWaterEnthalpy = 0.0;
4408 : }
4409 :
4410 45014786 : if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).VSCoilType == HVAC::CoilDX_HeatPumpWaterHeaterVariableSpeed) {
4411 1599176 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).InletWaterTemp = state.dataLoopNodes->Node(WaterInletNode).Temp;
4412 1599176 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).InletWaterEnthalpy = state.dataLoopNodes->Node(WaterInletNode).Enthalpy;
4413 : };
4414 :
4415 45014786 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).InletAirDBTemp = state.dataLoopNodes->Node(AirInletNode).Temp;
4416 45014786 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).InletAirHumRat = state.dataLoopNodes->Node(AirInletNode).HumRat;
4417 45014786 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).InletAirEnthalpy = state.dataLoopNodes->Node(AirInletNode).Enthalpy;
4418 :
4419 45014786 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).InletAirPressure = state.dataEnvrn->OutBaroPress; // temporary
4420 : // Outlet variables
4421 45014786 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Power = 0.0;
4422 45014786 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).QLoadTotal = 0.0;
4423 45014786 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).QSensible = 0.0;
4424 45014786 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).QLatent = 0.0;
4425 45014786 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).QSource = 0.0;
4426 45014786 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).QWasteHeat = 0.0;
4427 45014786 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Energy = 0.0;
4428 45014786 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).EnergyLoadTotal = 0.0;
4429 45014786 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).EnergySensible = 0.0;
4430 45014786 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).EnergyLatent = 0.0;
4431 45014786 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).EnergySource = 0.0;
4432 45014786 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).COP = 0.0;
4433 :
4434 45014786 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).OutletAirDBTemp = 0.0;
4435 45014786 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).OutletWaterTemp = 0.0;
4436 45014786 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).OutletAirHumRat = 0.0;
4437 45014786 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).OutletAirEnthalpy = 0.0;
4438 45014786 : 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 45014786 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).CrankcaseHeaterConsumption = 0.0;
4442 45014786 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).EvapWaterConsump = 0.0;
4443 45014786 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).BasinHeaterConsumption = 0.0;
4444 45014786 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).EvapCondPumpElecConsumption = 0.0;
4445 45014786 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).CrankcaseHeaterPower = 0.0;
4446 45014786 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).DefrostPower = 0.0;
4447 45014786 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).DefrostConsumption = 0.0;
4448 45014786 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).CondensateVdot = 0.0;
4449 45014786 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).CondensateVol = 0.0;
4450 45014786 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).QWasteHeat = 0.0;
4451 :
4452 : // clear zeros to HPWH variables
4453 45014786 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).ElecWaterHeatingPower =
4454 : 0.0; // Total electric power consumed by compressor and condenser pump [W]
4455 45014786 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).ElecWaterHeatingConsumption =
4456 : 0.0; // Total electric consumption by compressor and condenser pump [J]
4457 45014786 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).TotalHeatingEnergy = 0.0; // total water heating energy
4458 45014786 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).TotalHeatingEnergyRate = 0.0; // total WH energy rate
4459 45014786 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).HPWHCondPumpElecNomPower = 0.0; // power power
4460 :
4461 45014786 : state.dataVariableSpeedCoils->VSHPWHHeatingCapacity = 0.0; // Used by Heat Pump:Water Heater object as total water heating capacity [W]
4462 45014786 : state.dataVariableSpeedCoils->VSHPWHHeatingCOP = 0.0; // Used by Heat Pump:Water Heater object as water heating COP [W/W]
4463 45014786 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).OutletWaterTemp = state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).InletWaterTemp;
4464 45014786 : state.dataHeatBal->HeatReclaimVS_Coil(DXCoilNum).AvailCapacity = 0.0;
4465 45014786 : }
4466 :
4467 85 : 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 85 : auto &varSpeedCoil = state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum);
4492 :
4493 : // SUBROUTINE LOCAL VARIABLE DECLARATIONS:
4494 85 : Real64 rhoair = state.dataEnvrn->StdRhoAir;
4495 85 : Real64 MixTemp = -999.0;
4496 85 : Real64 MixHumRat = -999.0;
4497 85 : Real64 MixEnth = -999.0;
4498 85 : Real64 MixWetBulb = -999.0;
4499 85 : Real64 SupTemp = -999.0;
4500 85 : Real64 SupHumRat = -999.0;
4501 85 : Real64 SupEnth = -999.0;
4502 85 : Real64 OutTemp = -999.0;
4503 85 : Real64 OutAirFrac = -999.0;
4504 85 : Real64 VolFlowRate = -999.0;
4505 85 : Real64 CoolCapAtPeak = -999.0;
4506 85 : 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 85 : 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 85 : int UpperSpeed = varSpeedCoil.NumOfSpeeds;
4534 85 : int NormSpeed = varSpeedCoil.NormSpedLevel;
4535 85 : int PltSizNum = 0;
4536 85 : bool RatedAirFlowAutoSized = false;
4537 85 : bool RatedWaterFlowAutoSized = false;
4538 85 : bool RatedCapHeatAutoSized = false;
4539 85 : bool IsAutoSize = false;
4540 :
4541 85 : if (state.dataSize->SysSizingRunDone || state.dataSize->ZoneSizingRunDone) {
4542 53 : HardSizeNoDesRun = false;
4543 : } else {
4544 32 : HardSizeNoDesRun = true;
4545 : }
4546 85 : if (state.dataSize->CurSysNum > 0) {
4547 63 : CheckThisAirSystemForSizing(state, state.dataSize->CurSysNum, SizingDesRunThisAirSys);
4548 : } else {
4549 22 : SizingDesRunThisAirSys = false;
4550 : }
4551 85 : if (state.dataSize->CurZoneEqNum > 0) {
4552 18 : CheckThisZoneForSizing(state, state.dataSize->CurZoneEqNum, SizingDesRunThisZone);
4553 : } else {
4554 67 : SizingDesRunThisZone = false;
4555 : }
4556 85 : bool HardSizeNoDesRunAirFlow = false;
4557 85 : Real64 RatedAirVolFlowRateDes = 0.0;
4558 85 : Real64 RatedAirVolFlowRateUser = 0.0;
4559 85 : Real64 RatedCapCoolTotalDes = 0.0;
4560 85 : Real64 RatedCapCoolTotalUser = 0.0;
4561 85 : Real64 RatedCapHeatDes = 0.0;
4562 85 : Real64 RatedCapHeatUser = 0.0;
4563 85 : Real64 RatedWaterVolFlowRateDes = 0.0;
4564 85 : Real64 RatedWaterVolFlowRateUser = 0.0;
4565 85 : Real64 RatedCapCoolSensDes = 0.0;
4566 85 : Real64 EvapCondPumpElecNomPowerDes = 0.0;
4567 85 : Real64 EvapCondPumpElecNomPowerUser = 0.0;
4568 85 : Real64 DefrostCapacityDes = 0.0;
4569 85 : Real64 DefrostCapacityUser = 0.0;
4570 :
4571 85 : if (varSpeedCoil.VSCoilType == HVAC::Coil_CoolingWaterToAirHPVSEquationFit ||
4572 67 : varSpeedCoil.VSCoilType == HVAC::Coil_HeatingWaterToAirHPVSEquationFit) {
4573 36 : CurrentObjSubfix = ":WATERTOAIRHEATPUMP:VARIABLESPEEDEQUATIONFIT";
4574 49 : } else if (varSpeedCoil.VSCoilType == HVAC::CoilDX_HeatPumpWaterHeaterVariableSpeed) {
4575 14 : CurrentObjSubfix = ":WATERHEATING:AIRTOWATERHEATPUMP:VARIABLESPEED";
4576 : } else {
4577 35 : CurrentObjSubfix = ":DX:VARIABLESPEED";
4578 : }
4579 :
4580 85 : if (varSpeedCoil.VSCoilType == HVAC::CoilDX_HeatPumpWaterHeaterVariableSpeed) {
4581 14 : if (varSpeedCoil.RatedAirVolFlowRate == Constant::AutoCalculate) {
4582 4 : varSpeedCoil.RatedAirVolFlowRate =
4583 4 : varSpeedCoil.RatedCapWH * varSpeedCoil.MSRatedAirVolFlowRate(NormSpeed) / varSpeedCoil.MSRatedTotCap(NormSpeed); // 0.00005035;
4584 4 : varSpeedCoil.AirVolFlowAutoSized = true;
4585 : }
4586 14 : state.dataRptCoilSelection->coilSelectionReportObj->setCoilAirFlow(
4587 14 : state, varSpeedCoil.Name, varSpeedCoil.VarSpeedCoilType, varSpeedCoil.RatedAirVolFlowRate, varSpeedCoil.AirVolFlowAutoSized);
4588 :
4589 14 : if (varSpeedCoil.RatedWaterVolFlowRate == Constant::AutoCalculate) {
4590 4 : varSpeedCoil.RatedHPWHCondWaterFlow = varSpeedCoil.RatedCapWH * varSpeedCoil.MSRatedWaterVolFlowRate(NormSpeed) /
4591 4 : varSpeedCoil.MSRatedTotCap(NormSpeed); // 0.00000004487;
4592 4 : varSpeedCoil.RatedWaterVolFlowRate = varSpeedCoil.RatedHPWHCondWaterFlow;
4593 4 : varSpeedCoil.WaterVolFlowAutoSized = true;
4594 : }
4595 14 : state.dataRptCoilSelection->coilSelectionReportObj->setCoilWaterFlowPltSizNum(state,
4596 14 : varSpeedCoil.Name,
4597 14 : varSpeedCoil.VarSpeedCoilType,
4598 : varSpeedCoil.RatedWaterVolFlowRate,
4599 14 : varSpeedCoil.WaterVolFlowAutoSized,
4600 : -999,
4601 : varSpeedCoil.plantLoc.loopNum);
4602 : }
4603 :
4604 85 : if (varSpeedCoil.RatedAirVolFlowRate == DataSizing::AutoSize) {
4605 25 : RatedAirFlowAutoSized = true;
4606 : }
4607 :
4608 85 : if (state.dataSize->CurSysNum > 0) {
4609 63 : if (!RatedAirFlowAutoSized && !SizingDesRunThisAirSys) { // Simulation continue
4610 51 : HardSizeNoDesRunAirFlow = true;
4611 51 : if (varSpeedCoil.RatedAirVolFlowRate > 0.0) {
4612 153 : BaseSizer::reportSizerOutput(state,
4613 102 : format("COIL:{}{}", varSpeedCoil.CoolHeatType, CurrentObjSubfix),
4614 : varSpeedCoil.Name,
4615 : "User-Specified Rated Air Flow Rate [m3/s]",
4616 : varSpeedCoil.RatedAirVolFlowRate);
4617 : }
4618 : } else {
4619 12 : CheckSysSizing(state, format("COIL:{}{}", varSpeedCoil.CoolHeatType, CurrentObjSubfix), varSpeedCoil.Name);
4620 12 : 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 12 : if (state.dataSize->FinalSysSizing(state.dataSize->CurSysNum).DesMainVolFlow >= HVAC::SmallAirVolFlow) {
4626 12 : RatedAirVolFlowRateDes = state.dataSize->FinalSysSizing(state.dataSize->CurSysNum).DesMainVolFlow;
4627 : } else {
4628 0 : RatedAirVolFlowRateDes = 0.0;
4629 : }
4630 : }
4631 : }
4632 : }
4633 :
4634 85 : if (state.dataSize->CurZoneEqNum > 0) {
4635 18 : if (!RatedAirFlowAutoSized && !SizingDesRunThisZone) { // Simulation continue
4636 0 : HardSizeNoDesRunAirFlow = true;
4637 0 : if (varSpeedCoil.RatedAirVolFlowRate > 0.0) {
4638 0 : BaseSizer::reportSizerOutput(state,
4639 0 : format("COIL:{}{}", varSpeedCoil.CoolHeatType, CurrentObjSubfix),
4640 : varSpeedCoil.Name,
4641 : "User-Specified Rated Air Flow Rate [m3/s]",
4642 : varSpeedCoil.RatedAirVolFlowRate);
4643 : }
4644 : } else {
4645 18 : CheckZoneSizing(state, format("COIL:{}{}", varSpeedCoil.CoolHeatType, CurrentObjSubfix), varSpeedCoil.Name);
4646 18 : RatedAirVolFlowRateDes = max(state.dataSize->FinalZoneSizing(state.dataSize->CurZoneEqNum).DesCoolVolFlow,
4647 18 : state.dataSize->FinalZoneSizing(state.dataSize->CurZoneEqNum).DesHeatVolFlow);
4648 18 : if (RatedAirVolFlowRateDes < HVAC::SmallAirVolFlow) {
4649 0 : RatedAirVolFlowRateDes = 0.0;
4650 : }
4651 : }
4652 : }
4653 :
4654 85 : if (RatedAirFlowAutoSized) {
4655 25 : varSpeedCoil.RatedAirVolFlowRate = RatedAirVolFlowRateDes;
4656 : }
4657 :
4658 85 : RatedCapCoolTotalAutoSized = false;
4659 85 : RatedCapCoolSensAutoSized = false;
4660 :
4661 : // size rated total cooling capacity
4662 85 : IsAutoSize = false;
4663 85 : if (varSpeedCoil.RatedCapCoolTotal == DataSizing::AutoSize && (varSpeedCoil.VSCoilType == HVAC::Coil_CoolingWaterToAirHPVSEquationFit ||
4664 52 : varSpeedCoil.VSCoilType == HVAC::Coil_CoolingAirToAirVariableSpeed)) {
4665 18 : RatedCapCoolTotalAutoSized = true;
4666 : }
4667 85 : if (SizingDesRunThisZone || SizingDesRunThisAirSys) {
4668 30 : HardSizeNoDesRun = false;
4669 : }
4670 85 : if (state.dataSize->CurSysNum > 0) {
4671 63 : if (!RatedCapCoolTotalAutoSized && !SizingDesRunThisAirSys) { // Simulation continue
4672 51 : HardSizeNoDesRun = true;
4673 51 : if (varSpeedCoil.RatedCapCoolTotal > 0.0) {
4674 84 : BaseSizer::reportSizerOutput(state,
4675 56 : format("COIL:{}{}", varSpeedCoil.CoolHeatType, CurrentObjSubfix),
4676 : varSpeedCoil.Name,
4677 : "User-Specified Rated Total Cooling Capacity [W]",
4678 : varSpeedCoil.RatedCapCoolTotal);
4679 : }
4680 : } else {
4681 12 : CheckSysSizing(state, format("COIL:{}{}", varSpeedCoil.CoolHeatType, CurrentObjSubfix), varSpeedCoil.Name);
4682 12 : 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 12 : auto const &finalSysSizing = state.dataSize->FinalSysSizing(state.dataSize->CurSysNum);
4705 12 : VolFlowRate = varSpeedCoil.RatedAirVolFlowRate;
4706 12 : if (VolFlowRate >= HVAC::SmallAirVolFlow) {
4707 12 : 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 12 : SupTemp = finalSysSizing.CoolSupTemp;
4714 12 : SupHumRat = finalSysSizing.CoolSupHumRat;
4715 12 : if (state.dataAirSystemsData->PrimaryAirSystems(state.dataSize->CurSysNum).NumOACoolCoils ==
4716 : 0) { // there is no precooling of the OA stream
4717 12 : MixTemp = finalSysSizing.MixTempAtCoolPeak;
4718 12 : 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 12 : OutTemp = finalSysSizing.OutTempAtCoolPeak;
4731 12 : MixEnth = Psychrometrics::PsyHFnTdbW(MixTemp, MixHumRat);
4732 12 : SupEnth = Psychrometrics::PsyHFnTdbW(SupTemp, SupHumRat);
4733 :
4734 : // design fan heat will be added to coil load
4735 12 : 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 12 : Real64 CpAir = Psychrometrics::PsyCpAirFnW(MixHumRat);
4738 12 : if (state.dataAirSystemsData->PrimaryAirSystems(state.dataSize->CurSysNum).supFanPlace == HVAC::FanPlace::BlowThru) {
4739 12 : MixTemp += FanCoolLoad / (CpAir * rhoair * VolFlowRate);
4740 0 : } else if (state.dataAirSystemsData->PrimaryAirSystems(state.dataSize->CurSysNum).supFanPlace == HVAC::FanPlace::DrawThru) {
4741 0 : SupTemp -= FanCoolLoad / (CpAir * rhoair * VolFlowRate);
4742 : }
4743 12 : MixWetBulb = Psychrometrics::PsyTwbFnTdbWPb(state, MixTemp, MixHumRat, state.dataEnvrn->StdBaroPress, RoutineName);
4744 12 : if (varSpeedCoil.CondenserType == DataHeatBalance::RefrigCondenserType::Air) {
4745 12 : RatedSourceTempCool = OutTemp;
4746 : } else {
4747 0 : RatedSourceTempCool = GetVSCoilRatedSourceTemp(state, DXCoilNum);
4748 : }
4749 12 : TotCapTempModFac =
4750 12 : 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 12 : if (MixEnth > SupEnth) {
4755 12 : CoolCapAtPeak = (rhoair * VolFlowRate * (MixEnth - SupEnth)) + FanCoolLoad;
4756 : } else {
4757 0 : CoolCapAtPeak = (rhoair * VolFlowRate * (48000.0 - SupEnth)) + FanCoolLoad;
4758 : }
4759 12 : CoolCapAtPeak = max(0.0, CoolCapAtPeak);
4760 12 : if (TotCapTempModFac > 0.0) {
4761 12 : RatedCapCoolTotalDes = CoolCapAtPeak / TotCapTempModFac;
4762 : } else {
4763 0 : RatedCapCoolTotalDes = CoolCapAtPeak;
4764 : }
4765 : } else {
4766 0 : RatedCapCoolTotalDes = 0.0;
4767 : }
4768 : }
4769 : }
4770 :
4771 22 : } else if (state.dataSize->CurZoneEqNum > 0) {
4772 18 : if (!RatedCapCoolTotalAutoSized && !SizingDesRunThisZone) { // Simulation continue
4773 0 : HardSizeNoDesRun = true;
4774 0 : if (varSpeedCoil.RatedCapCoolTotal > 0.0) {
4775 0 : BaseSizer::reportSizerOutput(state,
4776 0 : format("COIL:{}{}", varSpeedCoil.CoolHeatType, CurrentObjSubfix),
4777 : varSpeedCoil.Name,
4778 : "User-Specified Rated Total Cooling Capacity [W]",
4779 : varSpeedCoil.RatedCapCoolTotal);
4780 : }
4781 : } else {
4782 18 : CheckZoneSizing(state, format("COIL:{}{}", varSpeedCoil.CoolHeatType, CurrentObjSubfix), varSpeedCoil.Name);
4783 18 : auto const &finalZoneSizing = state.dataSize->FinalZoneSizing(state.dataSize->CurZoneEqNum);
4784 18 : VolFlowRate = varSpeedCoil.RatedAirVolFlowRate;
4785 18 : if (VolFlowRate >= HVAC::SmallAirVolFlow) {
4786 18 : if (state.dataSize->ZoneEqDXCoil) {
4787 14 : if (state.dataSize->ZoneEqSizing(state.dataSize->CurZoneEqNum).OAVolFlow > 0.0) {
4788 10 : MixTemp = finalZoneSizing.DesCoolCoilInTemp;
4789 10 : MixHumRat = finalZoneSizing.DesCoolCoilInHumRat;
4790 : } else {
4791 4 : MixTemp = finalZoneSizing.ZoneTempAtCoolPeak;
4792 4 : MixHumRat = finalZoneSizing.ZoneHumRatAtCoolPeak;
4793 : }
4794 : } else {
4795 4 : MixTemp = finalZoneSizing.DesCoolCoilInTemp;
4796 4 : MixHumRat = finalZoneSizing.DesCoolCoilInHumRat;
4797 : }
4798 18 : SupTemp = finalZoneSizing.CoolDesTemp;
4799 18 : SupHumRat = finalZoneSizing.CoolDesHumRat;
4800 18 : TimeStepNumAtMax = finalZoneSizing.TimeStepNumAtCoolMax;
4801 18 : DDNum = finalZoneSizing.CoolDDNum;
4802 18 : if (DDNum > 0 && TimeStepNumAtMax > 0) {
4803 18 : OutTemp = state.dataSize->DesDayWeath(DDNum).Temp(TimeStepNumAtMax);
4804 : } else {
4805 0 : OutTemp = 0.0;
4806 : }
4807 18 : MixEnth = Psychrometrics::PsyHFnTdbW(MixTemp, MixHumRat);
4808 18 : SupEnth = Psychrometrics::PsyHFnTdbW(SupTemp, SupHumRat);
4809 :
4810 : // design fan heat will be added to coil load
4811 18 : 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 18 : Real64 CpAir = Psychrometrics::PsyCpAirFnW(MixHumRat);
4814 :
4815 18 : if (state.dataSize->DataFanPlacement == HVAC::FanPlace::BlowThru) {
4816 13 : MixTemp += FanCoolLoad / (CpAir * rhoair * VolFlowRate);
4817 : } else {
4818 5 : SupTemp -= FanCoolLoad / (CpAir * rhoair * VolFlowRate);
4819 : }
4820 :
4821 18 : MixWetBulb = Psychrometrics::PsyTwbFnTdbWPb(state, MixTemp, MixHumRat, state.dataEnvrn->StdBaroPress, RoutineName);
4822 18 : if (varSpeedCoil.CondenserType == DataHeatBalance::RefrigCondenserType::Air) {
4823 10 : RatedSourceTempCool = OutTemp;
4824 : } else {
4825 8 : RatedSourceTempCool = GetVSCoilRatedSourceTemp(state, DXCoilNum);
4826 : }
4827 18 : TotCapTempModFac =
4828 18 : 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 18 : if (MixEnth > SupEnth) {
4833 18 : CoolCapAtPeak = (rhoair * VolFlowRate * (MixEnth - SupEnth)) + FanCoolLoad;
4834 : } else {
4835 0 : CoolCapAtPeak = (rhoair * VolFlowRate * (48000.0 - SupEnth)) + FanCoolLoad;
4836 : }
4837 18 : CoolCapAtPeak = max(0.0, CoolCapAtPeak);
4838 18 : if (TotCapTempModFac > 0.0) {
4839 18 : RatedCapCoolTotalDes = CoolCapAtPeak / TotCapTempModFac;
4840 : } else {
4841 0 : RatedCapCoolTotalDes = CoolCapAtPeak;
4842 : }
4843 : } else {
4844 0 : RatedCapCoolTotalDes = 0.0;
4845 : }
4846 : }
4847 : }
4848 85 : if (RatedCapCoolTotalDes < HVAC::SmallLoad) {
4849 55 : RatedCapCoolTotalDes = 0.0;
4850 : }
4851 85 : if (!HardSizeNoDesRun) {
4852 33 : if (RatedCapCoolTotalAutoSized) {
4853 18 : varSpeedCoil.RatedCapCoolTotal = RatedCapCoolTotalDes;
4854 54 : BaseSizer::reportSizerOutput(state,
4855 36 : format("COIL:{}{}", varSpeedCoil.CoolHeatType, CurrentObjSubfix),
4856 : varSpeedCoil.Name,
4857 : "Design Size Rated Total Cooling Capacity [W]",
4858 : varSpeedCoil.RatedCapCoolTotal);
4859 36 : OutputReportPredefined::PreDefTableEntry(
4860 18 : state, state.dataOutRptPredefined->pdchCoolCoilTotCap, varSpeedCoil.Name, varSpeedCoil.RatedCapCoolTotal);
4861 36 : OutputReportPredefined::PreDefTableEntry(state,
4862 18 : state.dataOutRptPredefined->pdchCoolCoilLatCap,
4863 : varSpeedCoil.Name,
4864 18 : varSpeedCoil.RatedCapCoolTotal - varSpeedCoil.RatedCapCoolSens);
4865 18 : if (varSpeedCoil.RatedCapCoolTotal != 0.0) {
4866 36 : OutputReportPredefined::PreDefTableEntry(state,
4867 18 : state.dataOutRptPredefined->pdchCoolCoilSHR,
4868 : varSpeedCoil.Name,
4869 18 : varSpeedCoil.RatedCapCoolSens / varSpeedCoil.RatedCapCoolTotal);
4870 36 : OutputReportPredefined::PreDefTableEntry(
4871 18 : 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 36 : OutputReportPredefined::addFootNoteSubTable(
4877 : state,
4878 18 : 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 15 : if (varSpeedCoil.RatedCapCoolTotal > 0.0 && RatedCapCoolTotalDes > 0.0) {
4882 2 : RatedCapCoolTotalUser = varSpeedCoil.RatedCapCoolTotal;
4883 6 : BaseSizer::reportSizerOutput(state,
4884 4 : 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 2 : 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 33 : state.dataRptCoilSelection->coilSelectionReportObj->setCoilEntAirTemp(
4909 33 : state, varSpeedCoil.Name, varSpeedCoil.VarSpeedCoilType, MixTemp, state.dataSize->CurSysNum, state.dataSize->CurZoneEqNum);
4910 33 : state.dataRptCoilSelection->coilSelectionReportObj->setCoilEntAirHumRat(
4911 33 : state, varSpeedCoil.Name, varSpeedCoil.VarSpeedCoilType, MixHumRat);
4912 33 : state.dataRptCoilSelection->coilSelectionReportObj->setCoilLvgAirTemp(state, varSpeedCoil.Name, varSpeedCoil.VarSpeedCoilType, SupTemp);
4913 33 : state.dataRptCoilSelection->coilSelectionReportObj->setCoilLvgAirHumRat(
4914 33 : state, varSpeedCoil.Name, varSpeedCoil.VarSpeedCoilType, SupHumRat);
4915 33 : state.dataRptCoilSelection->coilSelectionReportObj->setCoilAirFlow(
4916 33 : state, varSpeedCoil.Name, varSpeedCoil.VarSpeedCoilType, varSpeedCoil.RatedAirVolFlowRate, RatedAirFlowAutoSized);
4917 33 : state.dataRptCoilSelection->coilSelectionReportObj->setCoilCoolingCapacity(state,
4918 33 : varSpeedCoil.Name,
4919 33 : varSpeedCoil.VarSpeedCoilType,
4920 : RatedCapCoolTotalDes,
4921 : RatedCapCoolTotalAutoSized,
4922 33 : state.dataSize->CurSysNum,
4923 33 : state.dataSize->CurZoneEqNum,
4924 33 : 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 85 : if (varSpeedCoil.VSCoilType == HVAC::Coil_CoolingWaterToAirHPVSEquationFit ||
4933 67 : varSpeedCoil.VSCoilType == HVAC::Coil_CoolingAirToAirVariableSpeed) {
4934 42 : state.dataSize->DXCoolCap = varSpeedCoil.RatedCapCoolTotal;
4935 : }
4936 :
4937 : // size rated heating capacity
4938 85 : if (varSpeedCoil.RatedCapHeat == DataSizing::AutoSize && (varSpeedCoil.VSCoilType == HVAC::Coil_HeatingWaterToAirHPVSEquationFit ||
4939 60 : varSpeedCoil.VSCoilType == HVAC::Coil_HeatingAirToAirVariableSpeed)) {
4940 7 : RatedCapHeatAutoSized = true;
4941 : }
4942 : // simply set heating capacity equal to the cooling capacity
4943 : // VarSpeedCoil(DXCoilNum)%RatedCapHeat = DXCoolCap
4944 85 : if (varSpeedCoil.VSCoilType == HVAC::Coil_HeatingWaterToAirHPVSEquationFit ||
4945 67 : varSpeedCoil.VSCoilType == HVAC::Coil_HeatingAirToAirVariableSpeed) {
4946 29 : if (varSpeedCoil.CompanionCoolingCoilNum > 0) {
4947 24 : RatedCapHeatDes = state.dataVariableSpeedCoils->VarSpeedCoil(varSpeedCoil.CompanionCoolingCoilNum).RatedCapCoolTotal;
4948 24 : varSpeedCoil.RatedCapCoolTotal = RatedCapHeatDes; // AVOID BEING ZERO
4949 : } else {
4950 5 : RatedCapHeatDes = state.dataSize->DXCoolCap; // previous code, can be risky
4951 : }
4952 : // END IF
4953 29 : if (RatedCapHeatAutoSized) {
4954 7 : 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 29 : if (RatedCapHeatDes < HVAC::SmallLoad) {
4964 0 : RatedCapHeatDes = 0.0;
4965 : }
4966 29 : state.dataRptCoilSelection->coilSelectionReportObj->setCoilHeatingCapacity(state,
4967 29 : varSpeedCoil.Name,
4968 29 : varSpeedCoil.VarSpeedCoilType,
4969 : RatedCapHeatDes,
4970 : RatedCapHeatAutoSized,
4971 29 : state.dataSize->CurSysNum,
4972 29 : state.dataSize->CurZoneEqNum,
4973 29 : state.dataSize->CurOASysNum,
4974 : 0.0,
4975 : 1.0,
4976 : -999.0,
4977 : -999.0);
4978 : }
4979 85 : if (RatedCapHeatAutoSized) {
4980 7 : varSpeedCoil.RatedCapHeat = RatedCapHeatDes;
4981 21 : BaseSizer::reportSizerOutput(state,
4982 14 : format("COIL:{}{}", varSpeedCoil.CoolHeatType, CurrentObjSubfix),
4983 : varSpeedCoil.Name,
4984 : "Design Size Nominal Heating Capacity [W]",
4985 : RatedCapHeatDes);
4986 14 : OutputReportPredefined::PreDefTableEntry(
4987 7 : state, state.dataOutRptPredefined->pdchHeatCoilNomCap, varSpeedCoil.Name, varSpeedCoil.RatedCapHeat);
4988 7 : if (varSpeedCoil.RatedCapHeat != 0.0) {
4989 14 : OutputReportPredefined::PreDefTableEntry(
4990 7 : 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 14 : OutputReportPredefined::addFootNoteSubTable(
4995 : state,
4996 7 : 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 78 : if (varSpeedCoil.RatedCapHeat > 0.0 && RatedCapHeatDes > 0.0) {
5000 22 : RatedCapHeatUser = varSpeedCoil.RatedCapHeat;
5001 66 : BaseSizer::reportSizerOutput(state,
5002 44 : 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 22 : if (state.dataGlobal->DisplayExtraWarnings) {
5009 4 : 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 85 : if (!HardSizeNoDesRunAirFlow) {
5025 34 : if ((RatedCapCoolTotalAutoSized) && (RatedAirFlowAutoSized)) {
5026 18 : RatedAirVolFlowRateDes = varSpeedCoil.RatedCapCoolTotal * varSpeedCoil.MSRatedAirVolFlowPerRatedTotCap(NormSpeed);
5027 16 : } else if ((RatedCapHeatAutoSized) && (RatedAirFlowAutoSized)) {
5028 7 : RatedAirVolFlowRateDes = varSpeedCoil.RatedCapHeat * varSpeedCoil.MSRatedAirVolFlowPerRatedTotCap(NormSpeed);
5029 : }
5030 :
5031 : // write the air flow sizing output
5032 34 : if (RatedAirFlowAutoSized) {
5033 25 : varSpeedCoil.RatedAirVolFlowRate = RatedAirVolFlowRateDes;
5034 75 : BaseSizer::reportSizerOutput(state,
5035 50 : format("COIL:{}{}", varSpeedCoil.CoolHeatType, CurrentObjSubfix),
5036 : varSpeedCoil.Name,
5037 : "Design Size Rated Air Flow Rate [m3/s]",
5038 : RatedAirVolFlowRateDes);
5039 : } else {
5040 9 : if (varSpeedCoil.RatedAirVolFlowRate > 0.0 && RatedAirVolFlowRateDes > 0.0) {
5041 5 : RatedAirVolFlowRateUser = varSpeedCoil.RatedAirVolFlowRate;
5042 15 : BaseSizer::reportSizerOutput(state,
5043 10 : 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 5 : 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 34 : state.dataRptCoilSelection->coilSelectionReportObj->setCoilAirFlow(
5066 34 : 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 85 : if ((varSpeedCoil.VSCoilType == HVAC::Coil_HeatingWaterToAirHPVSEquationFit ||
5071 67 : varSpeedCoil.VSCoilType == HVAC::Coil_HeatingAirToAirVariableSpeed) &&
5072 29 : varSpeedCoil.CompanionCoolingCoilNum > 0) {
5073 :
5074 24 : if (state.dataVariableSpeedCoils->VarSpeedCoil(varSpeedCoil.CompanionCoolingCoilNum).RatedCapCoolTotal > 0.0) {
5075 :
5076 24 : if (std::abs(state.dataVariableSpeedCoils->VarSpeedCoil(varSpeedCoil.CompanionCoolingCoilNum).RatedCapCoolTotal -
5077 24 : varSpeedCoil.RatedCapHeat) /
5078 24 : 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 85 : switch (varSpeedCoil.VSCoilType) {
5098 42 : case HVAC::Coil_CoolingWaterToAirHPVSEquationFit:
5099 : case HVAC::Coil_CoolingAirToAirVariableSpeed: {
5100 42 : varSpeedCoil.MSRatedTotCap(UpperSpeed) = varSpeedCoil.RatedCapCoolTotal / varSpeedCoil.MSRatedPercentTotCap(NormSpeed);
5101 42 : } break;
5102 29 : case HVAC::Coil_HeatingWaterToAirHPVSEquationFit:
5103 : case HVAC::Coil_HeatingAirToAirVariableSpeed: {
5104 29 : varSpeedCoil.MSRatedTotCap(UpperSpeed) = varSpeedCoil.RatedCapHeat / varSpeedCoil.MSRatedPercentTotCap(NormSpeed);
5105 29 : } break;
5106 14 : case HVAC::CoilDX_HeatPumpWaterHeaterVariableSpeed: {
5107 14 : varSpeedCoil.MSRatedTotCap(UpperSpeed) = varSpeedCoil.RatedCapWH / varSpeedCoil.MSRatedPercentTotCap(NormSpeed);
5108 14 : } break;
5109 : }
5110 :
5111 85 : if (varSpeedCoil.VSCoilType == HVAC::CoilDX_HeatPumpWaterHeaterVariableSpeed) {
5112 14 : HPInletAirHumRat = Psychrometrics::PsyWFnTdbTwbPb(
5113 14 : state, varSpeedCoil.WHRatedInletDBTemp, varSpeedCoil.WHRatedInletWBTemp, state.dataEnvrn->StdBaroPress, RoutineName);
5114 :
5115 154 : for (Mode = varSpeedCoil.NumOfSpeeds; Mode >= 1; --Mode) {
5116 140 : varSpeedCoil.MSRatedTotCap(Mode) = varSpeedCoil.MSRatedTotCap(UpperSpeed) * varSpeedCoil.MSRatedPercentTotCap(Mode);
5117 140 : varSpeedCoil.MSRatedAirVolFlowRate(Mode) = varSpeedCoil.MSRatedTotCap(Mode) * varSpeedCoil.MSRatedAirVolFlowPerRatedTotCap(Mode);
5118 140 : varSpeedCoil.MSRatedAirMassFlowRate(Mode) = varSpeedCoil.MSRatedAirVolFlowRate(Mode) * rhoair;
5119 : // EVAPORATIVE PRECOOLING CONDENSER AIR FLOW RATE
5120 140 : 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 71 : if (varSpeedCoil.MSHPDesignSpecIndex > -1 && state.dataUnitarySystems->designSpecMSHP.size() > 0) {
5126 1 : if (varSpeedCoil.VSCoilType == HVAC::Coil_CoolingWaterToAirHPVSEquationFit ||
5127 1 : 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 5 : for (Mode = varSpeedCoil.NumOfSpeeds; Mode >= 1; --Mode) {
5137 8 : varSpeedCoil.MSRatedAirVolFlowRate(Mode) =
5138 4 : varSpeedCoil.RatedAirVolFlowRate *
5139 4 : state.dataUnitarySystems->designSpecMSHP[varSpeedCoil.MSHPDesignSpecIndex].coolingVolFlowRatio[Mode - 1];
5140 8 : varSpeedCoil.MSRatedTotCap(Mode) =
5141 4 : varSpeedCoil.MSRatedAirVolFlowRate(Mode) / varSpeedCoil.MSRatedAirVolFlowPerRatedTotCap(Mode);
5142 4 : varSpeedCoil.MSRatedAirMassFlowRate(Mode) = varSpeedCoil.MSRatedAirVolFlowRate(Mode) * rhoair;
5143 : // EVAPORATIVE PRECOOLING CONDENSER AIR FLOW RATE
5144 4 : varSpeedCoil.EvapCondAirFlow(Mode) =
5145 4 : varSpeedCoil.MSRatedTotCap(Mode) * varSpeedCoil.MSRatedEvapCondVolFlowPerRatedTotCap(Mode);
5146 : }
5147 : }
5148 0 : } else if (varSpeedCoil.VSCoilType == HVAC::Coil_HeatingWaterToAirHPVSEquationFit ||
5149 0 : varSpeedCoil.VSCoilType == HVAC::Coil_HeatingAirToAirVariableSpeed) {
5150 0 : 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 0 : for (Mode = varSpeedCoil.NumOfSpeeds; Mode >= 1; --Mode) {
5159 0 : varSpeedCoil.MSRatedAirVolFlowRate(Mode) =
5160 0 : varSpeedCoil.RatedAirVolFlowRate *
5161 0 : state.dataUnitarySystems->designSpecMSHP[varSpeedCoil.MSHPDesignSpecIndex].heatingVolFlowRatio[Mode - 1];
5162 0 : varSpeedCoil.MSRatedTotCap(Mode) =
5163 0 : varSpeedCoil.MSRatedAirVolFlowRate(Mode) / varSpeedCoil.MSRatedAirVolFlowPerRatedTotCap(Mode);
5164 0 : varSpeedCoil.MSRatedAirMassFlowRate(Mode) = varSpeedCoil.MSRatedAirVolFlowRate(Mode) * rhoair;
5165 : // EVAPORATIVE PRECOOLING CONDENSER AIR FLOW RATE
5166 0 : varSpeedCoil.EvapCondAirFlow(Mode) =
5167 0 : varSpeedCoil.MSRatedTotCap(Mode) * varSpeedCoil.MSRatedEvapCondVolFlowPerRatedTotCap(Mode);
5168 : }
5169 : }
5170 : }
5171 : } else {
5172 706 : for (Mode = varSpeedCoil.NumOfSpeeds; Mode >= 1; --Mode) {
5173 636 : varSpeedCoil.MSRatedTotCap(Mode) = varSpeedCoil.MSRatedTotCap(UpperSpeed) * varSpeedCoil.MSRatedPercentTotCap(Mode);
5174 636 : varSpeedCoil.MSRatedAirVolFlowRate(Mode) = varSpeedCoil.MSRatedTotCap(Mode) * varSpeedCoil.MSRatedAirVolFlowPerRatedTotCap(Mode);
5175 636 : varSpeedCoil.MSRatedAirMassFlowRate(Mode) = varSpeedCoil.MSRatedAirVolFlowRate(Mode) * rhoair;
5176 : // EVAPORATIVE PRECOOLING CONDENSER AIR FLOW RATE
5177 636 : varSpeedCoil.EvapCondAirFlow(Mode) = varSpeedCoil.MSRatedTotCap(Mode) * varSpeedCoil.MSRatedEvapCondVolFlowPerRatedTotCap(Mode);
5178 : }
5179 : }
5180 : }
5181 :
5182 : // size rated power
5183 85 : switch (varSpeedCoil.VSCoilType) {
5184 42 : case HVAC::Coil_CoolingWaterToAirHPVSEquationFit:
5185 : case HVAC::Coil_CoolingAirToAirVariableSpeed: {
5186 42 : varSpeedCoil.RatedCOPCool = varSpeedCoil.MSRatedCOP(varSpeedCoil.NormSpedLevel);
5187 42 : varSpeedCoil.RatedPowerCool = varSpeedCoil.RatedCapCoolTotal / varSpeedCoil.RatedCOPCool;
5188 42 : } break;
5189 29 : case HVAC::Coil_HeatingWaterToAirHPVSEquationFit:
5190 : case HVAC::Coil_HeatingAirToAirVariableSpeed: {
5191 29 : varSpeedCoil.RatedCOPHeat = varSpeedCoil.MSRatedCOP(varSpeedCoil.NormSpedLevel);
5192 29 : varSpeedCoil.RatedPowerHeat = varSpeedCoil.RatedCapHeat / varSpeedCoil.RatedCOPHeat;
5193 29 : varSpeedCoil.RatedCapCoolTotal = varSpeedCoil.RatedCapHeat;
5194 29 : } break;
5195 14 : case HVAC::CoilDX_HeatPumpWaterHeaterVariableSpeed: {
5196 14 : varSpeedCoil.RatedCOPHeat = varSpeedCoil.MSRatedCOP(varSpeedCoil.NormSpedLevel);
5197 14 : varSpeedCoil.RatedPowerHeat = varSpeedCoil.RatedCapWH / varSpeedCoil.RatedCOPHeat;
5198 14 : varSpeedCoil.RatedCapCoolTotal = varSpeedCoil.RatedCapWH * (1.0 - 1.0 / varSpeedCoil.RatedCOPHeat);
5199 14 : } break;
5200 : }
5201 :
5202 : // Size water volumetric flow rate
5203 85 : if ((varSpeedCoil.RatedWaterVolFlowRate == DataSizing::AutoSize) &&
5204 41 : (varSpeedCoil.VSCoilType == HVAC::Coil_CoolingWaterToAirHPVSEquationFit ||
5205 38 : varSpeedCoil.VSCoilType == HVAC::Coil_HeatingWaterToAirHPVSEquationFit)) {
5206 6 : 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 85 : if (RatedWaterFlowAutoSized) {
5212 6 : if (varSpeedCoil.CondenserType == DataHeatBalance::RefrigCondenserType::Water) {
5213 12 : PltSizNum = PlantUtilities::MyPlantSizingIndex(state,
5214 12 : format("COIL:{}{}", varSpeedCoil.CoolHeatType, CurrentObjSubfix),
5215 : varSpeedCoil.Name,
5216 : varSpeedCoil.WaterInletNodeNum,
5217 : varSpeedCoil.WaterOutletNodeNum,
5218 : ErrorsFound,
5219 : false);
5220 : }
5221 :
5222 6 : if (PltSizNum > 0) {
5223 6 : rho = state.dataPlnt->PlantLoop(varSpeedCoil.plantLoc.loopNum)
5224 6 : .glycol->getDensity(state, state.dataSize->PlantSizData(PltSizNum).ExitTemp, RoutineNameAlt);
5225 6 : cp = state.dataPlnt->PlantLoop(varSpeedCoil.plantLoc.loopNum)
5226 6 : .glycol->getSpecificHeat(state, state.dataSize->PlantSizData(PltSizNum).ExitTemp, RoutineNameAlt);
5227 :
5228 6 : if (varSpeedCoil.VSCoilType == HVAC::Coil_HeatingWaterToAirHPVSEquationFit ||
5229 3 : varSpeedCoil.VSCoilType == HVAC::Coil_HeatingAirToAirVariableSpeed) {
5230 :
5231 3 : RatedWaterVolFlowRateDes = varSpeedCoil.RatedCapHeat / (state.dataSize->PlantSizData(PltSizNum).DeltaT * cp * rho);
5232 :
5233 3 : state.dataRptCoilSelection->coilSelectionReportObj->setCoilLvgWaterTemp(
5234 : state,
5235 3 : varSpeedCoil.Name,
5236 3 : varSpeedCoil.VarSpeedCoilType,
5237 3 : state.dataSize->PlantSizData(PltSizNum).ExitTemp +
5238 3 : state.dataSize->PlantSizData(PltSizNum).DeltaT); // TRACE 3D Plus coil selection report
5239 :
5240 3 : } 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 3 : if (varSpeedCoil.CompanionCoolingCoilNum > 0) {
5245 0 : SystemCapacity = state.dataVariableSpeedCoils->VarSpeedCoil(varSpeedCoil.CompanionCoolingCoilNum).RatedCapHeat;
5246 : } else {
5247 3 : SystemCapacity = varSpeedCoil.RatedCapCoolTotal;
5248 : }
5249 :
5250 3 : RatedWaterVolFlowRateDes = SystemCapacity / (state.dataSize->PlantSizData(PltSizNum).DeltaT * cp * rho);
5251 :
5252 3 : state.dataRptCoilSelection->coilSelectionReportObj->setCoilLvgWaterTemp(
5253 : state,
5254 3 : varSpeedCoil.Name,
5255 3 : varSpeedCoil.VarSpeedCoilType,
5256 3 : state.dataSize->PlantSizData(PltSizNum).ExitTemp -
5257 3 : state.dataSize->PlantSizData(PltSizNum).DeltaT); // TRACE 3D Plus coil selection report
5258 : }
5259 :
5260 6 : state.dataRptCoilSelection->coilSelectionReportObj->setCoilEntWaterTemp(
5261 : state,
5262 6 : varSpeedCoil.Name,
5263 6 : varSpeedCoil.VarSpeedCoilType,
5264 6 : state.dataSize->PlantSizData(PltSizNum).ExitTemp); // TRACE 3D Plus coil selection report
5265 :
5266 6 : state.dataRptCoilSelection->coilSelectionReportObj->setCoilWaterDeltaT(
5267 : state,
5268 6 : varSpeedCoil.Name,
5269 6 : varSpeedCoil.VarSpeedCoilType,
5270 6 : 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 6 : if (RatedCapCoolTotalAutoSized) {
5281 3 : RatedWaterVolFlowRateDes = varSpeedCoil.RatedCapCoolTotal * varSpeedCoil.MSRatedWaterVolFlowPerRatedTotCap(NormSpeed);
5282 3 : } else if (RatedCapHeatAutoSized) {
5283 3 : RatedWaterVolFlowRateDes = varSpeedCoil.RatedCapHeat * varSpeedCoil.MSRatedWaterVolFlowPerRatedTotCap(NormSpeed);
5284 : }
5285 6 : state.dataRptCoilSelection->coilSelectionReportObj->setCoilWaterFlowNodeNums(state,
5286 6 : varSpeedCoil.Name,
5287 6 : varSpeedCoil.VarSpeedCoilType,
5288 : RatedWaterVolFlowRateDes,
5289 : RatedWaterFlowAutoSized,
5290 : varSpeedCoil.WaterInletNodeNum,
5291 : varSpeedCoil.WaterOutletNodeNum,
5292 : varSpeedCoil.plantLoc.loopNum);
5293 6 : varSpeedCoil.RatedWaterVolFlowRate = RatedWaterVolFlowRateDes;
5294 18 : BaseSizer::reportSizerOutput(state,
5295 12 : 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 60 : for (Mode = 1; Mode <= varSpeedCoil.NumOfSpeeds - 1; ++Mode) {
5302 54 : 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 79 : 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 85 : if (varSpeedCoil.RatedWaterVolFlowRate > 0.0 && varSpeedCoil.VSCoilType == HVAC::CoilDX_HeatPumpWaterHeaterVariableSpeed) {
5344 14 : 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 71 : else if (varSpeedCoil.RatedWaterVolFlowRate > 0.0) {
5348 36 : PlantUtilities::RegisterPlantCompDesignFlow(state, varSpeedCoil.WaterInletNodeNum, 0.5 * varSpeedCoil.RatedWaterVolFlowRate);
5349 : }
5350 :
5351 85 : RatedSourceTempCool = GetVSCoilRatedSourceTemp(state, DXCoilNum);
5352 85 : if (varSpeedCoil.VSCoilType == HVAC::Coil_CoolingWaterToAirHPVSEquationFit ||
5353 67 : varSpeedCoil.VSCoilType == HVAC::Coil_HeatingWaterToAirHPVSEquationFit) {
5354 :
5355 36 : if (PltSizNum > 0) {
5356 6 : rhoW = rho;
5357 : } else {
5358 30 : rhoW = state.dataPlnt->PlantLoop(varSpeedCoil.plantLoc.loopNum).glycol->getDensity(state, RatedSourceTempCool, RoutineName);
5359 : }
5360 :
5361 36 : varSpeedCoil.RatedWaterMassFlowRate = varSpeedCoil.RatedWaterVolFlowRate * rhoW;
5362 396 : for (Mode = varSpeedCoil.NumOfSpeeds; Mode >= 1; --Mode) {
5363 360 : varSpeedCoil.MSRatedWaterVolFlowRate(Mode) = varSpeedCoil.MSRatedTotCap(Mode) * varSpeedCoil.MSRatedWaterVolFlowPerRatedTotCap(Mode);
5364 360 : varSpeedCoil.MSRatedWaterMassFlowRate(Mode) = varSpeedCoil.MSRatedWaterVolFlowRate(Mode) * rhoW;
5365 : }
5366 49 : } else if (varSpeedCoil.VSCoilType == HVAC::CoilDX_HeatPumpWaterHeaterVariableSpeed) {
5367 14 : rhoW = Psychrometrics::RhoH2O(RatedSourceTempCool);
5368 14 : varSpeedCoil.RatedWaterMassFlowRate = varSpeedCoil.RatedWaterVolFlowRate * rhoW;
5369 154 : for (Mode = varSpeedCoil.NumOfSpeeds; Mode >= 1; --Mode) {
5370 140 : varSpeedCoil.MSRatedWaterVolFlowRate(Mode) = varSpeedCoil.MSRatedTotCap(Mode) * varSpeedCoil.MSRatedWaterVolFlowPerRatedTotCap(Mode);
5371 140 : varSpeedCoil.MSWHPumpPower(Mode) = varSpeedCoil.MSRatedTotCap(Mode) * varSpeedCoil.MSWHPumpPowerPerRatedTotCap(Mode);
5372 140 : 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 780 : for (Mode = 1; Mode <= varSpeedCoil.NumOfSpeeds - 1; ++Mode) {
5379 695 : 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 780 : for (Mode = 1; Mode <= varSpeedCoil.NumOfSpeeds - 1; ++Mode) {
5395 695 : 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 85 : if (varSpeedCoil.VSCoilType == HVAC::Coil_CoolingWaterToAirHPVSEquationFit ||
5410 67 : varSpeedCoil.VSCoilType == HVAC::Coil_CoolingAirToAirVariableSpeed) {
5411 402 : for (Mode = 1; Mode <= varSpeedCoil.NumOfSpeeds; ++Mode) {
5412 360 : varSpeedCoil.MSRatedCBF(Mode) = DXCoils::CalcCBF(state,
5413 360 : varSpeedCoil.VarSpeedCoilType,
5414 360 : varSpeedCoil.Name,
5415 : RatedInletAirTemp,
5416 : RatedInletAirHumRat,
5417 360 : varSpeedCoil.MSRatedTotCap(Mode),
5418 360 : varSpeedCoil.MSRatedAirVolFlowRate(Mode),
5419 360 : varSpeedCoil.MSRatedSHR(Mode),
5420 : true);
5421 360 : if (varSpeedCoil.MSRatedCBF(Mode) > 0.0) {
5422 360 : varSpeedCoil.MSEffectiveAo(Mode) = -std::log(varSpeedCoil.MSRatedCBF(Mode)) * varSpeedCoil.MSRatedAirMassFlowRate(Mode);
5423 : } else {
5424 0 : varSpeedCoil.MSEffectiveAo(Mode) = 0.0;
5425 : }
5426 : }
5427 43 : } else if (varSpeedCoil.VSCoilType == HVAC::CoilDX_HeatPumpWaterHeaterVariableSpeed) {
5428 14 : state.dataHVACGlobal->HPWHInletDBTemp = varSpeedCoil.WHRatedInletDBTemp;
5429 14 : state.dataHVACGlobal->HPWHInletWBTemp = varSpeedCoil.WHRatedInletWBTemp;
5430 :
5431 154 : for (Mode = 1; Mode <= varSpeedCoil.NumOfSpeeds; ++Mode) {
5432 140 : varSpeedCoil.MSRatedAirMassFlowRate(Mode) = varSpeedCoil.MSRatedAirVolFlowRate(Mode) * rhoair;
5433 : }
5434 :
5435 154 : for (Mode = 1; Mode <= varSpeedCoil.NumOfSpeeds; ++Mode) {
5436 : // get cooling capacity, without fan power, i.e. total coil cooling
5437 140 : 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 140 : HPWHCoolCapacity = varSpeedCoil.MSRatedTotCap(Mode) * (1.0 - 1.0 / varSpeedCoil.MSRatedCOP(Mode)) -
5442 140 : varSpeedCoil.MSWHPumpPower(Mode) * varSpeedCoil.HPWHCondPumpFracToWater;
5443 : }
5444 :
5445 140 : varSpeedCoil.MSRatedCBF(Mode) = DXCoils::CalcCBF(state,
5446 140 : varSpeedCoil.VarSpeedCoilType,
5447 140 : varSpeedCoil.Name,
5448 140 : state.dataHVACGlobal->HPWHInletDBTemp,
5449 : HPInletAirHumRat,
5450 : HPWHCoolCapacity,
5451 140 : varSpeedCoil.MSRatedAirVolFlowRate(Mode),
5452 140 : varSpeedCoil.MSRatedSHR(Mode),
5453 : true);
5454 140 : if (varSpeedCoil.MSRatedCBF(Mode) > 0.0) {
5455 140 : 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 14 : Mode = varSpeedCoil.NormSpedLevel;
5463 14 : 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 14 : varSpeedCoil.RatedCapCoolTotal = varSpeedCoil.MSRatedTotCap(Mode) * (1.0 - 1.0 / varSpeedCoil.MSRatedCOP(Mode)) -
5469 14 : varSpeedCoil.MSWHPumpPower(Mode) * varSpeedCoil.HPWHCondPumpFracToWater;
5470 : }
5471 : }
5472 :
5473 : // size rated sensible cooling capacity
5474 85 : RatedCapCoolSensAutoSized = true; // always do that
5475 :
5476 85 : if (varSpeedCoil.RatedAirVolFlowRate >= HVAC::SmallAirVolFlow && (varSpeedCoil.VSCoilType == HVAC::Coil_CoolingWaterToAirHPVSEquationFit ||
5477 67 : varSpeedCoil.VSCoilType == HVAC::Coil_CoolingAirToAirVariableSpeed)) {
5478 42 : RatedAirMassFlowRate =
5479 42 : varSpeedCoil.RatedAirVolFlowRate *
5480 42 : Psychrometrics::PsyRhoAirFnPbTdbW(state, state.dataEnvrn->StdBaroPress, RatedInletAirTemp, RatedInletAirHumRat, RoutineName);
5481 42 : RatedInletEnth = Psychrometrics::PsyHFnTdbW(RatedInletAirTemp, RatedInletAirHumRat);
5482 42 : CBFRated = DXCoils::AdjustCBF(varSpeedCoil.MSRatedCBF(NormSpeed), varSpeedCoil.MSRatedAirMassFlowRate(NormSpeed), RatedAirMassFlowRate);
5483 42 : if (CBFRated > 0.999) {
5484 0 : CBFRated = 0.999;
5485 : }
5486 42 : if (varSpeedCoil.MSRatedAirMassFlowRate(NormSpeed) > 1.0e-10) {
5487 42 : AirMassFlowRatio = RatedAirMassFlowRate / varSpeedCoil.MSRatedAirMassFlowRate(NormSpeed);
5488 : } else {
5489 0 : AirMassFlowRatio = 1.0;
5490 : }
5491 :
5492 42 : if (varSpeedCoil.MSRatedWaterVolFlowRate(NormSpeed) > 1.0e-10) {
5493 18 : WaterMassFlowRatio = varSpeedCoil.RatedWaterVolFlowRate / varSpeedCoil.MSRatedWaterVolFlowRate(NormSpeed);
5494 : } else {
5495 24 : WaterMassFlowRatio = 1.0;
5496 : }
5497 :
5498 42 : Real64 TempInletWetBulb = RatedInletWetBulbTemp;
5499 210 : CalcTotCapSHR_VSWSHP(state,
5500 : RatedInletAirTemp,
5501 : RatedInletAirHumRat,
5502 : RatedInletEnth,
5503 : TempInletWetBulb,
5504 : AirMassFlowRatio,
5505 : WaterMassFlowRatio,
5506 : RatedAirMassFlowRate,
5507 : CBFRated,
5508 42 : varSpeedCoil.MSRatedTotCap(NormSpeed),
5509 42 : varSpeedCoil.MSCCapFTemp(NormSpeed),
5510 42 : varSpeedCoil.MSCCapAirFFlow(NormSpeed),
5511 42 : varSpeedCoil.MSCCapWaterFFlow(NormSpeed),
5512 : 0.0,
5513 : 0,
5514 : 0,
5515 : 0,
5516 : QLoadTotal1,
5517 : QLoadTotal2,
5518 : QLoadTotal,
5519 : SHR,
5520 : RatedSourceTempCool,
5521 42 : state.dataEnvrn->StdBaroPress,
5522 : 0.0,
5523 : 1,
5524 42 : varSpeedCoil.capModFacTotal);
5525 :
5526 42 : RatedCapCoolSensDes = varSpeedCoil.RatedCapCoolTotal * SHR;
5527 85 : } else if (varSpeedCoil.RatedAirVolFlowRate >= HVAC::SmallAirVolFlow &&
5528 43 : varSpeedCoil.VSCoilType == HVAC::CoilDX_HeatPumpWaterHeaterVariableSpeed) {
5529 14 : SHR = varSpeedCoil.MSRatedSHR(NormSpeed);
5530 14 : RatedCapCoolSensDes = varSpeedCoil.RatedCapCoolTotal * SHR;
5531 : } else {
5532 29 : RatedCapCoolSensDes = 0.0;
5533 : }
5534 :
5535 85 : if (RatedCapCoolSensDes < HVAC::SmallLoad) {
5536 29 : RatedCapCoolSensDes = 0.0;
5537 : }
5538 :
5539 85 : if (varSpeedCoil.VSCoilType == HVAC::Coil_CoolingWaterToAirHPVSEquationFit ||
5540 67 : varSpeedCoil.VSCoilType == HVAC::Coil_CoolingAirToAirVariableSpeed) { // always report for cooling mode
5541 42 : if (RatedCapCoolTotalAutoSized) {
5542 18 : varSpeedCoil.RatedCapCoolSens = RatedCapCoolSensDes;
5543 54 : BaseSizer::reportSizerOutput(state,
5544 36 : 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 24 : if (RatedCapCoolSensDes > 0.0) {
5552 24 : varSpeedCoil.RatedCapCoolSens = RatedCapCoolSensDes;
5553 72 : BaseSizer::reportSizerOutput(state,
5554 48 : format("COIL:{}{}", varSpeedCoil.CoolHeatType, CurrentObjSubfix),
5555 : varSpeedCoil.Name,
5556 : "Design Size Rated Sensible Cooling Capacity [W]",
5557 : RatedCapCoolSensDes); //, &
5558 : }
5559 : }
5560 84 : OutputReportPredefined::PreDefTableEntry(
5561 42 : state, state.dataOutRptPredefined->pdchCoolCoilTotCap, varSpeedCoil.Name, varSpeedCoil.RatedCapCoolTotal);
5562 84 : OutputReportPredefined::PreDefTableEntry(
5563 42 : state, state.dataOutRptPredefined->pdchCoolCoilSensCap, varSpeedCoil.Name, varSpeedCoil.RatedCapCoolSens);
5564 84 : OutputReportPredefined::PreDefTableEntry(state,
5565 42 : state.dataOutRptPredefined->pdchCoolCoilLatCap,
5566 : varSpeedCoil.Name,
5567 42 : varSpeedCoil.RatedCapCoolTotal - varSpeedCoil.RatedCapCoolSens);
5568 42 : if (varSpeedCoil.RatedCapCoolTotal != 0.0) {
5569 84 : OutputReportPredefined::PreDefTableEntry(state,
5570 42 : state.dataOutRptPredefined->pdchCoolCoilSHR,
5571 : varSpeedCoil.Name,
5572 42 : varSpeedCoil.RatedCapCoolSens / varSpeedCoil.RatedCapCoolTotal);
5573 : } else {
5574 0 : OutputReportPredefined::PreDefTableEntry(state, state.dataOutRptPredefined->pdchCoolCoilSHR, varSpeedCoil.Name, 0.0);
5575 : }
5576 84 : OutputReportPredefined::PreDefTableEntry(
5577 42 : state, state.dataOutRptPredefined->pdchCoolCoilNomEff, varSpeedCoil.Name, varSpeedCoil.MSRatedCOP(varSpeedCoil.NormSpedLevel));
5578 84 : OutputReportPredefined::addFootNoteSubTable(
5579 : state,
5580 42 : 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 85 : IsAutoSize = false;
5586 85 : if (varSpeedCoil.VSCoilType == HVAC::Coil_CoolingAirToAirVariableSpeed) {
5587 24 : 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 24 : EvapCondPumpElecNomPowerDes = varSpeedCoil.RatedCapCoolTotal * 0.004266;
5592 24 : 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 24 : 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 85 : IsAutoSize = false;
5636 85 : if (varSpeedCoil.VSCoilType == HVAC::Coil_HeatingAirToAirVariableSpeed) {
5637 11 : if (varSpeedCoil.DefrostCapacity == DataSizing::AutoSize) {
5638 2 : IsAutoSize = true;
5639 : }
5640 11 : if (varSpeedCoil.DefrostStrategy == Resistive) {
5641 11 : DefrostCapacityDes = varSpeedCoil.RatedCapHeat;
5642 : } else {
5643 0 : DefrostCapacityDes = 0.0;
5644 : }
5645 11 : if (IsAutoSize) {
5646 2 : varSpeedCoil.DefrostCapacity = DefrostCapacityDes;
5647 2 : BaseSizer::reportSizerOutput(
5648 : state, "AS VS HEATING COIL", varSpeedCoil.Name, "Design Size Resistive Defrost Heater Capacity [W]", DefrostCapacityDes);
5649 : } else {
5650 9 : if (varSpeedCoil.DefrostCapacity > 0.0 && DefrostCapacityDes > 0.0 && !HardSizeNoDesRun) {
5651 3 : DefrostCapacityUser = varSpeedCoil.DefrostCapacity;
5652 3 : 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 3 : 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 85 : if (RatedCapCoolSensAutoSized && RatedCapCoolTotalAutoSized) {
5680 18 : 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 67 : } 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 170 : Array1D<DataHeatBalance::RefrigCondenserType> CondenserType;
5728 : StandardRatings::HPdefrostControl DefrostControl;
5729 85 : switch (varSpeedCoil.VSCoilType) {
5730 24 : case HVAC::Coil_CoolingAirToAirVariableSpeed:
5731 24 : CondenserType.push_back(varSpeedCoil.CondenserType);
5732 24 : 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 24 : case 1:
5738 : default:
5739 24 : DefrostControl = StandardRatings::HPdefrostControl::Timed;
5740 24 : break;
5741 : }
5742 24 : if (varSpeedCoil.RatedCapCoolTotal > 0.0) {
5743 144 : StandardRatings::CalcDXCoilStandardRating(state,
5744 24 : varSpeedCoil.Name,
5745 24 : 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 24 : varSpeedCoil.PLFFPLR,
5755 : varSpeedCoil.MSRatedAirVolFlowRate,
5756 : varSpeedCoil.MSRatedEvaporatorFanPowerPerVolumeFlowRate2017,
5757 : varSpeedCoil.MSRatedEvaporatorFanPowerPerVolumeFlowRate2023,
5758 : CondenserType,
5759 48 : 0, // varSpeedCoil.RegionNum, // ??
5760 24 : varSpeedCoil.MinOATCompressor,
5761 24 : varSpeedCoil.OATempCompressorOn,
5762 48 : false, // varSpeedCoil.OATempCompressorOnOffBlank, // ??
5763 : DefrostControl,
5764 48 : ObjexxFCL::Optional_bool_const(),
5765 24 : varSpeedCoil.RatedCapCoolTotal,
5766 24 : varSpeedCoil.RatedAirVolFlowRate);
5767 : }
5768 24 : break;
5769 61 : default:
5770 61 : break;
5771 : }
5772 85 : }
5773 :
5774 37952571 : 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 37952571 : 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 37952571 : Real64 rhoair(0); // entering air density
5860 :
5861 37952571 : if (state.dataVariableSpeedCoils->firstTime) {
5862 : // Set indoor air conditions to the rated condition
5863 20 : state.dataVariableSpeedCoils->LoadSideInletDBTemp_Init = 26.7;
5864 20 : state.dataVariableSpeedCoils->LoadSideInletHumRat_Init = 0.0111;
5865 20 : state.dataVariableSpeedCoils->LoadSideInletEnth_Init = Psychrometrics::PsyHFnTdbW(state.dataVariableSpeedCoils->LoadSideInletDBTemp_Init,
5866 20 : state.dataVariableSpeedCoils->LoadSideInletHumRat_Init);
5867 20 : state.dataVariableSpeedCoils->CpAir_Init = Psychrometrics::PsyCpAirFnW(state.dataVariableSpeedCoils->LoadSideInletHumRat_Init);
5868 20 : state.dataVariableSpeedCoils->firstTime = false;
5869 : }
5870 :
5871 75905142 : state.dataVariableSpeedCoils->LoadSideInletWBTemp_Init =
5872 37952571 : Psychrometrics::PsyTwbFnTdbWPb(state,
5873 37952571 : state.dataVariableSpeedCoils->LoadSideInletDBTemp_Init,
5874 37952571 : state.dataVariableSpeedCoils->LoadSideInletHumRat_Init,
5875 37952571 : state.dataEnvrn->OutBaroPress,
5876 : RoutineName);
5877 :
5878 37952571 : 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 37952571 : if (SpeedNum > MaxSpeed) {
5882 0 : SpeedCal = MaxSpeed;
5883 : } else {
5884 37952571 : SpeedCal = SpeedNum;
5885 : }
5886 :
5887 : // LOAD LOCAL VARIABLES FROM DATA STRUCTURE (for code readability)
5888 37952571 : if (!(fanOp == HVAC::FanOp::Continuous) && PartLoadRatio > 0.0) {
5889 372475 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).AirMassFlowRate =
5890 372475 : state.dataLoopNodes->Node(state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).AirInletNodeNum).MassFlowRate / PartLoadRatio;
5891 : }
5892 :
5893 37952571 : Twet_Rated = state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Twet_Rated;
5894 37952571 : Gamma_Rated = state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Gamma_Rated;
5895 :
5896 37952571 : state.dataVariableSpeedCoils->LoadSideMassFlowRate = state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).AirMassFlowRate;
5897 :
5898 37952571 : if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).VSCoilType == HVAC::Coil_CoolingAirToAirVariableSpeed) {
5899 : // Get condenser outdoor node info from DX COOLING Coil
5900 33430760 : if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).CondenserInletNodeNum != 0) {
5901 52990 : state.dataVariableSpeedCoils->OutdoorDryBulb_CalcVarSpeedCoilCooling =
5902 26495 : state.dataLoopNodes->Node(state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).CondenserInletNodeNum).Temp;
5903 52990 : state.dataVariableSpeedCoils->OutdoorHumRat_CalcVarSpeedCoilCooling =
5904 26495 : state.dataLoopNodes->Node(state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).CondenserInletNodeNum).HumRat;
5905 52990 : state.dataVariableSpeedCoils->OutdoorPressure_CalcVarSpeedCoilCooling =
5906 26495 : state.dataLoopNodes->Node(state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).CondenserInletNodeNum).Press;
5907 26495 : state.dataVariableSpeedCoils->OutdoorWetBulb_CalcVarSpeedCoilCooling =
5908 26495 : state.dataLoopNodes->Node(state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).CondenserInletNodeNum).OutAirWetBulb;
5909 : } else {
5910 33404265 : state.dataVariableSpeedCoils->OutdoorDryBulb_CalcVarSpeedCoilCooling = state.dataEnvrn->OutDryBulbTemp;
5911 33404265 : state.dataVariableSpeedCoils->OutdoorHumRat_CalcVarSpeedCoilCooling = state.dataEnvrn->OutHumRat;
5912 33404265 : state.dataVariableSpeedCoils->OutdoorPressure_CalcVarSpeedCoilCooling = state.dataEnvrn->OutBaroPress;
5913 33404265 : state.dataVariableSpeedCoils->OutdoorWetBulb_CalcVarSpeedCoilCooling = state.dataEnvrn->OutWetBulbTemp;
5914 : }
5915 :
5916 66861520 : RhoSourceAir = Psychrometrics::PsyRhoAirFnPbTdbW(state,
5917 33430760 : state.dataVariableSpeedCoils->OutdoorPressure_CalcVarSpeedCoilCooling,
5918 33430760 : state.dataVariableSpeedCoils->OutdoorDryBulb_CalcVarSpeedCoilCooling,
5919 33430760 : state.dataVariableSpeedCoils->OutdoorHumRat_CalcVarSpeedCoilCooling);
5920 :
5921 33430760 : if ((SpeedNum == 1) || (SpeedNum > MaxSpeed) || (SpeedRatio == 1.0)) {
5922 26715771 : CondAirMassFlow = RhoSourceAir * state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).EvapCondAirFlow(SpeedCal);
5923 : } else {
5924 6714989 : CondAirMassFlow =
5925 6714989 : RhoSourceAir * (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).EvapCondAirFlow(SpeedCal) * SpeedRatio +
5926 6714989 : (1.0 - SpeedRatio) * state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).EvapCondAirFlow(SpeedCal - 1));
5927 : }
5928 :
5929 : // AIR COOL OR EVAP COOLED CONDENSER
5930 33430760 : 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 33430760 : CondInletTemp = state.dataVariableSpeedCoils->OutdoorDryBulb_CalcVarSpeedCoilCooling; // Outdoor dry-bulb temp
5949 66861520 : state.dataVariableSpeedCoils->CompAmbTemp_CalcVarSpeedCoilCooling =
5950 33430760 : state.dataVariableSpeedCoils->OutdoorDryBulb_CalcVarSpeedCoilCooling;
5951 33430760 : CondInletHumRat = state.dataEnvrn->OutHumRat;
5952 : }
5953 :
5954 33430760 : state.dataVariableSpeedCoils->SourceSideMassFlowRate = CondAirMassFlow;
5955 33430760 : state.dataVariableSpeedCoils->SourceSideInletTemp = CondInletTemp;
5956 33430760 : state.dataVariableSpeedCoils->SourceSideInletEnth = Psychrometrics::PsyHFnTdbW(CondInletTemp, CondInletHumRat);
5957 33430760 : CpSource = Psychrometrics::PsyCpAirFnW(CondInletHumRat);
5958 33430760 : 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 33430760 : if (state.dataVariableSpeedCoils->OutdoorDryBulb_CalcVarSpeedCoilCooling <
5963 33430760 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MaxOATCrankcaseHeater) {
5964 2741460 : state.dataVariableSpeedCoils->CrankcaseHeatingPower_CalcVarSpeedCoilCooling =
5965 1370730 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).CrankcaseHeaterCapacity;
5966 1370730 : if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).CrankcaseHeaterCapacityCurveIndex > 0) {
5967 125599 : state.dataVariableSpeedCoils->CrankcaseHeatingPower_CalcVarSpeedCoilCooling *=
5968 125599 : Curve::CurveValue(state,
5969 125599 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).CrankcaseHeaterCapacityCurveIndex,
5970 125599 : state.dataEnvrn->OutDryBulbTemp);
5971 : }
5972 : } else {
5973 32060030 : state.dataVariableSpeedCoils->CrankcaseHeatingPower_CalcVarSpeedCoilCooling = 0.0;
5974 : }
5975 : } else {
5976 4521811 : state.dataVariableSpeedCoils->SourceSideMassFlowRate = state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).WaterMassFlowRate;
5977 4521811 : state.dataVariableSpeedCoils->SourceSideInletTemp = state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).InletWaterTemp;
5978 4521811 : state.dataVariableSpeedCoils->SourceSideInletEnth = state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).InletWaterEnthalpy;
5979 4521811 : CpSource = state.dataPlnt->PlantLoop(state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).plantLoc.loopNum)
5980 4521811 : .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 37952571 : if (state.dataVariableSpeedCoils->SourceSideMassFlowRate <= 0.0 || state.dataVariableSpeedCoils->LoadSideMassFlowRate <= 0.0) {
5985 :
5986 9528426 : if ((state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).VSCoilType == HVAC::Coil_CoolingAirToAirVariableSpeed) &&
5987 16650790 : (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).CondenserType == DataHeatBalance::RefrigCondenserType::Air) &&
5988 7122364 : (state.dataVariableSpeedCoils->LoadSideMassFlowRate > 0.0)) {
5989 : // ALLOW SIMULATION IF AIR-COOLED CONDENSER COIL
5990 308249 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).SimFlag = true;
5991 : } else {
5992 9220177 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).SimFlag = false;
5993 9279042 : return;
5994 : }
5995 : } else {
5996 28424145 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).SimFlag = true;
5997 : }
5998 :
5999 28732394 : if (compressorOp == HVAC::CompressorOp::Off || state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).RatedCapCoolTotal <= 0.0) {
6000 58865 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).SimFlag = false;
6001 58865 : return;
6002 : }
6003 :
6004 55232843 : if ((state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).VSCoilType == HVAC::Coil_CoolingAirToAirVariableSpeed) &&
6005 26559314 : (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 28673529 : if ((PartLoadRatio < 1e-10) || (Twet_Rated <= 0.0) || (Gamma_Rated <= 0.0) || (SpeedNum > 1.0)) {
6014 28656447 : LatDegradModelSimFlag = false;
6015 : // Set NumIteration=1 so that latent model would quit after 1 simulation with the actual condition
6016 28656447 : NumIteration = 1;
6017 : } else {
6018 17082 : LatDegradModelSimFlag = true;
6019 : // Set NumIteration=0 so that latent model would simulate twice with rated and actual condition
6020 17082 : NumIteration = 0;
6021 : }
6022 :
6023 : // Set indoor air conditions to the actual condition
6024 28673529 : LoadSideInletDBTemp_Unit = state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).InletAirDBTemp;
6025 28673529 : LoadSideInletHumRat_Unit = state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).InletAirHumRat;
6026 : LoadSideInletWBTemp_Unit =
6027 28673529 : Psychrometrics::PsyTwbFnTdbWPb(state, LoadSideInletDBTemp_Unit, LoadSideInletHumRat_Unit, state.dataEnvrn->OutBaroPress, RoutineName);
6028 28673529 : LoadSideInletEnth_Unit = state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).InletAirEnthalpy;
6029 28673529 : CpAir_Unit = Psychrometrics::PsyCpAirFnW(LoadSideInletHumRat_Unit);
6030 :
6031 28673529 : state.dataHVACGlobal->OnOffFanPartLoadFraction = 1.0;
6032 28673529 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).RunFrac = 1.0;
6033 28673529 : if ((SpeedNum == 1) && (PartLoadRatio < 1.0)) {
6034 4074674 : PLF = Curve::CurveValue(state, state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).PLFFPLR, PartLoadRatio);
6035 4074674 : if (PLF < 0.7) {
6036 0 : PLF = 0.7;
6037 : }
6038 4074674 : if (fanOp == HVAC::FanOp::Cycling) {
6039 59408 : 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 4074674 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).RunFrac = PartLoadRatio / PLF;
6044 4074674 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).PartLoadRatio = PartLoadRatio;
6045 :
6046 4074674 : 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 4074674 : } 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 28690611 : ++NumIteration;
6055 28690611 : if (NumIteration == 1) {
6056 : // Set indoor air conditions to the rated conditions
6057 17082 : state.dataVariableSpeedCoils->LoadSideInletDBTemp = state.dataVariableSpeedCoils->LoadSideInletDBTemp_Init;
6058 17082 : state.dataVariableSpeedCoils->LoadSideInletHumRat = state.dataVariableSpeedCoils->LoadSideInletHumRat_Init;
6059 17082 : state.dataVariableSpeedCoils->LoadSideInletWBTemp = state.dataVariableSpeedCoils->LoadSideInletWBTemp_Init;
6060 17082 : state.dataVariableSpeedCoils->LoadSideInletEnth = state.dataVariableSpeedCoils->LoadSideInletEnth_Init;
6061 17082 : CpAir = state.dataVariableSpeedCoils->CpAir_Init;
6062 : } else {
6063 : // Set indoor air conditions to the actual condition
6064 28673529 : state.dataVariableSpeedCoils->LoadSideInletDBTemp = LoadSideInletDBTemp_Unit;
6065 28673529 : state.dataVariableSpeedCoils->LoadSideInletHumRat = LoadSideInletHumRat_Unit;
6066 28673529 : state.dataVariableSpeedCoils->LoadSideInletWBTemp = LoadSideInletWBTemp_Unit;
6067 28673529 : state.dataVariableSpeedCoils->LoadSideInletEnth = LoadSideInletEnth_Unit;
6068 28673529 : CpAir = CpAir_Unit;
6069 : }
6070 :
6071 : // must be placed inside the loop, otherwise cause bug in release mode
6072 28690611 : if (SpeedNum > MaxSpeed) {
6073 0 : SpeedCal = MaxSpeed;
6074 : } else {
6075 28690611 : SpeedCal = SpeedNum;
6076 : }
6077 :
6078 28690611 : if ((SpeedNum == 1) || (SpeedNum > MaxSpeed) || (SpeedRatio == 1.0)) {
6079 21633676 : AirMassFlowRatio =
6080 21633676 : state.dataVariableSpeedCoils->LoadSideMassFlowRate / state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).DesignAirMassFlowRate;
6081 :
6082 21633676 : if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).VSCoilType == HVAC::Coil_CoolingAirToAirVariableSpeed) {
6083 19861419 : WaterMassFlowRatio = 1.0;
6084 : } else {
6085 1772257 : WaterMassFlowRatio = state.dataVariableSpeedCoils->SourceSideMassFlowRate /
6086 1772257 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).DesignWaterMassFlowRate;
6087 : }
6088 :
6089 21633676 : CBFSpeed = DXCoils::AdjustCBF(state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedCBF(SpeedCal),
6090 21633676 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedAirMassFlowRate(SpeedCal),
6091 21633676 : state.dataVariableSpeedCoils->LoadSideMassFlowRate);
6092 :
6093 21633676 : if (CBFSpeed > 0.999) {
6094 0 : CBFSpeed = 0.999;
6095 : }
6096 :
6097 21633676 : CalcTotCapSHR_VSWSHP(state,
6098 21633676 : state.dataVariableSpeedCoils->LoadSideInletDBTemp,
6099 21633676 : state.dataVariableSpeedCoils->LoadSideInletHumRat,
6100 21633676 : state.dataVariableSpeedCoils->LoadSideInletEnth,
6101 21633676 : state.dataVariableSpeedCoils->LoadSideInletWBTemp,
6102 : AirMassFlowRatio,
6103 : WaterMassFlowRatio,
6104 21633676 : state.dataVariableSpeedCoils->LoadSideMassFlowRate,
6105 : CBFSpeed,
6106 21633676 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedTotCap(SpeedCal),
6107 21633676 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSCCapFTemp(SpeedCal),
6108 21633676 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSCCapAirFFlow(SpeedCal),
6109 21633676 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSCCapWaterFFlow(SpeedCal),
6110 : 0.0,
6111 : 0,
6112 : 0,
6113 : 0,
6114 : QLoadTotal1,
6115 : QLoadTotal2,
6116 21633676 : state.dataVariableSpeedCoils->QLoadTotal,
6117 : SHR,
6118 21633676 : state.dataVariableSpeedCoils->SourceSideInletTemp,
6119 21633676 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).InletAirPressure,
6120 : 0.0,
6121 : 1,
6122 21633676 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).capModFacTotal);
6123 :
6124 86534704 : EIRTempModFac = Curve::CurveValue(state,
6125 21633676 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSEIRFTemp(SpeedCal),
6126 21633676 : state.dataVariableSpeedCoils->LoadSideInletWBTemp,
6127 21633676 : state.dataVariableSpeedCoils->SourceSideInletTemp);
6128 : EIRAirFFModFac =
6129 21633676 : Curve::CurveValue(state, state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSEIRAirFFlow(SpeedCal), AirMassFlowRatio);
6130 :
6131 21633676 : if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).VSCoilType == HVAC::Coil_CoolingAirToAirVariableSpeed) {
6132 19861419 : EIRWaterFFModFac = 1.0;
6133 : } else {
6134 : EIRWaterFFModFac =
6135 1772257 : Curve::CurveValue(state, state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSEIRWaterFFlow(SpeedCal), WaterMassFlowRatio);
6136 : }
6137 :
6138 21633676 : EIR = (1.0 / state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedCOP(SpeedCal)) * EIRTempModFac * EIRAirFFModFac *
6139 : EIRWaterFFModFac;
6140 :
6141 21633676 : CBFSpeed = DXCoils::AdjustCBF(state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedCBF(SpeedCal),
6142 21633676 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedAirMassFlowRate(SpeedCal),
6143 21633676 : state.dataVariableSpeedCoils->LoadSideMassFlowRate);
6144 :
6145 21633676 : if (CBFSpeed > 0.999) {
6146 0 : CBFSpeed = 0.999;
6147 : }
6148 :
6149 21633676 : CalcTotCapSHR_VSWSHP(state,
6150 21633676 : state.dataVariableSpeedCoils->LoadSideInletDBTemp,
6151 21633676 : state.dataVariableSpeedCoils->LoadSideInletHumRat,
6152 21633676 : state.dataVariableSpeedCoils->LoadSideInletEnth,
6153 21633676 : state.dataVariableSpeedCoils->LoadSideInletWBTemp,
6154 : AirMassFlowRatio,
6155 : WaterMassFlowRatio,
6156 21633676 : state.dataVariableSpeedCoils->LoadSideMassFlowRate,
6157 : CBFSpeed,
6158 21633676 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedTotCap(SpeedCal),
6159 21633676 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSCCapFTemp(SpeedCal),
6160 21633676 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSCCapAirFFlow(SpeedCal),
6161 21633676 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSCCapWaterFFlow(SpeedCal),
6162 : 0.0,
6163 : 0,
6164 : 0,
6165 : 0,
6166 : QLoadTotal1,
6167 : QLoadTotal2,
6168 21633676 : state.dataVariableSpeedCoils->QLoadTotal,
6169 : SHR,
6170 21633676 : state.dataVariableSpeedCoils->SourceSideInletTemp,
6171 21633676 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).InletAirPressure,
6172 : 0.0,
6173 : 1,
6174 21633676 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).capModFacTotal);
6175 :
6176 21633676 : state.dataVariableSpeedCoils->Winput = state.dataVariableSpeedCoils->QLoadTotal * EIR;
6177 :
6178 43267352 : if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).VSCoilType == HVAC::Coil_CoolingAirToAirVariableSpeed) {
6179 19861419 : QWasteHeat = 0.0;
6180 : } else {
6181 1772257 : QWasteHeat =
6182 1772257 : state.dataVariableSpeedCoils->Winput * state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSWasteHeatFrac(SpeedCal);
6183 1772257 : QWasteHeat *= Curve::CurveValue(state,
6184 1772257 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSWasteHeat(SpeedCal),
6185 1772257 : state.dataVariableSpeedCoils->LoadSideInletWBTemp,
6186 1772257 : state.dataVariableSpeedCoils->SourceSideInletTemp);
6187 : }
6188 : } else {
6189 7056935 : AirMassFlowRatio =
6190 7056935 : state.dataVariableSpeedCoils->LoadSideMassFlowRate / state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).DesignAirMassFlowRate;
6191 :
6192 7056935 : if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).VSCoilType == HVAC::Coil_CoolingAirToAirVariableSpeed) {
6193 6714977 : WaterMassFlowRatio = 1.0;
6194 : } else {
6195 341958 : WaterMassFlowRatio = state.dataVariableSpeedCoils->SourceSideMassFlowRate /
6196 341958 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).DesignWaterMassFlowRate;
6197 : }
6198 :
6199 7056935 : AoEff = state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSEffectiveAo(SpeedCal) * SpeedRatio +
6200 7056935 : (1.0 - SpeedRatio) * state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSEffectiveAo(SpeedCal - 1);
6201 :
6202 7056935 : CBFSpeed = std::exp(-AoEff / state.dataVariableSpeedCoils->LoadSideMassFlowRate);
6203 :
6204 7056935 : if (CBFSpeed > 0.999) {
6205 0 : CBFSpeed = 0.999;
6206 : }
6207 :
6208 7056935 : CalcTotCapSHR_VSWSHP(state,
6209 7056935 : state.dataVariableSpeedCoils->LoadSideInletDBTemp,
6210 7056935 : state.dataVariableSpeedCoils->LoadSideInletHumRat,
6211 7056935 : state.dataVariableSpeedCoils->LoadSideInletEnth,
6212 7056935 : state.dataVariableSpeedCoils->LoadSideInletWBTemp,
6213 : AirMassFlowRatio,
6214 : WaterMassFlowRatio,
6215 7056935 : state.dataVariableSpeedCoils->LoadSideMassFlowRate,
6216 : CBFSpeed,
6217 7056935 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedTotCap(SpeedCal - 1),
6218 7056935 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSCCapFTemp(SpeedCal - 1),
6219 7056935 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSCCapAirFFlow(SpeedCal - 1),
6220 7056935 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSCCapWaterFFlow(SpeedCal - 1),
6221 7056935 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedTotCap(SpeedCal),
6222 7056935 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSCCapFTemp(SpeedCal),
6223 7056935 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSCCapAirFFlow(SpeedCal),
6224 7056935 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSCCapWaterFFlow(SpeedCal),
6225 : QLoadTotal1,
6226 : QLoadTotal2,
6227 7056935 : state.dataVariableSpeedCoils->QLoadTotal,
6228 : SHR,
6229 7056935 : state.dataVariableSpeedCoils->SourceSideInletTemp,
6230 7056935 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).InletAirPressure,
6231 : SpeedRatio,
6232 : 2,
6233 7056935 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).capModFacTotal);
6234 :
6235 7056935 : SpeedCal = SpeedNum - 1;
6236 28227740 : EIRTempModFac = Curve::CurveValue(state,
6237 7056935 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSEIRFTemp(SpeedCal),
6238 7056935 : state.dataVariableSpeedCoils->LoadSideInletWBTemp,
6239 7056935 : state.dataVariableSpeedCoils->SourceSideInletTemp);
6240 : EIRAirFFModFac =
6241 7056935 : Curve::CurveValue(state, state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSEIRAirFFlow(SpeedCal), AirMassFlowRatio);
6242 :
6243 7056935 : if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).VSCoilType == HVAC::Coil_CoolingAirToAirVariableSpeed) {
6244 6714977 : EIRWaterFFModFac = 1.0;
6245 : } else {
6246 : EIRWaterFFModFac =
6247 341958 : Curve::CurveValue(state, state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSEIRWaterFFlow(SpeedCal), WaterMassFlowRatio);
6248 : }
6249 :
6250 7056935 : EIR = (1.0 / state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedCOP(SpeedCal)) * EIRTempModFac * EIRAirFFModFac *
6251 : EIRWaterFFModFac;
6252 7056935 : Winput1 = QLoadTotal1 * EIR;
6253 :
6254 7056935 : if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).VSCoilType == HVAC::Coil_CoolingAirToAirVariableSpeed) {
6255 6714977 : QWasteHeat1 = 0.0;
6256 : } else {
6257 341958 : QWasteHeat1 = Winput1 * state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSWasteHeatFrac(SpeedCal);
6258 341958 : QWasteHeat1 *= Curve::CurveValue(state,
6259 341958 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSWasteHeat(SpeedCal),
6260 341958 : state.dataVariableSpeedCoils->LoadSideInletWBTemp,
6261 341958 : state.dataVariableSpeedCoils->SourceSideInletTemp);
6262 : }
6263 :
6264 7056935 : SpeedCal = SpeedNum;
6265 28227740 : EIRTempModFac = Curve::CurveValue(state,
6266 7056935 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSEIRFTemp(SpeedCal),
6267 7056935 : state.dataVariableSpeedCoils->LoadSideInletWBTemp,
6268 7056935 : state.dataVariableSpeedCoils->SourceSideInletTemp);
6269 : EIRAirFFModFac =
6270 7056935 : Curve::CurveValue(state, state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSEIRAirFFlow(SpeedCal), AirMassFlowRatio);
6271 :
6272 7056935 : if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).VSCoilType == HVAC::Coil_CoolingAirToAirVariableSpeed) {
6273 6714977 : EIRWaterFFModFac = 1.0;
6274 : } else {
6275 : EIRWaterFFModFac =
6276 341958 : Curve::CurveValue(state, state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSEIRWaterFFlow(SpeedCal), WaterMassFlowRatio);
6277 : }
6278 :
6279 7056935 : EIR = (1.0 / state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedCOP(SpeedCal)) * EIRTempModFac * EIRAirFFModFac *
6280 : EIRWaterFFModFac;
6281 7056935 : Winput2 = QLoadTotal2 * EIR;
6282 :
6283 7056935 : if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).VSCoilType == HVAC::Coil_CoolingAirToAirVariableSpeed) {
6284 6714977 : QWasteHeat2 = 0.0;
6285 : } else {
6286 341958 : QWasteHeat2 = Winput2 * state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSWasteHeatFrac(SpeedCal);
6287 341958 : QWasteHeat2 *= Curve::CurveValue(state,
6288 341958 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSWasteHeat(SpeedCal),
6289 341958 : state.dataVariableSpeedCoils->LoadSideInletWBTemp,
6290 341958 : state.dataVariableSpeedCoils->SourceSideInletTemp);
6291 : }
6292 :
6293 7056935 : state.dataVariableSpeedCoils->Winput = Winput2 * SpeedRatio + (1.0 - SpeedRatio) * Winput1;
6294 7056935 : QWasteHeat = QWasteHeat2 * SpeedRatio + (1.0 - SpeedRatio) * QWasteHeat1;
6295 : }
6296 :
6297 28690611 : state.dataVariableSpeedCoils->QSensible = state.dataVariableSpeedCoils->QLoadTotal * SHR;
6298 :
6299 28690611 : state.dataVariableSpeedCoils->QSource = state.dataVariableSpeedCoils->QLoadTotal + state.dataVariableSpeedCoils->Winput - QWasteHeat;
6300 :
6301 28690611 : 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 28690611 : if (state.dataVariableSpeedCoils->QSensible > state.dataVariableSpeedCoils->QLoadTotal) {
6308 0 : state.dataVariableSpeedCoils->QSensible = state.dataVariableSpeedCoils->QLoadTotal;
6309 : }
6310 :
6311 28690611 : if (LatDegradModelSimFlag) {
6312 : // Calculate for SHReff using the Latent Degradation Model
6313 34164 : if (NumIteration == 1) {
6314 17082 : state.dataVariableSpeedCoils->QLatRated = state.dataVariableSpeedCoils->QLoadTotal - state.dataVariableSpeedCoils->QSensible;
6315 17082 : } else if (NumIteration == 2) {
6316 17082 : state.dataVariableSpeedCoils->QLatActual = state.dataVariableSpeedCoils->QLoadTotal - state.dataVariableSpeedCoils->QSensible;
6317 17082 : SHRss = state.dataVariableSpeedCoils->QSensible / state.dataVariableSpeedCoils->QLoadTotal;
6318 102492 : SHReff = CalcEffectiveSHR(state,
6319 : DXCoilNum,
6320 : SHRss,
6321 : fanOp,
6322 17082 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).RunFrac,
6323 17082 : state.dataVariableSpeedCoils->QLatRated,
6324 17082 : state.dataVariableSpeedCoils->QLatActual,
6325 17082 : state.dataVariableSpeedCoils->LoadSideInletDBTemp,
6326 17082 : state.dataVariableSpeedCoils->LoadSideInletWBTemp);
6327 : // Update sensible capacity based on effective SHR
6328 17082 : state.dataVariableSpeedCoils->QSensible = state.dataVariableSpeedCoils->QLoadTotal * SHReff;
6329 17082 : goto LOOP_exit;
6330 : }
6331 : } else {
6332 : // Assume SHReff=SHRss
6333 28656447 : SHReff = state.dataVariableSpeedCoils->QSensible / state.dataVariableSpeedCoils->QLoadTotal;
6334 28656447 : goto LOOP_exit;
6335 : }
6336 : }
6337 28673529 : LOOP_exit:;
6338 :
6339 : // considering hot gas reheat here
6340 28673529 : if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).HOTGASREHEATFLG > 0) {
6341 1619941 : state.dataVariableSpeedCoils->QLoadTotal -= QWasteHeat;
6342 1619941 : state.dataVariableSpeedCoils->QSensible -= QWasteHeat;
6343 1619941 : SHReff = state.dataVariableSpeedCoils->QSensible / state.dataVariableSpeedCoils->QLoadTotal;
6344 : }
6345 :
6346 28673529 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).BasinHeaterPower = 0.0;
6347 28673529 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).CrankcaseHeaterPower = 0.0;
6348 :
6349 28673529 : if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).VSCoilType == HVAC::Coil_CoolingAirToAirVariableSpeed) {
6350 26559314 : 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 26559314 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).CrankcaseHeaterPower =
6374 26559314 : state.dataVariableSpeedCoils->CrankcaseHeatingPower_CalcVarSpeedCoilCooling *
6375 26559314 : (1.0 - state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).RunFrac);
6376 :
6377 : // set water system demand request (if needed)
6378 26559314 : 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 28673529 : if ((PartLoadRatio > 0.0 && fanOp == HVAC::FanOp::Continuous) || (fanOp == HVAC::FanOp::Cycling)) {
6386 : // calculate coil outlet state variables
6387 55903534 : state.dataVariableSpeedCoils->LoadSideOutletEnth =
6388 27951767 : state.dataVariableSpeedCoils->LoadSideInletEnth -
6389 27951767 : state.dataVariableSpeedCoils->QLoadTotal / state.dataVariableSpeedCoils->LoadSideMassFlowRate;
6390 55903534 : state.dataVariableSpeedCoils->LoadSideOutletDBTemp =
6391 27951767 : state.dataVariableSpeedCoils->LoadSideInletDBTemp -
6392 27951767 : state.dataVariableSpeedCoils->QSensible / (state.dataVariableSpeedCoils->LoadSideMassFlowRate * CpAir);
6393 :
6394 27951767 : MaxHumRat = Psychrometrics::PsyWFnTdbRhPb(state,
6395 27951767 : state.dataVariableSpeedCoils->LoadSideOutletDBTemp,
6396 : 0.9999,
6397 27951767 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).InletAirPressure,
6398 : RoutineName);
6399 27951767 : MaxOutletEnth = Psychrometrics::PsyHFnTdbW(state.dataVariableSpeedCoils->LoadSideOutletDBTemp, MaxHumRat);
6400 27951767 : if (state.dataVariableSpeedCoils->LoadSideOutletEnth > MaxOutletEnth) {
6401 153073 : state.dataVariableSpeedCoils->LoadSideOutletEnth = MaxOutletEnth;
6402 : // QLoadTotal = LoadSideMassFlowRate * (LoadSideInletEnth - LoadSideOutletEnth)
6403 : }
6404 27951767 : state.dataVariableSpeedCoils->LoadSideOutletHumRat = Psychrometrics::PsyWFnTdbH(
6405 27951767 : state, state.dataVariableSpeedCoils->LoadSideOutletDBTemp, state.dataVariableSpeedCoils->LoadSideOutletEnth, RoutineName);
6406 27951767 : if (state.dataVariableSpeedCoils->LoadSideOutletHumRat > MaxHumRat) {
6407 16939 : state.dataVariableSpeedCoils->LoadSideOutletHumRat = MaxHumRat;
6408 : }
6409 : }
6410 :
6411 : // Actual outlet conditions are "average" for time step
6412 28673529 : if (fanOp == HVAC::FanOp::Continuous) {
6413 : // continuous fan, cycling compressor
6414 28301060 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).OutletAirEnthalpy =
6415 28301060 : PartLoadRatio * state.dataVariableSpeedCoils->LoadSideOutletEnth +
6416 28301060 : (1.0 - PartLoadRatio) * state.dataVariableSpeedCoils->LoadSideInletEnth;
6417 28301060 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).OutletAirHumRat =
6418 28301060 : PartLoadRatio * state.dataVariableSpeedCoils->LoadSideOutletHumRat +
6419 28301060 : (1.0 - PartLoadRatio) * state.dataVariableSpeedCoils->LoadSideInletHumRat;
6420 28301060 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).OutletAirDBTemp =
6421 28301060 : Psychrometrics::PsyTdbFnHW(state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).OutletAirEnthalpy,
6422 28301060 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).OutletAirHumRat);
6423 28301060 : state.dataVariableSpeedCoils->PLRCorrLoadSideMdot = state.dataVariableSpeedCoils->LoadSideMassFlowRate;
6424 : } else {
6425 : // default to cycling fan, cycling compressor
6426 372469 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).OutletAirEnthalpy = state.dataVariableSpeedCoils->LoadSideOutletEnth;
6427 372469 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).OutletAirHumRat = state.dataVariableSpeedCoils->LoadSideOutletHumRat;
6428 372469 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).OutletAirDBTemp = state.dataVariableSpeedCoils->LoadSideOutletDBTemp;
6429 372469 : state.dataVariableSpeedCoils->PLRCorrLoadSideMdot = state.dataVariableSpeedCoils->LoadSideMassFlowRate * PartLoadRatio;
6430 : }
6431 :
6432 : // scale heat transfer rates to PLR and power to RTF
6433 28673529 : state.dataVariableSpeedCoils->QLoadTotal *= PartLoadRatio;
6434 28673529 : state.dataVariableSpeedCoils->QSensible *= PartLoadRatio;
6435 : // count the powr separately
6436 28673529 : state.dataVariableSpeedCoils->Winput *= state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).RunFrac;
6437 28673529 : state.dataVariableSpeedCoils->QSource *= PartLoadRatio;
6438 28673529 : QWasteHeat *= PartLoadRatio;
6439 :
6440 : // Update heat pump data structure
6441 28673529 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Power = state.dataVariableSpeedCoils->Winput;
6442 28673529 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).QLoadTotal = state.dataVariableSpeedCoils->QLoadTotal;
6443 28673529 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).QSensible = state.dataVariableSpeedCoils->QSensible;
6444 28673529 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).QLatent =
6445 28673529 : state.dataVariableSpeedCoils->QLoadTotal - state.dataVariableSpeedCoils->QSensible;
6446 28673529 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Energy = state.dataVariableSpeedCoils->Winput * TimeStepSysSec;
6447 28673529 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).EnergyLoadTotal = state.dataVariableSpeedCoils->QLoadTotal * TimeStepSysSec;
6448 28673529 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).EnergySensible = state.dataVariableSpeedCoils->QSensible * TimeStepSysSec;
6449 28673529 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).EnergyLatent =
6450 28673529 : (state.dataVariableSpeedCoils->QLoadTotal - state.dataVariableSpeedCoils->QSensible) * TimeStepSysSec;
6451 28673529 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).CrankcaseHeaterConsumption =
6452 28673529 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).CrankcaseHeaterPower * TimeStepSysSec;
6453 28673529 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).EvapWaterConsump =
6454 28673529 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).EvapWaterConsumpRate * TimeStepSysSec;
6455 28673529 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).BasinHeaterConsumption =
6456 28673529 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).BasinHeaterPower * TimeStepSysSec;
6457 28673529 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).EvapCondPumpElecConsumption =
6458 28673529 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).EvapCondPumpElecPower * TimeStepSysSec;
6459 28673529 : if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).RunFrac == 0.0) {
6460 721762 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).COP = 0.0;
6461 : } else {
6462 27951767 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).COP =
6463 27951767 : state.dataVariableSpeedCoils->QLoadTotal / state.dataVariableSpeedCoils->Winput;
6464 : }
6465 28673529 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).PartLoadRatio = PartLoadRatio;
6466 28673529 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).AirMassFlowRate = state.dataVariableSpeedCoils->PLRCorrLoadSideMdot;
6467 28673529 : rhoair = Psychrometrics::PsyRhoAirFnPbTdbW(state,
6468 28673529 : state.dataEnvrn->OutBaroPress,
6469 28673529 : state.dataVariableSpeedCoils->LoadSideInletDBTemp,
6470 28673529 : 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 28673529 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).AirVolFlowRate =
6476 28673529 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).AirMassFlowRate / rhoair;
6477 :
6478 28673529 : if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).VSCoilType == HVAC::Coil_CoolingAirToAirVariableSpeed) {
6479 26559314 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).WaterMassFlowRate = 0.0;
6480 26559314 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).OutletWaterTemp = 0.0;
6481 26559314 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).OutletWaterEnthalpy = 0.0;
6482 26559314 : state.dataHeatBal->HeatReclaimVS_Coil(DXCoilNum).AvailCapacity = state.dataVariableSpeedCoils->QSource;
6483 26559314 : if (state.dataHeatBal->HeatReclaimVS_Coil(DXCoilNum).WaterHeatingDesuperheaterReclaimedHeatTotal > 0.0) {
6484 42678 : state.dataVariableSpeedCoils->QSource -= state.dataHeatBal->HeatReclaimVS_Coil(DXCoilNum).WaterHeatingDesuperheaterReclaimedHeatTotal;
6485 : }
6486 : } else {
6487 2114215 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).WaterMassFlowRate = state.dataVariableSpeedCoils->SourceSideMassFlowRate;
6488 2114215 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).OutletWaterTemp =
6489 2114215 : state.dataVariableSpeedCoils->SourceSideInletTemp +
6490 2114215 : state.dataVariableSpeedCoils->QSource / (state.dataVariableSpeedCoils->SourceSideMassFlowRate * CpSource);
6491 2114215 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).OutletWaterEnthalpy =
6492 2114215 : state.dataVariableSpeedCoils->SourceSideInletEnth +
6493 2114215 : state.dataVariableSpeedCoils->QSource / state.dataVariableSpeedCoils->SourceSideMassFlowRate;
6494 2114215 : state.dataHeatBal->HeatReclaimVS_Coil(DXCoilNum).AvailCapacity = state.dataVariableSpeedCoils->QSource;
6495 2114215 : if (state.dataHeatBal->HeatReclaimVS_Coil(DXCoilNum).WaterHeatingDesuperheaterReclaimedHeatTotal > 0.0) {
6496 0 : state.dataVariableSpeedCoils->QSource -= state.dataHeatBal->HeatReclaimVS_Coil(DXCoilNum).WaterHeatingDesuperheaterReclaimedHeatTotal;
6497 : }
6498 : }
6499 28673529 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).QSource = state.dataVariableSpeedCoils->QSource;
6500 28673529 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).EnergySource = state.dataVariableSpeedCoils->QSource * TimeStepSysSec;
6501 :
6502 28673529 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).QWasteHeat = QWasteHeat;
6503 :
6504 28673529 : 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 1599176 : 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 1599176 : 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 1599176 : Real64 rhoair = 0.0; // entering air density
6596 1599176 : Real64 RhoWater = 0.0; // water density
6597 :
6598 : // note: load side is the evaporator side, and source side is the condenser side
6599 :
6600 1599176 : int CondInletNode = state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).WaterInletNodeNum;
6601 1599176 : int CondOutletNode = state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).WaterOutletNodeNum;
6602 : // If heat pump water heater is OFF, set outlet to inlet and RETURN
6603 1599176 : if (PartLoadRatio == 0.0) {
6604 1019091 : state.dataLoopNodes->Node(CondOutletNode) = state.dataLoopNodes->Node(CondInletNode);
6605 1019091 : return;
6606 : } else {
6607 580085 : EvapInletNode = state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).AirInletNodeNum;
6608 580085 : InletWaterTemp = state.dataLoopNodes->Node(CondInletNode).Temp;
6609 580085 : CondInletMassFlowRate = state.dataLoopNodes->Node(CondInletNode).MassFlowRate;
6610 580085 : EvapInletMassFlowRate = state.dataLoopNodes->Node(EvapInletNode).MassFlowRate;
6611 580085 : CpWater = Psychrometrics::CPHW(InletWaterTemp);
6612 580085 : CompressorPower = 0.0;
6613 580085 : OperatingHeatingPower = 0.0;
6614 580085 : TankHeatingCOP = 0.0;
6615 : }
6616 :
6617 : // LOAD LOCAL VARIABLES FROM DATA STRUCTURE (for code readability)
6618 580085 : if (!(fanOp == HVAC::FanOp::Continuous) && PartLoadRatio > 0.0) {
6619 580085 : CondInletMassFlowRate = CondInletMassFlowRate / PartLoadRatio;
6620 580085 : EvapInletMassFlowRate = EvapInletMassFlowRate / PartLoadRatio;
6621 : }
6622 :
6623 580085 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).AirMassFlowRate = EvapInletMassFlowRate;
6624 580085 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).WaterMassFlowRate = CondInletMassFlowRate;
6625 :
6626 : // determine inlet air temperature type for curve objects
6627 580085 : if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).InletAirTemperatureType == HVAC::OATType::WetBulb) {
6628 580085 : InletAirTemp = state.dataHVACGlobal->HPWHInletWBTemp;
6629 : } else {
6630 0 : InletAirTemp = state.dataHVACGlobal->HPWHInletDBTemp;
6631 : }
6632 :
6633 : // check if indoor evaporator or outdoor evaporator
6634 580085 : Real64 CrankcaseHeatingPower = 0.0;
6635 580085 : if (EvapInletNode != 0) {
6636 580085 : state.dataVariableSpeedCoils->LoadSideInletDBTemp = state.dataLoopNodes->Node(EvapInletNode).Temp;
6637 580085 : state.dataVariableSpeedCoils->LoadSideInletHumRat = state.dataLoopNodes->Node(EvapInletNode).HumRat;
6638 580085 : LoadPressure = state.dataLoopNodes->Node(EvapInletNode).Press;
6639 : // prevent the air pressure not given
6640 580085 : if (LoadPressure < 10.0) {
6641 0 : LoadPressure = state.dataEnvrn->OutBaroPress;
6642 : }
6643 :
6644 580085 : state.dataVariableSpeedCoils->LoadSideInletWBTemp = state.dataLoopNodes->Node(EvapInletNode).OutAirWetBulb;
6645 580085 : 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 580085 : state.dataVariableSpeedCoils->LoadSideMassFlowRate = EvapInletMassFlowRate;
6666 580085 : state.dataVariableSpeedCoils->SourceSideMassFlowRate = CondInletMassFlowRate;
6667 580085 : state.dataVariableSpeedCoils->SourceSideInletTemp = InletWaterTemp;
6668 580085 : state.dataVariableSpeedCoils->SourceSideInletEnth = state.dataLoopNodes->Node(CondInletNode).Enthalpy;
6669 580085 : 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 580085 : if ((state.dataVariableSpeedCoils->SourceSideMassFlowRate <= 0.0) || (state.dataVariableSpeedCoils->LoadSideMassFlowRate <= 0.0)) {
6673 548 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).SimFlag = false;
6674 548 : return;
6675 : } else {
6676 579537 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).SimFlag = true;
6677 : }
6678 :
6679 : // part-load calculation
6680 579537 : state.dataHVACGlobal->OnOffFanPartLoadFraction = 1.0;
6681 579537 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).RunFrac = 1.0;
6682 579537 : if ((SpeedNum == 1) && (PartLoadRatio < 1.0)) {
6683 14830 : PLF = Curve::CurveValue(state, state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).PLFFPLR, PartLoadRatio);
6684 14830 : if (PLF < 0.7) {
6685 0 : PLF = 0.7;
6686 : }
6687 14830 : if (fanOp == HVAC::FanOp::Cycling) {
6688 14830 : 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 14830 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).RunFrac = PartLoadRatio / PLF;
6693 14830 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).PartLoadRatio = PartLoadRatio;
6694 :
6695 14830 : 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 14830 : } else if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).RunFrac < 0.0) {
6698 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).RunFrac = 0.0;
6699 : }
6700 : }
6701 :
6702 579537 : 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 579537 : if (SpeedNum > MaxSpeed) {
6707 0 : SpeedCal = MaxSpeed;
6708 : } else {
6709 579537 : SpeedCal = SpeedNum;
6710 : }
6711 :
6712 579537 : Real64 locFanElecPower = 0.0; // local for fan electric power
6713 579537 : if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).SupplyFanIndex > 0) {
6714 492163 : locFanElecPower = state.dataFans->fans(state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).SupplyFanIndex)->totalPower;
6715 : }
6716 579537 : if ((SpeedNum == 1) || (SpeedNum > MaxSpeed) || (SpeedRatio == 1.0)) {
6717 472348 : AirMassFlowRatio =
6718 472348 : state.dataVariableSpeedCoils->LoadSideMassFlowRate / state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).DesignAirMassFlowRate;
6719 472348 : WaterMassFlowRatio =
6720 472348 : state.dataVariableSpeedCoils->SourceSideMassFlowRate / state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).DesignWaterMassFlowRate;
6721 472348 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).HPWHCondPumpElecNomPower =
6722 472348 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSWHPumpPower(SpeedCal);
6723 :
6724 1417044 : COPTempModFac = Curve::CurveValue(state,
6725 472348 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSEIRFTemp(SpeedCal),
6726 : InletAirTemp,
6727 472348 : state.dataVariableSpeedCoils->SourceSideInletTemp);
6728 : COPAirFFModFac =
6729 472348 : Curve::CurveValue(state, state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSEIRAirFFlow(SpeedCal), AirMassFlowRatio);
6730 : COPWaterFFModFac =
6731 472348 : Curve::CurveValue(state, state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSEIRWaterFFlow(SpeedCal), WaterMassFlowRatio);
6732 :
6733 472348 : COP = state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedCOP(SpeedCal) * COPTempModFac * COPAirFFModFac * COPWaterFFModFac;
6734 :
6735 1417044 : TOTCAPTempModFac = Curve::CurveValue(state,
6736 472348 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSCCapFTemp(SpeedCal),
6737 : InletAirTemp,
6738 472348 : state.dataVariableSpeedCoils->SourceSideInletTemp);
6739 : // Get capacity modifying factor (function of mass flow) for off-rated conditions
6740 : TOTCAPAirFFModFac =
6741 472348 : 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 472348 : Curve::CurveValue(state, state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSCCapWaterFFlow(SpeedCal), WaterMassFlowRatio);
6745 :
6746 472348 : OperatingHeatingCapacity = state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedTotCap(SpeedCal) * TOTCAPTempModFac *
6747 : TOTCAPAirFFModFac * TOTCAPWaterFFModFac;
6748 :
6749 472348 : state.dataVariableSpeedCoils->Winput = OperatingHeatingCapacity / COP;
6750 472348 : OperatingHeatingPower = state.dataVariableSpeedCoils->Winput;
6751 :
6752 472348 : OperatingHeatingCOP = COP;
6753 472348 : PumpHeatToWater = state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).HPWHCondPumpElecNomPower *
6754 472348 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).HPWHCondPumpFracToWater;
6755 472348 : TankHeatingCOP = OperatingHeatingCOP;
6756 :
6757 : // account for pump heat if not included in total water heating capacity
6758 472348 : if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).CondPumpHeatInCapacity) {
6759 0 : TotalTankHeatingCapacity = OperatingHeatingCapacity;
6760 : } else {
6761 472348 : TotalTankHeatingCapacity = OperatingHeatingCapacity + PumpHeatToWater;
6762 : }
6763 :
6764 : // calculate evaporator total cooling capacity
6765 472348 : if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).FanPowerIncludedInCOP) {
6766 8473 : 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 8473 : CompressorPower = OperatingHeatingPower - locFanElecPower / state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).RunFrac;
6775 8473 : if ((OperatingHeatingPower + state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).HPWHCondPumpElecNomPower) > 0.0) {
6776 8473 : TankHeatingCOP = TotalTankHeatingCapacity /
6777 8473 : (OperatingHeatingPower + state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).HPWHCondPumpElecNomPower);
6778 : }
6779 : }
6780 : } else {
6781 463875 : 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 463875 : CompressorPower = OperatingHeatingPower;
6790 463875 : if ((OperatingHeatingPower + locFanElecPower / state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).RunFrac +
6791 463875 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).HPWHCondPumpElecNomPower) > 0.0) {
6792 463875 : TankHeatingCOP = TotalTankHeatingCapacity /
6793 463875 : (OperatingHeatingPower + locFanElecPower / state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).RunFrac +
6794 463875 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).HPWHCondPumpElecNomPower);
6795 : }
6796 : }
6797 : }
6798 :
6799 472348 : if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).CondPumpHeatInCapacity) {
6800 0 : EvapCoolingCapacity = TotalTankHeatingCapacity - PumpHeatToWater - CompressorPower;
6801 : } else {
6802 472348 : EvapCoolingCapacity = TotalTankHeatingCapacity - CompressorPower;
6803 : }
6804 :
6805 472348 : CBFSpeed = DXCoils::AdjustCBF(state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedCBF(SpeedCal),
6806 472348 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedAirMassFlowRate(SpeedCal),
6807 472348 : state.dataVariableSpeedCoils->LoadSideMassFlowRate);
6808 :
6809 : } else {
6810 107189 : AirMassFlowRatio =
6811 107189 : state.dataVariableSpeedCoils->LoadSideMassFlowRate / state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).DesignAirMassFlowRate;
6812 107189 : WaterMassFlowRatio =
6813 107189 : state.dataVariableSpeedCoils->SourceSideMassFlowRate / state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).DesignWaterMassFlowRate;
6814 107189 : AoEff = state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSEffectiveAo(SpeedCal) * SpeedRatio +
6815 107189 : (1.0 - SpeedRatio) * state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSEffectiveAo(SpeedCal - 1);
6816 107189 : CBFSpeed = std::exp(-AoEff / state.dataVariableSpeedCoils->LoadSideMassFlowRate);
6817 :
6818 : // calculate low speed
6819 107189 : SpeedCal = SpeedNum - 1;
6820 :
6821 107189 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).HPWHCondPumpElecNomPower =
6822 107189 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSWHPumpPower(SpeedCal);
6823 321567 : COPTempModFac = Curve::CurveValue(state,
6824 107189 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSEIRFTemp(SpeedCal),
6825 : InletAirTemp,
6826 107189 : state.dataVariableSpeedCoils->SourceSideInletTemp);
6827 : COPAirFFModFac =
6828 107189 : Curve::CurveValue(state, state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSEIRAirFFlow(SpeedCal), AirMassFlowRatio);
6829 : COPWaterFFModFac =
6830 107189 : Curve::CurveValue(state, state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSEIRWaterFFlow(SpeedCal), WaterMassFlowRatio);
6831 :
6832 107189 : COP = state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedCOP(SpeedCal) * COPTempModFac * COPAirFFModFac * COPWaterFFModFac;
6833 :
6834 321567 : TOTCAPTempModFac = Curve::CurveValue(state,
6835 107189 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSCCapFTemp(SpeedCal),
6836 : InletAirTemp,
6837 107189 : state.dataVariableSpeedCoils->SourceSideInletTemp);
6838 : // Get capacity modifying factor (function of mass flow) for off-rated conditions
6839 : TOTCAPAirFFModFac =
6840 107189 : 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 107189 : Curve::CurveValue(state, state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSCCapWaterFFlow(SpeedCal), WaterMassFlowRatio);
6844 :
6845 107189 : OperatingHeatingCapacity = state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedTotCap(SpeedCal) * TOTCAPTempModFac *
6846 : TOTCAPAirFFModFac * TOTCAPWaterFFModFac;
6847 :
6848 107189 : state.dataVariableSpeedCoils->Winput = OperatingHeatingCapacity / COP;
6849 107189 : Winput1 = state.dataVariableSpeedCoils->Winput;
6850 107189 : WHCAP1 = OperatingHeatingCapacity;
6851 :
6852 : // calculate upper speed
6853 107189 : SpeedCal = SpeedNum;
6854 :
6855 107189 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).HPWHCondPumpElecNomPower =
6856 107189 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSWHPumpPower(SpeedCal);
6857 321567 : COPTempModFac = Curve::CurveValue(state,
6858 107189 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSEIRFTemp(SpeedCal),
6859 : InletAirTemp,
6860 107189 : state.dataVariableSpeedCoils->SourceSideInletTemp);
6861 : COPAirFFModFac =
6862 107189 : Curve::CurveValue(state, state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSEIRAirFFlow(SpeedCal), AirMassFlowRatio);
6863 : COPWaterFFModFac =
6864 107189 : Curve::CurveValue(state, state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSEIRWaterFFlow(SpeedCal), WaterMassFlowRatio);
6865 :
6866 107189 : COP = state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedCOP(SpeedCal) * COPTempModFac * COPAirFFModFac * COPWaterFFModFac;
6867 :
6868 321567 : TOTCAPTempModFac = Curve::CurveValue(state,
6869 107189 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSCCapFTemp(SpeedCal),
6870 : InletAirTemp,
6871 107189 : state.dataVariableSpeedCoils->SourceSideInletTemp);
6872 : // Get capacity modifying factor (function of mass flow) for off-rated conditions
6873 : TOTCAPAirFFModFac =
6874 107189 : 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 107189 : Curve::CurveValue(state, state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSCCapWaterFFlow(SpeedCal), WaterMassFlowRatio);
6878 :
6879 107189 : OperatingHeatingCapacity = state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedTotCap(SpeedCal) * TOTCAPTempModFac *
6880 : TOTCAPAirFFModFac * TOTCAPWaterFFModFac;
6881 :
6882 107189 : Winput2 = OperatingHeatingCapacity / COP;
6883 107189 : WHCAP2 = OperatingHeatingCapacity;
6884 :
6885 : // interpolation
6886 107189 : state.dataVariableSpeedCoils->Winput = Winput2 * SpeedRatio + (1.0 - SpeedRatio) * Winput1;
6887 107189 : OperatingHeatingPower = state.dataVariableSpeedCoils->Winput;
6888 107189 : OperatingHeatingCapacity = WHCAP2 * SpeedRatio + (1.0 - SpeedRatio) * WHCAP1;
6889 107189 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).HPWHCondPumpElecNomPower =
6890 107189 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSWHPumpPower(SpeedNum) * SpeedRatio +
6891 107189 : (1.0 - SpeedRatio) * state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSWHPumpPower(SpeedNum - 1);
6892 :
6893 107189 : OperatingHeatingCOP = OperatingHeatingCapacity / OperatingHeatingPower;
6894 107189 : TankHeatingCOP = OperatingHeatingCOP;
6895 :
6896 107189 : PumpHeatToWater = state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).HPWHCondPumpElecNomPower *
6897 107189 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).HPWHCondPumpFracToWater;
6898 :
6899 : // account for pump heat if not included in total water heating capacity
6900 107189 : if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).CondPumpHeatInCapacity) {
6901 0 : TotalTankHeatingCapacity = OperatingHeatingCapacity;
6902 : } else {
6903 107189 : TotalTankHeatingCapacity = OperatingHeatingCapacity + PumpHeatToWater;
6904 : }
6905 :
6906 107189 : Real64 HPRTF = state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).RunFrac;
6907 : // calculate evaporator total cooling capacity
6908 107189 : if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).FanPowerIncludedInCOP) {
6909 1266 : 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 1266 : CompressorPower = OperatingHeatingPower - locFanElecPower / HPRTF;
6918 1266 : if ((OperatingHeatingPower + state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).HPWHCondPumpElecNomPower) > 0.0) {
6919 1266 : TankHeatingCOP = TotalTankHeatingCapacity /
6920 1266 : (OperatingHeatingPower + state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).HPWHCondPumpElecNomPower);
6921 : }
6922 : }
6923 : } else {
6924 105923 : 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 105923 : CompressorPower = OperatingHeatingPower;
6932 211846 : if ((OperatingHeatingPower + locFanElecPower / HPRTF +
6933 105923 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).HPWHCondPumpElecNomPower) > 0.0) {
6934 211846 : TankHeatingCOP = TotalTankHeatingCapacity / (OperatingHeatingPower + locFanElecPower / HPRTF +
6935 105923 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).HPWHCondPumpElecNomPower);
6936 : }
6937 : }
6938 : }
6939 :
6940 107189 : if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).CondPumpHeatInCapacity) {
6941 0 : EvapCoolingCapacity = TotalTankHeatingCapacity - PumpHeatToWater - CompressorPower;
6942 : } else {
6943 107189 : EvapCoolingCapacity = TotalTankHeatingCapacity - CompressorPower;
6944 : }
6945 : }
6946 :
6947 579537 : state.dataVariableSpeedCoils->QSource = TotalTankHeatingCapacity;
6948 579537 : state.dataVariableSpeedCoils->QLoadTotal = EvapCoolingCapacity;
6949 579537 : state.dataHVACGlobal->DXCoilTotalCapacity = EvapCoolingCapacity; // for standard rating calculation
6950 579537 : SHR = 1.0;
6951 : // if indoor, calculate SHR
6952 579537 : if (EvapInletNode != 0) {
6953 579537 : if (CBFSpeed > 0.999) {
6954 0 : CBFSpeed = 0.999;
6955 : }
6956 :
6957 579537 : if (CBFSpeed < 0.001) {
6958 682 : SHR = 1.0;
6959 : } else {
6960 578855 : hDelta = state.dataVariableSpeedCoils->QLoadTotal / state.dataVariableSpeedCoils->LoadSideMassFlowRate;
6961 578855 : hADP = state.dataVariableSpeedCoils->LoadSideInletEnth - hDelta / (1.0 - CBFSpeed);
6962 578855 : tADP = Psychrometrics::PsyTsatFnHPb(state, hADP, LoadPressure, RoutineName);
6963 578855 : wADP = Psychrometrics::PsyWFnTdbH(state, tADP, hADP, RoutineName);
6964 578855 : hTinwADP = Psychrometrics::PsyHFnTdbW(state.dataVariableSpeedCoils->LoadSideInletDBTemp, wADP);
6965 578855 : if ((state.dataVariableSpeedCoils->LoadSideInletEnth - hADP) > 1.e-10) {
6966 578855 : SHR = min((hTinwADP - hADP) / (state.dataVariableSpeedCoils->LoadSideInletEnth - hADP), 1.0);
6967 : } else {
6968 0 : SHR = 1.0;
6969 : }
6970 : }
6971 : }
6972 :
6973 579537 : state.dataVariableSpeedCoils->QSensible = state.dataVariableSpeedCoils->QLoadTotal * SHR;
6974 :
6975 : // determine condenser water inlet/outlet condition at full capacity
6976 579537 : if (CondInletMassFlowRate == 0.0) {
6977 0 : OutletWaterTemp = InletWaterTemp;
6978 : } else {
6979 579537 : OutletWaterTemp = InletWaterTemp + TotalTankHeatingCapacity / (CpWater * CondInletMassFlowRate);
6980 : }
6981 :
6982 579537 : state.dataLoopNodes->Node(CondOutletNode).Temp = OutletWaterTemp;
6983 :
6984 579537 : 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 579537 : state.dataVariableSpeedCoils->VSHPWHHeatingCapacity = TotalTankHeatingCapacity;
6989 : // total heating COP including compressor, fan, and condenser pump
6990 579537 : state.dataVariableSpeedCoils->VSHPWHHeatingCOP = TankHeatingCOP;
6991 :
6992 579537 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).TotalHeatingEnergyRate = TotalTankHeatingCapacity * PartLoadRatio;
6993 : // calculate total compressor plus condenser pump power, fan power reported in fan module
6994 579537 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).ElecWaterHeatingPower =
6995 579537 : (CompressorPower + state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).HPWHCondPumpElecNomPower) *
6996 579537 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).RunFrac;
6997 :
6998 : // pass the outputs for the cooling coil section
6999 579537 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).BasinHeaterPower = 0.0;
7000 579537 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).CrankcaseHeaterPower =
7001 579537 : CrankcaseHeatingPower * (1.0 - state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).RunFrac);
7002 :
7003 : // calculate coil outlet state variables
7004 1159074 : state.dataVariableSpeedCoils->LoadSideOutletEnth =
7005 579537 : state.dataVariableSpeedCoils->LoadSideInletEnth -
7006 579537 : state.dataVariableSpeedCoils->QLoadTotal / state.dataVariableSpeedCoils->LoadSideMassFlowRate;
7007 579537 : CpAir = Psychrometrics::PsyCpAirFnW(state.dataVariableSpeedCoils->LoadSideInletHumRat);
7008 1159074 : state.dataVariableSpeedCoils->LoadSideOutletDBTemp =
7009 579537 : state.dataVariableSpeedCoils->LoadSideInletDBTemp -
7010 579537 : state.dataVariableSpeedCoils->QSensible / (state.dataVariableSpeedCoils->LoadSideMassFlowRate * CpAir);
7011 :
7012 579537 : MaxHumRat = Psychrometrics::PsyWFnTdbRhPb(state,
7013 579537 : state.dataVariableSpeedCoils->LoadSideOutletDBTemp,
7014 : 0.9999,
7015 579537 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).InletAirPressure,
7016 : RoutineName);
7017 579537 : MaxOutletEnth = Psychrometrics::PsyHFnTdbW(state.dataVariableSpeedCoils->LoadSideOutletDBTemp, MaxHumRat);
7018 579537 : if (state.dataVariableSpeedCoils->LoadSideOutletEnth > MaxOutletEnth) {
7019 682 : state.dataVariableSpeedCoils->LoadSideOutletEnth = MaxOutletEnth;
7020 : }
7021 579537 : state.dataVariableSpeedCoils->LoadSideOutletHumRat = Psychrometrics::PsyWFnTdbH(
7022 579537 : state, state.dataVariableSpeedCoils->LoadSideOutletDBTemp, state.dataVariableSpeedCoils->LoadSideOutletEnth, RoutineName);
7023 579537 : if (state.dataVariableSpeedCoils->LoadSideOutletHumRat > MaxHumRat) {
7024 283 : state.dataVariableSpeedCoils->LoadSideOutletHumRat = MaxHumRat;
7025 : }
7026 :
7027 : // Actual outlet conditions are "average" for time step
7028 579537 : 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 579537 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).OutletAirEnthalpy = state.dataVariableSpeedCoils->LoadSideOutletEnth;
7042 579537 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).OutletAirHumRat = state.dataVariableSpeedCoils->LoadSideOutletHumRat;
7043 579537 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).OutletAirDBTemp = state.dataVariableSpeedCoils->LoadSideOutletDBTemp;
7044 579537 : state.dataVariableSpeedCoils->PLRCorrLoadSideMdot = state.dataVariableSpeedCoils->LoadSideMassFlowRate * PartLoadRatio;
7045 : }
7046 :
7047 : // scale heat transfer rates to PLR and power to RTF
7048 579537 : state.dataVariableSpeedCoils->QLoadTotal *= PartLoadRatio;
7049 579537 : state.dataVariableSpeedCoils->QSensible *= PartLoadRatio;
7050 : // count the powr separately
7051 1159074 : state.dataVariableSpeedCoils->Winput *=
7052 579537 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).RunFrac; //+ VarSpeedCoil(DXCoilNum)%CrankcaseHeaterPower &
7053 : //+ VarSpeedCoil(DXCoilNum)%BasinHeaterPower + VarSpeedCoil(DXCoilNum)%EvapCondPumpElecPower
7054 579537 : state.dataVariableSpeedCoils->QSource *= PartLoadRatio;
7055 :
7056 : // Update heat pump data structure
7057 579537 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).HPWHCondPumpElecNomPower =
7058 579537 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).HPWHCondPumpElecNomPower *
7059 579537 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).RunFrac; // water heating pump power
7060 579537 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Power = state.dataVariableSpeedCoils->Winput;
7061 579537 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).QLoadTotal = state.dataVariableSpeedCoils->QLoadTotal;
7062 579537 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).QSensible = state.dataVariableSpeedCoils->QSensible;
7063 579537 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).QLatent =
7064 579537 : state.dataVariableSpeedCoils->QLoadTotal - state.dataVariableSpeedCoils->QSensible;
7065 579537 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).QSource = state.dataVariableSpeedCoils->QSource;
7066 579537 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Energy = state.dataVariableSpeedCoils->Winput * TimeStepSysSec;
7067 579537 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).EnergyLoadTotal = state.dataVariableSpeedCoils->QLoadTotal * TimeStepSysSec;
7068 579537 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).EnergySensible = state.dataVariableSpeedCoils->QSensible * TimeStepSysSec;
7069 579537 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).EnergyLatent =
7070 579537 : (state.dataVariableSpeedCoils->QLoadTotal - state.dataVariableSpeedCoils->QSensible) * TimeStepSysSec;
7071 579537 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).EnergySource = state.dataVariableSpeedCoils->QSource * TimeStepSysSec;
7072 579537 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).CrankcaseHeaterConsumption =
7073 579537 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).CrankcaseHeaterPower * TimeStepSysSec;
7074 579537 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).EvapWaterConsump = 0.0;
7075 579537 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).BasinHeaterConsumption = 0.0;
7076 : // re-use EvapCondPumpElecConsumption to store WH pump energy consumption
7077 579537 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).EvapCondPumpElecConsumption =
7078 579537 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).HPWHCondPumpElecNomPower * TimeStepSysSec;
7079 579537 : if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).RunFrac == 0.0) {
7080 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).COP = 0.0;
7081 : } else {
7082 579537 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).COP =
7083 579537 : state.dataVariableSpeedCoils->QLoadTotal / state.dataVariableSpeedCoils->Winput;
7084 : }
7085 579537 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).PartLoadRatio = PartLoadRatio;
7086 579537 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).AirMassFlowRate = state.dataVariableSpeedCoils->PLRCorrLoadSideMdot;
7087 579537 : rhoair = Psychrometrics::PsyRhoAirFnPbTdbW(state,
7088 579537 : state.dataEnvrn->OutBaroPress,
7089 579537 : state.dataVariableSpeedCoils->LoadSideInletDBTemp,
7090 579537 : state.dataVariableSpeedCoils->LoadSideInletHumRat,
7091 : RoutineName);
7092 579537 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).AirVolFlowRate =
7093 579537 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).AirMassFlowRate / rhoair;
7094 579537 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).WaterMassFlowRate = state.dataVariableSpeedCoils->SourceSideMassFlowRate;
7095 579537 : RhoWater = Psychrometrics::RhoH2O(InletWaterTemp); // initialize
7096 579537 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).WaterVolFlowRate =
7097 579537 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).WaterMassFlowRate / RhoWater;
7098 :
7099 579537 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).OutletWaterTemp =
7100 579537 : state.dataVariableSpeedCoils->SourceSideInletTemp +
7101 579537 : state.dataVariableSpeedCoils->QSource / (state.dataVariableSpeedCoils->SourceSideMassFlowRate * CpWater);
7102 579537 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).OutletWaterEnthalpy =
7103 579537 : state.dataVariableSpeedCoils->SourceSideInletEnth +
7104 579537 : state.dataVariableSpeedCoils->QSource / state.dataVariableSpeedCoils->SourceSideMassFlowRate;
7105 579537 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).QWasteHeat = 0.0;
7106 :
7107 579537 : 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 82596 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Power = 0.0;
7111 82596 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).QLoadTotal = 0.0;
7112 82596 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).QSensible = 0.0;
7113 82596 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).QLatent = 0.0;
7114 82596 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Energy = 0.0;
7115 82596 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).EnergyLoadTotal = 0.0;
7116 82596 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).EnergySensible = 0.0;
7117 82596 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).EnergyLatent = 0.0;
7118 82596 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).CrankcaseHeaterConsumption = 0.0;
7119 : }
7120 : }
7121 :
7122 7 : void setVarSpeedHPWHFanType(EnergyPlusData &state, int const dXCoilNum, HVAC::FanType fanType)
7123 : {
7124 7 : state.dataVariableSpeedCoils->VarSpeedCoil(dXCoilNum).supplyFanType = fanType;
7125 7 : }
7126 :
7127 7 : void setVarSpeedHPWHFanIndex(EnergyPlusData &state, int const dXCoilNum, int const fanIndex)
7128 : {
7129 7 : state.dataVariableSpeedCoils->VarSpeedCoil(dXCoilNum).SupplyFanIndex = fanIndex;
7130 7 : }
7131 :
7132 5463106 : 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 5463106 : 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 5463106 : Real64 rhoair(0.0); // entering air density
7181 :
7182 : // ADDED VARIABLES FOR air source coil
7183 5463106 : int MaxSpeed = state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).NumOfSpeeds;
7184 :
7185 : // LOAD LOCAL VARIABLES FROM DATA STRUCTURE (for code readability)
7186 5463106 : if (!(fanOp == HVAC::FanOp::Continuous) && PartLoadRatio > 0.0) {
7187 190375 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).AirMassFlowRate =
7188 190375 : state.dataLoopNodes->Node(state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).AirInletNodeNum).MassFlowRate / PartLoadRatio;
7189 : }
7190 :
7191 5463106 : state.dataVariableSpeedCoils->LoadSideMassFlowRate = state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).AirMassFlowRate;
7192 5463106 : state.dataVariableSpeedCoils->LoadSideInletDBTemp = state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).InletAirDBTemp;
7193 5463106 : state.dataVariableSpeedCoils->LoadSideInletHumRat = state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).InletAirHumRat;
7194 :
7195 5463106 : state.dataVariableSpeedCoils->LoadSideInletWBTemp = Psychrometrics::PsyTwbFnTdbWPb(state,
7196 5463106 : state.dataVariableSpeedCoils->LoadSideInletDBTemp,
7197 5463106 : state.dataVariableSpeedCoils->LoadSideInletHumRat,
7198 5463106 : state.dataEnvrn->OutBaroPress,
7199 : RoutineName);
7200 5463106 : state.dataVariableSpeedCoils->LoadSideInletEnth = state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).InletAirEnthalpy;
7201 5463106 : Real64 CpAir = Psychrometrics::PsyCpAirFnW(state.dataVariableSpeedCoils->LoadSideInletHumRat); // Specific heat of air [J/kg_C]
7202 :
7203 5463106 : if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).VSCoilType == HVAC::Coil_HeatingAirToAirVariableSpeed) {
7204 : // Get condenser outdoor node info from DX Heating Coil
7205 941295 : 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 941295 : state.dataVariableSpeedCoils->OutdoorDryBulb = state.dataEnvrn->OutDryBulbTemp;
7216 941295 : state.dataVariableSpeedCoils->OutdoorHumRat = state.dataEnvrn->OutHumRat;
7217 941295 : state.dataVariableSpeedCoils->OutdoorPressure = state.dataEnvrn->OutBaroPress;
7218 941295 : state.dataVariableSpeedCoils->OutdoorWetBulb = state.dataEnvrn->OutWetBulbTemp;
7219 : }
7220 941295 : state.dataVariableSpeedCoils->SourceSideMassFlowRate = 1.0; // not used and avoid divided by zero
7221 941295 : state.dataVariableSpeedCoils->SourceSideInletTemp = state.dataVariableSpeedCoils->OutdoorDryBulb;
7222 941295 : state.dataVariableSpeedCoils->SourceSideInletEnth =
7223 941295 : Psychrometrics::PsyHFnTdbW(state.dataVariableSpeedCoils->OutdoorDryBulb, state.dataVariableSpeedCoils->OutdoorHumRat);
7224 941295 : CpSource = Psychrometrics::PsyCpAirFnW(state.dataEnvrn->OutHumRat);
7225 :
7226 : // Initialize crankcase heater, operates below OAT defined in input deck for HP DX heating coil
7227 941295 : if (state.dataVariableSpeedCoils->OutdoorDryBulb < state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MaxOATCrankcaseHeater) {
7228 408681 : state.dataVariableSpeedCoils->CrankcaseHeatingPower = state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).CrankcaseHeaterCapacity;
7229 408681 : if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).CrankcaseHeaterCapacityCurveIndex > 0) {
7230 125600 : state.dataVariableSpeedCoils->CrankcaseHeatingPower *=
7231 125600 : Curve::CurveValue(state,
7232 125600 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).CrankcaseHeaterCapacityCurveIndex,
7233 125600 : state.dataEnvrn->OutDryBulbTemp);
7234 : }
7235 : } else {
7236 532614 : state.dataVariableSpeedCoils->CrankcaseHeatingPower = 0.0;
7237 : }
7238 : } else {
7239 4521811 : state.dataVariableSpeedCoils->SourceSideMassFlowRate = state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).WaterMassFlowRate;
7240 4521811 : state.dataVariableSpeedCoils->SourceSideInletTemp = state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).InletWaterTemp;
7241 4521811 : state.dataVariableSpeedCoils->SourceSideInletEnth = state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).InletWaterEnthalpy;
7242 4521811 : CpSource = state.dataPlnt->PlantLoop(state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).plantLoc.loopNum)
7243 4521811 : .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 5463106 : if ((state.dataVariableSpeedCoils->SourceSideMassFlowRate <= 0.0) || (state.dataVariableSpeedCoils->LoadSideMassFlowRate <= 0.0)) {
7248 4042268 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).SimFlag = false;
7249 4042268 : return;
7250 : } else {
7251 1420838 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).SimFlag = true;
7252 : }
7253 :
7254 1605067 : if ((state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).VSCoilType == HVAC::Coil_HeatingAirToAirVariableSpeed) &&
7255 184229 : (state.dataVariableSpeedCoils->OutdoorDryBulb < state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MinOATCompressor)) {
7256 116357 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).SimFlag = false;
7257 116357 : return;
7258 : }
7259 :
7260 1304481 : if (compressorOp == HVAC::CompressorOp::Off) {
7261 2071 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).SimFlag = false;
7262 2071 : return;
7263 : }
7264 :
7265 1302410 : if (SpeedNum > MaxSpeed) {
7266 0 : SpeedCal = MaxSpeed;
7267 : } else {
7268 1302410 : SpeedCal = SpeedNum;
7269 : }
7270 :
7271 1302410 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).RunFrac = 1.0;
7272 1302410 : state.dataHVACGlobal->OnOffFanPartLoadFraction = 1.0;
7273 1302410 : if ((SpeedNum == 1) && (PartLoadRatio < 1.0)) {
7274 135369 : PLF = Curve::CurveValue(state, state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).PLFFPLR, PartLoadRatio);
7275 135369 : if (PLF < 0.7) {
7276 0 : PLF = 0.7;
7277 : }
7278 135369 : if (fanOp == HVAC::FanOp::Cycling) {
7279 20142 : 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 135369 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).RunFrac = PartLoadRatio / PLF;
7284 135369 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).PartLoadRatio = PartLoadRatio;
7285 :
7286 135369 : 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 135369 : } else if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).RunFrac < 0.0) {
7289 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).RunFrac = 0.0;
7290 : }
7291 : }
7292 :
7293 1302410 : if ((SpeedNum == 1) || (SpeedNum > MaxSpeed) || (SpeedRatio == 1.0)) {
7294 1024211 : AirMassFlowRatio =
7295 1024211 : state.dataVariableSpeedCoils->LoadSideMassFlowRate / state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).DesignAirMassFlowRate;
7296 :
7297 1024211 : if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).VSCoilType == HVAC::Coil_HeatingAirToAirVariableSpeed) {
7298 58819 : WaterMassFlowRatio = 1.0;
7299 : } else {
7300 965392 : WaterMassFlowRatio = state.dataVariableSpeedCoils->SourceSideMassFlowRate /
7301 965392 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).DesignWaterMassFlowRate;
7302 : }
7303 :
7304 4096844 : TotCapTempModFac = Curve::CurveValue(state,
7305 1024211 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSCCapFTemp(SpeedCal),
7306 1024211 : state.dataVariableSpeedCoils->LoadSideInletDBTemp,
7307 1024211 : state.dataVariableSpeedCoils->SourceSideInletTemp);
7308 : TotCapAirFFModFac =
7309 1024211 : Curve::CurveValue(state, state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSCCapAirFFlow(SpeedCal), AirMassFlowRatio);
7310 :
7311 1024211 : if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).VSCoilType == HVAC::Coil_HeatingAirToAirVariableSpeed) {
7312 58819 : TotCapWaterFFModFac = 1.0;
7313 : } else {
7314 : TotCapWaterFFModFac =
7315 965392 : Curve::CurveValue(state, state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSCCapWaterFFlow(SpeedCal), WaterMassFlowRatio);
7316 : }
7317 :
7318 1024211 : state.dataVariableSpeedCoils->QLoadTotal = state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedTotCap(SpeedCal) *
7319 1024211 : TotCapTempModFac * TotCapAirFFModFac * TotCapWaterFFModFac;
7320 1024211 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).capModFacTotal = TotCapTempModFac * TotCapAirFFModFac * TotCapWaterFFModFac;
7321 2048422 : state.dataVariableSpeedCoils->TotRatedCapacity =
7322 1024211 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedTotCap(SpeedCal); // for defrosting power cal
7323 :
7324 4096844 : EIRTempModFac = Curve::CurveValue(state,
7325 1024211 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSEIRFTemp(SpeedCal),
7326 1024211 : state.dataVariableSpeedCoils->LoadSideInletDBTemp,
7327 1024211 : state.dataVariableSpeedCoils->SourceSideInletTemp);
7328 : EIRAirFFModFac =
7329 1024211 : Curve::CurveValue(state, state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSEIRAirFFlow(SpeedCal), AirMassFlowRatio);
7330 :
7331 1024211 : if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).VSCoilType == HVAC::Coil_HeatingAirToAirVariableSpeed) {
7332 58819 : EIRWaterFFModFac = 1.0;
7333 : } else {
7334 : EIRWaterFFModFac =
7335 965392 : Curve::CurveValue(state, state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSEIRWaterFFlow(SpeedCal), WaterMassFlowRatio);
7336 : }
7337 :
7338 1024211 : EIR = (1.0 / state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedCOP(SpeedCal)) * EIRTempModFac * EIRAirFFModFac *
7339 : EIRWaterFFModFac;
7340 1024211 : state.dataVariableSpeedCoils->Winput = state.dataVariableSpeedCoils->QLoadTotal * EIR;
7341 :
7342 2048422 : if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).VSCoilType == HVAC::Coil_HeatingAirToAirVariableSpeed) {
7343 58819 : QWasteHeat = 0.0;
7344 : } else {
7345 965392 : QWasteHeat = state.dataVariableSpeedCoils->Winput * state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSWasteHeatFrac(SpeedCal);
7346 965392 : QWasteHeat *= Curve::CurveValue(state,
7347 965392 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSWasteHeat(SpeedCal),
7348 965392 : state.dataVariableSpeedCoils->LoadSideInletDBTemp,
7349 965392 : state.dataVariableSpeedCoils->SourceSideInletTemp);
7350 : }
7351 :
7352 : } else {
7353 278199 : AirMassFlowRatio =
7354 278199 : state.dataVariableSpeedCoils->LoadSideMassFlowRate / state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).DesignAirMassFlowRate;
7355 :
7356 278199 : if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).VSCoilType == HVAC::Coil_HeatingAirToAirVariableSpeed) {
7357 8139 : WaterMassFlowRatio = 1.0;
7358 : } else {
7359 270060 : WaterMassFlowRatio = state.dataVariableSpeedCoils->SourceSideMassFlowRate /
7360 270060 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).DesignWaterMassFlowRate;
7361 : }
7362 :
7363 278199 : SpeedCal = SpeedNum - 1;
7364 1112796 : TotCapTempModFac = Curve::CurveValue(state,
7365 278199 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSCCapFTemp(SpeedCal),
7366 278199 : state.dataVariableSpeedCoils->LoadSideInletDBTemp,
7367 278199 : state.dataVariableSpeedCoils->SourceSideInletTemp);
7368 : TotCapAirFFModFac =
7369 278199 : Curve::CurveValue(state, state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSCCapAirFFlow(SpeedCal), AirMassFlowRatio);
7370 :
7371 278199 : if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).VSCoilType == HVAC::Coil_HeatingAirToAirVariableSpeed) {
7372 8139 : TotCapWaterFFModFac = 1.0;
7373 : } else {
7374 : TotCapWaterFFModFac =
7375 270060 : Curve::CurveValue(state, state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSCCapWaterFFlow(SpeedCal), WaterMassFlowRatio);
7376 : }
7377 :
7378 278199 : QLoadTotal1 = state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedTotCap(SpeedCal) * TotCapTempModFac * TotCapAirFFModFac *
7379 : TotCapWaterFFModFac;
7380 :
7381 1112796 : EIRTempModFac = Curve::CurveValue(state,
7382 278199 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSEIRFTemp(SpeedCal),
7383 278199 : state.dataVariableSpeedCoils->LoadSideInletDBTemp,
7384 278199 : state.dataVariableSpeedCoils->SourceSideInletTemp);
7385 : EIRAirFFModFac =
7386 278199 : Curve::CurveValue(state, state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSEIRAirFFlow(SpeedCal), AirMassFlowRatio);
7387 :
7388 278199 : if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).VSCoilType == HVAC::Coil_HeatingAirToAirVariableSpeed) {
7389 8139 : EIRWaterFFModFac = 1.0;
7390 : } else {
7391 : EIRWaterFFModFac =
7392 270060 : Curve::CurveValue(state, state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSEIRWaterFFlow(SpeedCal), WaterMassFlowRatio);
7393 : }
7394 :
7395 278199 : EIR = (1.0 / state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedCOP(SpeedCal)) * EIRTempModFac * EIRAirFFModFac *
7396 : EIRWaterFFModFac;
7397 278199 : Winput1 = QLoadTotal1 * EIR;
7398 :
7399 278199 : if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).VSCoilType == HVAC::Coil_HeatingAirToAirVariableSpeed) {
7400 8139 : QWasteHeat1 = 0.0;
7401 : } else {
7402 270060 : QWasteHeat1 = Winput1 * state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSWasteHeatFrac(SpeedCal);
7403 270060 : QWasteHeat1 *= Curve::CurveValue(state,
7404 270060 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSWasteHeat(SpeedCal),
7405 270060 : state.dataVariableSpeedCoils->LoadSideInletDBTemp,
7406 270060 : state.dataVariableSpeedCoils->SourceSideInletTemp);
7407 : }
7408 :
7409 278199 : SpeedCal = SpeedNum;
7410 1112796 : TotCapTempModFac = Curve::CurveValue(state,
7411 278199 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSCCapFTemp(SpeedCal),
7412 278199 : state.dataVariableSpeedCoils->LoadSideInletDBTemp,
7413 278199 : state.dataVariableSpeedCoils->SourceSideInletTemp);
7414 : TotCapAirFFModFac =
7415 278199 : Curve::CurveValue(state, state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSCCapAirFFlow(SpeedCal), AirMassFlowRatio);
7416 :
7417 278199 : if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).VSCoilType == HVAC::Coil_HeatingAirToAirVariableSpeed) {
7418 8139 : TotCapWaterFFModFac = 1.0;
7419 : } else {
7420 : TotCapWaterFFModFac =
7421 270060 : Curve::CurveValue(state, state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSCCapWaterFFlow(SpeedCal), WaterMassFlowRatio);
7422 : }
7423 :
7424 278199 : QLoadTotal2 = state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedTotCap(SpeedCal) * TotCapTempModFac * TotCapAirFFModFac *
7425 : TotCapWaterFFModFac;
7426 :
7427 1112796 : EIRTempModFac = Curve::CurveValue(state,
7428 278199 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSEIRFTemp(SpeedCal),
7429 278199 : state.dataVariableSpeedCoils->LoadSideInletDBTemp,
7430 278199 : state.dataVariableSpeedCoils->SourceSideInletTemp);
7431 : EIRAirFFModFac =
7432 278199 : Curve::CurveValue(state, state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSEIRAirFFlow(SpeedCal), AirMassFlowRatio);
7433 :
7434 278199 : if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).VSCoilType == HVAC::Coil_HeatingAirToAirVariableSpeed) {
7435 8139 : EIRWaterFFModFac = 1.0;
7436 : } else {
7437 : EIRWaterFFModFac =
7438 270060 : Curve::CurveValue(state, state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSEIRWaterFFlow(SpeedCal), WaterMassFlowRatio);
7439 : }
7440 :
7441 278199 : EIR = (1.0 / state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedCOP(SpeedCal)) * EIRTempModFac * EIRAirFFModFac *
7442 : EIRWaterFFModFac;
7443 278199 : Winput2 = QLoadTotal2 * EIR;
7444 :
7445 278199 : if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).VSCoilType == HVAC::Coil_HeatingAirToAirVariableSpeed) {
7446 8139 : QWasteHeat2 = 0.0;
7447 : } else {
7448 270060 : QWasteHeat2 = Winput2 * state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSWasteHeatFrac(SpeedCal);
7449 270060 : QWasteHeat2 *= Curve::CurveValue(state,
7450 270060 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSWasteHeat(SpeedCal),
7451 270060 : state.dataVariableSpeedCoils->LoadSideInletDBTemp,
7452 270060 : state.dataVariableSpeedCoils->SourceSideInletTemp);
7453 : }
7454 :
7455 278199 : state.dataVariableSpeedCoils->QLoadTotal = QLoadTotal2 * SpeedRatio + (1.0 - SpeedRatio) * QLoadTotal1;
7456 278199 : state.dataVariableSpeedCoils->Winput = Winput2 * SpeedRatio + (1.0 - SpeedRatio) * Winput1;
7457 278199 : QWasteHeat = QWasteHeat2 * SpeedRatio + (1.0 - SpeedRatio) * QWasteHeat1;
7458 278199 : state.dataVariableSpeedCoils->TotRatedCapacity =
7459 278199 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedTotCap(SpeedCal) * SpeedRatio +
7460 278199 : (1.0 - SpeedRatio) * state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MSRatedTotCap(SpeedCal - 1);
7461 : }
7462 :
7463 1302410 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).CrankcaseHeaterPower = 0.0; // necessary to clear zero for water source coils
7464 1302410 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).DefrostPower = 0.0; // clear the defrost power
7465 1302410 : 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 66958 : state.dataVariableSpeedCoils->OutdoorCoilT = 0.82 * state.dataVariableSpeedCoils->OutdoorDryBulb - 8.589;
7469 66958 : state.dataVariableSpeedCoils->OutdoorCoildw =
7470 66958 : max(1.0e-6,
7471 66958 : (state.dataVariableSpeedCoils->OutdoorHumRat -
7472 66958 : Psychrometrics::PsyWFnTdpPb(state, state.dataVariableSpeedCoils->OutdoorCoilT, state.dataVariableSpeedCoils->OutdoorPressure)));
7473 :
7474 : // Initializing defrost adjustment factors
7475 66958 : state.dataVariableSpeedCoils->LoadDueToDefrost = 0.0;
7476 66958 : state.dataVariableSpeedCoils->HeatingCapacityMultiplier = 1.0;
7477 66958 : state.dataVariableSpeedCoils->FractionalDefrostTime = 0.0;
7478 66958 : state.dataVariableSpeedCoils->InputPowerMultiplier = 1.0;
7479 : // Check outdoor temperature to determine of defrost is active
7480 66958 : if (state.dataVariableSpeedCoils->OutdoorDryBulb <= state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MaxOATDefrost) {
7481 : // Calculate defrost adjustment factors depending on defrost control type
7482 0 : if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).DefrostControl == Timed) {
7483 0 : state.dataVariableSpeedCoils->FractionalDefrostTime = state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).DefrostTime;
7484 0 : if (state.dataVariableSpeedCoils->FractionalDefrostTime > 0.0) {
7485 0 : if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).FrostHeatingCapacityMultiplierEMSOverrideOn &&
7486 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).FrostHeatingInputPowerMultiplierEMSOverrideOn) {
7487 0 : state.dataVariableSpeedCoils->HeatingCapacityMultiplier =
7488 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).FrostHeatingCapacityMultiplierEMSOverrideValue;
7489 0 : state.dataVariableSpeedCoils->InputPowerMultiplier =
7490 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).FrostHeatingInputPowerMultiplierEMSOverrideValue;
7491 : } else {
7492 0 : state.dataVariableSpeedCoils->HeatingCapacityMultiplier = 0.909 - 107.33 * state.dataVariableSpeedCoils->OutdoorCoildw;
7493 0 : state.dataVariableSpeedCoils->InputPowerMultiplier = 0.90 - 36.45 * state.dataVariableSpeedCoils->OutdoorCoildw;
7494 0 : if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).FrostHeatingCapacityMultiplierEMSOverrideOn ||
7495 0 : 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 0 : state.dataVariableSpeedCoils->FractionalDefrostTime = 1.0 / (1.0 + 0.01446 / state.dataVariableSpeedCoils->OutdoorCoildw);
7507 0 : 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 0 : state.dataVariableSpeedCoils->HeatingCapacityMultiplier = 0.875 * (1.0 - state.dataVariableSpeedCoils->FractionalDefrostTime);
7515 0 : state.dataVariableSpeedCoils->InputPowerMultiplier = 0.954 * (1.0 - state.dataVariableSpeedCoils->FractionalDefrostTime);
7516 0 : if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).FrostHeatingCapacityMultiplierEMSOverrideOn ||
7517 0 : 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 0 : state.dataVariableSpeedCoils->FractionalDefrostTime *= state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).RunFrac;
7528 :
7529 0 : if (state.dataVariableSpeedCoils->FractionalDefrostTime > 0.0) {
7530 : // Calculate defrost adjustment factors depending on defrost control strategy
7531 0 : 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 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).DefrostPower =
7545 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).DefrostCapacity *
7546 0 : state.dataVariableSpeedCoils->FractionalDefrostTime;
7547 : }
7548 : } else { // Defrost is not active because (OutDryBulbTemp > VarSpeedCoil(DXCoilNum).MaxOATDefrost)
7549 0 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).DefrostPower = 0.0;
7550 : }
7551 : }
7552 :
7553 66958 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).CrankcaseHeaterPower =
7554 66958 : 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 133916 : state.dataVariableSpeedCoils->QLoadTotal =
7563 66958 : state.dataVariableSpeedCoils->QLoadTotal * state.dataVariableSpeedCoils->HeatingCapacityMultiplier -
7564 66958 : state.dataVariableSpeedCoils->LoadDueToDefrost;
7565 : // count the powr separately
7566 66958 : state.dataVariableSpeedCoils->Winput *= state.dataVariableSpeedCoils->InputPowerMultiplier; //+ VarSpeedCoil(DXCoilNum)%DefrostPower
7567 : }
7568 :
7569 1302410 : state.dataVariableSpeedCoils->QSource = state.dataVariableSpeedCoils->QLoadTotal + QWasteHeat - state.dataVariableSpeedCoils->Winput;
7570 1302410 : state.dataVariableSpeedCoils->QSensible = state.dataVariableSpeedCoils->QLoadTotal;
7571 :
7572 1302410 : if (state.dataVariableSpeedCoils->QSource < 0) {
7573 0 : state.dataVariableSpeedCoils->QSource = 0.0;
7574 0 : QWasteHeat = state.dataVariableSpeedCoils->Winput - state.dataVariableSpeedCoils->QLoadTotal;
7575 : }
7576 :
7577 : // calculate coil outlet state variables
7578 2604820 : state.dataVariableSpeedCoils->LoadSideOutletEnth =
7579 1302410 : state.dataVariableSpeedCoils->LoadSideInletEnth +
7580 1302410 : state.dataVariableSpeedCoils->QLoadTotal / state.dataVariableSpeedCoils->LoadSideMassFlowRate;
7581 2604820 : state.dataVariableSpeedCoils->LoadSideOutletDBTemp =
7582 1302410 : state.dataVariableSpeedCoils->LoadSideInletDBTemp +
7583 1302410 : state.dataVariableSpeedCoils->QSensible / (state.dataVariableSpeedCoils->LoadSideMassFlowRate * CpAir);
7584 1302410 : state.dataVariableSpeedCoils->LoadSideOutletHumRat = Psychrometrics::PsyWFnTdbH(
7585 1302410 : state, state.dataVariableSpeedCoils->LoadSideOutletDBTemp, state.dataVariableSpeedCoils->LoadSideOutletEnth, RoutineName);
7586 :
7587 : // Actual outlet conditions are "average" for time step
7588 1302410 : if (fanOp == HVAC::FanOp::Continuous) {
7589 : // continuous fan, cycling compressor
7590 1224367 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).OutletAirEnthalpy =
7591 1224367 : PartLoadRatio * state.dataVariableSpeedCoils->LoadSideOutletEnth +
7592 1224367 : (1.0 - PartLoadRatio) * state.dataVariableSpeedCoils->LoadSideInletEnth;
7593 1224367 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).OutletAirHumRat =
7594 1224367 : PartLoadRatio * state.dataVariableSpeedCoils->LoadSideOutletHumRat +
7595 1224367 : (1.0 - PartLoadRatio) * state.dataVariableSpeedCoils->LoadSideInletHumRat;
7596 1224367 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).OutletAirDBTemp =
7597 1224367 : Psychrometrics::PsyTdbFnHW(state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).OutletAirEnthalpy,
7598 1224367 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).OutletAirHumRat);
7599 1224367 : state.dataVariableSpeedCoils->PLRCorrLoadSideMdot = state.dataVariableSpeedCoils->LoadSideMassFlowRate;
7600 : } else {
7601 : // default to cycling fan, cycling compressor
7602 78043 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).OutletAirEnthalpy = state.dataVariableSpeedCoils->LoadSideOutletEnth;
7603 78043 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).OutletAirHumRat = state.dataVariableSpeedCoils->LoadSideOutletHumRat;
7604 78043 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).OutletAirDBTemp = state.dataVariableSpeedCoils->LoadSideOutletDBTemp;
7605 78043 : state.dataVariableSpeedCoils->PLRCorrLoadSideMdot = state.dataVariableSpeedCoils->LoadSideMassFlowRate * PartLoadRatio;
7606 : }
7607 :
7608 : // scale heat transfer rates to PLR and power to RTF
7609 1302410 : state.dataVariableSpeedCoils->QLoadTotal *= PartLoadRatio;
7610 1302410 : state.dataVariableSpeedCoils->QSensible *= PartLoadRatio;
7611 : // count the powr separately
7612 2604820 : state.dataVariableSpeedCoils->Winput *=
7613 1302410 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).RunFrac; //+ VarSpeedCoil(DXCoilNum)%CrankcaseHeaterPower
7614 1302410 : state.dataVariableSpeedCoils->QSource *= PartLoadRatio;
7615 1302410 : QWasteHeat *= PartLoadRatio;
7616 :
7617 : // Update heat pump data structure
7618 1302410 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Power = state.dataVariableSpeedCoils->Winput;
7619 1302410 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).QLoadTotal = state.dataVariableSpeedCoils->QLoadTotal;
7620 1302410 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).QSensible = state.dataVariableSpeedCoils->QSensible;
7621 1302410 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).QSource = state.dataVariableSpeedCoils->QSource;
7622 1302410 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Energy = state.dataVariableSpeedCoils->Winput * TimeStepSysSec;
7623 1302410 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).EnergyLoadTotal = state.dataVariableSpeedCoils->QLoadTotal * TimeStepSysSec;
7624 1302410 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).EnergySensible = state.dataVariableSpeedCoils->QSensible * TimeStepSysSec;
7625 1302410 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).EnergyLatent = 0.0;
7626 1302410 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).EnergySource = state.dataVariableSpeedCoils->QSource * TimeStepSysSec;
7627 1302410 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).CrankcaseHeaterConsumption =
7628 1302410 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).CrankcaseHeaterPower * TimeStepSysSec;
7629 1302410 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).DefrostConsumption =
7630 1302410 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).DefrostPower * TimeStepSysSec;
7631 1302410 : if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).RunFrac == 0.0) {
7632 32032 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).COP = 0.0;
7633 : } else {
7634 1270378 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).COP =
7635 1270378 : state.dataVariableSpeedCoils->QLoadTotal / state.dataVariableSpeedCoils->Winput;
7636 : }
7637 1302410 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).PartLoadRatio = PartLoadRatio;
7638 1302410 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).AirMassFlowRate = state.dataVariableSpeedCoils->PLRCorrLoadSideMdot;
7639 1302410 : rhoair = Psychrometrics::PsyRhoAirFnPbTdbW(state,
7640 1302410 : state.dataEnvrn->OutBaroPress,
7641 1302410 : state.dataVariableSpeedCoils->LoadSideInletDBTemp,
7642 1302410 : state.dataVariableSpeedCoils->LoadSideInletHumRat,
7643 : RoutineName);
7644 1302410 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).AirVolFlowRate =
7645 1302410 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).AirMassFlowRate / rhoair;
7646 :
7647 1302410 : if (state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).VSCoilType == HVAC::Coil_HeatingAirToAirVariableSpeed) {
7648 66958 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).WaterMassFlowRate = 0.0;
7649 66958 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).OutletWaterTemp = 0.0;
7650 66958 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).OutletWaterEnthalpy = 0.0;
7651 : } else {
7652 1235452 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).WaterMassFlowRate = state.dataVariableSpeedCoils->SourceSideMassFlowRate;
7653 1235452 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).OutletWaterTemp =
7654 1235452 : state.dataVariableSpeedCoils->SourceSideInletTemp -
7655 1235452 : state.dataVariableSpeedCoils->QSource / (state.dataVariableSpeedCoils->SourceSideMassFlowRate * CpSource);
7656 1235452 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).OutletWaterEnthalpy =
7657 1235452 : state.dataVariableSpeedCoils->SourceSideInletEnth -
7658 1235452 : state.dataVariableSpeedCoils->QSource / state.dataVariableSpeedCoils->SourceSideMassFlowRate;
7659 : }
7660 :
7661 1302410 : state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).QWasteHeat = QWasteHeat;
7662 : }
7663 :
7664 61 : 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 61 : if (state.dataVariableSpeedCoils->GetCoilsInputFlag) { // First time subroutine has been entered
7688 0 : GetVarSpeedCoilInput(state);
7689 0 : state.dataVariableSpeedCoils->GetCoilsInputFlag = false;
7690 : }
7691 :
7692 104 : if (Util::SameString(CoilType, "COIL:COOLING:WATERTOAIRHEATPUMP:VARIABLESPEEDEQUATIONFIT") ||
7693 72 : Util::SameString(CoilType, "COIL:HEATING:WATERTOAIRHEATPUMP:VARIABLESPEEDEQUATIONFIT") ||
7694 140 : Util::SameString(CoilType, "COIL:COOLING:DX:VARIABLESPEED") || Util::SameString(CoilType, "COIL:HEATING:DX:VARIABLESPEED") ||
7695 68 : Util::SameString(CoilType, "COIL:WATERHEATING:AIRTOWATERHEATPUMP:VARIABLESPEED")) {
7696 61 : WhichCoil = Util::FindItemInList(CoilName, state.dataVariableSpeedCoils->VarSpeedCoil);
7697 61 : if (WhichCoil != 0) {
7698 108 : if (Util::SameString(CoilType, "COIL:HEATING:WATERTOAIRHEATPUMP:VARIABLESPEEDEQUATIONFIT") ||
7699 108 : Util::SameString(CoilType, "COIL:HEATING:DX:VARIABLESPEED")) {
7700 17 : CoilCapacity = state.dataVariableSpeedCoils->VarSpeedCoil(WhichCoil).RatedCapHeat;
7701 44 : } else if (Util::SameString(CoilType, "COIL:WATERHEATING:AIRTOWATERHEATPUMP:VARIABLESPEED")) {
7702 7 : CoilCapacity = state.dataVariableSpeedCoils->VarSpeedCoil(WhichCoil).RatedCapWH;
7703 : } else {
7704 37 : CoilCapacity = state.dataVariableSpeedCoils->VarSpeedCoil(WhichCoil).RatedCapCoolTotal;
7705 : }
7706 : }
7707 : } else {
7708 0 : WhichCoil = 0;
7709 : }
7710 :
7711 61 : 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 61 : return CoilCapacity;
7718 : }
7719 :
7720 78 : 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 78 : if (state.dataVariableSpeedCoils->GetCoilsInputFlag) { // First time subroutine has been entered
7740 20 : GetVarSpeedCoilInput(state);
7741 20 : state.dataVariableSpeedCoils->GetCoilsInputFlag = false;
7742 : }
7743 :
7744 78 : IndexNum = Util::FindItemInList(CoilName, state.dataVariableSpeedCoils->VarSpeedCoil);
7745 :
7746 78 : if (IndexNum == 0) {
7747 0 : ShowSevereError(state, format("GetCoilIndexVariableSpeed: Could not find CoilType=\"{}\" with Name=\"{}\"", CoilType, CoilName));
7748 0 : ErrorsFound = true;
7749 : }
7750 :
7751 78 : return IndexNum;
7752 : }
7753 :
7754 39 : 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 39 : if (state.dataVariableSpeedCoils->GetCoilsInputFlag) { // First time subroutine has been entered
7777 0 : GetVarSpeedCoilInput(state);
7778 0 : state.dataVariableSpeedCoils->GetCoilsInputFlag = false;
7779 : }
7780 :
7781 64 : if (Util::SameString(CoilType, "COIL:COOLING:WATERTOAIRHEATPUMP:VARIABLESPEEDEQUATIONFIT") ||
7782 36 : Util::SameString(CoilType, "COIL:HEATING:WATERTOAIRHEATPUMP:VARIABLESPEEDEQUATIONFIT") ||
7783 75 : Util::SameString(CoilType, "COIL:COOLING:DX:VARIABLESPEED") || Util::SameString(CoilType, "COIL:HEATING:DX:VARIABLESPEED") ||
7784 39 : Util::SameString(CoilType, "COIL:WATERHEATING:AIRTOWATERHEATPUMP:VARIABLESPEED")) {
7785 39 : WhichCoil = Util::FindItemInList(CoilName, state.dataVariableSpeedCoils->VarSpeedCoil);
7786 39 : if (WhichCoil != 0) {
7787 39 : if (state.dataVariableSpeedCoils->VarSpeedCoil(WhichCoil).RatedAirVolFlowRate == DataSizing::AutoSize) { // means autosize
7788 5 : CoilAirFlowRate = state.dataVariableSpeedCoils->VarSpeedCoil(WhichCoil).RatedAirVolFlowRate;
7789 : } else {
7790 34 : CoilAirFlowRate = state.dataVariableSpeedCoils->VarSpeedCoil(WhichCoil).MSRatedAirVolFlowRate(
7791 34 : state.dataVariableSpeedCoils->VarSpeedCoil(WhichCoil).NumOfSpeeds) /
7792 34 : state.dataVariableSpeedCoils->VarSpeedCoil(WhichCoil).MSRatedAirVolFlowRate(
7793 34 : state.dataVariableSpeedCoils->VarSpeedCoil(WhichCoil).NormSpedLevel) *
7794 34 : state.dataVariableSpeedCoils->VarSpeedCoil(WhichCoil).RatedAirVolFlowRate;
7795 : } // use largest air flow rate
7796 : }
7797 : } else {
7798 0 : WhichCoil = 0;
7799 : }
7800 :
7801 39 : 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 39 : return CoilAirFlowRate;
7808 : }
7809 :
7810 7 : 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 7 : if (state.dataVariableSpeedCoils->GetCoilsInputFlag) { // First time subroutine has been entered
7833 0 : GetVarSpeedCoilInput(state);
7834 0 : state.dataVariableSpeedCoils->GetCoilsInputFlag = false;
7835 : }
7836 :
7837 7 : WhichCoil = Util::FindItemInList(CoilName, state.dataVariableSpeedCoils->VarSpeedCoil);
7838 7 : if (WhichCoil != 0) {
7839 7 : PLRNumber = state.dataVariableSpeedCoils->VarSpeedCoil(WhichCoil).PLFFPLR;
7840 : }
7841 :
7842 7 : 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 7 : return PLRNumber;
7849 : }
7850 :
7851 14 : 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 14 : if (state.dataVariableSpeedCoils->GetCoilsInputFlag) { // First time subroutine has been entered
7870 0 : GetVarSpeedCoilInput(state);
7871 0 : state.dataVariableSpeedCoils->GetCoilsInputFlag = false;
7872 : }
7873 :
7874 14 : if (CoilIndex == 0) {
7875 0 : ShowSevereError(state, "GetVSCoilCapFTCurveIndex: Could not find Coil");
7876 0 : ErrorsFound = true;
7877 0 : CapFTIndex = 0;
7878 : } else {
7879 14 : CapFTIndex =
7880 14 : state.dataVariableSpeedCoils->VarSpeedCoil(CoilIndex).MSCCapFTemp(state.dataVariableSpeedCoils->VarSpeedCoil(CoilIndex).NumOfSpeeds);
7881 : }
7882 :
7883 14 : return CapFTIndex;
7884 : }
7885 :
7886 2453 : 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 2453 : if (state.dataVariableSpeedCoils->GetCoilsInputFlag) { // First time subroutine has been entered
7909 0 : GetVarSpeedCoilInput(state);
7910 0 : state.dataVariableSpeedCoils->GetCoilsInputFlag = false;
7911 : }
7912 :
7913 2453 : WhichCoil = Util::FindItemInList(CoilName, state.dataVariableSpeedCoils->VarSpeedCoil);
7914 2453 : if (WhichCoil != 0) {
7915 2453 : NodeNumber = state.dataVariableSpeedCoils->VarSpeedCoil(WhichCoil).AirInletNodeNum;
7916 : }
7917 :
7918 2453 : 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 2453 : return NodeNumber;
7925 : }
7926 :
7927 2451 : 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 2451 : if (state.dataVariableSpeedCoils->GetCoilsInputFlag) { // First time subroutine has been entered
7950 2 : GetVarSpeedCoilInput(state);
7951 2 : state.dataVariableSpeedCoils->GetCoilsInputFlag = false;
7952 : }
7953 :
7954 2451 : WhichCoil = Util::FindItemInList(CoilName, state.dataVariableSpeedCoils->VarSpeedCoil);
7955 2451 : if (WhichCoil != 0) {
7956 2451 : NodeNumber = state.dataVariableSpeedCoils->VarSpeedCoil(WhichCoil).AirOutletNodeNum;
7957 : }
7958 :
7959 2451 : 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 2451 : return NodeNumber;
7966 : }
7967 :
7968 22 : 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 22 : if (state.dataVariableSpeedCoils->GetCoilsInputFlag) { // First time subroutine has been entered
7990 0 : GetVarSpeedCoilInput(state);
7991 0 : state.dataVariableSpeedCoils->GetCoilsInputFlag = false;
7992 : }
7993 :
7994 22 : WhichCoil = Util::FindItemInList(CoilName, state.dataVariableSpeedCoils->VarSpeedCoil);
7995 22 : if (WhichCoil != 0) {
7996 22 : 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 22 : return CondNode;
8004 : }
8005 :
8006 23 : 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 23 : if (state.dataVariableSpeedCoils->GetCoilsInputFlag) { // First time subroutine has been entered
8013 0 : GetVarSpeedCoilInput(state);
8014 0 : state.dataVariableSpeedCoils->GetCoilsInputFlag = false;
8015 : }
8016 :
8017 23 : 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 23 : return state.dataVariableSpeedCoils->VarSpeedCoil(CoilIndex).MinOATCompressor;
8024 : }
8025 : }
8026 :
8027 20930 : 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 20930 : if (state.dataVariableSpeedCoils->GetCoilsInputFlag) { // First time subroutine has been entered
8046 0 : GetVarSpeedCoilInput(state);
8047 0 : state.dataVariableSpeedCoils->GetCoilsInputFlag = false;
8048 : }
8049 :
8050 20930 : int WhichCoil = Util::FindItemInList(CoilName, state.dataVariableSpeedCoils->VarSpeedCoil);
8051 20930 : if (WhichCoil != 0) {
8052 20930 : 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 20930 : return Speeds;
8060 : }
8061 :
8062 96 : Real64 GetVSCoilRatedSourceTemp(EnergyPlusData &state, int const CoilIndex)
8063 : {
8064 96 : Real64 RatedSourceTemp = 0.0;
8065 96 : switch (state.dataVariableSpeedCoils->VarSpeedCoil(CoilIndex).VSCoilType) {
8066 24 : case HVAC::Coil_CoolingWaterToAirHPVSEquationFit: {
8067 24 : RatedSourceTemp = RatedInletWaterTemp;
8068 24 : } break;
8069 21 : case HVAC::Coil_HeatingWaterToAirHPVSEquationFit: {
8070 21 : RatedSourceTemp = RatedInletWaterTempHeat;
8071 21 : } break;
8072 16 : case HVAC::CoilDX_HeatPumpWaterHeaterVariableSpeed: {
8073 16 : RatedSourceTemp = state.dataVariableSpeedCoils->VarSpeedCoil(CoilIndex).WHRatedInletWaterTemp;
8074 16 : } break;
8075 24 : case HVAC::Coil_CoolingAirToAirVariableSpeed: {
8076 24 : RatedSourceTemp = RatedAmbAirTemp;
8077 24 : } break;
8078 11 : case HVAC::Coil_HeatingAirToAirVariableSpeed: {
8079 11 : RatedSourceTemp = RatedAmbAirTempHeat;
8080 11 : } break;
8081 0 : default: {
8082 0 : assert(false);
8083 : } break;
8084 : }
8085 96 : return RatedSourceTemp;
8086 : }
8087 :
8088 36 : 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 36 : if (state.dataVariableSpeedCoils->GetCoilsInputFlag) { // First time subroutine has been entered
8106 0 : GetVarSpeedCoilInput(state);
8107 0 : state.dataVariableSpeedCoils->GetCoilsInputFlag = false;
8108 : }
8109 :
8110 36 : 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 36 : 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 36 : if (present(CompanionHeatingCoilNum)) {
8126 23 : state.dataVariableSpeedCoils->VarSpeedCoil(WSHPNum).CompanionHeatingCoilNum = CompanionHeatingCoilNum;
8127 23 : state.dataVariableSpeedCoils->VarSpeedCoil(CompanionHeatingCoilNum).CompanionCoolingCoilNum = WSHPNum;
8128 : }
8129 :
8130 36 : if (present(MSHPDesignSpecIndex)) {
8131 13 : state.dataVariableSpeedCoils->VarSpeedCoil(WSHPNum).MSHPDesignSpecIndex = MSHPDesignSpecIndex;
8132 : }
8133 : }
8134 :
8135 45014786 : 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 45014786 : Real64 TimeStepSysSec = state.dataHVACGlobal->TimeStepSysSec;
8149 :
8150 45014786 : auto &varSpeedCoil = state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum);
8151 :
8152 : // WatertoAirHP(DXCoilNum)%SimFlag=.FALSE.
8153 45014786 : if (!varSpeedCoil.SimFlag) {
8154 : // Heatpump is off; just pass through conditions
8155 13440447 : varSpeedCoil.Power = 0.0;
8156 13440447 : varSpeedCoil.QLoadTotal = 0.0;
8157 13440447 : varSpeedCoil.QSensible = 0.0;
8158 13440447 : varSpeedCoil.QLatent = 0.0;
8159 13440447 : varSpeedCoil.QSource = 0.0;
8160 13440447 : varSpeedCoil.Energy = 0.0;
8161 13440447 : varSpeedCoil.EnergyLoadTotal = 0.0;
8162 13440447 : varSpeedCoil.EnergySensible = 0.0;
8163 13440447 : varSpeedCoil.EnergyLatent = 0.0;
8164 13440447 : varSpeedCoil.EnergySource = 0.0;
8165 13440447 : varSpeedCoil.COP = 0.0;
8166 13440447 : varSpeedCoil.RunFrac = 0.0;
8167 13440447 : varSpeedCoil.PartLoadRatio = 0.0;
8168 :
8169 13440447 : varSpeedCoil.OutletAirDBTemp = varSpeedCoil.InletAirDBTemp;
8170 13440447 : varSpeedCoil.OutletAirHumRat = varSpeedCoil.InletAirHumRat;
8171 13440447 : varSpeedCoil.OutletAirEnthalpy = varSpeedCoil.InletAirEnthalpy;
8172 13440447 : varSpeedCoil.OutletWaterTemp = varSpeedCoil.InletWaterTemp;
8173 13440447 : varSpeedCoil.OutletWaterEnthalpy = varSpeedCoil.InletWaterEnthalpy;
8174 : }
8175 :
8176 45014786 : int AirInletNode = varSpeedCoil.AirInletNodeNum;
8177 45014786 : int WaterInletNode = varSpeedCoil.WaterInletNodeNum;
8178 45014786 : int AirOutletNode = varSpeedCoil.AirOutletNodeNum;
8179 45014786 : int WaterOutletNode = varSpeedCoil.WaterOutletNodeNum;
8180 :
8181 : // Set the air outlet nodes of the WatertoAirHPSimple
8182 45014786 : state.dataLoopNodes->Node(AirOutletNode).MassFlowRate = state.dataLoopNodes->Node(AirInletNode).MassFlowRate; // LoadSideMassFlowRate
8183 45014786 : state.dataLoopNodes->Node(AirOutletNode).Temp = varSpeedCoil.OutletAirDBTemp;
8184 45014786 : state.dataLoopNodes->Node(AirOutletNode).HumRat = varSpeedCoil.OutletAirHumRat;
8185 45014786 : state.dataLoopNodes->Node(AirOutletNode).Enthalpy = varSpeedCoil.OutletAirEnthalpy;
8186 :
8187 : // Set the air outlet nodes for properties that just pass through & not used
8188 45014786 : state.dataLoopNodes->Node(AirOutletNode).Quality = state.dataLoopNodes->Node(AirInletNode).Quality;
8189 45014786 : state.dataLoopNodes->Node(AirOutletNode).Press = state.dataLoopNodes->Node(AirInletNode).Press;
8190 45014786 : state.dataLoopNodes->Node(AirOutletNode).MassFlowRateMin = state.dataLoopNodes->Node(AirInletNode).MassFlowRateMin;
8191 45014786 : state.dataLoopNodes->Node(AirOutletNode).MassFlowRateMax = state.dataLoopNodes->Node(AirInletNode).MassFlowRateMax; // LoadSideMassFlowRate
8192 45014786 : state.dataLoopNodes->Node(AirOutletNode).MassFlowRateMinAvail = state.dataLoopNodes->Node(AirInletNode).MassFlowRateMinAvail;
8193 45014786 : state.dataLoopNodes->Node(AirOutletNode).MassFlowRateMaxAvail =
8194 45014786 : 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 45014786 : if (WaterInletNode != 0 && WaterOutletNode != 0) {
8199 10642762 : PlantUtilities::SafeCopyPlantNode(state, WaterInletNode, WaterOutletNode);
8200 10642762 : state.dataLoopNodes->Node(WaterOutletNode).Temp = varSpeedCoil.OutletWaterTemp;
8201 10642762 : state.dataLoopNodes->Node(WaterOutletNode).Enthalpy = varSpeedCoil.OutletWaterEnthalpy;
8202 : }
8203 :
8204 45014786 : varSpeedCoil.Energy = varSpeedCoil.Power * TimeStepSysSec;
8205 45014786 : varSpeedCoil.EnergyLoadTotal = varSpeedCoil.QLoadTotal * TimeStepSysSec;
8206 45014786 : varSpeedCoil.EnergySensible = varSpeedCoil.QSensible * TimeStepSysSec;
8207 45014786 : varSpeedCoil.EnergyLatent = varSpeedCoil.QLatent * TimeStepSysSec;
8208 45014786 : varSpeedCoil.EnergySource = varSpeedCoil.QSource * TimeStepSysSec;
8209 :
8210 45014786 : if (state.dataContaminantBalance->Contaminant.CO2Simulation) {
8211 0 : state.dataLoopNodes->Node(AirOutletNode).CO2 = state.dataLoopNodes->Node(AirInletNode).CO2;
8212 : }
8213 :
8214 45014786 : if (state.dataContaminantBalance->Contaminant.GenericContamSimulation) {
8215 0 : state.dataLoopNodes->Node(AirOutletNode).GenContam = state.dataLoopNodes->Node(AirInletNode).GenContam;
8216 : }
8217 :
8218 45014786 : if (varSpeedCoil.reportCoilFinalSizes) {
8219 4711037 : if (!state.dataGlobal->WarmupFlag && !state.dataGlobal->DoingHVACSizingSimulations && !state.dataGlobal->DoingSizing) {
8220 77 : if (varSpeedCoil.VSCoilType == HVAC::Coil_CoolingWaterToAirHPVSEquationFit ||
8221 59 : varSpeedCoil.VSCoilType == HVAC::Coil_CoolingAirToAirVariableSpeed) { // cooling coil
8222 40 : state.dataRptCoilSelection->coilSelectionReportObj->setCoilFinalSizes(state,
8223 40 : varSpeedCoil.Name,
8224 40 : varSpeedCoil.VarSpeedCoilType,
8225 : varSpeedCoil.RatedCapCoolTotal,
8226 : varSpeedCoil.RatedCapCoolSens,
8227 : varSpeedCoil.RatedAirVolFlowRate,
8228 : varSpeedCoil.RatedWaterMassFlowRate);
8229 37 : } else if (varSpeedCoil.VSCoilType == HVAC::Coil_HeatingWaterToAirHPVSEquationFit ||
8230 19 : varSpeedCoil.VSCoilType == HVAC::Coil_HeatingAirToAirVariableSpeed) { // heating coil
8231 27 : state.dataRptCoilSelection->coilSelectionReportObj->setCoilFinalSizes(state,
8232 27 : varSpeedCoil.Name,
8233 27 : varSpeedCoil.VarSpeedCoilType,
8234 : varSpeedCoil.RatedCapHeat,
8235 : varSpeedCoil.RatedCapHeat,
8236 : varSpeedCoil.RatedAirVolFlowRate,
8237 : varSpeedCoil.RatedWaterMassFlowRate);
8238 : }
8239 77 : varSpeedCoil.reportCoilFinalSizes = false;
8240 : }
8241 : }
8242 45014786 : if (varSpeedCoil.VSCoilType == HVAC::Coil_CoolingWaterToAirHPVSEquationFit ||
8243 40492993 : varSpeedCoil.VSCoilType == HVAC::Coil_CoolingAirToAirVariableSpeed) {
8244 : // Add power to global variable so power can be summed by parent object
8245 37952531 : state.dataHVACGlobal->DXElecCoolingPower = varSpeedCoil.Power;
8246 7062255 : } else if (varSpeedCoil.VSCoilType == HVAC::Coil_HeatingWaterToAirHPVSEquationFit) {
8247 : // Add power to global variable so power can be summed by parent object
8248 4521793 : state.dataHVACGlobal->DXElecHeatingPower = varSpeedCoil.Power;
8249 2540462 : } else if (varSpeedCoil.VSCoilType == HVAC::Coil_HeatingAirToAirVariableSpeed) {
8250 : // Add power to global variable so power can be summed by parent object
8251 941286 : state.dataHVACGlobal->DXElecHeatingPower = varSpeedCoil.Power + varSpeedCoil.CrankcaseHeaterPower;
8252 941286 : state.dataHVACGlobal->DefrostElecPower = varSpeedCoil.DefrostPower;
8253 : }
8254 45014786 : }
8255 :
8256 17082 : 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 17082 : Real64 Twet_Rated = state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Twet_Rated; // [s]
8308 17082 : Real64 Gamma_Rated = state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).Gamma_Rated;
8309 17082 : Real64 MaxONOFFCyclesperHour = state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).MaxONOFFCyclesperHour; // [cycles/hr]
8310 17082 : Real64 LatentCapacityTimeConstant = state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).LatentCapacityTimeConstant; // [s]
8311 17082 : 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 17082 : if ((RTF >= 1.0) || (QLatRated == 0.0) || (QLatActual == 0.0) || (Twet_Rated <= 0.0) || (Gamma_Rated <= 0.0) ||
8317 11521 : (MaxONOFFCyclesperHour <= 0.0) || (LatentCapacityTimeConstant <= 0.0) || (RTF <= 0.0)) {
8318 5561 : SHReff = SHRss;
8319 5561 : return SHReff;
8320 : }
8321 :
8322 11521 : Twet_max = 9999.0; // high limit for Twet
8323 :
8324 : // Calculate the model parameters at the actual operating conditions
8325 11521 : Twet = min(Twet_Rated * QLatRated / (QLatActual + 1.e-10), Twet_max);
8326 11521 : 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 11521 : Ton = 3600.0 / (4.0 * MaxONOFFCyclesperHour * (1.0 - RTF)); // duration of cooling coil on-cycle (sec)
8330 :
8331 11521 : 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 11521 : 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 11521 : if (Gamma > 0.0) {
8343 11521 : Toffa = min(Toff, 2.0 * Twet / Gamma);
8344 : } else {
8345 0 : Toffa = Toff;
8346 : }
8347 :
8348 : // Use sucessive substitution to solve for To
8349 11521 : aa = (Gamma * Toffa) - (0.25 / Twet) * pow_2(Gamma) * pow_2(Toffa);
8350 :
8351 11521 : To1 = aa + LatentCapacityTimeConstant;
8352 11521 : Error = 1.0;
8353 23624 : while (Error > 0.001) {
8354 12103 : To2 = aa - LatentCapacityTimeConstant * (std::exp(-To1 / LatentCapacityTimeConstant) - 1.0);
8355 12103 : Error = std::abs((To2 - To1) / To1);
8356 12103 : 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 11521 : aa = std::exp(max(-700.0, -Ton / LatentCapacityTimeConstant));
8363 : // Calculate latent heat ratio multiplier
8364 11521 : LHRmult = max(((Ton - To2) / (Ton + LatentCapacityTimeConstant * (aa - 1.0))), 0.0);
8365 :
8366 : // Calculate part-load or "effective" sensible heat ratio
8367 11521 : SHReff = 1.0 - (1.0 - SHRss) * LHRmult;
8368 :
8369 11521 : if (SHReff < SHRss) {
8370 16 : SHReff = SHRss; // Effective SHR can be less than the steady-state SHR
8371 : }
8372 11521 : if (SHReff > 1.0) {
8373 0 : SHReff = 1.0; // Effective sensible heat ratio can't be greater than 1.0
8374 : }
8375 :
8376 11521 : return SHReff;
8377 : }
8378 :
8379 50324329 : 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 50324329 : constexpr int MaxIter = 30; // Maximum number of iterations for dry evaporator calculations
8436 50324329 : 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 50324329 : int Counter = 0; // Error tolerance for dry evaporator iterations
8448 50324329 : Real64 RF = 0.4; // Relaxation factor for dry evaporator iterations
8449 50324329 : Real64 werror = 0.0; // Deviation of humidity ratio in dry evaporator iteration loop
8450 50324329 : Real64 SHRCalc = SHR; // initialize temporary calculated value of SHR
8451 50324329 : Real64 InletWetBulbCalc = InletWetBulb; // calculated inlet wetbulb temperature used for finding dry coil point [C]
8452 50324329 : Real64 InletHumRatCalc = InletHumRat; // calculated inlet humidity ratio used for finding dry coil point [kg water / kg dry air]
8453 50324329 : bool LoopOn = true; // flag to control the loop iteration
8454 :
8455 : // LOOP WHILE (ABS(werror) .gt. Tolerance .OR. Counter == 0)
8456 100743469 : while (LoopOn) {
8457 : // Get capacity modifying factor (function of inlet wetbulb & condenser inlet temp) for off-rated conditions
8458 50419140 : Real64 TotCapTempModFac1 = Curve::CurveValue(state, CCapFTemp1, InletWetBulbCalc, CondInletTemp);
8459 : // Get capacity modifying factor (function of mass flow) for off-rated conditions
8460 50419140 : Real64 TotCapAirFlowModFac1 = Curve::CurveValue(state, CCapAirFFlow1, AirMassFlowRatio);
8461 : // Get capacity modifying factor (function of mass flow) for off-rated conditions
8462 50419140 : if (CCapWaterFFlow1 == 0) {
8463 46525390 : TotCapWaterFlowModFac1 = 1.0;
8464 : } else {
8465 3893750 : TotCapWaterFlowModFac1 = Curve::CurveValue(state, CCapWaterFFlow1, WaterMassFlowRatio);
8466 : }
8467 :
8468 : // Get total capacity
8469 50419140 : if (NumSpeeds < 2) { // ONLY ONE SPEED
8470 43355849 : TotCapCalc = TotCapNom1 * TotCapAirFlowModFac1 * TotCapWaterFlowModFac1 * TotCapTempModFac1;
8471 43355849 : TotCapCalc1 = TotCapCalc;
8472 43355849 : TotCapCalc2 = 0.0;
8473 43355849 : TotCapModFac = TotCapAirFlowModFac1 * TotCapWaterFlowModFac1 * TotCapTempModFac1;
8474 : } else {
8475 7063291 : TotCapTempModFac2 = Curve::CurveValue(state, CCapFTemp2, InletWetBulbCalc, CondInletTemp);
8476 7063291 : TotCapAirFlowModFac2 = Curve::CurveValue(state, CCapAirFFlow2, AirMassFlowRatio);
8477 :
8478 7063291 : if (CCapWaterFFlow2 == 0) {
8479 6721333 : TotCapWaterFlowModFac2 = 1.0;
8480 : } else {
8481 341958 : TotCapWaterFlowModFac2 = Curve::CurveValue(state, CCapWaterFFlow2, WaterMassFlowRatio);
8482 : }
8483 :
8484 7063291 : TotCapCalc1 = TotCapNom1 * TotCapAirFlowModFac1 * TotCapWaterFlowModFac1 * TotCapTempModFac1;
8485 7063291 : TotCapCalc2 = TotCapNom2 * TotCapAirFlowModFac2 * TotCapWaterFlowModFac2 * TotCapTempModFac2;
8486 :
8487 7063291 : TotCapCalc = TotCapCalc2 * SpeedRatio + (1.0 - SpeedRatio) * TotCapCalc1;
8488 7063291 : TotCapModFac = (TotCapAirFlowModFac2 * TotCapWaterFlowModFac2 * TotCapTempModFac2) * SpeedRatio +
8489 7063291 : (1.0 - SpeedRatio) * (TotCapAirFlowModFac1 * TotCapWaterFlowModFac1 * TotCapTempModFac1);
8490 : }
8491 :
8492 50419140 : 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 50419140 : Real64 hDelta = TotCapCalc / AirMassFlow; // Change in air enthalpy across the cooling coil [J/kg]
8496 50419140 : Real64 hADP = InletEnthalpy - hDelta / (1.0 - localCBF); // Apparatus dew point enthalpy [J/kg]
8497 50419140 : Real64 tADP = Psychrometrics::PsyTsatFnHPb(state, hADP, Pressure, RoutineName); // Apparatus dew point temperature [C]
8498 50419140 : Real64 wADP = Psychrometrics::PsyWFnTdbH(state, tADP, hADP, RoutineName); // Apparatus dew point humidity ratio [kg/kg]
8499 50419140 : Real64 hTinwADP = Psychrometrics::PsyHFnTdbW(InletDryBulb, wADP); // Enthalpy at inlet dry-bulb and wADP [J/kg]
8500 50419140 : if (TotCapCalc > 1.0e-10) {
8501 50419140 : SHRCalc = min((hTinwADP - hADP) / (InletEnthalpy - hADP), 1.0); // temporary calculated value of SHR
8502 : } else {
8503 0 : SHRCalc = 1.0;
8504 : }
8505 :
8506 : // Check for dry evaporator conditions (win < wadp)
8507 50419140 : if (wADP > InletHumRatCalc || (Counter >= 1 && Counter < MaxIter)) {
8508 121166 : if (InletHumRatCalc == 0.0) {
8509 0 : InletHumRatCalc = 0.00001;
8510 : }
8511 121166 : 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 121166 : InletHumRatCalc = RF * wADP + (1.0 - RF) * InletHumRatCalc;
8516 121166 : InletWetBulbCalc = Psychrometrics::PsyTwbFnTdbWPb(state, InletDryBulb, InletHumRatCalc, Pressure);
8517 121166 : ++Counter;
8518 242332 : if (std::abs(werror) > Tolerance) {
8519 94811 : LoopOn = true; // Recalculate with modified inlet conditions
8520 : } else {
8521 26355 : LoopOn = false;
8522 : }
8523 : } else {
8524 50297974 : LoopOn = false;
8525 : }
8526 : } // END LOOP
8527 :
8528 : // Calculate full load output conditions
8529 50324329 : if (SHRCalc > 1.0 || Counter > 0) {
8530 26355 : SHRCalc = 1.0; // if Counter > 0 means a dry coil so SHR = 1
8531 : }
8532 :
8533 50324329 : SHR = SHRCalc;
8534 50324329 : TotCap1 = TotCapCalc1;
8535 50324329 : TotCap2 = TotCapCalc2;
8536 50324329 : TotCapSpeed = TotCapCalc;
8537 50324329 : InletWetBulb = InletWetBulbCalc;
8538 50324329 : }
8539 :
8540 20926 : Real64 getVarSpeedPartLoadRatio(EnergyPlusData &state, int const DXCoilNum)
8541 : {
8542 20926 : return state.dataVariableSpeedCoils->VarSpeedCoil(DXCoilNum).PartLoadRatio;
8543 : }
8544 :
8545 : } // namespace VariableSpeedCoils
8546 :
8547 : } // namespace EnergyPlus
|
