Line data Source code
1 : // EnergyPlus, Copyright (c) 1996-2023, 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 : // ObjexxFCL Headers
49 : #include <ObjexxFCL/Array.functions.hh>
50 : #include <ObjexxFCL/Array1D.hh>
51 : #include <ObjexxFCL/Fmath.hh>
52 :
53 : // EnergyPlus Headers
54 : #include <AirflowNetwork/Solver.hpp>
55 : #include <EnergyPlus/BaseboardElectric.hh>
56 : #include <EnergyPlus/BaseboardRadiator.hh>
57 : #include <EnergyPlus/Data/EnergyPlusData.hh>
58 : #include <EnergyPlus/DataDefineEquip.hh>
59 : #include <EnergyPlus/DataEnvironment.hh>
60 : #include <EnergyPlus/DataHVACGlobals.hh>
61 : #include <EnergyPlus/DataHeatBalSurface.hh>
62 : #include <EnergyPlus/DataHeatBalance.hh>
63 : #include <EnergyPlus/DataLoopNode.hh>
64 : #include <EnergyPlus/DataMoistureBalance.hh>
65 : #include <EnergyPlus/DataMoistureBalanceEMPD.hh>
66 : #include <EnergyPlus/DataRoomAirModel.hh>
67 : #include <EnergyPlus/DataSurfaceLists.hh>
68 : #include <EnergyPlus/DataSurfaces.hh>
69 : #include <EnergyPlus/DataZoneEquipment.hh>
70 : #include <EnergyPlus/ElectricBaseboardRadiator.hh>
71 : #include <EnergyPlus/FluidProperties.hh>
72 : #include <EnergyPlus/General.hh>
73 : #include <EnergyPlus/GlobalNames.hh>
74 : #include <EnergyPlus/HWBaseboardRadiator.hh>
75 : #include <EnergyPlus/HeatBalFiniteDiffManager.hh>
76 : #include <EnergyPlus/HeatBalanceHAMTManager.hh>
77 : #include <EnergyPlus/HighTempRadiantSystem.hh>
78 : #include <EnergyPlus/InputProcessing/InputProcessor.hh>
79 : #include <EnergyPlus/InternalHeatGains.hh>
80 : #include <EnergyPlus/MoistureBalanceEMPDManager.hh>
81 : #include <EnergyPlus/OutputProcessor.hh>
82 : #include <EnergyPlus/Psychrometrics.hh>
83 : #include <EnergyPlus/RefrigeratedCase.hh>
84 : #include <EnergyPlus/RoomAirModelAirflowNetwork.hh>
85 : #include <EnergyPlus/SteamBaseboardRadiator.hh>
86 : #include <EnergyPlus/UtilityRoutines.hh>
87 : #include <EnergyPlus/ZoneAirLoopEquipmentManager.hh>
88 : #include <EnergyPlus/ZoneDehumidifier.hh>
89 : #include <EnergyPlus/ZonePlenum.hh>
90 : #include <EnergyPlus/ZoneTempPredictorCorrector.hh>
91 :
92 : namespace EnergyPlus {
93 :
94 : namespace RoomAirModelAirflowNetwork {
95 :
96 : // MODULE INFORMATION:
97 : // AUTHOR Brent Griffith
98 : // DATE WRITTEN November 2009
99 : // MODIFIED Lixing Gu, Aug. 2015 for v8.4 replease
100 : // RE-ENGINEERED na
101 :
102 : // PURPOSE OF THIS MODULE:
103 : // contains the RoomAir model portions of RoomAirflowNetwork modeling
104 :
105 : // METHODOLOGY EMPLOYED:
106 : // Interact with Surface HB, internal gain, HVAC system and Airflow Network Domains
107 : // Do heat and moisture balance calculations on roomair nodes.
108 :
109 : // Using/Aliasing
110 : using namespace DataRoomAirModel;
111 : using namespace DataHeatBalSurface;
112 : using namespace DataSurfaces;
113 : using namespace DataHeatBalance;
114 :
115 : // Object Data
116 :
117 : // Functions
118 :
119 7689 : void SimRoomAirModelAirflowNetwork(EnergyPlusData &state, int const ZoneNum) // index number for the specified zone
120 : {
121 :
122 : // SUBROUTINE INFORMATION:
123 : // AUTHOR Brent Griffith
124 : // DATE WRITTEN January 2004/Aug 2005
125 : // MODIFIED Lixing Gu, Aug. 2015 for v8.4 replease
126 : // RE-ENGINEERED na
127 :
128 : // PURPOSE OF THIS SUBROUTINE:
129 : // This subroutine manages RoomAirflowNetwork model simulation
130 :
131 : // METHODOLOGY EMPLOYED:
132 : // calls subroutines
133 :
134 : // REFERENCES:
135 : // na
136 :
137 : // USE STATEMENTS:
138 : // na
139 :
140 : // SUBROUTINE LOCAL VARIABLE DECLARATIONS:
141 : int ThisRoomAirNode;
142 : int RAFNNum;
143 :
144 7689 : RAFNNum = state.dataRoomAirMod->RoomAirflowNetworkZoneInfo(ZoneNum).RAFNNum;
145 :
146 7689 : if (RAFNNum == 0) {
147 0 : ShowFatalError(state,
148 0 : "SimRoomAirModelAirflowNetwork: Zone is not defined in the RoomAirModelAirflowNetwork model =" +
149 0 : state.dataHeatBal->Zone(ZoneNum).Name);
150 : }
151 :
152 7689 : auto &thisRAFN(state.dataRoomAirflowNetModel->RAFN(RAFNNum));
153 7689 : thisRAFN.ZoneNum = ZoneNum;
154 :
155 : // model control volume for each roomAir:node in the zone.
156 53823 : for (ThisRoomAirNode = 1; ThisRoomAirNode <= state.dataRoomAirMod->RoomAirflowNetworkZoneInfo(ZoneNum).NumOfAirNodes; ++ThisRoomAirNode) {
157 :
158 46134 : thisRAFN.RoomAirNode = ThisRoomAirNode;
159 :
160 46134 : thisRAFN.InitRoomAirModelAirflowNetwork(state, ThisRoomAirNode);
161 :
162 46134 : thisRAFN.CalcRoomAirModelAirflowNetwork(state, ThisRoomAirNode);
163 : }
164 :
165 7689 : thisRAFN.UpdateRoomAirModelAirflowNetwork(state);
166 :
167 7689 : } // SimRoomAirModelAirflowNetwork
168 :
169 : //****************************************************
170 :
171 7689 : void LoadPredictionRoomAirModelAirflowNetwork(EnergyPlusData &state,
172 : int const ZoneNum,
173 : int const RoomAirNode) // index number for the specified zone and node
174 : {
175 :
176 : // SUBROUTINE INFORMATION:
177 : // AUTHOR Lixing Gu
178 : // DATE WRITTEN June, 2015
179 : // MODIFIED na
180 : // RE-ENGINEERED na
181 :
182 : // PURPOSE OF THIS SUBROUTINE:
183 : // Predict zone loads at a controlled node
184 :
185 : // METHODOLOGY EMPLOYED:
186 : // na
187 :
188 : // REFERENCES:
189 : // na
190 :
191 : // USE STATEMENTS:
192 : // na
193 :
194 : // SUBROUTINE LOCAL VARIABLE DECLARATIONS:
195 : //////////// hoisted into namespace ////////////////////////////////////////////////
196 : // static bool OneTimeFlag_FindFirstLastPtr( true ); // one time setup flag //
197 : // state.dataRoomAirflowNetModel->LoadPredictionRoomAirModelAirflowNetworkOneTimeFlag
198 : ////////////////////////////////////////////////////////////////////////////////////
199 : int RAFNNum;
200 :
201 7689 : if (state.dataRoomAirflowNetModel->LoadPredictionRoomAirModelAirflowNetworkOneTimeFlag) {
202 1 : state.dataRoomAirflowNetModel->RAFN.allocate(state.dataRoomAirMod->NumOfRoomAirflowNetControl);
203 1 : state.dataRoomAirflowNetModel->LoadPredictionRoomAirModelAirflowNetworkOneTimeFlag = false;
204 : }
205 :
206 7689 : RAFNNum = state.dataRoomAirMod->RoomAirflowNetworkZoneInfo(ZoneNum).RAFNNum;
207 :
208 7689 : if (RAFNNum == 0) {
209 0 : ShowFatalError(state,
210 0 : "LoadPredictionRoomAirModelAirflowNetwork: Zone is not defined in the RoomAirModelAirflowNetwork model =" +
211 0 : state.dataHeatBal->Zone(ZoneNum).Name);
212 : }
213 7689 : auto &thisRAFN(state.dataRoomAirflowNetModel->RAFN(RAFNNum));
214 7689 : thisRAFN.ZoneNum = ZoneNum;
215 :
216 7689 : thisRAFN.InitRoomAirModelAirflowNetwork(state, RoomAirNode);
217 :
218 7689 : } // LoadPredictionRoomAirModelAirflowNetwork
219 :
220 : //****************************************************
221 :
222 53823 : void RAFNData::InitRoomAirModelAirflowNetwork(EnergyPlusData &state, int const RoomAirNode) // index number for the specified zone
223 : {
224 :
225 : // SUBROUTINE INFORMATION:
226 : // AUTHOR B. Griffith
227 : // DATE WRITTEN November 2009
228 : // MODIFIED Lixing Gu, Aug. 2015 for v8.4 replease
229 : // RE-ENGINEERED na
230 :
231 : // PURPOSE OF THIS SUBROUTINE:
232 : // Perform one-time checking and term calculations
233 :
234 : using InternalHeatGains::SumInternalLatentGainsByTypes;
235 : using Psychrometrics::PsyCpAirFnW;
236 : using Psychrometrics::PsyRhoAirFnPbTdbW;
237 :
238 : // SUBROUTINE LOCAL VARIABLE DECLARATIONS:
239 : //////////// hoisted into namespace ////////////////////////////////////////////////
240 : // static bool MyOneTimeFlag( true ); // one time setup flag // InitRoomAirModelAirflowNetworkOneTimeFlag
241 : // static bool MyOneTimeFlagConf( true ); // one time setup flag for zone configuration // InitRoomAirModelAirflowNetworkOneTimeFlagConf
242 : // static bool MyEnvrnFlag( true ); // one time setup flag for zone configuration // InitRoomAirModelAirflowNetworkEnvrnFlag
243 : ////////////////////////////////////////////////////////////////////////////////////
244 : Real64 SumLinkMCp;
245 : Real64 SumLinkMCpT;
246 : int linkNum;
247 : Real64 LinkInTemp;
248 : Real64 CpAir;
249 : Real64 LinkInHumRat;
250 : Real64 LinkInMdot;
251 : Real64 SumLinkM;
252 : Real64 SumLinkMW;
253 : int LoopZone;
254 : int LoopAirNode;
255 : int NodeNum;
256 : int NodeIn;
257 : int Link;
258 : int IdNode;
259 : int EquipLoop;
260 : int MaxNodeNum;
261 107646 : Array1D_bool NodeFound; // True if a node is found.
262 : int MaxEquipNum;
263 107646 : Array1D_bool EquipFound;
264 : int ISum;
265 : bool ErrorsFound;
266 : int I;
267 107646 : Array1D<Real64> SupplyFrac;
268 107646 : Array1D<Real64> ReturnFrac;
269 :
270 53823 : if (state.dataRoomAirflowNetModel->InitRoomAirModelAirflowNetworkOneTimeFlag) { // then do one - time setup inits
271 :
272 : // loop over all zones with RoomAirflowNetwork model
273 6 : for (LoopZone = 1; LoopZone <= state.dataGlobal->NumOfZones; ++LoopZone) {
274 5 : if (!state.dataRoomAirMod->RoomAirflowNetworkZoneInfo(LoopZone).IsUsed) continue;
275 1 : int NumSurfs = 0;
276 2 : for (int spaceNum : state.dataHeatBal->Zone(ZoneNum).spaceIndexes) {
277 1 : auto &thisSpace = state.dataHeatBal->space(spaceNum);
278 1 : NumSurfs += thisSpace.HTSurfaceLast - thisSpace.HTSurfaceFirst + 1;
279 : }
280 :
281 7 : for (LoopAirNode = 1; LoopAirNode <= state.dataRoomAirMod->RoomAirflowNetworkZoneInfo(LoopZone).NumOfAirNodes;
282 : ++LoopAirNode) { // loop over all the modeled room air nodes
283 : // calculate volume of air in node's control volume
284 6 : state.dataRoomAirMod->RoomAirflowNetworkZoneInfo(LoopZone).Node(LoopAirNode).AirVolume =
285 12 : state.dataHeatBal->Zone(LoopZone).Volume *
286 6 : state.dataRoomAirMod->RoomAirflowNetworkZoneInfo(LoopZone).Node(LoopAirNode).ZoneVolumeFraction;
287 :
288 24 : SetupOutputVariable(state,
289 : "RoomAirflowNetwork Node NonAirSystemResponse",
290 : OutputProcessor::Unit::W,
291 6 : state.dataRoomAirMod->RoomAirflowNetworkZoneInfo(LoopZone).Node(LoopAirNode).NonAirSystemResponse,
292 : OutputProcessor::SOVTimeStepType::HVAC,
293 : OutputProcessor::SOVStoreType::Average,
294 12 : state.dataRoomAirMod->RoomAirflowNetworkZoneInfo(LoopZone).Node(LoopAirNode).Name);
295 24 : SetupOutputVariable(state,
296 : "RoomAirflowNetwork Node SysDepZoneLoadsLagged",
297 : OutputProcessor::Unit::W,
298 6 : state.dataRoomAirMod->RoomAirflowNetworkZoneInfo(LoopZone).Node(LoopAirNode).SysDepZoneLoadsLagged,
299 : OutputProcessor::SOVTimeStepType::HVAC,
300 : OutputProcessor::SOVStoreType::Average,
301 12 : state.dataRoomAirMod->RoomAirflowNetworkZoneInfo(LoopZone).Node(LoopAirNode).Name);
302 24 : SetupOutputVariable(state,
303 : "RoomAirflowNetwork Node SumIntSensibleGain",
304 : OutputProcessor::Unit::W,
305 6 : state.dataRoomAirMod->RoomAirflowNetworkZoneInfo(LoopZone).Node(LoopAirNode).SumIntSensibleGain,
306 : OutputProcessor::SOVTimeStepType::HVAC,
307 : OutputProcessor::SOVStoreType::Average,
308 12 : state.dataRoomAirMod->RoomAirflowNetworkZoneInfo(LoopZone).Node(LoopAirNode).Name);
309 24 : SetupOutputVariable(state,
310 : "RoomAirflowNetwork Node SumIntLatentGain",
311 : OutputProcessor::Unit::W,
312 6 : state.dataRoomAirMod->RoomAirflowNetworkZoneInfo(LoopZone).Node(LoopAirNode).SumIntLatentGain,
313 : OutputProcessor::SOVTimeStepType::HVAC,
314 : OutputProcessor::SOVStoreType::Average,
315 12 : state.dataRoomAirMod->RoomAirflowNetworkZoneInfo(LoopZone).Node(LoopAirNode).Name);
316 : }
317 : }
318 1 : state.dataRoomAirflowNetModel->InitRoomAirModelAirflowNetworkOneTimeFlag = false;
319 : }
320 :
321 53823 : if (state.dataRoomAirflowNetModel->InitRoomAirModelAirflowNetworkOneTimeFlagConf) { // then do one - time setup inits
322 1 : if (allocated(state.dataZoneEquip->ZoneEquipConfig) && allocated(state.dataZoneEquip->ZoneEquipList)) {
323 1 : MaxNodeNum = 0;
324 1 : MaxEquipNum = 0;
325 1 : ErrorsFound = false;
326 6 : for (LoopZone = 1; LoopZone <= state.dataGlobal->NumOfZones; ++LoopZone) {
327 5 : if (!state.dataHeatBal->Zone(LoopZone).IsControlled) continue;
328 1 : MaxEquipNum = max(MaxEquipNum, state.dataZoneEquip->ZoneEquipList(LoopZone).NumOfEquipTypes);
329 1 : MaxNodeNum = max(MaxNodeNum, state.dataZoneEquip->ZoneEquipConfig(LoopZone).NumInletNodes);
330 : }
331 1 : if (MaxNodeNum > 0) {
332 1 : NodeFound.allocate(MaxNodeNum);
333 1 : NodeFound = false;
334 : }
335 1 : if (MaxEquipNum > 0) {
336 1 : EquipFound.allocate(MaxEquipNum);
337 1 : SupplyFrac.allocate(MaxEquipNum);
338 1 : ReturnFrac.allocate(MaxEquipNum);
339 1 : EquipFound = false;
340 1 : SupplyFrac = 0.0;
341 1 : ReturnFrac = 0.0;
342 : }
343 :
344 : // loop over all zones with RoomAirflowNetwork model
345 6 : for (LoopZone = 1; LoopZone <= state.dataGlobal->NumOfZones; ++LoopZone) {
346 5 : if (!state.dataHeatBal->Zone(LoopZone).IsControlled) continue;
347 1 : if (!state.dataRoomAirMod->RoomAirflowNetworkZoneInfo(LoopZone).IsUsed) continue;
348 1 : state.dataRoomAirMod->RoomAirflowNetworkZoneInfo(LoopZone).ActualZoneID = LoopZone;
349 1 : SupplyFrac = 0.0;
350 1 : ReturnFrac = 0.0;
351 1 : NodeFound = false;
352 1 : int numAirDistUnits = 0;
353 :
354 : // find supply air node number
355 7 : for (LoopAirNode = 1; LoopAirNode <= state.dataRoomAirMod->RoomAirflowNetworkZoneInfo(LoopZone).NumOfAirNodes;
356 : ++LoopAirNode) { // loop over all the modeled room air nodes
357 12 : for (EquipLoop = 1; EquipLoop <= state.dataRoomAirMod->RoomAirflowNetworkZoneInfo(LoopZone).Node(LoopAirNode).NumHVACs;
358 : ++EquipLoop) { // loop over all the equip for a single room air node
359 : // Check zone equipment name
360 12 : for (I = 1; I <= state.dataZoneEquip->ZoneEquipList(LoopZone).NumOfEquipTypes; ++I) { // loop over all equip types
361 6 : if (state.dataZoneEquip->ZoneEquipList(LoopZone).EquipTypeEnum(I) == DataZoneEquipment::ZoneEquip::AirDistUnit) {
362 0 : if (numAirDistUnits == 0)
363 0 : numAirDistUnits =
364 0 : state.dataInputProcessing->inputProcessor->getNumObjectsFound(state, "ZoneHVAC:AirDistributionUnit");
365 0 : if (state.dataZoneAirLoopEquipmentManager->GetAirDistUnitsFlag) {
366 0 : ZoneAirLoopEquipmentManager::GetZoneAirLoopEquipment(state);
367 0 : state.dataZoneAirLoopEquipmentManager->GetAirDistUnitsFlag = false;
368 : }
369 0 : for (int AirDistUnitNum = 1; AirDistUnitNum <= numAirDistUnits; ++AirDistUnitNum) {
370 0 : if (state.dataZoneEquip->ZoneEquipList(LoopZone).EquipName(I) ==
371 0 : state.dataDefineEquipment->AirDistUnit(AirDistUnitNum).Name) {
372 0 : if (state.dataRoomAirMod->RoomAirflowNetworkZoneInfo(LoopZone).Node(LoopAirNode).HVAC(EquipLoop).Name ==
373 0 : state.dataDefineEquipment->AirDistUnit(AirDistUnitNum).EquipName(1)) {
374 0 : if (state.dataRoomAirMod->RoomAirflowNetworkZoneInfo(LoopZone)
375 0 : .Node(LoopAirNode)
376 0 : .HVAC(EquipLoop)
377 0 : .EquipConfigIndex == 0)
378 0 : state.dataRoomAirMod->RoomAirflowNetworkZoneInfo(LoopZone)
379 0 : .Node(LoopAirNode)
380 0 : .HVAC(EquipLoop)
381 0 : .EquipConfigIndex = I;
382 0 : if (!EquipFound(I)) EquipFound(I) = true;
383 0 : SupplyFrac(I) = SupplyFrac(I) + state.dataRoomAirMod->RoomAirflowNetworkZoneInfo(LoopZone)
384 0 : .Node(LoopAirNode)
385 0 : .HVAC(EquipLoop)
386 0 : .SupplyFraction;
387 0 : ReturnFrac(I) = ReturnFrac(I) + state.dataRoomAirMod->RoomAirflowNetworkZoneInfo(LoopZone)
388 0 : .Node(LoopAirNode)
389 0 : .HVAC(EquipLoop)
390 0 : .ReturnFraction;
391 : }
392 : }
393 : }
394 : } else {
395 12 : if (UtilityRoutines::SameString(
396 6 : state.dataZoneEquip->ZoneEquipList(LoopZone).EquipName(I),
397 6 : state.dataRoomAirMod->RoomAirflowNetworkZoneInfo(LoopZone).Node(LoopAirNode).HVAC(EquipLoop).Name)) {
398 12 : if (state.dataRoomAirMod->RoomAirflowNetworkZoneInfo(LoopZone)
399 6 : .Node(LoopAirNode)
400 6 : .HVAC(EquipLoop)
401 6 : .EquipConfigIndex == 0)
402 6 : state.dataRoomAirMod->RoomAirflowNetworkZoneInfo(LoopZone)
403 6 : .Node(LoopAirNode)
404 6 : .HVAC(EquipLoop)
405 12 : .EquipConfigIndex = I;
406 6 : EquipFound(I) = true;
407 12 : SupplyFrac(I) = SupplyFrac(I) + state.dataRoomAirMod->RoomAirflowNetworkZoneInfo(LoopZone)
408 6 : .Node(LoopAirNode)
409 6 : .HVAC(EquipLoop)
410 6 : .SupplyFraction;
411 12 : ReturnFrac(I) = ReturnFrac(I) + state.dataRoomAirMod->RoomAirflowNetworkZoneInfo(LoopZone)
412 6 : .Node(LoopAirNode)
413 6 : .HVAC(EquipLoop)
414 6 : .ReturnFraction;
415 : }
416 : }
417 : }
418 18 : for (IdNode = 1; IdNode <= state.dataLoopNodes->NumOfNodes; ++IdNode) { // loop over all nodes to find supply node ID
419 18 : if (UtilityRoutines::SameString(state.dataLoopNodes->NodeID(IdNode),
420 18 : state.dataRoomAirMod->RoomAirflowNetworkZoneInfo(LoopZone)
421 18 : .Node(LoopAirNode)
422 18 : .HVAC(EquipLoop)
423 : .SupplyNodeName)) {
424 6 : state.dataRoomAirMod->RoomAirflowNetworkZoneInfo(LoopZone).Node(LoopAirNode).HVAC(EquipLoop).SupNodeNum = IdNode;
425 6 : break;
426 : }
427 : }
428 : // Verify inlet nodes
429 6 : int inletNodeIndex = 0;
430 6 : for (NodeNum = 1; NodeNum <= state.dataZoneEquip->ZoneEquipConfig(LoopZone).NumInletNodes;
431 : ++NodeNum) { // loop over all supply inlet nodes in a single zone
432 : // !Get node conditions
433 6 : if (state.dataZoneEquip->ZoneEquipConfig(LoopZone).InletNode(NodeNum) == IdNode) {
434 6 : NodeFound(NodeNum) = true;
435 6 : inletNodeIndex = NodeNum;
436 6 : break;
437 : }
438 : }
439 :
440 18 : if (state.dataRoomAirMod->RoomAirflowNetworkZoneInfo(LoopZone).Node(LoopAirNode).HVAC(EquipLoop).SupNodeNum > 0 &&
441 12 : UtilityRoutines::SameString(
442 6 : state.dataRoomAirMod->RoomAirflowNetworkZoneInfo(LoopZone).Node(LoopAirNode).HVAC(EquipLoop).ReturnNodeName,
443 6 : "")) {
444 : // Find matching return node
445 0 : for (int retNode = 1; retNode <= state.dataZoneEquip->ZoneEquipConfig(LoopZone).NumReturnNodes; ++retNode) {
446 0 : if ((state.dataZoneEquip->ZoneEquipConfig(LoopZone).ReturnNodeInletNum(retNode) == inletNodeIndex) &&
447 0 : (state.dataZoneEquip->ZoneEquipConfig(LoopZone).ReturnNode(retNode) > 0)) {
448 0 : state.dataRoomAirMod->RoomAirflowNetworkZoneInfo(LoopZone).Node(LoopAirNode).HVAC(EquipLoop).RetNodeNum =
449 0 : state.dataZoneEquip->ZoneEquipConfig(LoopZone).ReturnNode(retNode); // Zone return node
450 0 : break;
451 : }
452 : }
453 : }
454 :
455 6 : if (state.dataRoomAirMod->RoomAirflowNetworkZoneInfo(LoopZone).Node(LoopAirNode).HVAC(EquipLoop).RetNodeNum == 0) {
456 12 : for (IdNode = 1; IdNode <= state.dataLoopNodes->NumOfNodes; ++IdNode) { // loop over all nodes to find return node ID
457 12 : if (UtilityRoutines::SameString(state.dataLoopNodes->NodeID(IdNode),
458 12 : state.dataRoomAirMod->RoomAirflowNetworkZoneInfo(LoopZone)
459 12 : .Node(LoopAirNode)
460 12 : .HVAC(EquipLoop)
461 : .ReturnNodeName)) {
462 6 : state.dataRoomAirMod->RoomAirflowNetworkZoneInfo(LoopZone).Node(LoopAirNode).HVAC(EquipLoop).RetNodeNum =
463 : IdNode;
464 6 : break;
465 : }
466 : }
467 : }
468 24 : SetupOutputVariable(
469 : state,
470 : "RoomAirflowNetwork Node HVAC Supply Fraction",
471 : OutputProcessor::Unit::None,
472 6 : state.dataRoomAirMod->RoomAirflowNetworkZoneInfo(LoopZone).Node(LoopAirNode).HVAC(EquipLoop).SupplyFraction,
473 : OutputProcessor::SOVTimeStepType::HVAC,
474 : OutputProcessor::SOVStoreType::Average,
475 12 : state.dataRoomAirMod->RoomAirflowNetworkZoneInfo(LoopZone).Node(LoopAirNode).HVAC(EquipLoop).Name);
476 24 : SetupOutputVariable(
477 : state,
478 : "RoomAirflowNetwork Node HVAC Return Fraction",
479 : OutputProcessor::Unit::None,
480 6 : state.dataRoomAirMod->RoomAirflowNetworkZoneInfo(LoopZone).Node(LoopAirNode).HVAC(EquipLoop).ReturnFraction,
481 : OutputProcessor::SOVTimeStepType::HVAC,
482 : OutputProcessor::SOVStoreType::Average,
483 12 : state.dataRoomAirMod->RoomAirflowNetworkZoneInfo(LoopZone).Node(LoopAirNode).HVAC(EquipLoop).Name);
484 : }
485 : }
486 : // Count node with.TRUE.
487 1 : ISum = 0;
488 2 : for (NodeNum = 1; NodeNum <= MaxNodeNum; ++NodeNum) { // loop over all supply inlet nodes in a single zone
489 1 : if (NodeFound(NodeNum)) ISum = ISum + 1;
490 : }
491 : // Provide error messages with incorrect supplu node inputs
492 1 : if (ISum != state.dataZoneEquip->ZoneEquipConfig(LoopZone).NumInletNodes) {
493 0 : if (ISum > state.dataZoneEquip->ZoneEquipConfig(LoopZone).NumInletNodes) {
494 0 : ShowSevereError(
495 : state, "GetRoomAirflowNetworkData: The number of equipment listed in RoomAirflowNetwork:Node:HVACEquipment objects");
496 0 : ShowContinueError(
497 0 : state, "is greater than the number of zone configuration inlet nodes in " + state.dataHeatBal->Zone(LoopZone).Name);
498 0 : ShowContinueError(state, "Please check inputs of both objects.");
499 0 : ErrorsFound = true;
500 : } else {
501 0 : ShowSevereError(
502 : state, "GetRoomAirflowNetworkData: The number of equipment listed in RoomAirflowNetwork:Node:HVACEquipment objects");
503 0 : ShowContinueError(
504 0 : state, "is less than the number of zone configuration inlet nodes in " + state.dataHeatBal->Zone(LoopZone).Name);
505 0 : ShowContinueError(state, "Please check inputs of both objects.");
506 0 : ErrorsFound = true;
507 : }
508 : }
509 :
510 : // Check equipment names to ensure they are used in RoomAirflowNetwork : Node : HVACEquipment objects
511 2 : for (I = 1; I <= state.dataZoneEquip->ZoneEquipList(LoopZone).NumOfEquipTypes; ++I) { // loop over all equip types
512 1 : if (!EquipFound(I)) {
513 0 : ShowSevereError(state,
514 : "GetRoomAirflowNetworkData: The equipment listed in ZoneEquipList is not found in the lsit of "
515 : "RoomAir:Node:AirflowNetwork:HVACEquipment objects =");
516 0 : ShowContinueError(state,
517 0 : state.dataZoneEquip->ZoneEquipList(LoopZone).EquipName(I) + ". Please check inputs of both objects.");
518 0 : ErrorsFound = true;
519 : }
520 : }
521 :
522 : // Check fraction to ensure sum = 1.0 for every equipment
523 2 : for (I = 1; I <= state.dataZoneEquip->ZoneEquipList(LoopZone).NumOfEquipTypes; ++I) { // loop over all equip types
524 1 : if (std::abs(SupplyFrac(I) - 1.0) > 0.001) {
525 0 : ShowSevereError(state, "GetRoomAirflowNetworkData: Invalid, zone supply fractions do not sum to 1.0");
526 0 : ShowContinueError(state,
527 0 : "Entered in " + state.dataZoneEquip->ZoneEquipList(LoopZone).EquipName(I) +
528 : " defined in RoomAir:Node:AirflowNetwork:HVACEquipment");
529 0 : ShowContinueError(state,
530 : "The Fraction of supply fraction values across all the roomair nodes in a zone needs to sum to 1.0.");
531 0 : ShowContinueError(state, format("The sum of fractions entered = {:.3R}", SupplyFrac(I)));
532 0 : ErrorsFound = true;
533 : }
534 1 : if (std::abs(ReturnFrac(I) - 1.0) > 0.001) {
535 0 : ShowSevereError(state, "GetRoomAirflowNetworkData: Invalid, zone return fractions do not sum to 1.0");
536 0 : ShowContinueError(state,
537 0 : "Entered in " + state.dataZoneEquip->ZoneEquipList(LoopZone).EquipName(I) +
538 : " defined in RoomAir:Node:AirflowNetwork:HVACEquipment");
539 0 : ShowContinueError(state,
540 : "The Fraction of return fraction values across all the roomair nodes in a zone needs to sum to 1.0.");
541 0 : ShowContinueError(state, format("The sum of fractions entered = {:.3R}", ReturnFrac(I)));
542 0 : ErrorsFound = true;
543 : }
544 : }
545 : }
546 1 : state.dataRoomAirflowNetModel->InitRoomAirModelAirflowNetworkOneTimeFlagConf = false;
547 1 : if (allocated(NodeFound)) NodeFound.deallocate();
548 1 : if (ErrorsFound) {
549 0 : ShowFatalError(state, "GetRoomAirflowNetworkData: Errors found getting air model input. Program terminates.");
550 : }
551 : }
552 : } // End of InitRoomAirModelAirflowNetworkOneTimeFlagConf
553 :
554 53823 : if (state.dataGlobal->BeginEnvrnFlag && state.dataRoomAirflowNetModel->InitRoomAirModelAirflowNetworkEnvrnFlag) {
555 54 : for (LoopZone = 1; LoopZone <= state.dataGlobal->NumOfZones; ++LoopZone) {
556 45 : if (!state.dataRoomAirMod->RoomAirflowNetworkZoneInfo(LoopZone).IsUsed) continue;
557 63 : for (LoopAirNode = 1; LoopAirNode <= state.dataRoomAirMod->RoomAirflowNetworkZoneInfo(LoopZone).NumOfAirNodes;
558 : ++LoopAirNode) { // loop over all the modeled room air nodes
559 54 : state.dataRoomAirMod->RoomAirflowNetworkZoneInfo(LoopZone).Node(LoopAirNode).AirTemp = 23.0;
560 54 : state.dataRoomAirMod->RoomAirflowNetworkZoneInfo(LoopZone).Node(LoopAirNode).AirTempX1 = 23.0;
561 54 : state.dataRoomAirMod->RoomAirflowNetworkZoneInfo(LoopZone).Node(LoopAirNode).AirTempX2 = 23.0;
562 54 : state.dataRoomAirMod->RoomAirflowNetworkZoneInfo(LoopZone).Node(LoopAirNode).AirTempX3 = 23.0;
563 54 : state.dataRoomAirMod->RoomAirflowNetworkZoneInfo(LoopZone).Node(LoopAirNode).AirTempX4 = 23.0;
564 54 : state.dataRoomAirMod->RoomAirflowNetworkZoneInfo(LoopZone).Node(LoopAirNode).AirTempDSX1 = 23.0;
565 54 : state.dataRoomAirMod->RoomAirflowNetworkZoneInfo(LoopZone).Node(LoopAirNode).AirTempDSX2 = 23.0;
566 54 : state.dataRoomAirMod->RoomAirflowNetworkZoneInfo(LoopZone).Node(LoopAirNode).AirTempDSX3 = 23.0;
567 54 : state.dataRoomAirMod->RoomAirflowNetworkZoneInfo(LoopZone).Node(LoopAirNode).AirTempDSX4 = 23.0;
568 54 : state.dataRoomAirMod->RoomAirflowNetworkZoneInfo(LoopZone).Node(LoopAirNode).AirTempT1 = 23.0;
569 54 : state.dataRoomAirMod->RoomAirflowNetworkZoneInfo(LoopZone).Node(LoopAirNode).AirTempTMX = 23.0;
570 54 : state.dataRoomAirMod->RoomAirflowNetworkZoneInfo(LoopZone).Node(LoopAirNode).AirTempTM2 = 23.0;
571 :
572 54 : state.dataRoomAirMod->RoomAirflowNetworkZoneInfo(LoopZone).Node(LoopAirNode).HumRat = 0.0;
573 54 : state.dataRoomAirMod->RoomAirflowNetworkZoneInfo(LoopZone).Node(LoopAirNode).HumRatX1 = 0.0;
574 54 : state.dataRoomAirMod->RoomAirflowNetworkZoneInfo(LoopZone).Node(LoopAirNode).HumRatX2 = 0.0;
575 54 : state.dataRoomAirMod->RoomAirflowNetworkZoneInfo(LoopZone).Node(LoopAirNode).HumRatX3 = 0.0;
576 54 : state.dataRoomAirMod->RoomAirflowNetworkZoneInfo(LoopZone).Node(LoopAirNode).HumRatX4 = 0.0;
577 54 : state.dataRoomAirMod->RoomAirflowNetworkZoneInfo(LoopZone).Node(LoopAirNode).HumRatDSX1 = 0.0;
578 54 : state.dataRoomAirMod->RoomAirflowNetworkZoneInfo(LoopZone).Node(LoopAirNode).HumRatDSX2 = 0.0;
579 54 : state.dataRoomAirMod->RoomAirflowNetworkZoneInfo(LoopZone).Node(LoopAirNode).HumRatDSX3 = 0.0;
580 54 : state.dataRoomAirMod->RoomAirflowNetworkZoneInfo(LoopZone).Node(LoopAirNode).HumRatDSX4 = 0.0;
581 54 : state.dataRoomAirMod->RoomAirflowNetworkZoneInfo(LoopZone).Node(LoopAirNode).HumRatW1 = 0.0;
582 54 : state.dataRoomAirMod->RoomAirflowNetworkZoneInfo(LoopZone).Node(LoopAirNode).HumRatWMX = 0.0;
583 54 : state.dataRoomAirMod->RoomAirflowNetworkZoneInfo(LoopZone).Node(LoopAirNode).HumRatWM2 = 0.0;
584 :
585 54 : state.dataRoomAirMod->RoomAirflowNetworkZoneInfo(LoopZone).Node(LoopAirNode).SysDepZoneLoadsLagged = 0.0;
586 54 : state.dataRoomAirMod->RoomAirflowNetworkZoneInfo(LoopZone).Node(LoopAirNode).SysDepZoneLoadsLaggedOld = 0.0;
587 : }
588 : }
589 9 : state.dataRoomAirflowNetModel->InitRoomAirModelAirflowNetworkEnvrnFlag = false;
590 : }
591 53823 : if (!state.dataGlobal->BeginEnvrnFlag) {
592 53557 : state.dataRoomAirflowNetModel->InitRoomAirModelAirflowNetworkEnvrnFlag = true;
593 : }
594 :
595 : // reuse code in ZoneTempPredictorCorrector for sensible components.
596 53823 : CalcNodeSums(state, RoomAirNode);
597 :
598 53823 : SumNonAirSystemResponseForNode(state, RoomAirNode);
599 :
600 : // latent gains.
601 53823 : auto &ThisRAFNNode(state.dataRoomAirMod->RoomAirflowNetworkZoneInfo(ZoneNum).Node(RoomAirNode));
602 :
603 53823 : if (allocated(ThisRAFNNode.SurfMask)) {
604 53823 : CalcSurfaceMoistureSums(state, RoomAirNode, ThisRAFNNode.SumHmAW, ThisRAFNNode.SumHmARa, ThisRAFNNode.SumHmARaW, ThisRAFNNode.SurfMask);
605 : }
606 :
607 : // prepare AirflowNetwor flow rates and temperatures
608 53823 : SumLinkMCp = 0.0;
609 53823 : SumLinkMCpT = 0.0;
610 53823 : SumLinkM = 0.0;
611 53823 : SumLinkMW = 0.0;
612 :
613 53823 : NodeNum = ThisRAFNNode.AirflowNetworkNodeID;
614 53823 : if (NodeNum > 0) {
615 384450 : for (linkNum = 1; linkNum <= ThisRAFNNode.NumOfAirflowLinks; ++linkNum) {
616 330627 : Link = ThisRAFNNode.Link(linkNum).AirflowNetworkLinkSimuID;
617 330627 : if (state.afn->AirflowNetworkLinkageData(Link).NodeNums[0] == NodeNum) { // incoming flow
618 176847 : NodeIn = state.afn->AirflowNetworkLinkageData(Link).NodeNums[1];
619 176847 : ThisRAFNNode.Link(linkNum).TempIn = state.afn->AirflowNetworkNodeSimu(NodeIn).TZ;
620 176847 : ThisRAFNNode.Link(linkNum).HumRatIn = state.afn->AirflowNetworkNodeSimu(NodeIn).WZ;
621 176847 : ThisRAFNNode.Link(linkNum).MdotIn = state.afn->AirflowNetworkLinkSimu(Link).FLOW2;
622 : }
623 330627 : if (state.afn->AirflowNetworkLinkageData(Link).NodeNums[1] == NodeNum) { // outgoing flow
624 153780 : NodeIn = state.afn->AirflowNetworkLinkageData(Link).NodeNums[0];
625 153780 : ThisRAFNNode.Link(linkNum).TempIn = state.afn->AirflowNetworkNodeSimu(NodeIn).TZ;
626 153780 : ThisRAFNNode.Link(linkNum).HumRatIn = state.afn->AirflowNetworkNodeSimu(NodeIn).WZ;
627 153780 : ThisRAFNNode.Link(linkNum).MdotIn = state.afn->AirflowNetworkLinkSimu(Link).FLOW;
628 : }
629 : }
630 :
631 384450 : for (linkNum = 1; linkNum <= ThisRAFNNode.NumOfAirflowLinks; ++linkNum) {
632 330627 : LinkInTemp = ThisRAFNNode.Link(linkNum).TempIn;
633 330627 : LinkInHumRat = ThisRAFNNode.Link(linkNum).HumRatIn;
634 330627 : LinkInMdot = ThisRAFNNode.Link(linkNum).MdotIn;
635 330627 : CpAir = PsyCpAirFnW(LinkInHumRat);
636 330627 : SumLinkMCp = SumLinkMCp + CpAir * LinkInMdot;
637 330627 : SumLinkMCpT = SumLinkMCpT + CpAir * LinkInMdot * LinkInTemp;
638 330627 : SumLinkM = SumLinkM + LinkInMdot;
639 330627 : SumLinkMW = SumLinkMW + LinkInMdot * LinkInHumRat;
640 : }
641 : }
642 :
643 53823 : ThisRAFNNode.SumLinkMCp = SumLinkMCp;
644 53823 : ThisRAFNNode.SumLinkMCpT = SumLinkMCpT;
645 53823 : ThisRAFNNode.SumLinkM = SumLinkM;
646 53823 : ThisRAFNNode.SumLinkMW = SumLinkMW;
647 53823 : ThisRAFNNode.SysDepZoneLoadsLagged = ThisRAFNNode.SysDepZoneLoadsLaggedOld;
648 :
649 53823 : ThisRAFNNode.RhoAir =
650 107646 : PsyRhoAirFnPbTdbW(state, state.dataEnvrn->OutBaroPress, ThisRAFNNode.AirTemp, ThisRAFNNode.HumRat, "InitRoomAirModelAirflowNetwork");
651 :
652 53823 : ThisRAFNNode.CpAir = PsyCpAirFnW(ThisRAFNNode.HumRat);
653 :
654 53823 : } // InitRoomAirModelAirflowNetwork
655 :
656 : //*****************************************************************************************
657 :
658 46134 : void RAFNData::CalcRoomAirModelAirflowNetwork(EnergyPlusData &state, int const RoomAirNode) // index number for the specified zone and node
659 : {
660 :
661 : // SUBROUTINE INFORMATION:
662 : // AUTHOR Brent Griffith
663 : // DATE WRITTEN November 2009
664 : // MODIFIED Lixing Gu, Aug. 2015 for v8.4 replease
665 : // RE-ENGINEERED
666 :
667 : // PURPOSE OF THIS SUBROUTINE:
668 : // calculate new values for temperature and humidity ratio for room air node
669 :
670 : // METHODOLOGY EMPLOYED:
671 : // take terms(updated in init routine) and use classic air balance equations
672 : // solved for state variables. Store results in structure.
673 :
674 : // REFERENCES:
675 : // na
676 :
677 : // Using/Aliasing
678 46134 : auto &TimeStepSys = state.dataHVACGlobal->TimeStepSys;
679 : using Psychrometrics::PsyHgAirFnWTdb;
680 : using Psychrometrics::PsyRhFnTdbWPb;
681 :
682 : // SUBROUTINE LOCAL VARIABLE DECLARATIONS:
683 : Real64 H2OHtOfVap;
684 : Real64 HumRatTmp;
685 : Real64 NodeTempX1;
686 : Real64 NodeTempX2;
687 : Real64 NodeTempX3;
688 : Real64 NodeHumRatX1;
689 : Real64 NodeHumRatX2;
690 : Real64 NodeHumRatX3;
691 : Real64 TempDepCoef;
692 : Real64 TempIndCoef;
693 : Real64 AirCap;
694 : Real64 TempTmp;
695 : Real64 A;
696 : Real64 B;
697 : Real64 C;
698 : Real64 AirTempT1;
699 : Real64 HumRatW1;
700 :
701 46134 : auto &ThisRAFNNode(state.dataRoomAirMod->RoomAirflowNetworkZoneInfo(ZoneNum).Node(RoomAirNode));
702 :
703 46134 : if (state.dataHVACGlobal->UseZoneTimeStepHistory) {
704 35514 : NodeTempX1 = ThisRAFNNode.AirTempX1;
705 35514 : NodeTempX2 = ThisRAFNNode.AirTempX2;
706 35514 : NodeTempX3 = ThisRAFNNode.AirTempX3;
707 :
708 35514 : NodeHumRatX1 = ThisRAFNNode.HumRatX1;
709 35514 : NodeHumRatX2 = ThisRAFNNode.HumRatX2;
710 35514 : NodeHumRatX3 = ThisRAFNNode.HumRatX3;
711 : } else { // use down - stepped history
712 10620 : NodeTempX1 = ThisRAFNNode.AirTempDSX1;
713 10620 : NodeTempX2 = ThisRAFNNode.AirTempDSX2;
714 10620 : NodeTempX3 = ThisRAFNNode.AirTempDSX3;
715 :
716 10620 : NodeHumRatX1 = ThisRAFNNode.HumRatDSX1;
717 10620 : NodeHumRatX2 = ThisRAFNNode.HumRatDSX2;
718 10620 : NodeHumRatX3 = ThisRAFNNode.HumRatDSX3;
719 : }
720 :
721 46134 : if (state.dataHeatBal->ZoneAirSolutionAlgo != DataHeatBalance::SolutionAlgo::ThirdOrder) {
722 0 : AirTempT1 = ThisRAFNNode.AirTempT1;
723 0 : HumRatW1 = ThisRAFNNode.HumRatW1;
724 : }
725 : // solve for node drybulb temperature
726 46134 : TempDepCoef = ThisRAFNNode.SumHA + ThisRAFNNode.SumLinkMCp + ThisRAFNNode.SumSysMCp;
727 138402 : TempIndCoef = ThisRAFNNode.SumIntSensibleGain + ThisRAFNNode.SumHATsurf - ThisRAFNNode.SumHATref + ThisRAFNNode.SumLinkMCpT +
728 92268 : ThisRAFNNode.SumSysMCpT + ThisRAFNNode.NonAirSystemResponse + ThisRAFNNode.SysDepZoneLoadsLagged;
729 92268 : AirCap = ThisRAFNNode.AirVolume * state.dataHeatBal->Zone(ZoneNum).ZoneVolCapMultpSens * ThisRAFNNode.RhoAir * ThisRAFNNode.CpAir /
730 46134 : (TimeStepSys * DataGlobalConstants::SecInHour);
731 :
732 46134 : if (state.dataHeatBal->ZoneAirSolutionAlgo == DataHeatBalance::SolutionAlgo::AnalyticalSolution) {
733 0 : if (TempDepCoef == 0.0) { // B=0
734 0 : TempTmp = AirTempT1 + TempIndCoef / AirCap;
735 : } else {
736 0 : TempTmp = (AirTempT1 - TempIndCoef / TempDepCoef) * std::exp(min(700.0, -TempDepCoef / AirCap)) + TempIndCoef / TempDepCoef;
737 : }
738 46134 : } else if (state.dataHeatBal->ZoneAirSolutionAlgo == DataHeatBalance::SolutionAlgo::EulerMethod) {
739 0 : TempTmp = (AirCap * AirTempT1 + TempIndCoef) / (AirCap + TempDepCoef);
740 : } else {
741 92268 : TempTmp = (TempIndCoef + AirCap * (3.0 * NodeTempX1 - (3.0 / 2.0) * NodeTempX2 + (1.0 / 3.0) * NodeTempX3)) /
742 46134 : ((11.0 / 6.0) * AirCap + TempDepCoef);
743 : }
744 :
745 46134 : ThisRAFNNode.AirTemp = TempTmp;
746 :
747 : // solve for node humidity ratio using 3 algorithms
748 46134 : H2OHtOfVap = PsyHgAirFnWTdb(ThisRAFNNode.HumRat, ThisRAFNNode.AirTemp);
749 46134 : A = ThisRAFNNode.SumLinkM + ThisRAFNNode.SumHmARa + ThisRAFNNode.SumSysM;
750 46134 : B = (ThisRAFNNode.SumIntLatentGain / H2OHtOfVap) + ThisRAFNNode.SumSysMW + ThisRAFNNode.SumLinkMW + ThisRAFNNode.SumHmARaW;
751 92268 : C = ThisRAFNNode.RhoAir * ThisRAFNNode.AirVolume * state.dataHeatBal->Zone(ZoneNum).ZoneVolCapMultpMoist /
752 46134 : (DataGlobalConstants::SecInHour * TimeStepSys);
753 :
754 : // Exact solution
755 46134 : if (state.dataHeatBal->ZoneAirSolutionAlgo == DataHeatBalance::SolutionAlgo::AnalyticalSolution) {
756 0 : if (A == 0.0) { // B=0
757 0 : HumRatTmp = HumRatW1 + B / C;
758 : } else {
759 0 : HumRatTmp = (HumRatW1 - B / A) * std::exp(min(700., -A / C)) + B / A;
760 : }
761 46134 : } else if (state.dataHeatBal->ZoneAirSolutionAlgo == DataHeatBalance::SolutionAlgo::EulerMethod) {
762 0 : HumRatTmp = (C * HumRatW1 + B) / (C + A);
763 : } else {
764 46134 : HumRatTmp = (B + C * (3.0 * NodeHumRatX1 - (3.0 / 2.0) * NodeHumRatX2 + (1.0 / 3.0) * NodeHumRatX3)) / ((11.0 / 6.0) * C + A);
765 : }
766 :
767 46134 : ThisRAFNNode.HumRat = HumRatTmp;
768 :
769 46134 : ThisRAFNNode.AirCap = AirCap;
770 46134 : ThisRAFNNode.AirHumRat = C;
771 :
772 46134 : ThisRAFNNode.RelHumidity = PsyRhFnTdbWPb(state, TempTmp, HumRatTmp, state.dataEnvrn->OutBaroPress, "CalcRoomAirModelAirflowNetwork") * 100.0;
773 :
774 46134 : } // CalcRoomAirModelAirflowNetwork
775 :
776 7689 : void RAFNData::UpdateRoomAirModelAirflowNetwork(EnergyPlusData &state)
777 : {
778 :
779 : // SUBROUTINE INFORMATION:
780 : // AUTHOR B Griffith
781 : // DATE WRITTEN November 2009
782 : // MODIFIED Lixing Gu, Aug. 2015 for v8.4 replease
783 : // RE-ENGINEERED na
784 :
785 : // PURPOSE OF THIS SUBROUTINE:
786 : // update variables
787 :
788 : // METHODOLOGY EMPLOYED:
789 : // na
790 :
791 : // REFERENCES:
792 : // na
793 :
794 : // SUBROUTINE LOCAL VARIABLE DECLARATIONS:
795 : int AirNodeNum; // nested node structure index
796 : int I;
797 : int LoopAirNode;
798 : int EquipLoop;
799 : Real64 NodeMass;
800 : Real64 SumMass;
801 : Real64 SumMassT;
802 : Real64 SumMassW;
803 : int RetNodeNum;
804 :
805 7689 : auto &ThisRAFNZone(state.dataRoomAirMod->RoomAirflowNetworkZoneInfo(ZoneNum));
806 :
807 7689 : if (!ThisRAFNZone.IsUsed) return;
808 :
809 7689 : if (!state.dataGlobal->ZoneSizingCalc) SumSystemDepResponseForNode(state);
810 :
811 7689 : AirNodeNum = state.dataRoomAirMod->RoomAirflowNetworkZoneInfo(ZoneNum).ControlAirNodeID;
812 :
813 : // Update return node conditions
814 15378 : for (I = 1; I <= state.dataZoneEquip->ZoneEquipList(ZoneNum).NumOfEquipTypes; ++I) { // loop over all equip types
815 7689 : SumMass = 0.0;
816 7689 : SumMassT = 0.0;
817 7689 : SumMassW = 0.0;
818 53823 : for (LoopAirNode = 1; LoopAirNode <= ThisRAFNZone.NumOfAirNodes; ++LoopAirNode) { // loop over all the modeled room air nodes
819 92268 : for (EquipLoop = 1; EquipLoop <= ThisRAFNZone.Node(LoopAirNode).NumHVACs;
820 : ++EquipLoop) { // loop over all the equip for a single room air node
821 46134 : if (ThisRAFNZone.Node(LoopAirNode).HVAC(EquipLoop).EquipConfigIndex == I) {
822 92268 : if (ThisRAFNZone.Node(LoopAirNode).HVAC(EquipLoop).SupNodeNum > 0 &&
823 46134 : ThisRAFNZone.Node(LoopAirNode).HVAC(EquipLoop).RetNodeNum > 0) {
824 92268 : NodeMass = state.dataLoopNodes->Node(ThisRAFNZone.Node(LoopAirNode).HVAC(EquipLoop).SupNodeNum).MassFlowRate *
825 46134 : ThisRAFNZone.Node(LoopAirNode).HVAC(EquipLoop).ReturnFraction;
826 46134 : SumMass += NodeMass;
827 46134 : SumMassT += NodeMass * ThisRAFNZone.Node(LoopAirNode).AirTemp;
828 46134 : SumMassW += NodeMass * ThisRAFNZone.Node(LoopAirNode).HumRat;
829 46134 : RetNodeNum = ThisRAFNZone.Node(LoopAirNode).HVAC(EquipLoop).RetNodeNum;
830 : }
831 : }
832 : }
833 : }
834 7689 : if (SumMass > 0.0) {
835 7572 : state.dataLoopNodes->Node(RetNodeNum).Temp = SumMassT / SumMass;
836 7572 : state.dataLoopNodes->Node(RetNodeNum).HumRat = SumMassW / SumMass;
837 : }
838 : }
839 : } // UpdateRoomAirModelAirflowNetwork
840 :
841 53823 : void RAFNData::CalcNodeSums(EnergyPlusData &state, int const RoomAirNodeNum)
842 : {
843 :
844 : // SUBROUTINE INFORMATION:
845 : // AUTHOR B Griffith
846 : // DATE WRITTEN August 2009
847 : // MODIFIED Lixing Gu, Aug. 2015 for v8.4 replease
848 : // RE - ENGINEERED na
849 :
850 : // PURPOSE OF THIS SUBROUTINE :
851 : // This subroutine calculates the various sums that go into the zone heat balance
852 : // equation.This replaces the SUMC, SUMHA, and SUMHAT calculations that were
853 : // previously done in various places throughout the program.
854 : // The SumHAT portion of the code is reproduced in RadiantSystemHighTemp and
855 : // RadiantSystemLowTemp and should be updated accordingly.
856 : //
857 : // A reference temperature(Tref) is specified for use with the ceiling diffuser
858 : // convection correlation.A bogus value of Tref = -999.9 defaults to using
859 : // the zone air(i.e.outlet) temperature for the reference temperature.
860 : // If Tref is applied to all surfaces, SumHA = 0, and SumHATref /= 0.
861 : // If Tref is not used at all, SumHATref = 0, and SumHA /= 0.
862 : //
863 :
864 : // USE STATEMENTS:
865 : using InternalHeatGains::SumInternalConvectionGainsByIndices;
866 : using InternalHeatGains::SumInternalLatentGainsByIndices;
867 : using InternalHeatGains::SumReturnAirConvectionGainsByIndices;
868 : using InternalHeatGains::SumReturnAirConvectionGainsByTypes;
869 : using Psychrometrics::PsyCpAirFnW;
870 : using Psychrometrics::PsyRhoAirFnPbTdbW;
871 :
872 : // SUBROUTINE LOCAL VARIABLE DECLARATIONS:
873 : int NodeNum; // System node number
874 : Real64 NodeTemp; // System node temperature
875 : Real64 NodeW; // System node humidity ratio
876 : Real64 MassFlowRate; // System node mass flow rate
877 : int ZoneRetPlenumNum;
878 : int ZoneSupPlenumNum;
879 : bool ZoneRetPlenumAirFlag;
880 : bool ZoneSupPlenumAirFlag;
881 : Real64 CpAir; // Specific heat of air
882 : Real64 HA; // !Hc*Area
883 : Real64 Area; // !Effective surface area
884 : Real64 RefAirTemp; // !Reference air temperature for surface convection calculations
885 : Real64 ZoneMult;
886 : int ADUListIndex;
887 : int ADUNum;
888 : int ADUInNode;
889 : int ADUOutNode;
890 : Real64 SumIntGain; // !node sum of convective internal gains
891 : Real64 SumHA; // Zone sum of Hc*Area
892 : Real64 SumHATsurf; // !Zone sum of Hc*Area*Tsurf
893 : Real64 SumHATref; // !Zone sum of Hc*Area*Tref, for ceiling diffuser convection correlation
894 : Real64 SumMCp; // !Zone sum of MassFlowRate*Cp
895 : Real64 SumMCpT; // !Zone sum of MassFlowRate*Cp*T
896 : Real64 SumSysMCp; // !Zone sum of air system MassFlowRate*Cp
897 : Real64 SumSysMCpT; // !Zone sum of air system MassFlowRate*Cp*T
898 : Real64 SumSysM; // !Zone sum of air system MassFlowRate
899 : Real64 SumSysMW; // !Zone sum of air system MassFlowRate*W
900 : int EquipLoop; // !Index of equipment loop
901 : int Loop; // !Index of RAFN node
902 : bool Found; //
903 : Real64 SumLinkM; // !Zone sum of MassFlowRate from the AirflowNetwork model
904 : Real64 SumLinkMW; // !Zone sum of MassFlowRate*W from the AirflowNetwork model
905 :
906 53823 : SumIntGain = 0.0;
907 53823 : SumHA = 0.0;
908 53823 : SumHATsurf = 0.0;
909 53823 : SumHATref = 0.0;
910 53823 : SumMCp = 0.0;
911 53823 : SumMCpT = 0.0;
912 53823 : SumSysMCp = 0.0;
913 53823 : SumSysMCpT = 0.0;
914 53823 : SumSysM = 0.0;
915 53823 : SumSysMW = 0.0;
916 53823 : SumLinkM = 0.0;
917 53823 : SumLinkMW = 0.0;
918 :
919 : // Sum all convective internal gains: SumIntGain
920 53823 : state.dataRoomAirMod->RoomAirflowNetworkZoneInfo(ZoneNum).Node(RoomAirNodeNum).SumIntSensibleGain =
921 215292 : SumInternalConvectionGainsByIndices(state,
922 53823 : state.dataRoomAirMod->RoomAirflowNetworkZoneInfo(ZoneNum).Node(RoomAirNodeNum).NumIntGains,
923 53823 : state.dataRoomAirMod->RoomAirflowNetworkZoneInfo(ZoneNum).Node(RoomAirNodeNum).intGainsDeviceSpaces,
924 53823 : state.dataRoomAirMod->RoomAirflowNetworkZoneInfo(ZoneNum).Node(RoomAirNodeNum).IntGainsDeviceIndices,
925 53823 : state.dataRoomAirMod->RoomAirflowNetworkZoneInfo(ZoneNum).Node(RoomAirNodeNum).IntGainsFractions);
926 :
927 53823 : state.dataRoomAirMod->RoomAirflowNetworkZoneInfo(ZoneNum).Node(RoomAirNodeNum).SumIntLatentGain =
928 215292 : SumInternalLatentGainsByIndices(state,
929 53823 : state.dataRoomAirMod->RoomAirflowNetworkZoneInfo(ZoneNum).Node(RoomAirNodeNum).NumIntGains,
930 53823 : state.dataRoomAirMod->RoomAirflowNetworkZoneInfo(ZoneNum).Node(RoomAirNodeNum).intGainsDeviceSpaces,
931 53823 : state.dataRoomAirMod->RoomAirflowNetworkZoneInfo(ZoneNum).Node(RoomAirNodeNum).IntGainsDeviceIndices,
932 53823 : state.dataRoomAirMod->RoomAirflowNetworkZoneInfo(ZoneNum).Node(RoomAirNodeNum).IntGainsFractions);
933 : // Add heat to return air if zonal system(no return air) or cycling system(return air frequently very low or zero)
934 53823 : if (state.dataHeatBal->Zone(ZoneNum).NoHeatToReturnAir) {
935 : // *******************************************
936 109732 : SumIntGain = SumReturnAirConvectionGainsByIndices(
937 : state,
938 27433 : state.dataRoomAirMod->RoomAirflowNetworkZoneInfo(ZoneNum).Node(RoomAirNodeNum).NumIntGains,
939 27433 : state.dataRoomAirMod->RoomAirflowNetworkZoneInfo(ZoneNum).Node(RoomAirNodeNum).intGainsDeviceSpaces,
940 27433 : state.dataRoomAirMod->RoomAirflowNetworkZoneInfo(ZoneNum).Node(RoomAirNodeNum).IntGainsDeviceIndices,
941 27433 : state.dataRoomAirMod->RoomAirflowNetworkZoneInfo(ZoneNum).Node(RoomAirNodeNum).IntGainsFractions);
942 27433 : state.dataRoomAirMod->RoomAirflowNetworkZoneInfo(ZoneNum).Node(RoomAirNodeNum).SumIntSensibleGain += SumIntGain;
943 : }
944 :
945 : // Check to see if this is a controlled zone
946 :
947 53823 : bool ControlledZoneAirFlag = state.dataHeatBal->Zone(ZoneNum).IsControlled;
948 :
949 : // Check to see if this is a plenum zone
950 53823 : ZoneRetPlenumAirFlag = false;
951 53823 : for (ZoneRetPlenumNum = 1; ZoneRetPlenumNum <= state.dataZonePlenum->NumZoneReturnPlenums; ++ZoneRetPlenumNum) {
952 0 : if (state.dataZonePlenum->ZoneRetPlenCond(ZoneRetPlenumNum).ActualZoneNum != ZoneNum) continue;
953 0 : ZoneRetPlenumAirFlag = true;
954 0 : break;
955 : } // ZoneRetPlenumNum
956 53823 : ZoneSupPlenumAirFlag = false;
957 53823 : for (ZoneSupPlenumNum = 1; ZoneSupPlenumNum <= state.dataZonePlenum->NumZoneSupplyPlenums; ++ZoneSupPlenumNum) {
958 0 : if (state.dataZonePlenum->ZoneSupPlenCond(ZoneSupPlenumNum).ActualZoneNum != ZoneNum) continue;
959 0 : ZoneSupPlenumAirFlag = true;
960 0 : break;
961 : } // ZoneSupPlenumNum
962 :
963 : // Plenum and controlled zones have a different set of inlet nodes which must be calculated.
964 53823 : auto &thisZoneHB = state.dataZoneTempPredictorCorrector->zoneHeatBalance(ZoneNum);
965 53823 : if (ControlledZoneAirFlag) {
966 53823 : auto &thisZoneEquipConfig = state.dataZoneEquip->ZoneEquipConfig(ZoneNum);
967 107646 : for (NodeNum = 1; NodeNum <= thisZoneEquipConfig.NumInletNodes; ++NodeNum) {
968 : // Get node conditions
969 : // this next block is of interest to irratic system loads... maybe nodes are not accurate at time of call ?
970 : // how can we tell ? predict step must be lagged ? correct step, systems have run.
971 107646 : for (EquipLoop = 1; EquipLoop <= state.dataRoomAirMod->RoomAirflowNetworkZoneInfo(ZoneNum).Node(RoomAirNodeNum).NumHVACs;
972 : ++EquipLoop) {
973 107646 : if (state.dataRoomAirMod->RoomAirflowNetworkZoneInfo(ZoneNum).Node(RoomAirNodeNum).HVAC(EquipLoop).SupNodeNum ==
974 53823 : thisZoneEquipConfig.InletNode(NodeNum)) {
975 53823 : NodeTemp = state.dataLoopNodes->Node(thisZoneEquipConfig.InletNode(NodeNum)).Temp;
976 53823 : NodeW = state.dataLoopNodes->Node(thisZoneEquipConfig.InletNode(NodeNum)).HumRat;
977 107646 : MassFlowRate = state.dataLoopNodes->Node(thisZoneEquipConfig.InletNode(NodeNum)).MassFlowRate *
978 53823 : state.dataRoomAirMod->RoomAirflowNetworkZoneInfo(ZoneNum).Node(RoomAirNodeNum).HVAC(EquipLoop).SupplyFraction;
979 53823 : CpAir = PsyCpAirFnW(thisZoneHB.ZoneAirHumRat);
980 53823 : SumSysMCp += MassFlowRate * CpAir;
981 53823 : SumSysMCpT += MassFlowRate * CpAir * NodeTemp;
982 53823 : SumSysM += MassFlowRate;
983 53823 : SumSysMW += MassFlowRate * NodeW;
984 : }
985 : } // EquipLoop
986 : } // NodeNum
987 0 : } else if (ZoneRetPlenumAirFlag) {
988 0 : for (NodeNum = 1; NodeNum <= state.dataZonePlenum->ZoneRetPlenCond(ZoneRetPlenumNum).NumInletNodes; ++NodeNum) {
989 : // Get node conditions
990 0 : NodeTemp = state.dataLoopNodes->Node(state.dataZonePlenum->ZoneRetPlenCond(ZoneRetPlenumNum).InletNode(NodeNum)).Temp;
991 0 : MassFlowRate = state.dataLoopNodes->Node(state.dataZonePlenum->ZoneRetPlenCond(ZoneRetPlenumNum).InletNode(NodeNum)).MassFlowRate;
992 0 : CpAir = PsyCpAirFnW(thisZoneHB.ZoneAirHumRat);
993 0 : SumSysMCp += MassFlowRate * CpAir;
994 0 : SumSysMCpT += MassFlowRate * CpAir * NodeTemp;
995 : } // NodeNum
996 : // add in the leaks
997 0 : for (ADUListIndex = 1; ADUListIndex <= state.dataZonePlenum->ZoneRetPlenCond(ZoneRetPlenumNum).NumADUs; ++ADUListIndex) {
998 0 : ADUNum = state.dataZonePlenum->ZoneRetPlenCond(ZoneRetPlenumNum).ADUIndex(ADUListIndex);
999 0 : if (state.dataDefineEquipment->AirDistUnit(ADUNum).UpStreamLeak) {
1000 0 : ADUInNode = state.dataDefineEquipment->AirDistUnit(ADUNum).InletNodeNum;
1001 0 : NodeTemp = state.dataLoopNodes->Node(ADUInNode).Temp;
1002 0 : MassFlowRate = state.dataDefineEquipment->AirDistUnit(ADUNum).MassFlowRateUpStrLk;
1003 0 : CpAir = PsyCpAirFnW(thisZoneHB.ZoneAirHumRat);
1004 0 : SumSysMCp += MassFlowRate * CpAir;
1005 0 : SumSysMCpT += MassFlowRate * CpAir * NodeTemp;
1006 : }
1007 0 : if (state.dataDefineEquipment->AirDistUnit(ADUNum).DownStreamLeak) {
1008 0 : ADUOutNode = state.dataDefineEquipment->AirDistUnit(ADUNum).OutletNodeNum;
1009 0 : NodeTemp = state.dataLoopNodes->Node(ADUOutNode).Temp;
1010 0 : MassFlowRate = state.dataDefineEquipment->AirDistUnit(ADUNum).MassFlowRateDnStrLk;
1011 0 : CpAir = PsyCpAirFnW(thisZoneHB.ZoneAirHumRat);
1012 0 : SumSysMCp += MassFlowRate * CpAir;
1013 0 : SumSysMCpT += MassFlowRate * CpAir * NodeTemp;
1014 : }
1015 : } // ADUListIndex
1016 0 : } else if (ZoneSupPlenumAirFlag) {
1017 : // Get node conditions
1018 0 : NodeTemp = state.dataLoopNodes->Node(state.dataZonePlenum->ZoneSupPlenCond(ZoneSupPlenumNum).InletNode).Temp;
1019 0 : MassFlowRate = state.dataLoopNodes->Node(state.dataZonePlenum->ZoneSupPlenCond(ZoneSupPlenumNum).InletNode).MassFlowRate;
1020 0 : CpAir = PsyCpAirFnW(thisZoneHB.ZoneAirHumRat);
1021 0 : SumSysMCp += MassFlowRate * CpAir;
1022 0 : SumSysMCpT += MassFlowRate * CpAir * NodeTemp;
1023 : }
1024 :
1025 53823 : ZoneMult = state.dataHeatBal->Zone(ZoneNum).Multiplier * state.dataHeatBal->Zone(ZoneNum).ListMultiplier;
1026 :
1027 53823 : SumSysMCp = SumSysMCp / ZoneMult;
1028 53823 : SumSysMCpT = SumSysMCpT / ZoneMult;
1029 53823 : SumSysM = SumSysM / ZoneMult;
1030 53823 : SumSysMW = SumSysMW / ZoneMult;
1031 :
1032 : // Sum all surface convection : SumHA, SumHATsurf, SumHATref(and additional contributions to SumIntGain)
1033 : // Modified by Gu to include assigned surfaces only shown in the surface lsit
1034 53823 : if (!state.dataRoomAirMod->RoomAirflowNetworkZoneInfo(ZoneNum).Node(RoomAirNodeNum).HasSurfacesAssigned) return;
1035 :
1036 53823 : int surfCount = 0;
1037 107646 : for (int spaceNum : state.dataHeatBal->Zone(ZoneNum).spaceIndexes) {
1038 53823 : auto &thisSpace = state.dataHeatBal->space(spaceNum);
1039 914991 : for (int SurfNum = thisSpace.HTSurfaceFirst; SurfNum <= thisSpace.HTSurfaceLast; ++SurfNum) {
1040 861168 : ++surfCount;
1041 861168 : if (state.dataRoomAirMod->RoomAirflowNetworkZoneInfo(ZoneNum).ControlAirNodeID == RoomAirNodeNum) {
1042 246048 : Found = false;
1043 1460910 : for (Loop = 1; Loop <= state.dataRoomAirMod->RoomAirflowNetworkZoneInfo(ZoneNum).NumOfAirNodes; ++Loop) {
1044 1291752 : if (Loop != RoomAirNodeNum) {
1045 1076460 : if (state.dataRoomAirMod->RoomAirflowNetworkZoneInfo(ZoneNum).Node(Loop).SurfMask(surfCount)) {
1046 76890 : Found = true;
1047 76890 : break;
1048 : }
1049 : }
1050 : }
1051 246048 : if (Found) continue;
1052 : } else {
1053 615120 : if (!state.dataRoomAirMod->RoomAirflowNetworkZoneInfo(ZoneNum).Node(RoomAirNodeNum).SurfMask(surfCount)) continue;
1054 : }
1055 :
1056 207603 : HA = 0.0;
1057 207603 : Area = state.dataSurface->Surface(SurfNum).Area; // For windows, this is the glazing area
1058 :
1059 207603 : if (state.dataSurface->Surface(SurfNum).Class == DataSurfaces::SurfaceClass::Window) {
1060 :
1061 : // Add to the convective internal gains
1062 30756 : if (ANY_INTERIOR_SHADE_BLIND(state.dataSurface->SurfWinShadingFlag(SurfNum))) {
1063 : // The shade area covers the area of the glazing plus the area of the dividers.
1064 0 : Area += state.dataSurface->SurfWinDividerArea(SurfNum);
1065 0 : SumIntGain += state.dataSurface->SurfWinDividerHeatGain(SurfNum);
1066 : }
1067 :
1068 : // Convective heat gain from natural convection in gap between glass and interior shade or blind
1069 30756 : if (ANY_INTERIOR_SHADE_BLIND(state.dataSurface->SurfWinShadingFlag(SurfNum)))
1070 0 : SumIntGain += state.dataSurface->SurfWinConvHeatFlowNatural(SurfNum);
1071 :
1072 : // Convective heat gain from airflow window
1073 30756 : if (state.dataSurface->SurfWinAirflowThisTS(SurfNum) > 0.0) {
1074 0 : SumIntGain += state.dataSurface->SurfWinConvHeatGainToZoneAir(SurfNum);
1075 0 : if (state.dataHeatBal->Zone(ZoneNum).NoHeatToReturnAir) {
1076 0 : SumIntGain += state.dataSurface->SurfWinRetHeatGainToZoneAir(SurfNum);
1077 0 : state.dataSurface->SurfWinHeatGain(SurfNum) += state.dataSurface->SurfWinRetHeatGainToZoneAir(SurfNum);
1078 0 : if (state.dataSurface->SurfWinHeatGain(SurfNum) >= 0.0) {
1079 0 : state.dataSurface->SurfWinHeatGainRep(SurfNum) = state.dataSurface->SurfWinHeatGain(SurfNum);
1080 0 : state.dataSurface->SurfWinHeatGainRepEnergy(SurfNum) =
1081 0 : state.dataSurface->SurfWinHeatGainRep(SurfNum) * state.dataGlobal->TimeStepZone * DataGlobalConstants::SecInHour;
1082 : } else {
1083 0 : state.dataSurface->SurfWinHeatLossRep(SurfNum) = -state.dataSurface->SurfWinHeatGain(SurfNum);
1084 0 : state.dataSurface->SurfWinHeatLossRepEnergy(SurfNum) =
1085 0 : state.dataSurface->SurfWinHeatLossRep(SurfNum) * state.dataGlobal->TimeStepZone * DataGlobalConstants::SecInHour;
1086 : }
1087 0 : state.dataSurface->SurfWinHeatTransferRepEnergy(SurfNum) =
1088 0 : state.dataSurface->SurfWinHeatGain(SurfNum) * state.dataGlobal->TimeStepZone * DataGlobalConstants::SecInHour;
1089 : }
1090 : }
1091 :
1092 : // Add to the surface convection sums
1093 30756 : if (state.dataSurface->SurfWinFrameArea(SurfNum) > 0.0) {
1094 : // Window frame contribution
1095 0 : SumHATsurf += state.dataHeatBalSurf->SurfHConvInt(SurfNum) * state.dataSurface->SurfWinFrameArea(SurfNum) *
1096 0 : (1.0 + state.dataSurface->SurfWinProjCorrFrIn(SurfNum)) * state.dataSurface->SurfWinFrameTempIn(SurfNum);
1097 0 : HA += state.dataHeatBalSurf->SurfHConvInt(SurfNum) * state.dataSurface->SurfWinFrameArea(SurfNum) *
1098 0 : (1.0 + state.dataSurface->SurfWinProjCorrFrIn(SurfNum));
1099 : }
1100 :
1101 30756 : if (state.dataSurface->SurfWinDividerArea(SurfNum) > 0.0 &&
1102 0 : !ANY_INTERIOR_SHADE_BLIND(state.dataSurface->SurfWinShadingFlag(SurfNum))) {
1103 : // Window divider contribution(only from shade or blind for window with divider and interior shade or blind)
1104 0 : SumHATsurf += state.dataHeatBalSurf->SurfHConvInt(SurfNum) * state.dataSurface->SurfWinDividerArea(SurfNum) *
1105 0 : (1.0 + 2.0 * state.dataSurface->SurfWinProjCorrDivIn(SurfNum)) *
1106 0 : state.dataSurface->SurfWinDividerTempIn(SurfNum);
1107 0 : HA += state.dataHeatBalSurf->SurfHConvInt(SurfNum) * state.dataSurface->SurfWinDividerArea(SurfNum) *
1108 0 : (1.0 + 2.0 * state.dataSurface->SurfWinProjCorrDivIn(SurfNum));
1109 : }
1110 :
1111 : } // End of check if window
1112 :
1113 207603 : HA = HA + state.dataHeatBalSurf->SurfHConvInt(SurfNum) * Area;
1114 207603 : SumHATsurf += state.dataHeatBalSurf->SurfHConvInt(SurfNum) * Area * state.dataHeatBalSurf->SurfTempInTmp(SurfNum);
1115 :
1116 207603 : if (state.dataSurface->SurfTAirRef(SurfNum) == DataSurfaces::RefAirTemp::ZoneMeanAirTemp) {
1117 : // The zone air is the reference temperature(which is to be solved for in CorrectZoneAirTemp).
1118 0 : RefAirTemp = thisZoneHB.MAT;
1119 0 : SumHA += HA;
1120 207603 : } else if (state.dataSurface->SurfTAirRef(SurfNum) == DataSurfaces::RefAirTemp::AdjacentAirTemp) {
1121 0 : RefAirTemp = state.dataHeatBal->SurfTempEffBulkAir(SurfNum);
1122 0 : SumHATref += HA * RefAirTemp;
1123 207603 : } else if (state.dataSurface->SurfTAirRef(SurfNum) == DataSurfaces::RefAirTemp::ZoneSupplyAirTemp) {
1124 : // check whether this zone is a controlled zone or not
1125 0 : if (!ControlledZoneAirFlag) {
1126 0 : ShowFatalError(state,
1127 0 : "Zones must be controlled for Ceiling-Diffuser Convection model. No system serves zone " +
1128 0 : state.dataHeatBal->Zone(ZoneNum).Name);
1129 0 : return;
1130 : }
1131 : // determine supply air temperature as a weighted average of the inlet temperatures.
1132 0 : RefAirTemp = SumSysMCpT / SumSysMCp;
1133 0 : SumHATref += HA * RefAirTemp;
1134 : } else {
1135 207603 : RefAirTemp = thisZoneHB.MAT;
1136 207603 : SumHA = SumHA + HA;
1137 : }
1138 :
1139 : } // SurfNum
1140 : }
1141 : // Assemble values
1142 53823 : state.dataRoomAirMod->RoomAirflowNetworkZoneInfo(ZoneNum).Node(RoomAirNodeNum).SumHA = SumHA;
1143 53823 : state.dataRoomAirMod->RoomAirflowNetworkZoneInfo(ZoneNum).Node(RoomAirNodeNum).SumHATsurf = SumHATsurf;
1144 53823 : state.dataRoomAirMod->RoomAirflowNetworkZoneInfo(ZoneNum).Node(RoomAirNodeNum).SumHATref = SumHATref;
1145 53823 : state.dataRoomAirMod->RoomAirflowNetworkZoneInfo(ZoneNum).Node(RoomAirNodeNum).SumSysMCp = SumSysMCp;
1146 53823 : state.dataRoomAirMod->RoomAirflowNetworkZoneInfo(ZoneNum).Node(RoomAirNodeNum).SumSysMCpT = SumSysMCpT;
1147 53823 : state.dataRoomAirMod->RoomAirflowNetworkZoneInfo(ZoneNum).Node(RoomAirNodeNum).SumSysM = SumSysM;
1148 53823 : state.dataRoomAirMod->RoomAirflowNetworkZoneInfo(ZoneNum).Node(RoomAirNodeNum).SumSysMW = SumSysMW;
1149 :
1150 : } // CalcNodeSums
1151 :
1152 53823 : void RAFNData::CalcSurfaceMoistureSums(EnergyPlusData &state,
1153 : int const RoomAirNode,
1154 : Real64 &SumHmAW,
1155 : Real64 &SumHmARa,
1156 : Real64 &SumHmARaW,
1157 : [[maybe_unused]] Array1D<bool> const &SurfMask)
1158 : {
1159 :
1160 : // SUBROUTINE INFORMATION:
1161 : // AUTHOR B Griffith
1162 : // derived from P. Biddulph-- HAMT, L. Gu -- EPMD,
1163 : // DATE WRITTEN November 2009
1164 : // MODIFIED Lixing Gu, Aug. 2015 for v8.4 replease
1165 : // RE-ENGINEERED na
1166 :
1167 : // PURPOSE OF THIS SUBROUTINE:
1168 : // Breakout summation of surface moisture interaction terms
1169 :
1170 : // Using/Aliasing
1171 :
1172 : using HeatBalanceHAMTManager::UpdateHeatBalHAMT;
1173 : using MoistureBalanceEMPDManager::UpdateMoistureBalanceEMPD;
1174 : using Psychrometrics::PsyRhFnTdbRhov;
1175 : using Psychrometrics::PsyRhFnTdbRhovLBnd0C;
1176 : using Psychrometrics::PsyRhoAirFnPbTdbW;
1177 : using Psychrometrics::PsyWFnTdbRhPb;
1178 :
1179 : // SUBROUTINE LOCAL VARIABLE DECLARATIONS:
1180 : int Loop;
1181 : Real64 RhoAirZone;
1182 : Real64 Wsurf;
1183 : bool Found;
1184 :
1185 53823 : SumHmAW = 0.0;
1186 53823 : SumHmARa = 0.0;
1187 53823 : SumHmARaW = 0.0;
1188 :
1189 53823 : int surfCount = 0;
1190 107646 : for (int spaceNum : state.dataHeatBal->Zone(ZoneNum).spaceIndexes) {
1191 53823 : auto &thisSpace = state.dataHeatBal->space(spaceNum);
1192 914991 : for (int SurfNum = thisSpace.HTSurfaceFirst; SurfNum <= thisSpace.HTSurfaceLast; ++SurfNum) {
1193 861168 : ++surfCount;
1194 861168 : if (state.dataSurface->Surface(SurfNum).Class == SurfaceClass::Window) continue;
1195 :
1196 753522 : if (state.dataRoomAirMod->RoomAirflowNetworkZoneInfo(ZoneNum).ControlAirNodeID == RoomAirNode) {
1197 215292 : Found = false;
1198 1245618 : for (Loop = 1; Loop <= state.dataRoomAirMod->RoomAirflowNetworkZoneInfo(ZoneNum).NumOfAirNodes; ++Loop) {
1199 : // None - assigned surfaces belong to the zone node
1200 1107216 : if (Loop != RoomAirNode) {
1201 922680 : if (state.dataRoomAirMod->RoomAirflowNetworkZoneInfo(ZoneNum).Node(Loop).SurfMask(surfCount)) {
1202 76890 : Found = true;
1203 76890 : break;
1204 : }
1205 : }
1206 : }
1207 215292 : if (Found) continue;
1208 : } else {
1209 538230 : if (!state.dataRoomAirMod->RoomAirflowNetworkZoneInfo(ZoneNum).Node(RoomAirNode).SurfMask(surfCount)) continue;
1210 : }
1211 :
1212 176847 : auto &HMassConvInFD = state.dataMstBal->HMassConvInFD;
1213 176847 : auto &RhoVaporSurfIn = state.dataMstBal->RhoVaporSurfIn;
1214 176847 : auto &RhoVaporAirIn = state.dataMstBal->RhoVaporAirIn;
1215 176847 : if (state.dataSurface->Surface(SurfNum).HeatTransferAlgorithm == DataSurfaces::HeatTransferModel::HAMT) {
1216 0 : UpdateHeatBalHAMT(state, SurfNum);
1217 :
1218 0 : SumHmAW += HMassConvInFD(SurfNum) * state.dataSurface->Surface(SurfNum).Area * (RhoVaporSurfIn(SurfNum) - RhoVaporAirIn(SurfNum));
1219 :
1220 0 : RhoAirZone = PsyRhoAirFnPbTdbW(
1221 : state,
1222 0 : state.dataEnvrn->OutBaroPress,
1223 0 : state.dataZoneTempPredictorCorrector->zoneHeatBalance(state.dataSurface->Surface(SurfNum).Zone).MAT,
1224 : PsyRhFnTdbRhov(state,
1225 0 : state.dataZoneTempPredictorCorrector->zoneHeatBalance(state.dataSurface->Surface(SurfNum).Zone).MAT,
1226 0 : RhoVaporAirIn(SurfNum),
1227 0 : "RhoAirZone"));
1228 :
1229 0 : Wsurf = PsyWFnTdbRhPb(state,
1230 0 : state.dataHeatBalSurf->SurfTempInTmp(SurfNum),
1231 0 : PsyRhFnTdbRhov(state, state.dataHeatBalSurf->SurfTempInTmp(SurfNum), RhoVaporSurfIn(SurfNum), "Wsurf"),
1232 0 : state.dataEnvrn->OutBaroPress);
1233 :
1234 0 : SumHmARa = SumHmARa + HMassConvInFD(SurfNum) * state.dataSurface->Surface(SurfNum).Area * RhoAirZone;
1235 :
1236 0 : SumHmARaW = SumHmARaW + HMassConvInFD(SurfNum) * state.dataSurface->Surface(SurfNum).Area * RhoAirZone * Wsurf;
1237 : }
1238 :
1239 176847 : if (state.dataSurface->Surface(SurfNum).HeatTransferAlgorithm == DataSurfaces::HeatTransferModel::EMPD) {
1240 :
1241 0 : UpdateMoistureBalanceEMPD(state, SurfNum);
1242 0 : RhoVaporSurfIn(SurfNum) = state.dataMstBalEMPD->RVSurface(SurfNum);
1243 :
1244 0 : SumHmAW = SumHmAW +
1245 0 : HMassConvInFD(SurfNum) * state.dataSurface->Surface(SurfNum).Area * (RhoVaporSurfIn(SurfNum) - RhoVaporAirIn(SurfNum));
1246 0 : SumHmARa =
1247 0 : SumHmARa +
1248 0 : HMassConvInFD(SurfNum) * state.dataSurface->Surface(SurfNum).Area *
1249 0 : PsyRhoAirFnPbTdbW(
1250 : state,
1251 0 : state.dataEnvrn->OutBaroPress,
1252 0 : state.dataHeatBalSurf->SurfTempInTmp(SurfNum),
1253 : PsyWFnTdbRhPb(state,
1254 0 : state.dataHeatBalSurf->SurfTempInTmp(SurfNum),
1255 0 : PsyRhFnTdbRhovLBnd0C(state, state.dataHeatBalSurf->SurfTempInTmp(SurfNum), RhoVaporAirIn(SurfNum)),
1256 0 : state.dataEnvrn->OutBaroPress));
1257 0 : SumHmARaW = SumHmARaW + HMassConvInFD(SurfNum) * state.dataSurface->Surface(SurfNum).Area * RhoVaporSurfIn(SurfNum);
1258 : }
1259 : }
1260 : }
1261 :
1262 53823 : } // CalcSurfaceMoistureSums
1263 :
1264 53823 : void RAFNData::SumNonAirSystemResponseForNode(EnergyPlusData &state, int const RAFNNodeNum)
1265 : {
1266 :
1267 : // SUBROUTINE INFORMATION:
1268 : // AUTHOR B. Griffith
1269 : // DATE WRITTEN June 2012
1270 : // MODIFIED Lixing Gu, Aug. 2015 for v8.4 replease
1271 : // RE-ENGINEERED na
1272 :
1273 : // PURPOSE OF THIS SUBROUTINE:
1274 : // Sum system response from none air systems
1275 :
1276 : // METHODOLOGY EMPLOYED:
1277 : // na
1278 :
1279 : // REFERENCES:
1280 : // na
1281 :
1282 : // USE STATEMENTS:
1283 : using BaseboardElectric::SimElectricBaseboard;
1284 : using BaseboardRadiator::SimBaseboard;
1285 : using DataHVACGlobals::ZoneEquipTypeOf_BaseboardConvectiveElectric;
1286 : using DataHVACGlobals::ZoneEquipTypeOf_BaseboardConvectiveWater;
1287 : using DataHVACGlobals::ZoneEquipTypeOf_BaseboardRadiantConvectiveElectric;
1288 : using DataHVACGlobals::ZoneEquipTypeOf_BaseboardRadiantConvectiveSteam;
1289 : using DataHVACGlobals::ZoneEquipTypeOf_BaseboardRadiantConvectiveWater;
1290 : using DataHVACGlobals::ZoneEquipTypeOf_HighTemperatureRadiant;
1291 : using DataHVACGlobals::ZoneEquipTypeOf_RefrigerationChillerSet;
1292 : using ElectricBaseboardRadiator::SimElecBaseboard;
1293 : using HighTempRadiantSystem::SimHighTempRadiantSystem;
1294 : using HWBaseboardRadiator::SimHWBaseboard;
1295 : using RefrigeratedCase::SimAirChillerSet;
1296 : using SteamBaseboardRadiator::SimSteamBaseboard;
1297 :
1298 : // SUBROUTINE LOCAL VARIABLE DECLARATIONS:
1299 : int I;
1300 : Real64 SysOutputProvided;
1301 : Real64 LatOutputProvided;
1302 :
1303 : // TODO
1304 53823 : auto &ThisRAFNNode(state.dataRoomAirMod->RoomAirflowNetworkZoneInfo(ZoneNum).Node(RAFNNodeNum));
1305 :
1306 53823 : ThisRAFNNode.NonAirSystemResponse = 0.0;
1307 :
1308 53823 : if (!allocated(state.dataZoneEquip->ZoneEquipConfig)) return;
1309 :
1310 107646 : for (I = 1; I <= ThisRAFNNode.NumHVACs; ++I) {
1311 :
1312 53823 : if (ThisRAFNNode.HVAC(I).TypeOfNum == ZoneEquipTypeOf_BaseboardRadiantConvectiveWater) {
1313 : //'ZoneHVAC:Baseboard:RadiantConvective:Water' 13
1314 0 : SimHWBaseboard(state, ThisRAFNNode.HVAC(I).Name, ZoneNum, false, SysOutputProvided, ThisRAFNNode.HVAC(I).CompIndex);
1315 0 : ThisRAFNNode.NonAirSystemResponse += ThisRAFNNode.HVAC(I).SupplyFraction * SysOutputProvided;
1316 : // LatOutputProvided = 0.0d0 !This baseboard does not add / remove any latent heat
1317 : }
1318 :
1319 53823 : if (ThisRAFNNode.HVAC(I).TypeOfNum == ZoneEquipTypeOf_BaseboardRadiantConvectiveSteam) {
1320 : // CASE(BBSteam_Num) !'ZoneHVAC:Baseboard:RadiantConvective:Steam' 14
1321 0 : SimSteamBaseboard(state, ThisRAFNNode.HVAC(I).Name, ZoneNum, false, SysOutputProvided, ThisRAFNNode.HVAC(I).CompIndex);
1322 :
1323 0 : ThisRAFNNode.NonAirSystemResponse += ThisRAFNNode.HVAC(I).SupplyFraction * SysOutputProvided;
1324 : // LatOutputProvided = 0.0d0 !This baseboard does not add / remove any latent heat
1325 : }
1326 :
1327 53823 : if (ThisRAFNNode.HVAC(I).TypeOfNum == ZoneEquipTypeOf_BaseboardConvectiveWater) {
1328 : // CASE(BBWaterConvective_Num) !'ZoneHVAC:Baseboard:Convective:Water' 16
1329 0 : SimBaseboard(state, ThisRAFNNode.HVAC(I).Name, ZoneNum, false, SysOutputProvided, ThisRAFNNode.HVAC(I).CompIndex);
1330 0 : ThisRAFNNode.NonAirSystemResponse += ThisRAFNNode.HVAC(I).SupplyFraction * SysOutputProvided;
1331 : // LatOutputProvided = 0.0d0 !This baseboard does not add / remove any latent heat
1332 : }
1333 :
1334 53823 : if (ThisRAFNNode.HVAC(I).TypeOfNum == ZoneEquipTypeOf_BaseboardConvectiveElectric) {
1335 : // CASE(BBElectricConvective_Num) !'ZoneHVAC:Baseboard:Convective:Electric' 15
1336 0 : SimElectricBaseboard(state, ThisRAFNNode.HVAC(I).Name, ZoneNum, SysOutputProvided, ThisRAFNNode.HVAC(I).CompIndex);
1337 0 : ThisRAFNNode.NonAirSystemResponse += ThisRAFNNode.HVAC(I).SupplyFraction * SysOutputProvided;
1338 : // LatOutputProvided = 0.0d0 !This baseboard does not add / remove any latent heat
1339 : }
1340 :
1341 53823 : if (ThisRAFNNode.HVAC(I).TypeOfNum == ZoneEquipTypeOf_RefrigerationChillerSet) {
1342 : // CASE(RefrigerationAirChillerSet_Num) !'ZoneHVAC:RefrigerationChillerSet' 20
1343 0 : SimAirChillerSet(
1344 0 : state, ThisRAFNNode.HVAC(I).Name, ZoneNum, false, SysOutputProvided, LatOutputProvided, ThisRAFNNode.HVAC(I).CompIndex);
1345 0 : ThisRAFNNode.NonAirSystemResponse += ThisRAFNNode.HVAC(I).SupplyFraction * SysOutputProvided;
1346 : }
1347 :
1348 53823 : if (ThisRAFNNode.HVAC(I).TypeOfNum == ZoneEquipTypeOf_BaseboardRadiantConvectiveElectric) {
1349 : // CASE(BBElectric_Num) !'ZoneHVAC:Baseboard:RadiantConvective:Electric' 12
1350 0 : SimElecBaseboard(state, ThisRAFNNode.HVAC(I).Name, ZoneNum, false, SysOutputProvided, ThisRAFNNode.HVAC(I).CompIndex);
1351 0 : ThisRAFNNode.NonAirSystemResponse += ThisRAFNNode.HVAC(I).SupplyFraction * SysOutputProvided;
1352 : // LatOutputProvided = 0.0d0 !This baseboard does not add / remove any latent heat
1353 : }
1354 :
1355 53823 : if (ThisRAFNNode.HVAC(I).TypeOfNum == ZoneEquipTypeOf_HighTemperatureRadiant) {
1356 : // CASE(BBElectric_Num) !'ZoneHVAC:HighTemperatureRadiant' 17
1357 0 : SimHighTempRadiantSystem(state, ThisRAFNNode.HVAC(I).Name, false, SysOutputProvided, ThisRAFNNode.HVAC(I).CompIndex);
1358 0 : ThisRAFNNode.NonAirSystemResponse += ThisRAFNNode.HVAC(I).SupplyFraction * SysOutputProvided;
1359 : // LatOutputProvided = 0.0d0 !This baseboard does not add / remove any latent heat
1360 : }
1361 :
1362 : // Zone sum of system convective gains, collected via NonAirSystemResponse
1363 : }
1364 :
1365 : } // SumNonAirSystemResponseForNode
1366 :
1367 : //*****************************************************************************************
1368 :
1369 3934 : void RAFNData::SumSystemDepResponseForNode(EnergyPlusData &state)
1370 : {
1371 : // SUBROUTINE INFORMATION:
1372 : // AUTHOR B.Griffith
1373 : // DATE WRITTEN aug 2005, Jan2004
1374 : // MODIFIED Lixing Gu, Aug. 2015 for v8.4 replease
1375 : // RE-ENGINEERED na
1376 :
1377 : // PURPOSE OF THIS SUBROUTINE:
1378 : // Sum system sensible loads used at the next time step
1379 :
1380 : // METHODOLOGY EMPLOYED:
1381 : // na
1382 :
1383 : // REFERENCES:
1384 : // na
1385 :
1386 : // USE STATEMENTS:
1387 : using DataHVACGlobals::ZoneEquipTypeOf_DehumidifierDX;
1388 : using ZoneDehumidifier::SimZoneDehumidifier;
1389 :
1390 : // Return value
1391 : // na
1392 :
1393 : // SUBROUTINE LOCAL VARIABLE DECLARATIONS:
1394 : int I;
1395 : Real64 SysOutputProvided;
1396 : Real64 LatOutputProvided;
1397 : int RoomAirNode;
1398 :
1399 : // TODO
1400 :
1401 3934 : auto &ThisRAFNZone(state.dataRoomAirMod->RoomAirflowNetworkZoneInfo(ZoneNum));
1402 :
1403 : // SysDepZoneLoads saved to be added to zone heat balance next
1404 3934 : SysOutputProvided = 0.0;
1405 27538 : for (RoomAirNode = 1; RoomAirNode <= ThisRAFNZone.NumOfAirNodes; ++RoomAirNode) {
1406 23604 : ThisRAFNZone.Node(RoomAirNode).SysDepZoneLoadsLaggedOld = 0.0;
1407 47208 : for (I = 1; I <= ThisRAFNZone.Node(RoomAirNode).NumHVACs; ++I) {
1408 23604 : if (ThisRAFNZone.Node(RoomAirNode).HVAC(I).TypeOfNum == ZoneEquipTypeOf_DehumidifierDX) {
1409 0 : if (SysOutputProvided == 0.0)
1410 0 : SimZoneDehumidifier(state,
1411 0 : ThisRAFNZone.Node(RoomAirNode).HVAC(I).Name,
1412 : ZoneNum,
1413 : false,
1414 : SysOutputProvided,
1415 : LatOutputProvided,
1416 0 : ThisRAFNZone.Node(RoomAirNode).HVAC(I).CompIndex);
1417 0 : if (SysOutputProvided > 0.0) break;
1418 : }
1419 : }
1420 : }
1421 :
1422 3934 : if (SysOutputProvided > 0.0) {
1423 0 : for (RoomAirNode = 1; RoomAirNode <= ThisRAFNZone.NumOfAirNodes; ++RoomAirNode) {
1424 0 : for (I = 1; I <= ThisRAFNZone.Node(RoomAirNode).NumHVACs; ++I) {
1425 0 : if (ThisRAFNZone.Node(RoomAirNode).HVAC(I).TypeOfNum == ZoneEquipTypeOf_DehumidifierDX) {
1426 0 : ThisRAFNZone.Node(RoomAirNode).SysDepZoneLoadsLaggedOld +=
1427 0 : ThisRAFNZone.Node(RoomAirNode).HVAC(I).SupplyFraction * SysOutputProvided;
1428 : }
1429 : }
1430 : }
1431 : }
1432 :
1433 3934 : } // SumSystemDepResponseForNode
1434 :
1435 : //*****************************************************************************************
1436 :
1437 : } // namespace RoomAirModelAirflowNetwork
1438 :
1439 2313 : } // namespace EnergyPlus
|
