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 : // C++ Headers
49 : #include <algorithm>
50 : #include <cmath>
51 : #include <limits>
52 :
53 : // ObjexxFCL Headers
54 : #include <ObjexxFCL/Array.functions.hh>
55 : #include <ObjexxFCL/Array1D.hh>
56 : #include <ObjexxFCL/Array2D.hh>
57 : #include <ObjexxFCL/Fmath.hh>
58 :
59 : // EnergyPlus Headers
60 : #include <AirflowNetwork/Solver.hpp>
61 : #include <EnergyPlus/CrossVentMgr.hh>
62 : #include <EnergyPlus/Data/EnergyPlusData.hh>
63 : #include <EnergyPlus/DataEnvironment.hh>
64 : #include <EnergyPlus/DataErrorTracking.hh>
65 : #include <EnergyPlus/DataHVACGlobals.hh>
66 : #include <EnergyPlus/DataHeatBalFanSys.hh>
67 : #include <EnergyPlus/DataHeatBalance.hh>
68 : #include <EnergyPlus/DataIPShortCuts.hh>
69 : #include <EnergyPlus/DataLoopNode.hh>
70 : #include <EnergyPlus/DataRoomAirModel.hh>
71 : #include <EnergyPlus/DataSurfaces.hh>
72 : #include <EnergyPlus/DataUCSDSharedData.hh>
73 : #include <EnergyPlus/DataZoneEquipment.hh>
74 : #include <EnergyPlus/DisplacementVentMgr.hh>
75 : #include <EnergyPlus/Fans.hh>
76 : #include <EnergyPlus/General.hh>
77 : #include <EnergyPlus/InputProcessing/InputProcessor.hh>
78 : #include <EnergyPlus/InternalHeatGains.hh>
79 : #include <EnergyPlus/MundtSimMgr.hh>
80 : #include <EnergyPlus/OutputProcessor.hh>
81 : #include <EnergyPlus/Psychrometrics.hh>
82 : #include <EnergyPlus/RoomAirModelAirflowNetwork.hh>
83 : #include <EnergyPlus/RoomAirModelManager.hh>
84 : #include <EnergyPlus/RoomAirModelUserTempPattern.hh>
85 : #include <EnergyPlus/ScheduleManager.hh>
86 : #include <EnergyPlus/UFADManager.hh>
87 : #include <EnergyPlus/UtilityRoutines.hh>
88 : #include <EnergyPlus/ZoneTempPredictorCorrector.hh>
89 :
90 : namespace EnergyPlus {
91 :
92 : namespace RoomAirModelManager {
93 :
94 : // MODULE INFORMATION
95 : // AUTHOR Weixiu Kong
96 : // DATE WRITTEN March 2003
97 : // MODIFIED July 2003, CC
98 : // Aug, 2005, BG
99 : // RE-ENGINEERED na
100 :
101 : // PURPOSE OF THIS MODULE:
102 : // Contains subroutines for managing the room air models
103 :
104 : // Using/Aliasing
105 : using namespace DataRoomAirModel;
106 :
107 27928091 : void ManageAirModel(EnergyPlusData &state, int const ZoneNum)
108 : {
109 :
110 : // SUBROUTINE INFORMATION:
111 : // AUTHOR Weixiu Kong
112 : // DATE WRITTEN April 2003
113 : // MODIFIED July 2003, CC
114 : // Jan 2004, CC
115 : // RE-ENGINEERED na
116 :
117 : // PURPOSE OF THIS SUBROUTINE:
118 : // manage room air models.
119 :
120 27928091 : if (state.dataRoomAirModelMgr->GetAirModelData) {
121 740 : GetAirModelDatas(state);
122 740 : state.dataRoomAirModelMgr->GetAirModelData = false;
123 : }
124 :
125 27928091 : if (!state.dataRoomAirMod->anyNonMixingRoomAirModel) return;
126 :
127 162216 : if (state.dataRoomAirMod->UCSDModelUsed) {
128 43671 : SharedDVCVUFDataInit(state, ZoneNum);
129 : }
130 :
131 162216 : switch (state.dataRoomAirMod->AirModel(ZoneNum).AirModelType) {
132 37512 : case DataRoomAirModel::RoomAirModel::UserDefined:
133 37512 : RoomAirModelUserTempPattern::ManageUserDefinedPatterns(state, ZoneNum);
134 37512 : break;
135 :
136 63250 : case DataRoomAirModel::RoomAirModel::Mixing: // Mixing air model
137 63250 : break; // do nothing
138 :
139 17126 : case DataRoomAirModel::RoomAirModel::Mundt: // Mundt air model
140 : // simulate room airflow using Mundt model
141 17126 : MundtSimMgr::ManageMundtModel(state, ZoneNum);
142 17126 : break;
143 :
144 15024 : case DataRoomAirModel::RoomAirModel::UCSDDV: // UCDV Displacement Ventilation model
145 : // simulate room airflow using UCSDDV model
146 15024 : DisplacementVentMgr::ManageUCSDDVModel(state, ZoneNum);
147 15024 : break;
148 :
149 4035 : case DataRoomAirModel::RoomAirModel::UCSDCV: // UCSD Cross Ventilation model
150 : // simulate room airflow using UCSDDV model
151 4035 : CrossVentMgr::ManageUCSDCVModel(state, ZoneNum);
152 4035 : break;
153 :
154 3516 : case DataRoomAirModel::RoomAirModel::UCSDUFI: // UCSD UFAD interior zone model
155 : // simulate room airflow using the UCSDUFI model
156 3516 : UFADManager::ManageUCSDUFModels(state, ZoneNum, DataRoomAirModel::RoomAirModel::UCSDUFI);
157 3516 : break;
158 :
159 14064 : case DataRoomAirModel::RoomAirModel::UCSDUFE: // UCSD UFAD exterior zone model
160 : // simulate room airflow using the UCSDUFE model
161 14064 : UFADManager::ManageUCSDUFModels(state, ZoneNum, DataRoomAirModel::RoomAirModel::UCSDUFE);
162 14064 : break;
163 :
164 7689 : case DataRoomAirModel::RoomAirModel::AirflowNetwork: // RoomAirflowNetwork zone model
165 : // simulate room airflow using the AirflowNetwork - based model
166 7689 : RoomAirModelAirflowNetwork::SimRoomAirModelAirflowNetwork(state, ZoneNum);
167 7689 : break;
168 :
169 0 : default: // mixing air model
170 0 : break; // do nothing
171 : }
172 : }
173 :
174 : //*****************************************************************************************
175 :
176 741 : void GetAirModelDatas(EnergyPlusData &state)
177 : {
178 :
179 : // SUBROUTINE INFORMATION:
180 : // AUTHOR Linda Lawrie
181 : // DATE WRITTEN March 2005
182 : // MODIFIED na
183 : // RE-ENGINEERED na
184 :
185 : // PURPOSE OF THIS SUBROUTINE:
186 : // This routine "gets" all the data for the "RoomAir" models by calling individual
187 : // routines.
188 :
189 : // SUBROUTINE LOCAL VARIABLE DECLARATIONS:
190 : bool ErrorsFound;
191 :
192 741 : ErrorsFound = false;
193 : // get air node input data for all zones
194 741 : GetAirNodeData(state, ErrorsFound);
195 :
196 : // get mundt model controls for all zones
197 741 : GetMundtData(state, ErrorsFound);
198 :
199 : // get airflow network model info for all zones
200 741 : GetRoomAirflowNetworkData(state, ErrorsFound);
201 :
202 : // get UCSDDV model controls for all zones
203 741 : GetDisplacementVentData(state, ErrorsFound);
204 :
205 : // get UCSDCV model controls for all zones
206 741 : GetCrossVentData(state, ErrorsFound);
207 :
208 : // get BTG's user-defined patterns for all zones
209 741 : GetUserDefinedPatternData(state, ErrorsFound);
210 :
211 : // get UCSD UFAD interior zone model controls for all zones
212 : // get UCSD UFAD exterior zone model controls for all zones
213 741 : GetUFADZoneData(state, ErrorsFound);
214 :
215 741 : if (ErrorsFound) {
216 0 : ShowFatalError(state, "GetAirModelData: Errors found getting air model input. Program terminates.");
217 : }
218 741 : }
219 :
220 741 : void GetUserDefinedPatternData(EnergyPlusData &state, bool &ErrorsFound) // True if errors found during this get input routine
221 : {
222 : // SUBROUTINE INFORMATION:
223 : // AUTHOR Brent Griffith
224 : // DATE WRITTEN Aug 2005
225 : // MODIFIED na
226 : // RE-ENGINEERED na
227 :
228 : // PURPOSE OF THIS SUBROUTINE:
229 : // This routine "gets" all the data for the "User-Defined RoomAir"
230 :
231 : // METHODOLOGY EMPLOYED:
232 : // usual energyplus input routines
233 : // for the actual patterns, a single structure array holds
234 : // different patterns in nested derived types.
235 :
236 : // Using/Aliasing
237 : using DataZoneEquipment::EquipConfiguration;
238 :
239 : using RoomAirModelUserTempPattern::FigureNDheightInZone;
240 : using ScheduleManager::GetScheduleIndex;
241 :
242 : // SUBROUTINE PARAMETER DEFINITIONS:
243 : static constexpr std::string_view RoutineName("GetUserDefinedPatternData: ");
244 :
245 : // SUBROUTINE LOCAL VARIABLE DECLARATIONS:
246 : int NumAlphas; // number of alphas
247 : int NumNumbers; // Number of numbers encountered
248 : int Status; // Notes if there was an error in processing the input
249 :
250 : int thisSurfinZone; // working variable for indexing surfaces within a ZoneRadiantInfo structure
251 : int thisPattern;
252 :
253 : int i; // do loop indexer
254 : int NumPairs; // number of zeta/deltaTai pairs
255 : int ObjNum; // loop indexer of input objects if the same type
256 : int ZoneNum; // zone number in heat balance domain
257 : int found; // test for UtilityRoutines::FindItemInList(
258 :
259 : // access input file and setup
260 741 : state.dataRoomAirMod->numTempDistContrldZones =
261 1482 : state.dataInputProcessing->inputProcessor->getNumObjectsFound(state, cUserDefinedControlObject);
262 :
263 741 : state.dataRoomAirMod->NumConstantGradient =
264 1482 : state.dataInputProcessing->inputProcessor->getNumObjectsFound(state, cTempPatternConstGradientObject);
265 741 : state.dataRoomAirMod->NumTwoGradientInterp =
266 1482 : state.dataInputProcessing->inputProcessor->getNumObjectsFound(state, cTempPatternTwoGradientObject);
267 741 : state.dataRoomAirMod->NumNonDimensionalHeight =
268 1482 : state.dataInputProcessing->inputProcessor->getNumObjectsFound(state, cTempPatternNDHeightObject);
269 741 : state.dataRoomAirMod->NumSurfaceMapping = state.dataInputProcessing->inputProcessor->getNumObjectsFound(state, cTempPatternSurfMapObject);
270 :
271 2223 : state.dataRoomAirMod->NumAirTempPatterns = state.dataRoomAirMod->NumConstantGradient + state.dataRoomAirMod->NumTwoGradientInterp +
272 1482 : state.dataRoomAirMod->NumNonDimensionalHeight + state.dataRoomAirMod->NumSurfaceMapping;
273 741 : auto &cCurrentModuleObject = state.dataIPShortCut->cCurrentModuleObject;
274 741 : cCurrentModuleObject = cUserDefinedControlObject;
275 741 : if (state.dataRoomAirMod->numTempDistContrldZones == 0) {
276 740 : if (state.dataRoomAirMod->NumAirTempPatterns != 0) { // user may have missed control object
277 0 : ShowWarningError(state, "Missing " + cCurrentModuleObject + " object needed to use roomair temperature patterns");
278 : // ErrorsFound = .TRUE.
279 : }
280 1480 : return;
281 : }
282 :
283 : // now allocate AirPatternZoneInfo to length of all zones for easy indexing
284 1 : if (!allocated(state.dataRoomAirMod->AirPatternZoneInfo)) {
285 1 : state.dataRoomAirMod->AirPatternZoneInfo.allocate(state.dataGlobal->NumOfZones);
286 : }
287 :
288 10 : for (ObjNum = 1; ObjNum <= state.dataRoomAirMod->numTempDistContrldZones; ++ObjNum) {
289 :
290 54 : state.dataInputProcessing->inputProcessor->getObjectItem(state,
291 : cCurrentModuleObject,
292 : ObjNum,
293 9 : state.dataIPShortCut->cAlphaArgs,
294 : NumAlphas,
295 9 : state.dataIPShortCut->rNumericArgs,
296 : NumNumbers,
297 : Status,
298 : _,
299 9 : state.dataIPShortCut->lAlphaFieldBlanks,
300 9 : state.dataIPShortCut->cAlphaFieldNames,
301 9 : state.dataIPShortCut->cNumericFieldNames);
302 : // first get zone ID
303 9 : ZoneNum = UtilityRoutines::FindItemInList(state.dataIPShortCut->cAlphaArgs(2), state.dataHeatBal->Zone);
304 9 : if (ZoneNum == 0) { // throw error
305 0 : ShowSevereError(state,
306 0 : std::string{RoutineName} + cCurrentModuleObject + "=\"" + state.dataIPShortCut->cAlphaArgs(1) + "\", invalid data.");
307 0 : ShowContinueError(
308 0 : state, "Invalid-not found " + state.dataIPShortCut->cAlphaFieldNames(2) + "=\"" + state.dataIPShortCut->cAlphaArgs(2) + "\".");
309 0 : ErrorsFound = true;
310 0 : return; // halt to avoid hard crash
311 : }
312 9 : state.dataRoomAirMod->AirPatternZoneInfo(ZoneNum).IsUsed = true;
313 9 : state.dataRoomAirMod->AirPatternZoneInfo(ZoneNum).Name = state.dataIPShortCut->cAlphaArgs(1); // Name of this Control Object
314 9 : state.dataRoomAirMod->AirPatternZoneInfo(ZoneNum).ZoneName = state.dataIPShortCut->cAlphaArgs(2); // Zone Name
315 :
316 9 : state.dataRoomAirMod->AirPatternZoneInfo(ZoneNum).AvailSched = state.dataIPShortCut->cAlphaArgs(3);
317 9 : if (state.dataIPShortCut->lAlphaFieldBlanks(3)) {
318 0 : state.dataRoomAirMod->AirPatternZoneInfo(ZoneNum).AvailSchedID = DataGlobalConstants::ScheduleAlwaysOn;
319 : } else {
320 9 : state.dataRoomAirMod->AirPatternZoneInfo(ZoneNum).AvailSchedID = GetScheduleIndex(state, state.dataIPShortCut->cAlphaArgs(3));
321 9 : if (state.dataRoomAirMod->AirPatternZoneInfo(ZoneNum).AvailSchedID == 0) {
322 0 : ShowSevereError(
323 0 : state, std::string{RoutineName} + cCurrentModuleObject + "=\"" + state.dataIPShortCut->cAlphaArgs(1) + "\", invalid data.");
324 0 : ShowContinueError(state,
325 0 : "Invalid-not found " + state.dataIPShortCut->cAlphaFieldNames(3) + "=\"" + state.dataIPShortCut->cAlphaArgs(3) +
326 : "\".");
327 0 : ErrorsFound = true;
328 : }
329 : }
330 :
331 18 : state.dataRoomAirMod->AirPatternZoneInfo(ZoneNum).PatternCntrlSched =
332 18 : state.dataIPShortCut->cAlphaArgs(4); // Schedule Name for Leading Pattern Control for this Zone
333 9 : state.dataRoomAirMod->AirPatternZoneInfo(ZoneNum).PatternSchedID = GetScheduleIndex(state, state.dataIPShortCut->cAlphaArgs(4));
334 9 : if (state.dataRoomAirMod->AirPatternZoneInfo(ZoneNum).PatternSchedID == 0) {
335 0 : ShowSevereError(state,
336 0 : std::string{RoutineName} + cCurrentModuleObject + "=\"" + state.dataIPShortCut->cAlphaArgs(1) + "\", invalid data.");
337 0 : ShowContinueError(
338 0 : state, "Invalid-not found " + state.dataIPShortCut->cAlphaFieldNames(4) + "=\"" + state.dataIPShortCut->cAlphaArgs(4) + "\".");
339 0 : ErrorsFound = true;
340 : }
341 :
342 9 : state.dataRoomAirMod->AirPatternZoneInfo(ZoneNum).ZoneID = ZoneNum;
343 :
344 : // figure number of surfaces for this zone
345 9 : state.dataRoomAirMod->AirPatternZoneInfo(ZoneNum).totNumSurfs = 0;
346 18 : for (int spaceNum : state.dataHeatBal->Zone(ZoneNum).spaceIndexes) {
347 9 : auto &thisSpace = state.dataHeatBal->space(spaceNum);
348 9 : state.dataRoomAirMod->AirPatternZoneInfo(ZoneNum).totNumSurfs += thisSpace.HTSurfaceLast - thisSpace.HTSurfaceFirst + 1;
349 : }
350 : // allocate nested derived type for surface info
351 9 : state.dataRoomAirMod->AirPatternZoneInfo(ZoneNum).Surf.allocate(state.dataRoomAirMod->AirPatternZoneInfo(ZoneNum).totNumSurfs);
352 :
353 : // Fill in what we know for nested structure for surfaces
354 9 : thisSurfinZone = 0;
355 18 : for (int spaceNum : state.dataHeatBal->Zone(ZoneNum).spaceIndexes) {
356 9 : auto &thisSpace = state.dataHeatBal->space(spaceNum);
357 420 : for (int thisHBsurfID = thisSpace.HTSurfaceFirst; thisHBsurfID <= thisSpace.HTSurfaceLast; ++thisHBsurfID) {
358 411 : ++thisSurfinZone;
359 420 : if (state.dataSurface->Surface(thisHBsurfID).Class == DataSurfaces::SurfaceClass::IntMass) {
360 9 : state.dataRoomAirMod->AirPatternZoneInfo(ZoneNum).Surf(thisSurfinZone).SurfID = thisHBsurfID;
361 9 : state.dataRoomAirMod->AirPatternZoneInfo(ZoneNum).Surf(thisSurfinZone).Zeta = 0.5;
362 9 : continue;
363 : }
364 :
365 402 : state.dataRoomAirMod->AirPatternZoneInfo(ZoneNum).Surf(thisSurfinZone).SurfID = thisHBsurfID;
366 :
367 402 : state.dataRoomAirMod->AirPatternZoneInfo(ZoneNum).Surf(thisSurfinZone).Zeta = FigureNDheightInZone(state, thisHBsurfID);
368 : }
369 : } // loop through surfaces in this zone
370 :
371 : } // loop through number of 'RoomAir:TemperaturePattern:UserDefined' objects
372 :
373 : // Check against AirModel. Make sure there is a match here.
374 12 : for (ZoneNum = 1; ZoneNum <= state.dataGlobal->NumOfZones; ++ZoneNum) {
375 11 : if (state.dataRoomAirMod->AirModel(ZoneNum).AirModelType != DataRoomAirModel::RoomAirModel::UserDefined) continue;
376 9 : if (state.dataRoomAirMod->AirPatternZoneInfo(ZoneNum).IsUsed) continue; // There is a Room Air Temperatures object for this zone
377 0 : ShowSevereError(state,
378 0 : std::string{RoutineName} + "AirModel for Zone=[" + state.dataHeatBal->Zone(ZoneNum).Name +
379 : "] is indicated as \"User Defined\".");
380 0 : ShowContinueError(state, "...but missing a " + cCurrentModuleObject + " object for control.");
381 0 : ErrorsFound = true;
382 : }
383 :
384 : // now get user defined temperature patterns
385 1 : if (!allocated(state.dataRoomAirMod->RoomAirPattern)) {
386 1 : state.dataRoomAirMod->RoomAirPattern.allocate(state.dataRoomAirMod->NumAirTempPatterns);
387 : }
388 :
389 : // Four different objects to get
390 1 : cCurrentModuleObject = cTempPatternConstGradientObject;
391 6 : for (ObjNum = 1; ObjNum <= state.dataRoomAirMod->NumConstantGradient; ++ObjNum) {
392 5 : thisPattern = ObjNum;
393 25 : state.dataInputProcessing->inputProcessor->getObjectItem(state,
394 : cCurrentModuleObject,
395 : ObjNum,
396 5 : state.dataIPShortCut->cAlphaArgs,
397 : NumAlphas,
398 5 : state.dataIPShortCut->rNumericArgs,
399 : NumNumbers,
400 : Status,
401 : _,
402 : _,
403 5 : state.dataIPShortCut->cAlphaFieldNames,
404 5 : state.dataIPShortCut->cNumericFieldNames);
405 :
406 5 : state.dataRoomAirMod->RoomAirPattern(thisPattern).Name = state.dataIPShortCut->cAlphaArgs(1);
407 5 : state.dataRoomAirMod->RoomAirPattern(thisPattern).PatrnID = state.dataIPShortCut->rNumericArgs(1);
408 5 : state.dataRoomAirMod->RoomAirPattern(thisPattern).PatternMode = DataRoomAirModel::UserDefinedPatternType::ConstGradTemp;
409 5 : state.dataRoomAirMod->RoomAirPattern(thisPattern).DeltaTstat = state.dataIPShortCut->rNumericArgs(2);
410 5 : state.dataRoomAirMod->RoomAirPattern(thisPattern).DeltaTleaving = state.dataIPShortCut->rNumericArgs(3);
411 5 : state.dataRoomAirMod->RoomAirPattern(thisPattern).DeltaTexhaust = state.dataIPShortCut->rNumericArgs(4);
412 5 : state.dataRoomAirMod->RoomAirPattern(thisPattern).GradPatrn.Gradient = state.dataIPShortCut->rNumericArgs(5);
413 : }
414 :
415 1 : cCurrentModuleObject = cTempPatternTwoGradientObject;
416 6 : for (ObjNum = 1; ObjNum <= state.dataRoomAirMod->NumTwoGradientInterp; ++ObjNum) {
417 5 : thisPattern = state.dataRoomAirMod->NumConstantGradient + ObjNum;
418 25 : state.dataInputProcessing->inputProcessor->getObjectItem(state,
419 : cCurrentModuleObject,
420 : ObjNum,
421 5 : state.dataIPShortCut->cAlphaArgs,
422 : NumAlphas,
423 5 : state.dataIPShortCut->rNumericArgs,
424 : NumNumbers,
425 : Status,
426 : _,
427 : _,
428 5 : state.dataIPShortCut->cAlphaFieldNames,
429 5 : state.dataIPShortCut->cNumericFieldNames);
430 5 : state.dataRoomAirMod->RoomAirPattern(thisPattern).PatternMode = DataRoomAirModel::UserDefinedPatternType::TwoGradInterp;
431 5 : state.dataRoomAirMod->RoomAirPattern(thisPattern).Name = state.dataIPShortCut->cAlphaArgs(1);
432 5 : state.dataRoomAirMod->RoomAirPattern(thisPattern).PatrnID = state.dataIPShortCut->rNumericArgs(1);
433 5 : state.dataRoomAirMod->RoomAirPattern(thisPattern).TwoGradPatrn.TstatHeight = state.dataIPShortCut->rNumericArgs(2);
434 5 : state.dataRoomAirMod->RoomAirPattern(thisPattern).TwoGradPatrn.TleavingHeight = state.dataIPShortCut->rNumericArgs(3);
435 5 : state.dataRoomAirMod->RoomAirPattern(thisPattern).TwoGradPatrn.TexhaustHeight = state.dataIPShortCut->rNumericArgs(4);
436 5 : state.dataRoomAirMod->RoomAirPattern(thisPattern).TwoGradPatrn.LowGradient = state.dataIPShortCut->rNumericArgs(5);
437 5 : state.dataRoomAirMod->RoomAirPattern(thisPattern).TwoGradPatrn.HiGradient = state.dataIPShortCut->rNumericArgs(6);
438 :
439 5 : if (UtilityRoutines::SameString(state.dataIPShortCut->cAlphaArgs(2), "OutdoorDryBulbTemperature")) {
440 1 : state.dataRoomAirMod->RoomAirPattern(thisPattern).TwoGradPatrn.InterpolationMode =
441 : DataRoomAirModel::UserDefinedPatternMode::OutdoorDryBulb;
442 4 : } else if (UtilityRoutines::SameString(state.dataIPShortCut->cAlphaArgs(2), "ZoneDryBulbTemperature")) {
443 1 : state.dataRoomAirMod->RoomAirPattern(thisPattern).TwoGradPatrn.InterpolationMode =
444 : DataRoomAirModel::UserDefinedPatternMode::ZoneAirTemp;
445 3 : } else if (UtilityRoutines::SameString(state.dataIPShortCut->cAlphaArgs(2), "ZoneAndOutdoorTemperatureDifference")) {
446 1 : state.dataRoomAirMod->RoomAirPattern(thisPattern).TwoGradPatrn.InterpolationMode =
447 : DataRoomAirModel::UserDefinedPatternMode::DeltaOutdoorZone;
448 2 : } else if (UtilityRoutines::SameString(state.dataIPShortCut->cAlphaArgs(2), "SensibleCoolingLoad")) {
449 1 : state.dataRoomAirMod->RoomAirPattern(thisPattern).TwoGradPatrn.InterpolationMode =
450 : DataRoomAirModel::UserDefinedPatternMode::SensibleCooling;
451 1 : } else if (UtilityRoutines::SameString(state.dataIPShortCut->cAlphaArgs(2), "SensibleHeatingLoad")) {
452 1 : state.dataRoomAirMod->RoomAirPattern(thisPattern).TwoGradPatrn.InterpolationMode =
453 : DataRoomAirModel::UserDefinedPatternMode::SensibleHeating;
454 : } else {
455 0 : ShowSevereError(state, "Invalid " + state.dataIPShortCut->cAlphaFieldNames(2) + " = " + state.dataIPShortCut->cAlphaArgs(2));
456 0 : ShowContinueError(state, "Entered in " + cCurrentModuleObject + " = " + state.dataIPShortCut->cAlphaArgs(1));
457 0 : ErrorsFound = true;
458 : }
459 :
460 5 : state.dataRoomAirMod->RoomAirPattern(thisPattern).TwoGradPatrn.UpperBoundTempScale = state.dataIPShortCut->rNumericArgs(7);
461 5 : state.dataRoomAirMod->RoomAirPattern(thisPattern).TwoGradPatrn.LowerBoundTempScale = state.dataIPShortCut->rNumericArgs(8);
462 :
463 5 : state.dataRoomAirMod->RoomAirPattern(thisPattern).TwoGradPatrn.UpperBoundHeatRateScale = state.dataIPShortCut->rNumericArgs(9);
464 5 : state.dataRoomAirMod->RoomAirPattern(thisPattern).TwoGradPatrn.LowerBoundHeatRateScale = state.dataIPShortCut->rNumericArgs(10);
465 :
466 : // now test the input some
467 10 : if (state.dataRoomAirMod->RoomAirPattern(thisPattern).TwoGradPatrn.HiGradient ==
468 5 : state.dataRoomAirMod->RoomAirPattern(thisPattern).TwoGradPatrn.LowGradient) {
469 0 : ShowWarningError(state, format("Upper and lower gradients equal, use {} instead ", cTempPatternConstGradientObject));
470 0 : ShowContinueError(state, "Entered in " + cCurrentModuleObject + " = " + state.dataIPShortCut->cAlphaArgs(1));
471 : }
472 10 : if ((state.dataRoomAirMod->RoomAirPattern(thisPattern).TwoGradPatrn.UpperBoundTempScale ==
473 7 : state.dataRoomAirMod->RoomAirPattern(thisPattern).TwoGradPatrn.LowerBoundTempScale) &&
474 2 : ((state.dataRoomAirMod->RoomAirPattern(thisPattern).TwoGradPatrn.InterpolationMode ==
475 2 : DataRoomAirModel::UserDefinedPatternMode::OutdoorDryBulb) ||
476 2 : (state.dataRoomAirMod->RoomAirPattern(thisPattern).TwoGradPatrn.InterpolationMode ==
477 2 : DataRoomAirModel::UserDefinedPatternMode::ZoneAirTemp) ||
478 2 : (state.dataRoomAirMod->RoomAirPattern(thisPattern).TwoGradPatrn.InterpolationMode ==
479 : DataRoomAirModel::UserDefinedPatternMode::DeltaOutdoorZone))) {
480 : // throw error, will cause divide by zero when used for scaling
481 0 : ShowSevereError(state, "Error in temperature scale in " + cCurrentModuleObject + ": " + state.dataIPShortCut->cAlphaArgs(1));
482 0 : ErrorsFound = true;
483 : }
484 10 : if ((state.dataRoomAirMod->RoomAirPattern(thisPattern).TwoGradPatrn.HiGradient ==
485 5 : state.dataRoomAirMod->RoomAirPattern(thisPattern).TwoGradPatrn.LowGradient) &&
486 0 : ((state.dataRoomAirMod->RoomAirPattern(thisPattern).TwoGradPatrn.InterpolationMode ==
487 0 : DataRoomAirModel::UserDefinedPatternMode::SensibleCooling) ||
488 0 : (state.dataRoomAirMod->RoomAirPattern(thisPattern).TwoGradPatrn.InterpolationMode ==
489 : DataRoomAirModel::UserDefinedPatternMode::SensibleHeating))) {
490 : // throw error, will cause divide by zero when used for scaling
491 0 : ShowSevereError(state, "Error in load scale in " + cCurrentModuleObject + ": " + state.dataIPShortCut->cAlphaArgs(1));
492 0 : ErrorsFound = true;
493 : }
494 : }
495 :
496 1 : cCurrentModuleObject = cTempPatternNDHeightObject;
497 2 : for (ObjNum = 1; ObjNum <= state.dataRoomAirMod->NumNonDimensionalHeight; ++ObjNum) {
498 1 : thisPattern = state.dataRoomAirMod->NumConstantGradient + state.dataRoomAirMod->NumTwoGradientInterp + ObjNum;
499 1 : state.dataRoomAirMod->RoomAirPattern(thisPattern).PatternMode = DataRoomAirModel::UserDefinedPatternType::NonDimenHeight;
500 :
501 5 : state.dataInputProcessing->inputProcessor->getObjectItem(state,
502 : cCurrentModuleObject,
503 : ObjNum,
504 1 : state.dataIPShortCut->cAlphaArgs,
505 : NumAlphas,
506 1 : state.dataIPShortCut->rNumericArgs,
507 : NumNumbers,
508 : Status,
509 : _,
510 : _,
511 1 : state.dataIPShortCut->cAlphaFieldNames,
512 1 : state.dataIPShortCut->cNumericFieldNames);
513 1 : state.dataRoomAirMod->RoomAirPattern(thisPattern).Name = state.dataIPShortCut->cAlphaArgs(1);
514 1 : state.dataRoomAirMod->RoomAirPattern(thisPattern).PatrnID = state.dataIPShortCut->rNumericArgs(1);
515 1 : state.dataRoomAirMod->RoomAirPattern(thisPattern).DeltaTstat = state.dataIPShortCut->rNumericArgs(2);
516 1 : state.dataRoomAirMod->RoomAirPattern(thisPattern).DeltaTleaving = state.dataIPShortCut->rNumericArgs(3);
517 1 : state.dataRoomAirMod->RoomAirPattern(thisPattern).DeltaTexhaust = state.dataIPShortCut->rNumericArgs(4);
518 :
519 1 : NumPairs = std::floor((double(NumNumbers) - 4.0) / 2.0);
520 :
521 : // TODO error checking
522 :
523 1 : state.dataRoomAirMod->RoomAirPattern(thisPattern).VertPatrn.ZetaPatrn.allocate(NumPairs);
524 1 : state.dataRoomAirMod->RoomAirPattern(thisPattern).VertPatrn.DeltaTaiPatrn.allocate(NumPairs);
525 :
526 : // init these since they can't be in derived type
527 1 : state.dataRoomAirMod->RoomAirPattern(thisPattern).VertPatrn.ZetaPatrn = 0.0;
528 1 : state.dataRoomAirMod->RoomAirPattern(thisPattern).VertPatrn.DeltaTaiPatrn = 0.0;
529 :
530 12 : for (i = 0; i <= NumPairs - 1; ++i) {
531 :
532 11 : state.dataRoomAirMod->RoomAirPattern(thisPattern).VertPatrn.ZetaPatrn(i + 1) = state.dataIPShortCut->rNumericArgs(2 * i + 5);
533 11 : state.dataRoomAirMod->RoomAirPattern(thisPattern).VertPatrn.DeltaTaiPatrn(i + 1) = state.dataIPShortCut->rNumericArgs(2 * i + 6);
534 : }
535 :
536 : // TODO check order (TODO sort ? )
537 11 : for (i = 2; i <= NumPairs; ++i) {
538 20 : if (state.dataRoomAirMod->RoomAirPattern(thisPattern).VertPatrn.ZetaPatrn(i) <
539 10 : state.dataRoomAirMod->RoomAirPattern(thisPattern).VertPatrn.ZetaPatrn(i - 1)) {
540 0 : ShowSevereError(state,
541 0 : "Zeta values not in increasing order in " + cCurrentModuleObject + ": " + state.dataIPShortCut->cAlphaArgs(1));
542 0 : ErrorsFound = true;
543 : }
544 : }
545 : }
546 :
547 1 : cCurrentModuleObject = cTempPatternSurfMapObject;
548 3 : for (ObjNum = 1; ObjNum <= state.dataRoomAirMod->NumSurfaceMapping; ++ObjNum) {
549 4 : thisPattern = state.dataRoomAirMod->NumConstantGradient + state.dataRoomAirMod->NumTwoGradientInterp +
550 2 : state.dataRoomAirMod->NumNonDimensionalHeight + ObjNum;
551 2 : state.dataRoomAirMod->RoomAirPattern(thisPattern).PatternMode = DataRoomAirModel::UserDefinedPatternType::SurfMapTemp;
552 :
553 10 : state.dataInputProcessing->inputProcessor->getObjectItem(state,
554 : cCurrentModuleObject,
555 : ObjNum,
556 2 : state.dataIPShortCut->cAlphaArgs,
557 : NumAlphas,
558 2 : state.dataIPShortCut->rNumericArgs,
559 : NumNumbers,
560 : Status,
561 : _,
562 : _,
563 2 : state.dataIPShortCut->cAlphaFieldNames,
564 2 : state.dataIPShortCut->cNumericFieldNames);
565 2 : state.dataRoomAirMod->RoomAirPattern(thisPattern).Name = state.dataIPShortCut->cAlphaArgs(1);
566 2 : state.dataRoomAirMod->RoomAirPattern(thisPattern).PatrnID = state.dataIPShortCut->rNumericArgs(1);
567 2 : state.dataRoomAirMod->RoomAirPattern(thisPattern).DeltaTstat = state.dataIPShortCut->rNumericArgs(2);
568 2 : state.dataRoomAirMod->RoomAirPattern(thisPattern).DeltaTleaving = state.dataIPShortCut->rNumericArgs(3);
569 2 : state.dataRoomAirMod->RoomAirPattern(thisPattern).DeltaTexhaust = state.dataIPShortCut->rNumericArgs(4);
570 :
571 2 : NumPairs = NumNumbers - 4;
572 :
573 2 : if (NumPairs != (NumAlphas - 1)) {
574 0 : ShowSevereError(state, "Error in number of entries in " + cCurrentModuleObject + " object: " + state.dataIPShortCut->cAlphaArgs(1));
575 0 : ErrorsFound = true;
576 : }
577 2 : state.dataRoomAirMod->RoomAirPattern(thisPattern).MapPatrn.SurfName.allocate(NumPairs);
578 2 : state.dataRoomAirMod->RoomAirPattern(thisPattern).MapPatrn.DeltaTai.allocate(NumPairs);
579 2 : state.dataRoomAirMod->RoomAirPattern(thisPattern).MapPatrn.SurfID.allocate(NumPairs);
580 :
581 : // init just allocated
582 2 : state.dataRoomAirMod->RoomAirPattern(thisPattern).MapPatrn.SurfName = "";
583 2 : state.dataRoomAirMod->RoomAirPattern(thisPattern).MapPatrn.DeltaTai = 0.0;
584 2 : state.dataRoomAirMod->RoomAirPattern(thisPattern).MapPatrn.SurfID = 0;
585 :
586 20 : for (i = 1; i <= NumPairs; ++i) {
587 18 : state.dataRoomAirMod->RoomAirPattern(thisPattern).MapPatrn.SurfName(i) = state.dataIPShortCut->cAlphaArgs(i + 1);
588 18 : state.dataRoomAirMod->RoomAirPattern(thisPattern).MapPatrn.DeltaTai(i) = state.dataIPShortCut->rNumericArgs(i + 4);
589 18 : found = UtilityRoutines::FindItemInList(state.dataIPShortCut->cAlphaArgs(i + 1), state.dataSurface->Surface);
590 18 : if (found != 0) {
591 18 : state.dataRoomAirMod->RoomAirPattern(thisPattern).MapPatrn.SurfID(i) = found;
592 : } else {
593 0 : ShowSevereError(state, "Surface name not found in " + cCurrentModuleObject + " object: " + state.dataIPShortCut->cAlphaArgs(1));
594 0 : ErrorsFound = true;
595 : }
596 : }
597 2 : state.dataRoomAirMod->RoomAirPattern(thisPattern).MapPatrn.NumSurfs = NumPairs;
598 : }
599 :
600 1 : if (state.dataErrTracking->TotalRoomAirPatternTooLow > 0) {
601 0 : ShowWarningError(state,
602 0 : format("GetUserDefinedPatternData: RoomAirModelUserTempPattern: {} problem(s) in non-dimensional height calculations, "
603 : "too low surface height(s) in relation to floor height of zone(s).",
604 0 : state.dataErrTracking->TotalRoomAirPatternTooLow));
605 0 : ShowContinueError(state, "...Use OutputDiagnostics,DisplayExtraWarnings; to see details.");
606 0 : state.dataErrTracking->TotalWarningErrors += state.dataErrTracking->TotalRoomAirPatternTooLow;
607 : }
608 1 : if (state.dataErrTracking->TotalRoomAirPatternTooHigh > 0) {
609 0 : ShowWarningError(state,
610 0 : format("GetUserDefinedPatternData: RoomAirModelUserTempPattern: {} problem(s) in non-dimensional height calculations, "
611 : "too high surface height(s) in relation to ceiling height of zone(s).",
612 0 : state.dataErrTracking->TotalRoomAirPatternTooHigh));
613 0 : ShowContinueError(state, "...Use OutputDiagnostics,DisplayExtraWarnings; to see details.");
614 0 : state.dataErrTracking->TotalWarningErrors += state.dataErrTracking->TotalRoomAirPatternTooHigh;
615 : }
616 :
617 : // now do one time setups from and checks on user data
618 :
619 : // Find and set return and exhaust node ids
620 :
621 12 : for (i = 1; i <= state.dataGlobal->NumOfZones; ++i) {
622 11 : if (state.dataRoomAirMod->AirPatternZoneInfo(i).IsUsed) {
623 : // first get return and exhaust air node index
624 18 : found = UtilityRoutines::FindItemInList(
625 18 : state.dataRoomAirMod->AirPatternZoneInfo(i).ZoneName, state.dataZoneEquip->ZoneEquipConfig, &EquipConfiguration::ZoneName);
626 9 : if (found != 0) {
627 :
628 9 : state.dataRoomAirMod->AirPatternZoneInfo(i).ZoneNodeID = state.dataZoneEquip->ZoneEquipConfig(found).ZoneNode;
629 9 : if (allocated(state.dataZoneEquip->ZoneEquipConfig(found).ExhaustNode)) {
630 18 : state.dataRoomAirMod->AirPatternZoneInfo(i).ExhaustAirNodeID.allocate(
631 18 : state.dataZoneEquip->ZoneEquipConfig(found).NumExhaustNodes);
632 9 : state.dataRoomAirMod->AirPatternZoneInfo(i).ExhaustAirNodeID = state.dataZoneEquip->ZoneEquipConfig(found).ExhaustNode;
633 : } // exhaust nodes present
634 : } // found ZoneEquipConf
635 :
636 : // second get zone height values
637 9 : state.dataRoomAirMod->AirPatternZoneInfo(i).ZoneHeight = state.dataHeatBal->Zone(i).CeilingHeight;
638 :
639 : } // air pattern is used
640 : }
641 : }
642 :
643 741 : void GetAirNodeData(EnergyPlusData &state, bool &ErrorsFound) // True if errors found during this get input routine
644 : {
645 :
646 : // SUBROUTINE INFORMATION:
647 : // AUTHOR Brent Griffith
648 : // DATE WRITTEN August 2001
649 : // RE-ENGINEERED April 2003, Weixiu Kong
650 : // MODIFIED July 2003, CC
651 : // Jan 2004, CC
652 :
653 : // PURPOSE OF THIS SUBROUTINE:
654 : // Get AirNode data for all zones at once
655 :
656 : // METHODOLOGY EMPLOYED:
657 : // Use input processer to get input from idf file
658 :
659 : // Using/Aliasing
660 :
661 : // SUBROUTINE LOCAL VARIABLE DECLARATIONS:
662 : int NumAlphas; // States which alpha value to read from a
663 : // "Number" line
664 : int NumNumbers; // Number of numbers encountered
665 : int Status; // Notes if there was an error in processing the input
666 : int AirNodeNum; // Index number for air nodes
667 : int ZoneNum; // Index number for zones
668 : int NumSurfsInvolved; // Number of surfaces involved with air nodes
669 : int SurfCount; // Number of surfaces involved with air nodes
670 : // (used for checking error)
671 : int NumOfSurfs; // Index number for last surface of zones
672 : bool SurfNeeded;
673 :
674 1480 : if (!state.dataRoomAirMod->MundtModelUsed) return;
675 :
676 : // Initialize default values for air nodes
677 2 : state.dataRoomAirMod->TotNumOfZoneAirNodes.allocate(state.dataGlobal->NumOfZones);
678 2 : state.dataRoomAirMod->TotNumOfAirNodes = 0;
679 2 : state.dataRoomAirMod->TotNumOfZoneAirNodes = 0;
680 2 : auto &cCurrentModuleObject = state.dataIPShortCut->cCurrentModuleObject;
681 2 : cCurrentModuleObject = "RoomAir:Node";
682 2 : state.dataRoomAirMod->TotNumOfAirNodes = state.dataInputProcessing->inputProcessor->getNumObjectsFound(state, cCurrentModuleObject);
683 :
684 2 : if (state.dataRoomAirMod->TotNumOfAirNodes <= 0) {
685 : // no air node object is found, terminate the program
686 0 : ShowSevereError(state, "No " + cCurrentModuleObject + " objects found in input.");
687 0 : ShowContinueError(state, "The OneNodeDisplacementVentilation model requires " + cCurrentModuleObject + " objects");
688 0 : ErrorsFound = true;
689 0 : return;
690 : } else {
691 : // air node objects are found so allocate airnode variable
692 2 : state.dataRoomAirMod->AirNode.allocate(state.dataRoomAirMod->TotNumOfAirNodes);
693 : }
694 :
695 38 : for (AirNodeNum = 1; AirNodeNum <= state.dataRoomAirMod->TotNumOfAirNodes; ++AirNodeNum) {
696 :
697 : // get air node objects
698 180 : state.dataInputProcessing->inputProcessor->getObjectItem(state,
699 : cCurrentModuleObject,
700 : AirNodeNum,
701 36 : state.dataIPShortCut->cAlphaArgs,
702 : NumAlphas,
703 36 : state.dataIPShortCut->rNumericArgs,
704 : NumNumbers,
705 : Status,
706 : _,
707 : _,
708 36 : state.dataIPShortCut->cAlphaFieldNames,
709 36 : state.dataIPShortCut->cNumericFieldNames);
710 36 : UtilityRoutines::IsNameEmpty(state, state.dataIPShortCut->cAlphaArgs(1), cCurrentModuleObject, ErrorsFound);
711 :
712 36 : state.dataRoomAirMod->AirNode(AirNodeNum).Name = state.dataIPShortCut->cAlphaArgs(1);
713 :
714 36 : state.dataRoomAirMod->AirNode(AirNodeNum).ZoneName = state.dataIPShortCut->cAlphaArgs(3); // Zone name
715 36 : state.dataRoomAirMod->AirNode(AirNodeNum).ZonePtr =
716 36 : UtilityRoutines::FindItemInList(state.dataRoomAirMod->AirNode(AirNodeNum).ZoneName, state.dataHeatBal->Zone);
717 36 : if (state.dataRoomAirMod->AirNode(AirNodeNum).ZonePtr == 0) {
718 0 : ShowSevereError(state, "Invalid " + state.dataIPShortCut->cAlphaFieldNames(3) + " = " + state.dataIPShortCut->cAlphaArgs(3));
719 0 : ShowContinueError(state, "Entered in " + cCurrentModuleObject + " = " + state.dataIPShortCut->cAlphaArgs(1));
720 0 : ErrorsFound = true;
721 : } else {
722 36 : ZoneNum = state.dataRoomAirMod->AirNode(AirNodeNum).ZonePtr;
723 36 : NumOfSurfs = 0;
724 72 : for (int spaceNum : state.dataHeatBal->Zone(ZoneNum).spaceIndexes) {
725 36 : auto &thisSpace = state.dataHeatBal->space(spaceNum);
726 36 : NumOfSurfs += thisSpace.HTSurfaceLast - thisSpace.HTSurfaceFirst + 1;
727 : }
728 36 : state.dataRoomAirMod->AirNode(AirNodeNum).SurfMask.allocate(NumOfSurfs);
729 : }
730 :
731 : {
732 72 : auto const nodeType(state.dataIPShortCut->cAlphaArgs(2));
733 36 : if (nodeType == "INLET") {
734 4 : state.dataRoomAirMod->AirNode(AirNodeNum).ClassType = AirNodeType::InletAir;
735 32 : } else if (nodeType == "FLOOR") {
736 4 : state.dataRoomAirMod->AirNode(AirNodeNum).ClassType = AirNodeType::FloorAir;
737 28 : } else if (nodeType == "CONTROL") {
738 4 : state.dataRoomAirMod->AirNode(AirNodeNum).ClassType = AirNodeType::ControlAir;
739 24 : } else if (nodeType == "CEILING") {
740 4 : state.dataRoomAirMod->AirNode(AirNodeNum).ClassType = AirNodeType::CeilingAir;
741 20 : } else if (nodeType == "MUNDTROOM") {
742 16 : state.dataRoomAirMod->AirNode(AirNodeNum).ClassType = AirNodeType::MundtRoomAir;
743 4 : } else if (nodeType == "RETURN") {
744 4 : state.dataRoomAirMod->AirNode(AirNodeNum).ClassType = AirNodeType::ReturnAir;
745 : } else {
746 0 : ShowSevereError(state, "Invalid " + state.dataIPShortCut->cAlphaFieldNames(2) + " = " + state.dataIPShortCut->cAlphaArgs(2));
747 0 : ShowContinueError(state, "Entered in " + cCurrentModuleObject + " = " + state.dataIPShortCut->cAlphaArgs(1));
748 0 : ErrorsFound = true;
749 : }
750 : }
751 :
752 36 : state.dataRoomAirMod->AirNode(AirNodeNum).Height = state.dataIPShortCut->rNumericArgs(1); // Air node height
753 36 : NumSurfsInvolved = NumAlphas - 3; // Number of surfaces involved with air nodes
754 :
755 : // Initialize
756 36 : state.dataRoomAirMod->AirNode(AirNodeNum).SurfMask = false;
757 :
758 36 : if (NumSurfsInvolved <= 0) {
759 :
760 : // report severe error since the following air nodes require surfaces associated with them
761 : {
762 24 : auto const nodeType(state.dataIPShortCut->cAlphaArgs(2));
763 48 : if (nodeType == "FLOOR" || nodeType == "CEILING" || nodeType == "MUNDTROOM" || nodeType == "PLUME4" || nodeType == "REESROOM1" ||
764 36 : nodeType == "REESROOM2" || nodeType == "REESROOM3" || nodeType == "REESROOM4") {
765 : // terminate the program due to a severe error in the specified input
766 0 : ShowSevereError(state,
767 0 : "GetAirNodeData: " + cCurrentModuleObject + "=\"" + state.dataIPShortCut->cAlphaArgs(1) +
768 : "\" invalid air node specification.");
769 0 : ShowContinueError(state,
770 0 : "Mundt Room Air Model: No surface names specified. Air node=\"" +
771 0 : state.dataRoomAirMod->AirNode(AirNodeNum).Name + " requires name of surfaces associated with it.");
772 0 : ErrorsFound = true;
773 : } else {
774 : }
775 : }
776 :
777 : } else {
778 :
779 : // initialize
780 24 : SurfNeeded = true;
781 :
782 : // report warning error since the following air nodes do not require surfaces associated with them
783 : // and assign .FALSE. to 'SurfNeeded'
784 : {
785 48 : auto const nodeType(state.dataIPShortCut->cAlphaArgs(2));
786 48 : if (nodeType == "INLET" || nodeType == "CONTROL" || nodeType == "RETURN" || nodeType == "PLUME1" || nodeType == "PLUME2" ||
787 24 : nodeType == "PLUME3") {
788 0 : ShowWarningError(
789 0 : state, "GetAirNodeData: " + cCurrentModuleObject + "=\"" + state.dataIPShortCut->cAlphaArgs(1) + "\" invalid linkage");
790 0 : ShowContinueError(state,
791 0 : "Mundt Room Air Model: No surface names needed. Air node=\"" +
792 0 : state.dataRoomAirMod->AirNode(AirNodeNum).Name + " does not relate to any surfaces.");
793 0 : SurfNeeded = false;
794 : } else {
795 : }
796 : }
797 :
798 24 : if (SurfNeeded) {
799 :
800 : // this air node is in this zone; hence, first get name of all surfaces in this zone
801 24 : ZoneNum = state.dataRoomAirMod->AirNode(AirNodeNum).ZonePtr;
802 24 : NumOfSurfs = 0;
803 48 : for (int spaceNum : state.dataHeatBal->Zone(ZoneNum).spaceIndexes) {
804 24 : auto &thisSpace = state.dataHeatBal->space(spaceNum);
805 24 : NumOfSurfs += thisSpace.HTSurfaceLast - thisSpace.HTSurfaceFirst + 1;
806 : }
807 :
808 : // terminate the program due to a severe error in the specified input
809 24 : if ((NumSurfsInvolved) > NumOfSurfs) {
810 0 : ShowFatalError(state,
811 0 : "GetAirNodeData: Mundt Room Air Model: Number of surfaces connected to " +
812 0 : state.dataRoomAirMod->AirNode(AirNodeNum).Name + " is greater than number of surfaces in " +
813 0 : state.dataHeatBal->Zone(ZoneNum).Name);
814 0 : return;
815 : }
816 :
817 : // relate surfaces to this air node and check to see whether surface names are specified correctly or not
818 24 : SurfCount = 0;
819 112 : for (int ListSurfNum = 4; ListSurfNum <= NumAlphas; ++ListSurfNum) {
820 88 : int thisSurfinZone = 0;
821 88 : bool surfaceFound = false;
822 88 : for (int spaceNum : state.dataHeatBal->Zone(ZoneNum).spaceIndexes) {
823 88 : auto &thisSpace = state.dataHeatBal->space(spaceNum);
824 1012 : for (int SurfNum = thisSpace.HTSurfaceFirst; SurfNum <= thisSpace.HTSurfaceLast; ++SurfNum) {
825 1012 : ++thisSurfinZone;
826 1012 : if (state.dataIPShortCut->cAlphaArgs(ListSurfNum) == state.dataSurface->Surface(SurfNum).Name) {
827 : ;
828 88 : state.dataRoomAirMod->AirNode(AirNodeNum).SurfMask(thisSurfinZone) = true;
829 88 : ++SurfCount;
830 88 : surfaceFound = true;
831 88 : break;
832 : }
833 : }
834 88 : if (surfaceFound) break;
835 : }
836 : }
837 :
838 : // report warning error since surface names are specified correctly
839 24 : if ((NumSurfsInvolved) != SurfCount) {
840 0 : ShowWarningError(state,
841 0 : "GetAirNodeData: Mundt Room Air Model: Some surface names specified for " +
842 0 : state.dataRoomAirMod->AirNode(AirNodeNum).Name + " are not in " + state.dataHeatBal->Zone(ZoneNum).Name);
843 : }
844 : }
845 : }
846 : }
847 :
848 : // get number of air nodes in each zone
849 10 : for (ZoneNum = 1; ZoneNum <= state.dataGlobal->NumOfZones; ++ZoneNum) {
850 :
851 : // this zone uses other air model so skip the rest
852 8 : if (state.dataRoomAirMod->AirModel(ZoneNum).AirModelType != DataRoomAirModel::RoomAirModel::Mundt) continue;
853 :
854 : // this zone uses a nodal air model so get number of air nodes in each zone
855 76 : for (AirNodeNum = 1; AirNodeNum <= state.dataRoomAirMod->TotNumOfAirNodes; ++AirNodeNum) {
856 72 : if (state.dataRoomAirMod->AirNode(AirNodeNum).ZonePtr == ZoneNum) {
857 36 : ++state.dataRoomAirMod->TotNumOfZoneAirNodes(ZoneNum);
858 : }
859 : }
860 : }
861 : }
862 :
863 : //*****************************************************************************************
864 :
865 741 : void GetMundtData(EnergyPlusData &state, bool &ErrorsFound) // True if errors found during this get input routine
866 : {
867 :
868 : // SUBROUTINE INFORMATION:
869 : // AUTHOR Brent Griffith
870 : // DATE WRITTEN August 2001
871 : // MODIFIED na
872 : // RE-ENGINEERED April 2003, Weixiu Kong
873 : // July 2003, CC
874 :
875 : // PURPOSE OF THIS SUBROUTINE:
876 : // Get Mundt model controls for all zones at once
877 :
878 : // METHODOLOGY EMPLOYED:
879 : // Use input processer to get input from idf file
880 :
881 : // Using/Aliasing
882 :
883 : // SUBROUTINE LOCAL VARIABLE DECLARATIONS:
884 : int NumAlphas;
885 : int NumNumbers; // Number of numbers encountered
886 : int Status; // Notes if there was an error in processing the input
887 : int ControlNum; // Index number
888 : int NumOfMundtContrl; // Number of Mundt Model Controls
889 : int ZoneNum; // Index number for zones
890 :
891 1480 : if (!state.dataRoomAirMod->MundtModelUsed) return;
892 :
893 : // Initialize default values for Mundt model controls
894 2 : state.dataRoomAirMod->ConvectiveFloorSplit.allocate(state.dataGlobal->NumOfZones);
895 2 : state.dataRoomAirMod->InfiltratFloorSplit.allocate(state.dataGlobal->NumOfZones);
896 2 : state.dataRoomAirMod->ConvectiveFloorSplit = 0.0;
897 2 : state.dataRoomAirMod->InfiltratFloorSplit = 0.0;
898 2 : auto &cCurrentModuleObject = state.dataIPShortCut->cCurrentModuleObject;
899 2 : cCurrentModuleObject = "RoomAirSettings:OneNodeDisplacementVentilation";
900 2 : NumOfMundtContrl = state.dataInputProcessing->inputProcessor->getNumObjectsFound(state, cCurrentModuleObject);
901 2 : if (NumOfMundtContrl > state.dataGlobal->NumOfZones) {
902 0 : ShowSevereError(state, "Too many " + cCurrentModuleObject + " objects in input file");
903 0 : ShowContinueError(state, "There cannot be more " + cCurrentModuleObject + " objects than number of zones.");
904 0 : ErrorsFound = true;
905 : }
906 :
907 2 : if (NumOfMundtContrl == 0) {
908 0 : ShowWarningError(state, "No " + cCurrentModuleObject + " objects found, program assumes no convection or infiltration gains near floors");
909 0 : return;
910 : }
911 :
912 : // this zone uses Mundt model so get Mundt Model Control
913 : // loop through all 'RoomAirSettings:OneNodeDisplacementVentilation' objects
914 6 : for (ControlNum = 1; ControlNum <= NumOfMundtContrl; ++ControlNum) {
915 20 : state.dataInputProcessing->inputProcessor->getObjectItem(state,
916 : cCurrentModuleObject,
917 : ControlNum,
918 4 : state.dataIPShortCut->cAlphaArgs,
919 : NumAlphas,
920 4 : state.dataIPShortCut->rNumericArgs,
921 : NumNumbers,
922 : Status,
923 : _,
924 : _,
925 4 : state.dataIPShortCut->cAlphaFieldNames,
926 4 : state.dataIPShortCut->cNumericFieldNames);
927 4 : ZoneNum = UtilityRoutines::FindItemInList(state.dataIPShortCut->cAlphaArgs(1), state.dataHeatBal->Zone);
928 4 : if (ZoneNum == 0) {
929 0 : ShowSevereError(state, "Invalid " + state.dataIPShortCut->cAlphaFieldNames(1) + " = " + state.dataIPShortCut->cAlphaArgs(1));
930 0 : ShowContinueError(state, "Entered in " + cCurrentModuleObject + " = " + state.dataIPShortCut->cAlphaArgs(1));
931 0 : ShowContinueError(state, "Not a valid zone name.");
932 0 : ErrorsFound = true;
933 0 : continue;
934 : }
935 4 : if (state.dataRoomAirMod->AirModel(ZoneNum).AirModelType != DataRoomAirModel::RoomAirModel::Mundt) {
936 0 : ShowSevereError(
937 0 : state, "Zone specified=\"" + state.dataIPShortCut->cAlphaArgs(1) + "\", Air Model type is not OneNodeDisplacementVentilation.");
938 0 : ShowContinueError(
939 0 : state, format("Air Model Type for zone={}", ChAirModel[static_cast<int>(state.dataRoomAirMod->AirModel(ZoneNum).AirModelType)]));
940 0 : ErrorsFound = true;
941 0 : continue;
942 : }
943 4 : state.dataRoomAirMod->ConvectiveFloorSplit(ZoneNum) = state.dataIPShortCut->rNumericArgs(1);
944 4 : state.dataRoomAirMod->InfiltratFloorSplit(ZoneNum) = state.dataIPShortCut->rNumericArgs(2);
945 : }
946 : }
947 :
948 741 : void GetDisplacementVentData(EnergyPlusData &state, bool &ErrorsFound) // True if errors found during this get input routine
949 : {
950 :
951 : // SUBROUTINE INFORMATION:
952 : // AUTHOR G. Carrilho da Graca
953 : // DATE WRITTEN January 2004
954 : // MODIFIED
955 : // RE-ENGINEERED
956 :
957 : // PURPOSE OF THIS SUBROUTINE:
958 : // Get UCSD Displacement ventilation model controls for all zones at once
959 :
960 : // METHODOLOGY EMPLOYED:
961 : // Use input processor to get input from idf file
962 :
963 : // Using/Aliasing
964 : using namespace ScheduleManager;
965 :
966 : // SUBROUTINE LOCAL VARIABLE DECLARATIONS:
967 : int IOStat;
968 : int NumAlpha;
969 : int NumNumber;
970 : int Loop;
971 741 : auto &cCurrentModuleObject = state.dataIPShortCut->cCurrentModuleObject;
972 1478 : if (!state.dataRoomAirMod->UCSDModelUsed) return;
973 7 : cCurrentModuleObject = "RoomAirSettings:ThreeNodeDisplacementVentilation";
974 7 : state.dataRoomAirMod->TotUCSDDV = state.dataInputProcessing->inputProcessor->getNumObjectsFound(state, cCurrentModuleObject);
975 :
976 7 : if (state.dataRoomAirMod->TotUCSDDV <= 0) return;
977 :
978 4 : state.dataRoomAirMod->ZoneUCSDDV.allocate(state.dataRoomAirMod->TotUCSDDV);
979 :
980 8 : for (Loop = 1; Loop <= state.dataRoomAirMod->TotUCSDDV; ++Loop) {
981 :
982 24 : state.dataInputProcessing->inputProcessor->getObjectItem(state,
983 : cCurrentModuleObject,
984 : Loop,
985 4 : state.dataIPShortCut->cAlphaArgs,
986 : NumAlpha,
987 4 : state.dataIPShortCut->rNumericArgs,
988 : NumNumber,
989 : IOStat,
990 : _,
991 4 : state.dataIPShortCut->lAlphaFieldBlanks,
992 4 : state.dataIPShortCut->cAlphaFieldNames,
993 4 : state.dataIPShortCut->cNumericFieldNames);
994 : // First is Zone Name
995 4 : state.dataRoomAirMod->ZoneUCSDDV(Loop).ZoneName = state.dataIPShortCut->cAlphaArgs(1);
996 4 : state.dataRoomAirMod->ZoneUCSDDV(Loop).ZonePtr =
997 4 : UtilityRoutines::FindItemInList(state.dataIPShortCut->cAlphaArgs(1), state.dataHeatBal->Zone);
998 4 : if (state.dataRoomAirMod->ZoneUCSDDV(Loop).ZonePtr == 0) {
999 0 : ShowSevereError(state, "Invalid " + state.dataIPShortCut->cAlphaFieldNames(1) + " = " + state.dataIPShortCut->cAlphaArgs(1));
1000 0 : ShowContinueError(state, "Entered in " + cCurrentModuleObject + " = " + state.dataIPShortCut->cAlphaArgs(1));
1001 0 : ShowContinueError(state, "Zone Name not found.");
1002 0 : ErrorsFound = true;
1003 : } else {
1004 4 : state.dataRoomAirMod->IsZoneDV(state.dataRoomAirMod->ZoneUCSDDV(Loop).ZonePtr) = true;
1005 : }
1006 : // Second Alpha is Schedule Name
1007 4 : state.dataRoomAirMod->ZoneUCSDDV(Loop).SchedGainsName = state.dataIPShortCut->cAlphaArgs(2);
1008 4 : state.dataRoomAirMod->ZoneUCSDDV(Loop).SchedGainsPtr = GetScheduleIndex(state, state.dataIPShortCut->cAlphaArgs(2));
1009 4 : if (state.dataRoomAirMod->ZoneUCSDDV(Loop).SchedGainsPtr == 0) {
1010 0 : if (state.dataIPShortCut->lAlphaFieldBlanks(2)) {
1011 0 : ShowSevereError(state, "Invalid " + state.dataIPShortCut->cAlphaFieldNames(2) + " = " + state.dataIPShortCut->cAlphaArgs(2));
1012 0 : ShowContinueError(state, "Entered in " + cCurrentModuleObject + " = " + state.dataIPShortCut->cAlphaArgs(1));
1013 0 : ShowContinueError(state, " Schedule name must be input.");
1014 0 : ErrorsFound = true;
1015 : } else {
1016 0 : ShowSevereError(state, "Invalid " + state.dataIPShortCut->cAlphaFieldNames(2) + " = " + state.dataIPShortCut->cAlphaArgs(2));
1017 0 : ShowContinueError(state, "Entered in " + cCurrentModuleObject + " = " + state.dataIPShortCut->cAlphaArgs(1));
1018 0 : ShowContinueError(state, "Schedule name was not found.");
1019 0 : ErrorsFound = true;
1020 : }
1021 : }
1022 :
1023 4 : state.dataRoomAirMod->ZoneUCSDDV(Loop).NumPlumesPerOcc = state.dataIPShortCut->rNumericArgs(1);
1024 4 : state.dataRoomAirMod->ZoneUCSDDV(Loop).ThermostatHeight = state.dataIPShortCut->rNumericArgs(2);
1025 4 : state.dataRoomAirMod->ZoneUCSDDV(Loop).ComfortHeight = state.dataIPShortCut->rNumericArgs(3);
1026 4 : state.dataRoomAirMod->ZoneUCSDDV(Loop).TempTrigger = state.dataIPShortCut->rNumericArgs(4);
1027 : }
1028 : }
1029 :
1030 741 : void GetCrossVentData(EnergyPlusData &state, bool &ErrorsFound) // True if errors found during this get input routine
1031 : {
1032 :
1033 : // SUBROUTINE INFORMATION:
1034 : // AUTHOR G. Carrilho da Graca
1035 : // DATE WRITTEN October 2004
1036 : // MODIFIED
1037 : // RE-ENGINEERED
1038 :
1039 : // PURPOSE OF THIS SUBROUTINE:
1040 : // Get UCSD Cross ventilation model controls for all zones at once
1041 :
1042 : // METHODOLOGY EMPLOYED:
1043 : // Use input processor to get input from idf file
1044 :
1045 : // Using/Aliasing
1046 : using namespace ScheduleManager;
1047 :
1048 : // SUBROUTINE LOCAL VARIABLE DECLARATIONS:
1049 : int IOStat;
1050 : int NumAlpha;
1051 : int NumNumber;
1052 : int Loop;
1053 : int Loop2;
1054 : int ThisZone;
1055 741 : auto &cCurrentModuleObject = state.dataIPShortCut->cCurrentModuleObject;
1056 1480 : if (!state.dataRoomAirMod->UCSDModelUsed) return;
1057 7 : cCurrentModuleObject = "RoomAirSettings:CrossVentilation";
1058 7 : state.dataRoomAirMod->TotUCSDCV = state.dataInputProcessing->inputProcessor->getNumObjectsFound(state, cCurrentModuleObject);
1059 :
1060 7 : if (state.dataRoomAirMod->TotUCSDCV <= 0) return;
1061 :
1062 2 : state.dataRoomAirMod->ZoneUCSDCV.allocate(state.dataRoomAirMod->TotUCSDCV);
1063 :
1064 4 : for (Loop = 1; Loop <= state.dataRoomAirMod->TotUCSDCV; ++Loop) {
1065 :
1066 12 : state.dataInputProcessing->inputProcessor->getObjectItem(state,
1067 : cCurrentModuleObject,
1068 : Loop,
1069 2 : state.dataIPShortCut->cAlphaArgs,
1070 : NumAlpha,
1071 2 : state.dataIPShortCut->rNumericArgs,
1072 : NumNumber,
1073 : IOStat,
1074 : _,
1075 2 : state.dataIPShortCut->lAlphaFieldBlanks,
1076 2 : state.dataIPShortCut->cAlphaFieldNames,
1077 2 : state.dataIPShortCut->cNumericFieldNames);
1078 : // First is Zone Name
1079 2 : state.dataRoomAirMod->ZoneUCSDCV(Loop).ZoneName = state.dataIPShortCut->cAlphaArgs(1);
1080 2 : state.dataRoomAirMod->ZoneUCSDCV(Loop).ZonePtr =
1081 2 : UtilityRoutines::FindItemInList(state.dataIPShortCut->cAlphaArgs(1), state.dataHeatBal->Zone);
1082 2 : if (state.dataRoomAirMod->ZoneUCSDCV(Loop).ZonePtr == 0) {
1083 0 : ShowSevereError(state, "Invalid " + state.dataIPShortCut->cAlphaFieldNames(1) + " = " + state.dataIPShortCut->cAlphaArgs(1));
1084 0 : ShowContinueError(state, "Entered in " + cCurrentModuleObject + " = " + state.dataIPShortCut->cAlphaArgs(1));
1085 0 : ShowContinueError(state, "Zone name was not found.");
1086 0 : ErrorsFound = true;
1087 : } else {
1088 2 : state.dataRoomAirMod->IsZoneCV(state.dataRoomAirMod->ZoneUCSDCV(Loop).ZonePtr) = true;
1089 : }
1090 : // Second Alpha is Schedule Name
1091 2 : state.dataRoomAirMod->ZoneUCSDCV(Loop).SchedGainsName = state.dataIPShortCut->cAlphaArgs(2);
1092 2 : state.dataRoomAirMod->ZoneUCSDCV(Loop).SchedGainsPtr = GetScheduleIndex(state, state.dataIPShortCut->cAlphaArgs(2));
1093 2 : if (state.dataRoomAirMod->ZoneUCSDCV(Loop).SchedGainsPtr == 0) {
1094 0 : if (state.dataIPShortCut->lAlphaFieldBlanks(2)) {
1095 0 : ShowSevereError(state, "Invalid " + state.dataIPShortCut->cAlphaFieldNames(2) + " = " + state.dataIPShortCut->cAlphaArgs(2));
1096 0 : ShowContinueError(state, "Entered in " + cCurrentModuleObject + " = " + state.dataIPShortCut->cAlphaArgs(1));
1097 0 : ShowContinueError(state, "Schedule name field is blank.");
1098 0 : ErrorsFound = true;
1099 : } else {
1100 0 : ShowSevereError(state, "Invalid " + state.dataIPShortCut->cAlphaFieldNames(2) + " = " + state.dataIPShortCut->cAlphaArgs(2));
1101 0 : ShowContinueError(state, "Entered in " + cCurrentModuleObject + " = " + state.dataIPShortCut->cAlphaArgs(1));
1102 0 : ShowContinueError(state, "Schedule name was not found.");
1103 0 : ErrorsFound = true;
1104 : }
1105 : }
1106 :
1107 : // Third Alpha is a string: JET or RECIRCULATION
1108 2 : if (UtilityRoutines::SameString(state.dataIPShortCut->cAlphaArgs(3), "Jet")) {
1109 2 : state.dataRoomAirMod->ZoneUCSDCV(Loop).VforComfort = Comfort::Jet;
1110 0 : } else if (UtilityRoutines::SameString(state.dataIPShortCut->cAlphaArgs(3), "Recirculation")) {
1111 0 : state.dataRoomAirMod->ZoneUCSDCV(Loop).VforComfort = Comfort::Recirculation;
1112 : } else {
1113 0 : state.dataRoomAirMod->ZoneUCSDCV(Loop).VforComfort = Comfort::Invalid;
1114 : }
1115 :
1116 2 : for (Loop2 = 1; Loop2 <= state.dataHeatBal->TotPeople; ++Loop2) {
1117 0 : if (state.dataHeatBal->People(Loop2).ZonePtr != state.dataRoomAirMod->ZoneUCSDCV(Loop).ZonePtr) continue;
1118 0 : if (state.dataHeatBal->People(Loop2).Fanger) {
1119 0 : if (state.dataRoomAirMod->ZoneUCSDCV(Loop).VforComfort == Comfort::Invalid) {
1120 0 : if (state.dataIPShortCut->lAlphaFieldBlanks(3)) {
1121 0 : ShowSevereError(state,
1122 0 : "Invalid " + state.dataIPShortCut->cAlphaFieldNames(3) + " = " + state.dataIPShortCut->cAlphaArgs(3));
1123 0 : ShowContinueError(state, "Entered in " + cCurrentModuleObject + " = " + state.dataIPShortCut->cAlphaArgs(1));
1124 0 : ShowContinueError(state,
1125 0 : "Airflow region used for thermal comfort evaluation is required for Zone=" +
1126 0 : state.dataIPShortCut->cAlphaArgs(1));
1127 0 : ShowContinueError(state, "Field is blank, please choose Jet or Recirculation.");
1128 0 : ErrorsFound = true;
1129 : } else {
1130 0 : ShowSevereError(state,
1131 0 : "Invalid " + state.dataIPShortCut->cAlphaFieldNames(3) + " = " + state.dataIPShortCut->cAlphaArgs(3));
1132 0 : ShowContinueError(state, "Entered in " + cCurrentModuleObject + " = " + state.dataIPShortCut->cAlphaArgs(1));
1133 0 : ShowContinueError(state,
1134 0 : "Airflow region used for thermal comfort evaluation is required for Zone=" +
1135 0 : state.dataIPShortCut->cAlphaArgs(1));
1136 0 : ShowContinueError(state, "Please choose Jet or Recirculation.");
1137 0 : ErrorsFound = true;
1138 : }
1139 : }
1140 : }
1141 : }
1142 :
1143 2 : ThisZone = state.dataRoomAirMod->ZoneUCSDCV(Loop).ZonePtr;
1144 2 : if (ThisZone == 0) continue;
1145 :
1146 : // Following depend on valid zone
1147 :
1148 2 : Loop2 = UtilityRoutines::FindItemInList(state.dataHeatBal->Zone(state.dataRoomAirMod->ZoneUCSDCV(Loop).ZonePtr).Name,
1149 2 : state.afn->MultizoneZoneData,
1150 : &AirflowNetwork::MultizoneZoneProp::ZoneName);
1151 2 : if (Loop2 == 0) {
1152 0 : ShowSevereError(state, "Problem with " + cCurrentModuleObject + " = " + state.dataIPShortCut->cAlphaArgs(1));
1153 0 : ShowContinueError(state, "AirflowNetwork airflow model must be active in this zone");
1154 0 : ErrorsFound = true;
1155 : }
1156 :
1157 : // If a crack is used it must have an air flow coefficient = 0.5
1158 8 : for (Loop2 = 1; Loop2 <= state.afn->NumOfLinksMultiZone; ++Loop2) {
1159 6 : state.dataRoomAirModelMgr->NodeNum1 = state.afn->MultizoneSurfaceData(Loop2).NodeNums[0];
1160 6 : state.dataRoomAirModelMgr->NodeNum2 = state.afn->MultizoneSurfaceData(Loop2).NodeNums[1];
1161 12 : if (state.dataSurface->Surface(state.afn->MultizoneSurfaceData(Loop2).SurfNum).Zone == ThisZone ||
1162 0 : (state.afn->AirflowNetworkNodeData(state.dataRoomAirModelMgr->NodeNum2).EPlusZoneNum == ThisZone &&
1163 12 : state.afn->AirflowNetworkNodeData(state.dataRoomAirModelMgr->NodeNum1).EPlusZoneNum > 0) ||
1164 0 : (state.afn->AirflowNetworkNodeData(state.dataRoomAirModelMgr->NodeNum2).EPlusZoneNum > 0 &&
1165 0 : state.afn->AirflowNetworkNodeData(state.dataRoomAirModelMgr->NodeNum1).EPlusZoneNum == ThisZone)) {
1166 6 : state.dataRoomAirModelMgr->CompNum = state.afn->AirflowNetworkLinkageData(Loop2).CompNum;
1167 6 : state.dataRoomAirModelMgr->TypeNum = state.afn->AirflowNetworkCompData(state.dataRoomAirModelMgr->CompNum).TypeNum;
1168 6 : if (state.afn->AirflowNetworkCompData(state.dataRoomAirModelMgr->CompNum).CompTypeNum == AirflowNetwork::iComponentTypeNum::SCR) {
1169 0 : if (state.afn->MultizoneSurfaceCrackData(state.dataRoomAirModelMgr->TypeNum).exponent != 0.50) {
1170 0 : state.dataRoomAirMod->AirModel(ThisZone).AirModelType = DataRoomAirModel::RoomAirModel::Mixing;
1171 0 : ShowWarningError(state, "Problem with " + cCurrentModuleObject + " = " + state.dataIPShortCut->cAlphaArgs(1));
1172 0 : ShowWarningError(state, "Roomair model will not be applied for Zone=" + state.dataIPShortCut->cAlphaArgs(1) + '.');
1173 0 : ShowContinueError(
1174 : state,
1175 0 : format("AirflowNetwrok:Multizone:Surface crack object must have an air flow coefficient = 0.5, value was={:.2R}",
1176 0 : state.afn->MultizoneSurfaceCrackData(state.dataRoomAirModelMgr->TypeNum).exponent));
1177 : }
1178 : }
1179 : }
1180 : }
1181 : }
1182 : }
1183 :
1184 741 : void GetUFADZoneData(EnergyPlusData &state, bool &ErrorsFound) // True if errors found during this get input routine
1185 : {
1186 :
1187 : // SUBROUTINE INFORMATION:
1188 : // AUTHOR Fred Buhl
1189 : // DATE WRITTEN August 2005
1190 : // MODIFIED
1191 : // RE-ENGINEERED
1192 :
1193 : // PURPOSE OF THIS SUBROUTINE:
1194 : // Get UCSD UFAD interior zone model controls for all zones at once
1195 :
1196 : // METHODOLOGY EMPLOYED:
1197 : // Use input processor to get input from idf file
1198 :
1199 : // Using/Aliasing
1200 : using namespace ScheduleManager;
1201 :
1202 : // SUBROUTINE LOCAL VARIABLE DECLARATIONS:
1203 : int IOStat;
1204 : int NumAlpha;
1205 : int NumNumber;
1206 : int Loop;
1207 :
1208 741 : if (!state.dataRoomAirMod->UCSDModelUsed) {
1209 734 : state.dataRoomAirMod->TotUCSDUI = 0;
1210 734 : state.dataRoomAirMod->TotUCSDUE = 0;
1211 1474 : return;
1212 : }
1213 7 : auto &cCurrentModuleObject = state.dataIPShortCut->cCurrentModuleObject;
1214 7 : cCurrentModuleObject = "RoomAirSettings:UnderFloorAirDistributionInterior";
1215 7 : state.dataRoomAirMod->TotUCSDUI = state.dataInputProcessing->inputProcessor->getNumObjectsFound(state, cCurrentModuleObject);
1216 7 : cCurrentModuleObject = "RoomAirSettings:UnderFloorAirDistributionExterior";
1217 7 : state.dataRoomAirMod->TotUCSDUE = state.dataInputProcessing->inputProcessor->getNumObjectsFound(state, cCurrentModuleObject);
1218 :
1219 7 : if (state.dataRoomAirMod->TotUCSDUI <= 0 && state.dataRoomAirMod->TotUCSDUE <= 0) return;
1220 :
1221 1 : state.dataRoomAirMod->ZoneUCSDUI.allocate(state.dataRoomAirMod->TotUCSDUI);
1222 1 : state.dataRoomAirMod->ZoneUCSDUE.allocate(state.dataRoomAirMod->TotUCSDUE);
1223 1 : state.dataRoomAirMod->ZoneUFPtr.dimension(state.dataGlobal->NumOfZones, 0);
1224 :
1225 1 : cCurrentModuleObject = "RoomAirSettings:UnderFloorAirDistributionInterior";
1226 2 : for (Loop = 1; Loop <= state.dataRoomAirMod->TotUCSDUI; ++Loop) {
1227 6 : state.dataInputProcessing->inputProcessor->getObjectItem(state,
1228 : cCurrentModuleObject,
1229 : Loop,
1230 1 : state.dataIPShortCut->cAlphaArgs,
1231 : NumAlpha,
1232 1 : state.dataIPShortCut->rNumericArgs,
1233 : NumNumber,
1234 : IOStat,
1235 : _,
1236 1 : state.dataIPShortCut->lAlphaFieldBlanks,
1237 1 : state.dataIPShortCut->cAlphaFieldNames,
1238 1 : state.dataIPShortCut->cNumericFieldNames);
1239 : // First is Zone Name
1240 1 : state.dataRoomAirMod->ZoneUCSDUI(Loop).ZoneName = state.dataIPShortCut->cAlphaArgs(1);
1241 1 : state.dataRoomAirMod->ZoneUCSDUI(Loop).ZonePtr =
1242 1 : UtilityRoutines::FindItemInList(state.dataIPShortCut->cAlphaArgs(1), state.dataHeatBal->Zone);
1243 1 : state.dataRoomAirMod->ZoneUFPtr(state.dataRoomAirMod->ZoneUCSDUI(Loop).ZonePtr) = Loop;
1244 1 : if (state.dataRoomAirMod->ZoneUCSDUI(Loop).ZonePtr == 0) {
1245 0 : ShowSevereError(state, "Invalid " + state.dataIPShortCut->cAlphaFieldNames(1) + " = " + state.dataIPShortCut->cAlphaArgs(1));
1246 0 : ShowContinueError(state, "Entered in " + cCurrentModuleObject + " = " + state.dataIPShortCut->cAlphaArgs(1));
1247 0 : ShowContinueError(state, "Zone name was not found.");
1248 0 : ErrorsFound = true;
1249 : } else {
1250 1 : state.dataRoomAirMod->IsZoneUI(state.dataRoomAirMod->ZoneUCSDUI(Loop).ZonePtr) = true;
1251 : }
1252 : // 2nd alpha is diffuser type
1253 1 : if (UtilityRoutines::SameString(state.dataIPShortCut->cAlphaArgs(2), "Swirl")) {
1254 1 : state.dataRoomAirMod->ZoneUCSDUI(Loop).DiffuserType = Diffuser::Swirl;
1255 0 : } else if (UtilityRoutines::SameString(state.dataIPShortCut->cAlphaArgs(2), "VariableArea")) {
1256 0 : state.dataRoomAirMod->ZoneUCSDUI(Loop).DiffuserType = Diffuser::VarArea;
1257 0 : } else if (UtilityRoutines::SameString(state.dataIPShortCut->cAlphaArgs(2), "HorizontalSwirl")) {
1258 0 : state.dataRoomAirMod->ZoneUCSDUI(Loop).DiffuserType = Diffuser::DisplVent;
1259 0 : } else if (UtilityRoutines::SameString(state.dataIPShortCut->cAlphaArgs(2), "Custom")) {
1260 0 : state.dataRoomAirMod->ZoneUCSDUI(Loop).DiffuserType = Diffuser::Custom;
1261 0 : } else if (UtilityRoutines::SameString(state.dataIPShortCut->cAlphaArgs(2), "LinearBarGrille")) {
1262 0 : state.dataRoomAirMod->ZoneUCSDUI(Loop).DiffuserType = Diffuser::LinBarGrille;
1263 : } else {
1264 0 : ShowSevereError(state, "Invalid " + state.dataIPShortCut->cAlphaFieldNames(2) + " = " + state.dataIPShortCut->cAlphaArgs(2));
1265 0 : ShowContinueError(state, "Entered in " + cCurrentModuleObject + " = " + state.dataIPShortCut->cAlphaArgs(1));
1266 0 : ErrorsFound = true;
1267 : }
1268 : // 1st number is Number of Diffusers per Zone
1269 1 : state.dataRoomAirMod->ZoneUCSDUI(Loop).DiffusersPerZone = state.dataIPShortCut->rNumericArgs(1);
1270 : // 2nd number is Power per Plume
1271 1 : state.dataRoomAirMod->ZoneUCSDUI(Loop).PowerPerPlume = state.dataIPShortCut->rNumericArgs(2);
1272 : // 3rd number is Design Effective Area of Diffuser
1273 1 : state.dataRoomAirMod->ZoneUCSDUI(Loop).DiffArea = state.dataIPShortCut->rNumericArgs(3);
1274 : // 4th number is Diffuser Slot Angle from Vertical
1275 1 : state.dataRoomAirMod->ZoneUCSDUI(Loop).DiffAngle = state.dataIPShortCut->rNumericArgs(4);
1276 : // 5th number is Thermostat Height
1277 1 : state.dataRoomAirMod->ZoneUCSDUI(Loop).ThermostatHeight = state.dataIPShortCut->rNumericArgs(5);
1278 : // 6th number is Comfort Height
1279 1 : state.dataRoomAirMod->ZoneUCSDUI(Loop).ComfortHeight = state.dataIPShortCut->rNumericArgs(6);
1280 : // 7th number is Temperature Difference Threshold for Reporting
1281 1 : state.dataRoomAirMod->ZoneUCSDUI(Loop).TempTrigger = state.dataIPShortCut->rNumericArgs(7);
1282 : // 8th number user-specified transition height
1283 1 : state.dataRoomAirMod->ZoneUCSDUI(Loop).TransHeight = state.dataIPShortCut->rNumericArgs(8);
1284 : // 9th number is Coefficient A in formula Kc = A*Gamma**B + C + D*Gamma + E*Gamma**2
1285 1 : state.dataRoomAirMod->ZoneUCSDUI(Loop).A_Kc = state.dataIPShortCut->rNumericArgs(9);
1286 : // 10th number is Coefficient B in formula Kc = A*Gamma**B + C + D*Gamma + E*Gamma**2
1287 1 : state.dataRoomAirMod->ZoneUCSDUI(Loop).B_Kc = state.dataIPShortCut->rNumericArgs(10);
1288 : // 11th number is Coefficient C in formula Kc = A*Gamma**B + C + D*Gamma + E*Gamma**2
1289 1 : state.dataRoomAirMod->ZoneUCSDUI(Loop).C_Kc = state.dataIPShortCut->rNumericArgs(11);
1290 : // 12th number is Coefficient D in formula Kc = A*Gamma**B + C + D*Gamma + E*Gamma**2
1291 1 : state.dataRoomAirMod->ZoneUCSDUI(Loop).D_Kc = state.dataIPShortCut->rNumericArgs(12);
1292 : // 13th number is Coefficient E in formula Kc = A*Gamma**B + C + D*Gamma + E*Gamma**2
1293 1 : state.dataRoomAirMod->ZoneUCSDUI(Loop).E_Kc = state.dataIPShortCut->rNumericArgs(13);
1294 : }
1295 :
1296 1 : cCurrentModuleObject = "RoomAirSettings:UnderFloorAirDistributionExterior";
1297 5 : for (Loop = 1; Loop <= state.dataRoomAirMod->TotUCSDUE; ++Loop) {
1298 24 : state.dataInputProcessing->inputProcessor->getObjectItem(state,
1299 : cCurrentModuleObject,
1300 : Loop,
1301 4 : state.dataIPShortCut->cAlphaArgs,
1302 : NumAlpha,
1303 4 : state.dataIPShortCut->rNumericArgs,
1304 : NumNumber,
1305 : IOStat,
1306 : _,
1307 4 : state.dataIPShortCut->lAlphaFieldBlanks,
1308 4 : state.dataIPShortCut->cAlphaFieldNames,
1309 4 : state.dataIPShortCut->cNumericFieldNames);
1310 : // First is Zone Name
1311 4 : state.dataRoomAirMod->ZoneUCSDUE(Loop).ZoneName = state.dataIPShortCut->cAlphaArgs(1);
1312 4 : state.dataRoomAirMod->ZoneUCSDUE(Loop).ZonePtr =
1313 4 : UtilityRoutines::FindItemInList(state.dataIPShortCut->cAlphaArgs(1), state.dataHeatBal->Zone);
1314 4 : state.dataRoomAirMod->ZoneUFPtr(state.dataRoomAirMod->ZoneUCSDUE(Loop).ZonePtr) = Loop;
1315 4 : if (state.dataRoomAirMod->ZoneUCSDUE(Loop).ZonePtr == 0) {
1316 0 : ShowSevereError(state, "Invalid " + state.dataIPShortCut->cAlphaFieldNames(1) + " = " + state.dataIPShortCut->cAlphaArgs(1));
1317 0 : ShowContinueError(state, "Entered in " + cCurrentModuleObject + " = " + state.dataIPShortCut->cAlphaArgs(1));
1318 0 : ShowContinueError(state, "Zone name was not found.");
1319 0 : ErrorsFound = true;
1320 : } else {
1321 4 : state.dataRoomAirMod->IsZoneUI(state.dataRoomAirMod->ZoneUCSDUE(Loop).ZonePtr) = true;
1322 : }
1323 : // 2nd alpha is diffuser type
1324 4 : if (UtilityRoutines::SameString(state.dataIPShortCut->cAlphaArgs(2), "Swirl")) {
1325 0 : state.dataRoomAirMod->ZoneUCSDUE(Loop).DiffuserType = Diffuser::Swirl;
1326 4 : } else if (UtilityRoutines::SameString(state.dataIPShortCut->cAlphaArgs(2), "VariableArea")) {
1327 0 : state.dataRoomAirMod->ZoneUCSDUE(Loop).DiffuserType = Diffuser::VarArea;
1328 4 : } else if (UtilityRoutines::SameString(state.dataIPShortCut->cAlphaArgs(2), "HorizontalSwirl")) {
1329 0 : state.dataRoomAirMod->ZoneUCSDUE(Loop).DiffuserType = Diffuser::DisplVent;
1330 4 : } else if (UtilityRoutines::SameString(state.dataIPShortCut->cAlphaArgs(2), "Custom")) {
1331 0 : state.dataRoomAirMod->ZoneUCSDUE(Loop).DiffuserType = Diffuser::Custom;
1332 4 : } else if (UtilityRoutines::SameString(state.dataIPShortCut->cAlphaArgs(2), "LinearBarGrille")) {
1333 4 : state.dataRoomAirMod->ZoneUCSDUE(Loop).DiffuserType = Diffuser::LinBarGrille;
1334 : } else {
1335 0 : ShowSevereError(state, "Invalid " + state.dataIPShortCut->cAlphaFieldNames(2) + " = " + state.dataIPShortCut->cAlphaArgs(2));
1336 0 : ShowContinueError(state, "Entered in " + cCurrentModuleObject + " = " + state.dataIPShortCut->cAlphaArgs(1));
1337 0 : ErrorsFound = true;
1338 : }
1339 : // 1st number is Number of Diffusers per Zone
1340 4 : state.dataRoomAirMod->ZoneUCSDUE(Loop).DiffusersPerZone = state.dataIPShortCut->rNumericArgs(1);
1341 : // 2nd number is Power per Plume
1342 4 : state.dataRoomAirMod->ZoneUCSDUE(Loop).PowerPerPlume = state.dataIPShortCut->rNumericArgs(2);
1343 : // 3rd number is Design Effective Area of Diffuser
1344 4 : state.dataRoomAirMod->ZoneUCSDUE(Loop).DiffArea = state.dataIPShortCut->rNumericArgs(3);
1345 : // 4th number is Diffuser Slot Angle from Vertical
1346 4 : state.dataRoomAirMod->ZoneUCSDUE(Loop).DiffAngle = state.dataIPShortCut->rNumericArgs(4);
1347 : // 5th number is Thermostat Height
1348 4 : state.dataRoomAirMod->ZoneUCSDUE(Loop).ThermostatHeight = state.dataIPShortCut->rNumericArgs(5);
1349 : // 6th number is Comfort Height
1350 4 : state.dataRoomAirMod->ZoneUCSDUE(Loop).ComfortHeight = state.dataIPShortCut->rNumericArgs(6);
1351 : // 7th number is Temperature Difference Threshold for Reporting
1352 4 : state.dataRoomAirMod->ZoneUCSDUE(Loop).TempTrigger = state.dataIPShortCut->rNumericArgs(7);
1353 : // 8th number user-specified transition height
1354 4 : state.dataRoomAirMod->ZoneUCSDUE(Loop).TransHeight = state.dataIPShortCut->rNumericArgs(8);
1355 : // 9th number is Coefficient A in formula Kc = A*Gamma**B + C + D*Gamma + E*Gamma**2
1356 4 : state.dataRoomAirMod->ZoneUCSDUE(Loop).A_Kc = state.dataIPShortCut->rNumericArgs(9);
1357 : // 10th number is Coefficient B in formula Kc = A*Gamma**B + C + D*Gamma + E*Gamma**2
1358 4 : state.dataRoomAirMod->ZoneUCSDUE(Loop).B_Kc = state.dataIPShortCut->rNumericArgs(10);
1359 : // 11th number is Coefficient C in formula Kc = A*Gamma**B + C + D*Gamma + E*Gamma**2
1360 4 : state.dataRoomAirMod->ZoneUCSDUE(Loop).C_Kc = state.dataIPShortCut->rNumericArgs(11);
1361 : // 12th number is Coefficient D in formula Kc = A*Gamma**B + C + D*Gamma + E*Gamma**2
1362 4 : state.dataRoomAirMod->ZoneUCSDUE(Loop).D_Kc = state.dataIPShortCut->rNumericArgs(12);
1363 : // 13th number is Coefficient E in formula Kc = A*Gamma**B + C + D*Gamma + E*Gamma**2
1364 4 : state.dataRoomAirMod->ZoneUCSDUE(Loop).E_Kc = state.dataIPShortCut->rNumericArgs(13);
1365 : }
1366 : }
1367 :
1368 741 : void GetRoomAirflowNetworkData(EnergyPlusData &state, bool &ErrorsFound) // True if errors found during this get input routine
1369 : {
1370 :
1371 : // SUBROUTINE INFORMATION:
1372 : // AUTHOR Brent Griffith
1373 : // DATE WRITTEN November 2009
1374 : // MODIFIED na
1375 : // RE-ENGINEERED na
1376 :
1377 : // PURPOSE OF THIS SUBROUTINE:
1378 : // Get RoomAirflowNetwork data for all zones at once
1379 :
1380 : // METHODOLOGY EMPLOYED:
1381 : // Use input processor to get input from idf file
1382 :
1383 : // Using/Aliasing
1384 : using DataHVACGlobals::NumZoneHVACTerminalTypes;
1385 : using DataHVACGlobals::ZoneHVACTerminalTypes;
1386 : using InternalHeatGains::GetInternalGainDeviceIndex;
1387 : using ScheduleManager::GetScheduleIndex;
1388 :
1389 : // SUBROUTINE LOCAL VARIABLE DECLARATIONS:
1390 : int Loop; // local do loop index
1391 : int NumAlphas;
1392 : int NumNumbers;
1393 : int status;
1394 : int ZoneNum;
1395 : int thisAirNodeinZone;
1396 : int AlphaArgNum;
1397 : int AirCntrlNodeNum;
1398 : int TotNumOfRAFNNodeSurfLists;
1399 : int TotNumOfRAFNNodeGainsLists;
1400 : int TotNumOfRAFNNodeHVACLists;
1401 : int RAFNNodeNum;
1402 : bool foundList;
1403 : int NumSurfsThisNode;
1404 : int NumOfSurfs;
1405 : int gainsLoop;
1406 : int TypeNum;
1407 : int numEquip;
1408 : int EquipLoop;
1409 : int TotNumEquip;
1410 : bool IntEquipError;
1411 : Real64 SumFraction;
1412 742 : std::string Name;
1413 : int GainNum;
1414 : int RAFNNum;
1415 741 : auto &cCurrentModuleObject = state.dataIPShortCut->cCurrentModuleObject;
1416 741 : cCurrentModuleObject = "RoomAirSettings:AirflowNetwork";
1417 741 : state.dataRoomAirMod->NumOfRoomAirflowNetControl = state.dataInputProcessing->inputProcessor->getNumObjectsFound(state, cCurrentModuleObject);
1418 741 : if (state.dataRoomAirMod->NumOfRoomAirflowNetControl == 0) return;
1419 1 : if (state.dataRoomAirMod->NumOfRoomAirflowNetControl > state.dataGlobal->NumOfZones) {
1420 0 : ShowSevereError(state, "Too many " + cCurrentModuleObject + " objects in input file");
1421 0 : ShowContinueError(state, "There cannot be more " + cCurrentModuleObject + " objects than number of zones.");
1422 0 : ErrorsFound = true;
1423 : }
1424 :
1425 1 : if (!allocated(state.dataRoomAirMod->RoomAirflowNetworkZoneInfo)) {
1426 1 : state.dataRoomAirMod->RoomAirflowNetworkZoneInfo.allocate(state.dataGlobal->NumOfZones);
1427 : }
1428 :
1429 2 : for (Loop = 1; Loop <= state.dataRoomAirMod->NumOfRoomAirflowNetControl; ++Loop) {
1430 6 : state.dataInputProcessing->inputProcessor->getObjectItem(state,
1431 : cCurrentModuleObject,
1432 : Loop,
1433 1 : state.dataIPShortCut->cAlphaArgs,
1434 : NumAlphas,
1435 1 : state.dataIPShortCut->rNumericArgs,
1436 : NumNumbers,
1437 : status,
1438 : _,
1439 1 : state.dataIPShortCut->lAlphaFieldBlanks,
1440 1 : state.dataIPShortCut->cAlphaFieldNames,
1441 1 : state.dataIPShortCut->cNumericFieldNames);
1442 1 : ZoneNum = UtilityRoutines::FindItemInList(state.dataIPShortCut->cAlphaArgs(2), state.dataHeatBal->Zone, state.dataGlobal->NumOfZones);
1443 1 : if (ZoneNum == 0) {
1444 0 : ShowSevereError(state,
1445 0 : "GetRoomAirflowNetworkData: Invalid " + state.dataIPShortCut->cAlphaFieldNames(2) + " = " +
1446 0 : state.dataIPShortCut->cAlphaArgs(2));
1447 0 : ShowContinueError(state, "Entered in " + cCurrentModuleObject + " = " + state.dataIPShortCut->cAlphaArgs(2));
1448 0 : ShowContinueError(state, "Not a valid zone name.");
1449 0 : ErrorsFound = true;
1450 0 : continue;
1451 : }
1452 1 : if (state.dataRoomAirMod->AirModel(ZoneNum).AirModelType != DataRoomAirModel::RoomAirModel::AirflowNetwork) {
1453 0 : ShowSevereError(state,
1454 0 : "GetRoomAirflowNetworkData: Zone specified='" + state.dataIPShortCut->cAlphaArgs(1) +
1455 : "', Air Model type is not AirflowNetwork.");
1456 0 : ShowContinueError(
1457 0 : state, format("Air Model Type for zone ={}", ChAirModel[static_cast<int>(state.dataRoomAirMod->AirModel(ZoneNum).AirModelType)]));
1458 0 : ErrorsFound = true;
1459 0 : continue;
1460 : }
1461 1 : state.dataRoomAirMod->RoomAirflowNetworkZoneInfo(ZoneNum).ZoneID = ZoneNum;
1462 1 : state.dataRoomAirMod->RoomAirflowNetworkZoneInfo(ZoneNum).RAFNNum = Loop;
1463 1 : state.dataRoomAirMod->RoomAirflowNetworkZoneInfo(ZoneNum).IsUsed = true;
1464 1 : state.dataRoomAirMod->RoomAirflowNetworkZoneInfo(ZoneNum).Name = state.dataIPShortCut->cAlphaArgs(1);
1465 1 : state.dataRoomAirMod->RoomAirflowNetworkZoneInfo(ZoneNum).ZoneName = state.dataIPShortCut->cAlphaArgs(2); // Zone Name
1466 :
1467 1 : state.dataRoomAirMod->RoomAirflowNetworkZoneInfo(ZoneNum).NumOfAirNodes = (NumAlphas - 3);
1468 :
1469 1 : if (state.dataRoomAirMod->RoomAirflowNetworkZoneInfo(ZoneNum).NumOfAirNodes > 0) {
1470 2 : state.dataRoomAirMod->RoomAirflowNetworkZoneInfo(ZoneNum).Node.allocate(
1471 2 : state.dataRoomAirMod->RoomAirflowNetworkZoneInfo(ZoneNum).NumOfAirNodes);
1472 : } else {
1473 0 : ShowSevereError(
1474 0 : state, "GetRoomAirflowNetworkData: Incomplete input in " + cCurrentModuleObject + " = " + state.dataIPShortCut->cAlphaArgs(1));
1475 0 : ErrorsFound = true;
1476 : }
1477 :
1478 7 : for (thisAirNodeinZone = 1; thisAirNodeinZone <= state.dataRoomAirMod->RoomAirflowNetworkZoneInfo(ZoneNum).NumOfAirNodes;
1479 : ++thisAirNodeinZone) {
1480 6 : AlphaArgNum = thisAirNodeinZone + 3;
1481 12 : state.dataRoomAirMod->RoomAirflowNetworkZoneInfo(ZoneNum).Node(thisAirNodeinZone).Name =
1482 12 : state.dataIPShortCut->cAlphaArgs(AlphaArgNum);
1483 : }
1484 : // control point node
1485 2 : AirCntrlNodeNum = UtilityRoutines::FindItemInList(state.dataIPShortCut->cAlphaArgs(3),
1486 1 : state.dataRoomAirMod->RoomAirflowNetworkZoneInfo(ZoneNum).Node,
1487 1 : state.dataRoomAirMod->RoomAirflowNetworkZoneInfo(ZoneNum).NumOfAirNodes);
1488 1 : if (AirCntrlNodeNum == 0) {
1489 0 : ShowSevereError(state,
1490 0 : "GetRoomAirflowNetworkData: Invalid " + state.dataIPShortCut->cAlphaFieldNames(3) + " = " +
1491 0 : state.dataIPShortCut->cAlphaArgs(3));
1492 0 : ShowContinueError(state, "Entered in " + cCurrentModuleObject + " = " + state.dataIPShortCut->cAlphaArgs(1));
1493 0 : ShowContinueError(state, "Not a valid RoomAir:Node:AirflowNetwork name for this zone.");
1494 0 : ErrorsFound = true;
1495 0 : continue;
1496 : } else {
1497 1 : state.dataRoomAirMod->RoomAirflowNetworkZoneInfo(ZoneNum).ControlAirNodeID = AirCntrlNodeNum;
1498 : }
1499 1 : state.dataRoomAirMod->RoomAirflowNetworkZoneInfo(ZoneNum).totNumSurfs = 0;
1500 2 : for (int spaceNum : state.dataHeatBal->Zone(ZoneNum).spaceIndexes) {
1501 1 : auto &thisSpace = state.dataHeatBal->space(spaceNum);
1502 1 : state.dataRoomAirMod->RoomAirflowNetworkZoneInfo(ZoneNum).totNumSurfs += thisSpace.HTSurfaceLast - thisSpace.HTSurfaceFirst + 1;
1503 : }
1504 : } // loop thru NumOfRoomAirflowNetControl
1505 :
1506 1 : cCurrentModuleObject = "RoomAir:Node:AirflowNetwork";
1507 1 : state.dataRoomAirMod->TotNumOfRoomAFNNodes = state.dataInputProcessing->inputProcessor->getNumObjectsFound(state, cCurrentModuleObject);
1508 7 : for (Loop = 1; Loop <= state.dataRoomAirMod->TotNumOfRoomAFNNodes; ++Loop) {
1509 36 : state.dataInputProcessing->inputProcessor->getObjectItem(state,
1510 : cCurrentModuleObject,
1511 : Loop,
1512 6 : state.dataIPShortCut->cAlphaArgs,
1513 : NumAlphas,
1514 6 : state.dataIPShortCut->rNumericArgs,
1515 : NumNumbers,
1516 : status,
1517 : _,
1518 6 : state.dataIPShortCut->lAlphaFieldBlanks,
1519 6 : state.dataIPShortCut->cAlphaFieldNames,
1520 6 : state.dataIPShortCut->cNumericFieldNames);
1521 6 : ZoneNum = UtilityRoutines::FindItemInList(state.dataIPShortCut->cAlphaArgs(2), state.dataHeatBal->Zone, state.dataGlobal->NumOfZones);
1522 6 : if (ZoneNum == 0) {
1523 0 : ShowSevereError(state,
1524 0 : "GetRoomAirflowNetworkData: Invalid " + state.dataIPShortCut->cAlphaFieldNames(2) + " = " +
1525 0 : state.dataIPShortCut->cAlphaArgs(2));
1526 0 : ShowContinueError(state, "Entered in " + cCurrentModuleObject + " = " + state.dataIPShortCut->cAlphaArgs(1));
1527 0 : ShowContinueError(state, "Not a valid zone name.");
1528 0 : ErrorsFound = true;
1529 0 : continue;
1530 : }
1531 :
1532 12 : RAFNNodeNum = UtilityRoutines::FindItemInList(state.dataIPShortCut->cAlphaArgs(1),
1533 6 : state.dataRoomAirMod->RoomAirflowNetworkZoneInfo(ZoneNum).Node,
1534 6 : state.dataRoomAirMod->RoomAirflowNetworkZoneInfo(ZoneNum).NumOfAirNodes);
1535 6 : if (RAFNNodeNum == 0) {
1536 0 : ShowSevereError(state,
1537 0 : "GetRoomAirflowNetworkData: Invalid " + state.dataIPShortCut->cAlphaFieldNames(2) + " = " +
1538 0 : state.dataIPShortCut->cAlphaArgs(2));
1539 0 : ShowContinueError(state, "Entered in " + cCurrentModuleObject + " = " + state.dataIPShortCut->cAlphaArgs(1));
1540 0 : ShowContinueError(state, "Not a valid RoomAir:Node:AirflowNetwork name.");
1541 0 : ErrorsFound = true;
1542 0 : continue;
1543 : }
1544 :
1545 6 : state.dataRoomAirMod->RoomAirflowNetworkZoneInfo(ZoneNum).Node(RAFNNodeNum).ZoneVolumeFraction = state.dataIPShortCut->rNumericArgs(1);
1546 6 : if (!state.dataIPShortCut->lAlphaFieldBlanks(3)) {
1547 6 : state.dataRoomAirMod->RoomAirflowNetworkZoneInfo(ZoneNum).Node(RAFNNodeNum).NodeSurfListName = state.dataIPShortCut->cAlphaArgs(3);
1548 : } else {
1549 0 : state.dataRoomAirMod->RoomAirflowNetworkZoneInfo(ZoneNum).Node(RAFNNodeNum).HasSurfacesAssigned = false;
1550 : }
1551 6 : if (!state.dataIPShortCut->lAlphaFieldBlanks(4)) {
1552 12 : state.dataRoomAirMod->RoomAirflowNetworkZoneInfo(ZoneNum).Node(RAFNNodeNum).NodeIntGainsListName =
1553 12 : state.dataIPShortCut->cAlphaArgs(4);
1554 : } else {
1555 0 : state.dataRoomAirMod->RoomAirflowNetworkZoneInfo(ZoneNum).Node(RAFNNodeNum).HasIntGainsAssigned = false;
1556 : }
1557 6 : if (!state.dataIPShortCut->lAlphaFieldBlanks(5)) {
1558 6 : state.dataRoomAirMod->RoomAirflowNetworkZoneInfo(ZoneNum).Node(RAFNNodeNum).NodeHVACListName = state.dataIPShortCut->cAlphaArgs(5);
1559 : } else {
1560 0 : state.dataRoomAirMod->RoomAirflowNetworkZoneInfo(ZoneNum).Node(RAFNNodeNum).HasHVACAssigned = false;
1561 : }
1562 :
1563 : } // loop thru TotNumOfRoomAFNNodes
1564 :
1565 1 : cCurrentModuleObject = "RoomAir:Node:AirflowNetwork:AdjacentSurfaceList";
1566 1 : TotNumOfRAFNNodeSurfLists = state.dataInputProcessing->inputProcessor->getNumObjectsFound(state, cCurrentModuleObject);
1567 7 : for (Loop = 1; Loop <= TotNumOfRAFNNodeSurfLists; ++Loop) {
1568 6 : foundList = false;
1569 30 : state.dataInputProcessing->inputProcessor->getObjectItem(state,
1570 : cCurrentModuleObject,
1571 : Loop,
1572 6 : state.dataIPShortCut->cAlphaArgs,
1573 : NumAlphas,
1574 6 : state.dataIPShortCut->rNumericArgs,
1575 : NumNumbers,
1576 : status,
1577 : _,
1578 : _,
1579 6 : state.dataIPShortCut->cAlphaFieldNames,
1580 6 : state.dataIPShortCut->cNumericFieldNames);
1581 18 : for (ZoneNum = 1; ZoneNum <= state.dataGlobal->NumOfZones; ++ZoneNum) {
1582 : // find surface list
1583 18 : if (state.dataRoomAirMod->RoomAirflowNetworkZoneInfo(ZoneNum).NumOfAirNodes > 0) {
1584 12 : RAFNNodeNum = UtilityRoutines::FindItemInList(state.dataIPShortCut->cAlphaArgs(1),
1585 6 : state.dataRoomAirMod->RoomAirflowNetworkZoneInfo(ZoneNum).Node,
1586 : &RoomAirflowNetworkAirNodeNestedStruct::NodeSurfListName,
1587 6 : state.dataRoomAirMod->RoomAirflowNetworkZoneInfo(ZoneNum).NumOfAirNodes);
1588 : } else {
1589 12 : RAFNNodeNum = 0;
1590 : }
1591 18 : if (RAFNNodeNum > 0) { // found it
1592 6 : foundList = true;
1593 6 : NumSurfsThisNode = NumAlphas - 1;
1594 6 : NumOfSurfs = 0;
1595 12 : for (int spaceNum : state.dataHeatBal->Zone(ZoneNum).spaceIndexes) {
1596 6 : auto &thisSpace = state.dataHeatBal->space(spaceNum);
1597 6 : NumOfSurfs += thisSpace.HTSurfaceLast - thisSpace.HTSurfaceFirst + 1;
1598 : }
1599 6 : if (allocated(state.dataRoomAirMod->RoomAirflowNetworkZoneInfo(ZoneNum).Node(RAFNNodeNum).SurfMask)) {
1600 : // throw error found twice
1601 0 : ShowSevereError(state,
1602 0 : "GetRoomAirflowNetworkData: Invalid " + state.dataIPShortCut->cAlphaFieldNames(1) + " = " +
1603 0 : state.dataIPShortCut->cAlphaArgs(1));
1604 0 : ShowContinueError(state, "Entered in " + cCurrentModuleObject + " = " + state.dataIPShortCut->cAlphaArgs(1));
1605 0 : ShowContinueError(state, "Duplicate RoomAir:Node:AirflowNetwork:AdjacentSurfaceList name.");
1606 0 : ErrorsFound = true;
1607 : } else {
1608 6 : state.dataRoomAirMod->RoomAirflowNetworkZoneInfo(ZoneNum)
1609 6 : .Node(RAFNNodeNum)
1610 6 : .SurfMask.allocate(state.dataRoomAirMod->RoomAirflowNetworkZoneInfo(ZoneNum).totNumSurfs);
1611 6 : state.dataRoomAirMod->RoomAirflowNetworkZoneInfo(ZoneNum).Node(RAFNNodeNum).SurfMask = false; // init
1612 6 : state.dataRoomAirMod->RoomAirflowNetworkZoneInfo(ZoneNum).Node(RAFNNodeNum).HasSurfacesAssigned = true;
1613 : // relate surfaces to this air node and check to see whether surface names are specified correctly or not
1614 6 : int SurfCount = 0;
1615 6 : int thisSurfinZone = 0;
1616 6 : bool surfaceFound = false;
1617 12 : for (int ListSurfNum = 2; ListSurfNum <= NumAlphas; ++ListSurfNum) {
1618 6 : for (int spaceNum : state.dataHeatBal->Zone(ZoneNum).spaceIndexes) {
1619 6 : auto &thisSpace = state.dataHeatBal->space(spaceNum);
1620 48 : for (int SurfNum = thisSpace.HTSurfaceFirst; SurfNum <= thisSpace.HTSurfaceLast; ++SurfNum) {
1621 48 : ++thisSurfinZone;
1622 48 : if (state.dataIPShortCut->cAlphaArgs(ListSurfNum) == state.dataSurface->Surface(SurfNum).Name) {
1623 6 : state.dataRoomAirMod->RoomAirflowNetworkZoneInfo(ZoneNum).Node(RAFNNodeNum).SurfMask(thisSurfinZone) = true;
1624 6 : ++SurfCount;
1625 6 : surfaceFound = true;
1626 6 : break;
1627 : }
1628 : }
1629 6 : if (surfaceFound) break;
1630 : }
1631 : }
1632 6 : if (NumSurfsThisNode != SurfCount) {
1633 0 : ShowSevereError(state,
1634 0 : "GetRoomAirflowNetworkData: Invalid " + state.dataIPShortCut->cAlphaFieldNames(1) + " = " +
1635 0 : state.dataIPShortCut->cAlphaArgs(1));
1636 0 : ShowContinueError(state, "Entered in " + cCurrentModuleObject + " = " + state.dataIPShortCut->cAlphaArgs(1));
1637 0 : ShowContinueError(state, "Some surface names were not found in the zone");
1638 0 : ErrorsFound = true;
1639 : }
1640 : }
1641 6 : break;
1642 : }
1643 : } // loop over zones
1644 6 : if (!foundList) { // throw error
1645 0 : ShowSevereError(state,
1646 0 : "GetRoomAirflowNetworkData: Invalid " + state.dataIPShortCut->cAlphaFieldNames(1) + " = " +
1647 0 : state.dataIPShortCut->cAlphaArgs(1));
1648 0 : ShowContinueError(state, "Entered in " + cCurrentModuleObject + " = " + state.dataIPShortCut->cAlphaArgs(1));
1649 0 : ShowContinueError(state, "Did not find a RoomAir:Node:AirflowNetwork object that references this object");
1650 0 : ErrorsFound = true;
1651 : }
1652 : } // loop thru TotNumOfRAFNNodeSurfLists
1653 :
1654 1 : cCurrentModuleObject = "RoomAir:Node:AirflowNetwork:InternalGains";
1655 1 : TotNumOfRAFNNodeGainsLists = state.dataInputProcessing->inputProcessor->getNumObjectsFound(state, cCurrentModuleObject);
1656 7 : for (Loop = 1; Loop <= TotNumOfRAFNNodeGainsLists; ++Loop) {
1657 6 : foundList = false;
1658 30 : state.dataInputProcessing->inputProcessor->getObjectItem(state,
1659 : cCurrentModuleObject,
1660 : Loop,
1661 6 : state.dataIPShortCut->cAlphaArgs,
1662 : NumAlphas,
1663 6 : state.dataIPShortCut->rNumericArgs,
1664 : NumNumbers,
1665 : status,
1666 : _,
1667 : _,
1668 6 : state.dataIPShortCut->cAlphaFieldNames,
1669 6 : state.dataIPShortCut->cNumericFieldNames);
1670 6 : if (mod((NumAlphas + NumNumbers - 1), 3) != 0) {
1671 0 : ShowSevereError(state, "GetRoomAirflowNetworkData: For " + cCurrentModuleObject + ": " + state.dataIPShortCut->cAlphaArgs(1));
1672 0 : ShowContinueError(state,
1673 0 : "Extensible field set are not evenly divisable by 3. Number of data entries = " +
1674 0 : fmt::to_string(NumAlphas + NumNumbers - 1));
1675 0 : ErrorsFound = true;
1676 0 : break;
1677 : }
1678 36 : for (ZoneNum = 1; ZoneNum <= state.dataGlobal->NumOfZones; ++ZoneNum) {
1679 : // find surface list
1680 30 : if (state.dataRoomAirMod->RoomAirflowNetworkZoneInfo(ZoneNum).NumOfAirNodes > 0) {
1681 12 : RAFNNodeNum = UtilityRoutines::FindItemInList(state.dataIPShortCut->cAlphaArgs(1),
1682 6 : state.dataRoomAirMod->RoomAirflowNetworkZoneInfo(ZoneNum).Node,
1683 : &RoomAirflowNetworkAirNodeNestedStruct::NodeIntGainsListName,
1684 6 : state.dataRoomAirMod->RoomAirflowNetworkZoneInfo(ZoneNum).NumOfAirNodes);
1685 : } else {
1686 24 : RAFNNodeNum = 0;
1687 : }
1688 30 : if (RAFNNodeNum > 0) { // found it
1689 6 : foundList = true;
1690 6 : int numInputGains = (NumAlphas + NumNumbers - 1) / 3;
1691 6 : int numSpacesInZone = state.dataHeatBal->Zone(ZoneNum).numSpaces;
1692 6 : int maxNumGains = numInputGains * numSpacesInZone;
1693 6 : if (allocated(state.dataRoomAirMod->RoomAirflowNetworkZoneInfo(ZoneNum).Node(RAFNNodeNum).IntGain)) {
1694 0 : ShowSevereError(state,
1695 0 : "GetRoomAirflowNetworkData: Invalid " + state.dataIPShortCut->cAlphaFieldNames(1) + " = " +
1696 0 : state.dataIPShortCut->cAlphaArgs(1));
1697 0 : ShowContinueError(state, "Entered in " + cCurrentModuleObject + " = " + state.dataIPShortCut->cAlphaArgs(1));
1698 0 : ShowContinueError(state, "Duplicate " + cCurrentModuleObject + " name.");
1699 0 : ErrorsFound = true;
1700 : } else {
1701 6 : state.dataRoomAirMod->RoomAirflowNetworkZoneInfo(ZoneNum).Node(RAFNNodeNum).IntGain.allocate(maxNumGains);
1702 6 : state.dataRoomAirMod->RoomAirflowNetworkZoneInfo(ZoneNum).Node(RAFNNodeNum).IntGainsDeviceIndices.allocate(maxNumGains);
1703 6 : state.dataRoomAirMod->RoomAirflowNetworkZoneInfo(ZoneNum).Node(RAFNNodeNum).intGainsDeviceSpaces.allocate(maxNumGains);
1704 6 : state.dataRoomAirMod->RoomAirflowNetworkZoneInfo(ZoneNum).Node(RAFNNodeNum).IntGainsFractions.allocate(maxNumGains);
1705 6 : state.dataRoomAirMod->RoomAirflowNetworkZoneInfo(ZoneNum).Node(RAFNNodeNum).HasIntGainsAssigned = true;
1706 6 : int numGainsFound = 0;
1707 24 : for (gainsLoop = 1; gainsLoop <= numInputGains; ++gainsLoop) {
1708 36 : TypeNum = getEnumerationValue(DataHeatBalance::IntGainTypeNamesUC,
1709 54 : UtilityRoutines::MakeUPPERCase(state.dataIPShortCut->cAlphaArgs(gainsLoop * 2)));
1710 18 : if (TypeNum >= 0) {
1711 18 : state.dataRoomAirMod->RoomAirflowNetworkZoneInfo(ZoneNum).Node(RAFNNodeNum).IntGain(gainsLoop).Type =
1712 : static_cast<DataHeatBalance::IntGainType>(TypeNum);
1713 : } else {
1714 0 : ShowSevereError(state,
1715 0 : "GetRoomAirflowNetworkData: Invalid " + state.dataIPShortCut->cAlphaFieldNames(gainsLoop * 2) +
1716 0 : " = " + state.dataIPShortCut->cAlphaArgs(gainsLoop * 2));
1717 0 : ShowContinueError(state, "Entered in " + cCurrentModuleObject + " = " + state.dataIPShortCut->cAlphaArgs(1));
1718 0 : ShowContinueError(state, "incorrect type of internal gain");
1719 0 : ErrorsFound = true;
1720 0 : continue;
1721 : }
1722 36 : state.dataRoomAirMod->RoomAirflowNetworkZoneInfo(ZoneNum).Node(RAFNNodeNum).IntGain(gainsLoop).Name =
1723 36 : state.dataIPShortCut->cAlphaArgs(gainsLoop * 2 + 1);
1724 :
1725 18 : bool gainFound = false;
1726 : // check all spaces in this zone for matching gains
1727 36 : for (int spaceNum : state.dataHeatBal->Zone(ZoneNum).spaceIndexes) {
1728 : // verify type and name and get pointer to device in internal gains structure array
1729 36 : int intGainIndex = GetInternalGainDeviceIndex(
1730 : state,
1731 : spaceNum,
1732 18 : state.dataRoomAirMod->RoomAirflowNetworkZoneInfo(ZoneNum).Node(RAFNNodeNum).IntGain(gainsLoop).Type,
1733 36 : state.dataRoomAirMod->RoomAirflowNetworkZoneInfo(ZoneNum).Node(RAFNNodeNum).IntGain(gainsLoop).Name);
1734 18 : if (intGainIndex >= 0) {
1735 18 : gainFound = true;
1736 18 : ++numGainsFound;
1737 18 : state.dataRoomAirMod->RoomAirflowNetworkZoneInfo(ZoneNum).Node(RAFNNodeNum).intGainsDeviceSpaces(numGainsFound) =
1738 : spaceNum;
1739 18 : state.dataRoomAirMod->RoomAirflowNetworkZoneInfo(ZoneNum).Node(RAFNNodeNum).IntGainsDeviceIndices(numGainsFound) =
1740 : intGainIndex;
1741 18 : state.dataRoomAirMod->RoomAirflowNetworkZoneInfo(ZoneNum).Node(RAFNNodeNum).IntGainsFractions(numGainsFound) =
1742 18 : state.dataIPShortCut->rNumericArgs(gainsLoop);
1743 : }
1744 : }
1745 18 : if (gainFound) {
1746 18 : state.dataRoomAirMod->RoomAirflowNetworkZoneInfo(ZoneNum).Node(RAFNNodeNum).NumIntGains = numGainsFound;
1747 : } else {
1748 0 : ShowSevereError(state,
1749 0 : "GetRoomAirflowNetworkData: Invalid " + state.dataIPShortCut->cAlphaFieldNames(gainsLoop * 2 + 1) +
1750 0 : " = " + state.dataIPShortCut->cAlphaArgs(gainsLoop * 2 + 1));
1751 0 : ShowContinueError(state, "Entered in " + cCurrentModuleObject + " = " + state.dataIPShortCut->cAlphaArgs(1));
1752 0 : ShowContinueError(state, "Internal gain did not match correctly");
1753 0 : ErrorsFound = true;
1754 : }
1755 : }
1756 : }
1757 : }
1758 : }
1759 : } // loop thru TotNumOfRAFNNodeGainsLists
1760 :
1761 : // Get data of HVAC equipment
1762 1 : cCurrentModuleObject = "RoomAir:Node:AirflowNetwork:HVACEquipment";
1763 1 : TotNumOfRAFNNodeHVACLists = state.dataInputProcessing->inputProcessor->getNumObjectsFound(state, cCurrentModuleObject);
1764 7 : for (Loop = 1; Loop <= TotNumOfRAFNNodeHVACLists; ++Loop) {
1765 30 : state.dataInputProcessing->inputProcessor->getObjectItem(state,
1766 : cCurrentModuleObject,
1767 : Loop,
1768 6 : state.dataIPShortCut->cAlphaArgs,
1769 : NumAlphas,
1770 6 : state.dataIPShortCut->rNumericArgs,
1771 : NumNumbers,
1772 : status,
1773 : _,
1774 : _,
1775 6 : state.dataIPShortCut->cAlphaFieldNames,
1776 6 : state.dataIPShortCut->cNumericFieldNames);
1777 6 : if (mod((NumAlphas + NumNumbers - 1), 4) != 0) {
1778 0 : ShowSevereError(state, "GetRoomAirflowNetworkData: For " + cCurrentModuleObject + ": " + state.dataIPShortCut->cAlphaArgs(1));
1779 0 : ShowContinueError(state,
1780 0 : "Extensible field set are not evenly divisable by 4. Number of data entries = " +
1781 0 : fmt::to_string(NumAlphas + NumNumbers - 1));
1782 0 : ErrorsFound = true;
1783 0 : break;
1784 : }
1785 36 : for (ZoneNum = 1; ZoneNum <= state.dataGlobal->NumOfZones; ++ZoneNum) {
1786 : // find surface list
1787 30 : if (state.dataRoomAirMod->RoomAirflowNetworkZoneInfo(ZoneNum).NumOfAirNodes > 0) {
1788 12 : RAFNNodeNum = UtilityRoutines::FindItemInList(state.dataIPShortCut->cAlphaArgs(1),
1789 6 : state.dataRoomAirMod->RoomAirflowNetworkZoneInfo(ZoneNum).Node,
1790 : &RoomAirflowNetworkAirNodeNestedStruct::NodeHVACListName,
1791 6 : state.dataRoomAirMod->RoomAirflowNetworkZoneInfo(ZoneNum).NumOfAirNodes);
1792 : } else {
1793 24 : RAFNNodeNum = 0;
1794 : }
1795 30 : if (RAFNNodeNum > 0) { // found it
1796 6 : foundList = true;
1797 6 : numEquip = (NumAlphas + NumNumbers - 1) / 4;
1798 6 : state.dataRoomAirMod->RoomAirflowNetworkZoneInfo(ZoneNum).Node(RAFNNodeNum).NumHVACs = numEquip;
1799 6 : if (allocated(state.dataRoomAirMod->RoomAirflowNetworkZoneInfo(ZoneNum).Node(RAFNNodeNum).HVAC)) {
1800 0 : ShowSevereError(state,
1801 0 : "GetRoomAirflowNetworkData: Invalid " + state.dataIPShortCut->cAlphaFieldNames(1) + " = " +
1802 0 : state.dataIPShortCut->cAlphaArgs(1));
1803 0 : ShowContinueError(state, "Entered in " + cCurrentModuleObject + " = " + state.dataIPShortCut->cAlphaArgs(1));
1804 0 : ShowContinueError(state, "Duplicate " + cCurrentModuleObject + " name.");
1805 0 : ErrorsFound = true;
1806 : } else {
1807 6 : state.dataRoomAirMod->RoomAirflowNetworkZoneInfo(ZoneNum).Node(RAFNNodeNum).HVAC.allocate(numEquip);
1808 6 : state.dataRoomAirMod->RoomAirflowNetworkZoneInfo(ZoneNum).Node(RAFNNodeNum).HasHVACAssigned = true;
1809 12 : for (EquipLoop = 1; EquipLoop <= numEquip; ++EquipLoop) {
1810 6 : TypeNum = UtilityRoutines::FindItemInList(
1811 6 : state.dataIPShortCut->cAlphaArgs(2 + (EquipLoop - 1) * 2), ZoneHVACTerminalTypes, NumZoneHVACTerminalTypes);
1812 6 : if (TypeNum > 0) {
1813 6 : state.dataRoomAirMod->RoomAirflowNetworkZoneInfo(ZoneNum).Node(RAFNNodeNum).HVAC(EquipLoop).TypeOfNum = TypeNum;
1814 : } else {
1815 0 : ShowSevereError(state,
1816 0 : "GetRoomAirflowNetworkData: Invalid " +
1817 0 : state.dataIPShortCut->cAlphaFieldNames(2 + (EquipLoop - 1) * 2) + " = " +
1818 0 : state.dataIPShortCut->cAlphaArgs(2 + (EquipLoop - 1) * 2));
1819 0 : ShowContinueError(state, "Entered in " + cCurrentModuleObject + " = " + state.dataIPShortCut->cAlphaArgs(1));
1820 0 : ShowContinueError(state, "incorrect type of HVACEquipment");
1821 0 : ErrorsFound = true;
1822 : }
1823 12 : state.dataRoomAirMod->RoomAirflowNetworkZoneInfo(ZoneNum).Node(RAFNNodeNum).HVAC(EquipLoop).ObjectTypeName =
1824 12 : state.dataIPShortCut->cAlphaArgs(2 + (EquipLoop - 1) * 2);
1825 12 : state.dataRoomAirMod->RoomAirflowNetworkZoneInfo(ZoneNum).Node(RAFNNodeNum).HVAC(EquipLoop).Name =
1826 12 : state.dataIPShortCut->cAlphaArgs(3 + (EquipLoop - 1) * 2);
1827 :
1828 : // verify type and name and get pointer to device in HVAC equipment type and name structure array
1829 6 : TotNumEquip = state.dataInputProcessing->inputProcessor->getNumObjectsFound(state, ZoneHVACTerminalTypes(TypeNum));
1830 6 : if (TotNumEquip == 0) {
1831 0 : ShowSevereError(state,
1832 0 : "GetRoomAirflowNetworkData: No such " +
1833 0 : state.dataIPShortCut->cAlphaFieldNames(2 + (EquipLoop - 1) * 2) + " = " +
1834 0 : state.dataIPShortCut->cAlphaArgs(2 + (EquipLoop - 1) * 2));
1835 0 : ShowContinueError(
1836 0 : state, "is available in the input file in " + cCurrentModuleObject + " = " + state.dataIPShortCut->cAlphaArgs(1));
1837 0 : ErrorsFound = true;
1838 : }
1839 6 : state.dataRoomAirMod->RoomAirflowNetworkZoneInfo(ZoneNum).Node(RAFNNodeNum).HVAC(EquipLoop).SupplyFraction =
1840 6 : state.dataIPShortCut->rNumericArgs(1 + (EquipLoop - 1) * 2);
1841 6 : state.dataRoomAirMod->RoomAirflowNetworkZoneInfo(ZoneNum).Node(RAFNNodeNum).HVAC(EquipLoop).ReturnFraction =
1842 6 : state.dataIPShortCut->rNumericArgs(2 + (EquipLoop - 1) * 2);
1843 :
1844 24 : IntEquipError = CheckEquipName(
1845 : state,
1846 6 : state.dataRoomAirMod->RoomAirflowNetworkZoneInfo(ZoneNum).Node(RAFNNodeNum).HVAC(EquipLoop).ObjectTypeName,
1847 6 : state.dataRoomAirMod->RoomAirflowNetworkZoneInfo(ZoneNum).Node(RAFNNodeNum).HVAC(EquipLoop).Name,
1848 6 : state.dataRoomAirMod->RoomAirflowNetworkZoneInfo(ZoneNum).Node(RAFNNodeNum).HVAC(EquipLoop).SupplyNodeName,
1849 6 : state.dataRoomAirMod->RoomAirflowNetworkZoneInfo(ZoneNum).Node(RAFNNodeNum).HVAC(EquipLoop).ReturnNodeName,
1850 : TotNumEquip,
1851 : TypeNum);
1852 :
1853 6 : if (!IntEquipError) {
1854 0 : ShowSevereError(state,
1855 0 : "GetRoomAirflowNetworkData: Invalid " +
1856 0 : state.dataIPShortCut->cAlphaFieldNames(3 + (EquipLoop - 1) * 2) + " = " +
1857 0 : state.dataIPShortCut->cAlphaArgs(2 + (EquipLoop - 1) * 2));
1858 0 : ShowContinueError(state, "Entered in " + cCurrentModuleObject + " = " + state.dataIPShortCut->cAlphaArgs(1));
1859 0 : ShowContinueError(state, "Internal gain did not match correctly");
1860 0 : ErrorsFound = true;
1861 : }
1862 : //!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
1863 : // TYPE RoomAirflowNetworkHVACStruct
1864 : // INTEGER::EquipConfigIndex = 0
1865 : }
1866 : }
1867 : }
1868 : }
1869 : } // loop thru TotNumOfRAFNNodeHVACLists
1870 :
1871 : // do some checks on input data
1872 6 : for (ZoneNum = 1; ZoneNum <= state.dataGlobal->NumOfZones; ++ZoneNum) {
1873 5 : if (state.dataRoomAirMod->RoomAirflowNetworkZoneInfo(ZoneNum).NumOfAirNodes > 0) {
1874 : // Check zone volume fraction
1875 1 : SumFraction = 0.0;
1876 7 : for (RAFNNodeNum = 1; RAFNNodeNum <= state.dataRoomAirMod->RoomAirflowNetworkZoneInfo(ZoneNum).NumOfAirNodes; ++RAFNNodeNum) {
1877 6 : SumFraction = SumFraction + state.dataRoomAirMod->RoomAirflowNetworkZoneInfo(ZoneNum).Node(RAFNNodeNum).ZoneVolumeFraction;
1878 : }
1879 1 : if (std::abs(SumFraction - 1.0) > 0.001) {
1880 0 : ShowSevereError(state, "GetRoomAirflowNetworkData: Invalid, zone volume fractions do not sum to 1.0");
1881 0 : ShowContinueError(state, "Entered in RoomAir:Node:AirflowNetwork with Zone Name = " + state.dataHeatBal->Zone(ZoneNum).Name);
1882 0 : ShowContinueError(state, "The Fraction of Zone Air Volume values across all the nodes needs to sum to 1.0.");
1883 0 : ShowContinueError(state, format("The sum of fractions entered = {:.3R}", SumFraction));
1884 0 : ErrorsFound = true;
1885 : }
1886 : // Check internal gain fraction
1887 7 : for (RAFNNodeNum = 1; RAFNNodeNum <= state.dataRoomAirMod->RoomAirflowNetworkZoneInfo(ZoneNum).NumOfAirNodes; ++RAFNNodeNum) {
1888 24 : for (gainsLoop = 1; gainsLoop <= state.dataRoomAirMod->RoomAirflowNetworkZoneInfo(ZoneNum).Node(RAFNNodeNum).NumIntGains;
1889 : ++gainsLoop) {
1890 18 : if (state.dataRoomAirMod->RoomAirflowNetworkZoneInfo(ZoneNum).Node(RAFNNodeNum).IntGain(gainsLoop).FractionCheck) continue;
1891 3 : SumFraction = state.dataRoomAirMod->RoomAirflowNetworkZoneInfo(ZoneNum).Node(RAFNNodeNum).IntGainsFractions(gainsLoop);
1892 3 : TypeNum =
1893 3 : static_cast<int>(state.dataRoomAirMod->RoomAirflowNetworkZoneInfo(ZoneNum).Node(RAFNNodeNum).IntGain(gainsLoop).Type);
1894 3 : Name = state.dataRoomAirMod->RoomAirflowNetworkZoneInfo(ZoneNum).Node(RAFNNodeNum).IntGain(gainsLoop).Name;
1895 3 : state.dataRoomAirMod->RoomAirflowNetworkZoneInfo(ZoneNum).Node(RAFNNodeNum).IntGain(gainsLoop).FractionCheck = true;
1896 21 : for (RAFNNum = 1; RAFNNum <= state.dataRoomAirMod->RoomAirflowNetworkZoneInfo(ZoneNum).NumOfAirNodes; ++RAFNNum) {
1897 72 : for (GainNum = 1; GainNum <= state.dataRoomAirMod->RoomAirflowNetworkZoneInfo(ZoneNum).Node(RAFNNum).NumIntGains;
1898 : ++GainNum) {
1899 54 : if (state.dataRoomAirMod->RoomAirflowNetworkZoneInfo(ZoneNum).Node(RAFNNum).IntGain(GainNum).FractionCheck) continue;
1900 33 : if (TypeNum == static_cast<int>(
1901 48 : state.dataRoomAirMod->RoomAirflowNetworkZoneInfo(ZoneNum).Node(RAFNNum).IntGain(GainNum).Type) &&
1902 15 : UtilityRoutines::SameString(
1903 15 : Name, state.dataRoomAirMod->RoomAirflowNetworkZoneInfo(ZoneNum).Node(RAFNNum).IntGain(GainNum).Name)) {
1904 15 : SumFraction += state.dataRoomAirMod->RoomAirflowNetworkZoneInfo(ZoneNum).Node(RAFNNum).IntGainsFractions(GainNum);
1905 15 : state.dataRoomAirMod->RoomAirflowNetworkZoneInfo(ZoneNum).Node(RAFNNum).IntGain(GainNum).FractionCheck = true;
1906 : }
1907 : }
1908 : }
1909 3 : if (std::abs(SumFraction - 1.0) > 0.001) {
1910 0 : ShowSevereError(state, "GetRoomAirflowNetworkData: Invalid, internal gain fractions do not sum to 1.0");
1911 0 : ShowContinueError(state,
1912 0 : "Entered in RoomAir:Node:AirflowNetwork with Zone Name = " + state.dataHeatBal->Zone(ZoneNum).Name +
1913 0 : ", Intrnal gain name = " + Name);
1914 0 : ShowContinueError(state, "The Fraction of internal gain across all the nodes needs to sum to 1.0.");
1915 0 : ShowContinueError(state, format("The sum of fractions entered = {:.3R}", SumFraction));
1916 0 : ErrorsFound = true;
1917 : }
1918 : }
1919 : }
1920 : }
1921 : }
1922 :
1923 1 : if (!ErrorsFound) {
1924 6 : for (ZoneNum = 1; ZoneNum <= state.dataGlobal->NumOfZones; ++ZoneNum) {
1925 5 : if (state.dataRoomAirMod->RoomAirflowNetworkZoneInfo(ZoneNum).IsUsed) {
1926 1 : if (state.dataRoomAirMod->RoomAirflowNetworkZoneInfo(ZoneNum).NumOfAirNodes > 0) {
1927 7 : for (Loop = 1; Loop <= state.dataRoomAirMod->RoomAirflowNetworkZoneInfo(ZoneNum).NumOfAirNodes; ++Loop) {
1928 24 : SetupOutputVariable(state,
1929 : "RoomAirflowNetwork Node Temperature",
1930 : OutputProcessor::Unit::C,
1931 6 : state.dataRoomAirMod->RoomAirflowNetworkZoneInfo(ZoneNum).Node(Loop).AirTemp,
1932 : OutputProcessor::SOVTimeStepType::HVAC,
1933 : OutputProcessor::SOVStoreType::Average,
1934 12 : state.dataRoomAirMod->RoomAirflowNetworkZoneInfo(ZoneNum).Node(Loop).Name);
1935 24 : SetupOutputVariable(state,
1936 : "RoomAirflowNetwork Node Humidity Ratio",
1937 : OutputProcessor::Unit::kgWater_kgDryAir,
1938 6 : state.dataRoomAirMod->RoomAirflowNetworkZoneInfo(ZoneNum).Node(Loop).HumRat,
1939 : OutputProcessor::SOVTimeStepType::HVAC,
1940 : OutputProcessor::SOVStoreType::Average,
1941 12 : state.dataRoomAirMod->RoomAirflowNetworkZoneInfo(ZoneNum).Node(Loop).Name);
1942 24 : SetupOutputVariable(state,
1943 : "RoomAirflowNetwork Node Relative Humidity",
1944 : OutputProcessor::Unit::Perc,
1945 6 : state.dataRoomAirMod->RoomAirflowNetworkZoneInfo(ZoneNum).Node(Loop).RelHumidity,
1946 : OutputProcessor::SOVTimeStepType::HVAC,
1947 : OutputProcessor::SOVStoreType::Average,
1948 12 : state.dataRoomAirMod->RoomAirflowNetworkZoneInfo(ZoneNum).Node(Loop).Name);
1949 : }
1950 : }
1951 : }
1952 : }
1953 : }
1954 : }
1955 :
1956 43671 : void SharedDVCVUFDataInit(EnergyPlusData &state, int const ZoneNum)
1957 : {
1958 :
1959 : // SUBROUTINE INFORMATION:
1960 : // AUTHOR Linda Lawrie
1961 : // DATE WRITTEN March 2005
1962 : // MODIFIED Aug, 2013, Sam Brunswick -- for RoomAirCrossCrossVent modifications
1963 : // RE-ENGINEERED na
1964 :
1965 : // PURPOSE OF THIS SUBROUTINE:
1966 : // This routine allocates and initializes(?) the data that is shared between the
1967 : // UCSD models (DV and CV)
1968 :
1969 : // METHODOLOGY EMPLOYED:
1970 : // na
1971 :
1972 : // REFERENCES:
1973 : // na
1974 :
1975 : // Using/Aliasing
1976 : using namespace DataEnvironment;
1977 : using namespace DataSurfaces;
1978 : using Psychrometrics::PsyRhoAirFnPbTdbW;
1979 :
1980 : // Locals
1981 : // SUBROUTINE ARGUMENT DEFINITIONS:
1982 :
1983 : // SUBROUTINE PARAMETER DEFINITIONS:
1984 43671 : Real64 constexpr BaseDischargeCoef(0.62);
1985 :
1986 : // INTERFACE BLOCK SPECIFICATIONS:
1987 : // na
1988 :
1989 : // DERIVED TYPE DEFINITIONS:
1990 : // na
1991 :
1992 : // SUBROUTINE LOCAL VARIABLE DECLARATIONS:
1993 : bool SetZoneAux;
1994 87342 : Array1D_int AuxSurf;
1995 : int MaxSurf;
1996 87342 : Array2D_int AuxAirflowNetworkSurf;
1997 : Real64 WidthFactMax;
1998 : Real64 HeightFactMax;
1999 : Real64 WidthFact;
2000 : Real64 HeightFact;
2001 : int ZoneEquipConfigNum; // counter
2002 : Real64 AinCV;
2003 : int AirflowNetworkSurfPtr;
2004 : int NSides;
2005 :
2006 : // Do the one time initializations
2007 43671 : if (state.dataRoomAirModelMgr->MyOneTimeFlag) {
2008 :
2009 7 : state.dataRoomAirModelMgr->MyEnvrnFlag.allocate(state.dataGlobal->NumOfZones);
2010 :
2011 7 : state.dataUCSDShared->APos_Wall.allocate(state.dataSurface->TotSurfaces);
2012 7 : state.dataUCSDShared->APos_Floor.allocate(state.dataSurface->TotSurfaces);
2013 7 : state.dataUCSDShared->APos_Ceiling.allocate(state.dataSurface->TotSurfaces);
2014 7 : state.dataUCSDShared->PosZ_Wall.allocate(state.dataGlobal->NumOfZones * 2);
2015 7 : state.dataUCSDShared->PosZ_Floor.allocate(state.dataGlobal->NumOfZones * 2);
2016 7 : state.dataUCSDShared->PosZ_Ceiling.allocate(state.dataGlobal->NumOfZones * 2);
2017 7 : state.dataUCSDShared->APos_Window.allocate(state.dataSurface->TotSurfaces);
2018 7 : state.dataUCSDShared->APos_Door.allocate(state.dataSurface->TotSurfaces);
2019 7 : state.dataUCSDShared->APos_Internal.allocate(state.dataSurface->TotSurfaces);
2020 7 : state.dataUCSDShared->PosZ_Window.allocate(state.dataGlobal->NumOfZones * 2);
2021 7 : state.dataUCSDShared->PosZ_Door.allocate(state.dataGlobal->NumOfZones * 2);
2022 7 : state.dataUCSDShared->PosZ_Internal.allocate(state.dataGlobal->NumOfZones * 2);
2023 7 : state.dataUCSDShared->HCeiling.allocate(state.dataSurface->TotSurfaces);
2024 7 : state.dataUCSDShared->HWall.allocate(state.dataSurface->TotSurfaces);
2025 7 : state.dataUCSDShared->HFloor.allocate(state.dataSurface->TotSurfaces);
2026 7 : state.dataUCSDShared->HInternal.allocate(state.dataSurface->TotSurfaces);
2027 7 : state.dataUCSDShared->HWindow.allocate(state.dataSurface->TotSurfaces);
2028 7 : state.dataUCSDShared->HDoor.allocate(state.dataSurface->TotSurfaces);
2029 :
2030 7 : AuxSurf.allocate(state.dataGlobal->NumOfZones);
2031 :
2032 7 : state.dataRoomAirMod->ZoneCeilingHeight.allocate(state.dataGlobal->NumOfZones * 2);
2033 7 : state.dataRoomAirMod->ZoneCeilingHeight = 0.0;
2034 :
2035 : // Arrays initializations
2036 7 : state.dataUCSDShared->APos_Wall = 0;
2037 7 : state.dataUCSDShared->APos_Floor = 0;
2038 7 : state.dataUCSDShared->APos_Ceiling = 0;
2039 7 : state.dataUCSDShared->PosZ_Wall = 0;
2040 7 : state.dataUCSDShared->PosZ_Floor = 0;
2041 7 : state.dataUCSDShared->PosZ_Ceiling = 0;
2042 7 : state.dataUCSDShared->APos_Window = 0;
2043 7 : state.dataUCSDShared->APos_Door = 0;
2044 7 : state.dataUCSDShared->APos_Internal = 0;
2045 7 : state.dataUCSDShared->PosZ_Window = 0;
2046 7 : state.dataUCSDShared->PosZ_Door = 0;
2047 7 : state.dataUCSDShared->PosZ_Internal = 0;
2048 7 : state.dataUCSDShared->HCeiling = 0.0;
2049 7 : state.dataUCSDShared->HWall = 0.0;
2050 7 : state.dataUCSDShared->HFloor = 0.0;
2051 7 : state.dataUCSDShared->HInternal = 0.0;
2052 7 : state.dataUCSDShared->HWindow = 0.0;
2053 7 : state.dataUCSDShared->HDoor = 0.0;
2054 :
2055 : // Put the surface and zone information in Apos and PosZ arrays
2056 20 : for (int ZNum = 1; ZNum <= state.dataGlobal->NumOfZones; ++ZNum) {
2057 : // advance ONE position in the arrays PosZ because this is a new zone
2058 13 : state.dataRoomAirModelMgr->contWallBegin = state.dataRoomAirModelMgr->contWall + 1;
2059 13 : state.dataRoomAirModelMgr->contFloorBegin = state.dataRoomAirModelMgr->contFloor + 1;
2060 13 : state.dataRoomAirModelMgr->contCeilingBegin = state.dataRoomAirModelMgr->contCeiling + 1;
2061 13 : state.dataRoomAirModelMgr->contWindowBegin = state.dataRoomAirModelMgr->contWindow + 1;
2062 13 : state.dataRoomAirModelMgr->contInternalBegin = state.dataRoomAirModelMgr->contInternal + 1;
2063 13 : state.dataRoomAirModelMgr->contDoorBegin = state.dataRoomAirModelMgr->contDoor + 1;
2064 13 : SetZoneAux = true;
2065 :
2066 : // cycle in this zone for all the surfaces
2067 26 : for (int spaceNum : state.dataHeatBal->Zone(ZNum).spaceIndexes) {
2068 13 : auto &thisSpace = state.dataHeatBal->space(spaceNum);
2069 131 : for (int SurfNum = thisSpace.HTSurfaceFirst; SurfNum <= thisSpace.HTSurfaceLast; ++SurfNum) {
2070 118 : if (state.dataSurface->Surface(SurfNum).Class != DataSurfaces::SurfaceClass::IntMass) {
2071 : // Recalculate lowest and highest height for the zone
2072 113 : state.dataRoomAirModelMgr->Z1ofZone = std::numeric_limits<Real64>::max();
2073 113 : state.dataRoomAirModelMgr->Z2ofZone = std::numeric_limits<Real64>::lowest();
2074 565 : for (int i = 1, u = state.dataSurface->Surface(SurfNum).Sides; i <= u; ++i) {
2075 452 : Real64 const z_i(state.dataSurface->Surface(SurfNum).Vertex(i).z);
2076 452 : state.dataRoomAirModelMgr->Z1ofZone = std::min(state.dataRoomAirModelMgr->Z1ofZone, z_i);
2077 452 : state.dataRoomAirModelMgr->Z2ofZone = std::max(state.dataRoomAirModelMgr->Z2ofZone, z_i);
2078 : }
2079 : }
2080 :
2081 118 : if (SetZoneAux) {
2082 : // lowest height for the zone (for the first surface of the zone)
2083 13 : state.dataRoomAirModelMgr->Z1ofZoneAux = state.dataRoomAirModelMgr->Z1ofZone;
2084 : // highest height for the zone (for the first surface of the zone)
2085 13 : state.dataRoomAirModelMgr->Z2ofZoneAux = state.dataRoomAirModelMgr->Z2ofZone;
2086 13 : SetZoneAux = false;
2087 : }
2088 :
2089 118 : if (state.dataRoomAirModelMgr->Z1ofZone < state.dataRoomAirModelMgr->Z1ofZoneAux) {
2090 0 : state.dataRoomAirModelMgr->Z1ofZoneAux = state.dataRoomAirModelMgr->Z1ofZone;
2091 : }
2092 118 : if (state.dataRoomAirModelMgr->Z2ofZone > state.dataRoomAirModelMgr->Z2ofZoneAux) {
2093 0 : state.dataRoomAirModelMgr->Z2ofZoneAux = state.dataRoomAirModelMgr->Z2ofZone;
2094 : }
2095 118 : state.dataRoomAirModelMgr->Z1ofZone = state.dataRoomAirModelMgr->Z1ofZoneAux;
2096 118 : state.dataRoomAirModelMgr->Z2ofZone = state.dataRoomAirModelMgr->Z2ofZoneAux;
2097 :
2098 : // Put the reference to this surface in the appropriate array
2099 118 : if (state.dataSurface->Surface(SurfNum).Class == SurfaceClass::Floor) {
2100 17 : ++state.dataRoomAirModelMgr->contFloor;
2101 17 : state.dataUCSDShared->APos_Floor(state.dataRoomAirModelMgr->contFloor) = SurfNum;
2102 101 : } else if (state.dataSurface->Surface(SurfNum).Class == SurfaceClass::Wall) {
2103 52 : ++state.dataRoomAirModelMgr->contWall;
2104 52 : state.dataUCSDShared->APos_Wall(state.dataRoomAirModelMgr->contWall) = SurfNum;
2105 49 : } else if (state.dataSurface->Surface(SurfNum).Class == SurfaceClass::Window) {
2106 27 : ++state.dataRoomAirModelMgr->contWindow;
2107 27 : state.dataUCSDShared->APos_Window(state.dataRoomAirModelMgr->contWindow) = SurfNum;
2108 22 : } else if (state.dataSurface->Surface(SurfNum).Class == SurfaceClass::IntMass) {
2109 5 : ++state.dataRoomAirModelMgr->contInternal;
2110 5 : state.dataUCSDShared->APos_Internal(state.dataRoomAirModelMgr->contInternal) = SurfNum;
2111 17 : } else if (state.dataSurface->Surface(SurfNum).Class == SurfaceClass::Door) {
2112 0 : ++state.dataRoomAirModelMgr->contDoor;
2113 0 : state.dataUCSDShared->APos_Door(state.dataRoomAirModelMgr->contDoor) = SurfNum;
2114 : } else {
2115 17 : ++state.dataRoomAirModelMgr->contCeiling;
2116 17 : state.dataUCSDShared->APos_Ceiling(state.dataRoomAirModelMgr->contCeiling) = SurfNum;
2117 : }
2118 : }
2119 : } // Surfaces
2120 :
2121 13 : state.dataRoomAirModelMgr->contWallLast = state.dataRoomAirModelMgr->contWall;
2122 13 : state.dataRoomAirModelMgr->contFloorLast = state.dataRoomAirModelMgr->contFloor;
2123 13 : state.dataRoomAirModelMgr->contCeilingLast = state.dataRoomAirModelMgr->contCeiling;
2124 13 : state.dataRoomAirModelMgr->contWindowLast = state.dataRoomAirModelMgr->contWindow;
2125 13 : state.dataRoomAirModelMgr->contDoorLast = state.dataRoomAirModelMgr->contDoor;
2126 13 : state.dataRoomAirModelMgr->contInternalLast = state.dataRoomAirModelMgr->contInternal;
2127 : // PosZ_Wall (... + 1) has the Begin Wall reference in Apos_Wall for the ZNum
2128 : // PosZ_Wall (... + 2) has the End Wall reference in Apos_Wall for the ZNum
2129 13 : state.dataUCSDShared->PosZ_Wall((ZNum - 1) * 2 + 1) = state.dataRoomAirModelMgr->contWallBegin;
2130 13 : state.dataUCSDShared->PosZ_Wall((ZNum - 1) * 2 + 2) = state.dataRoomAirModelMgr->contWallLast;
2131 13 : state.dataUCSDShared->PosZ_Floor((ZNum - 1) * 2 + 1) = state.dataRoomAirModelMgr->contFloorBegin;
2132 13 : state.dataUCSDShared->PosZ_Floor((ZNum - 1) * 2 + 2) = state.dataRoomAirModelMgr->contFloorLast;
2133 13 : state.dataUCSDShared->PosZ_Ceiling((ZNum - 1) * 2 + 1) = state.dataRoomAirModelMgr->contCeilingBegin;
2134 13 : state.dataUCSDShared->PosZ_Ceiling((ZNum - 1) * 2 + 2) = state.dataRoomAirModelMgr->contCeilingLast;
2135 13 : state.dataUCSDShared->PosZ_Window((ZNum - 1) * 2 + 1) = state.dataRoomAirModelMgr->contWindowBegin;
2136 13 : state.dataUCSDShared->PosZ_Window((ZNum - 1) * 2 + 2) = state.dataRoomAirModelMgr->contWindowLast;
2137 13 : state.dataUCSDShared->PosZ_Door((ZNum - 1) * 2 + 1) = state.dataRoomAirModelMgr->contDoorBegin;
2138 13 : state.dataUCSDShared->PosZ_Door((ZNum - 1) * 2 + 2) = state.dataRoomAirModelMgr->contDoorLast;
2139 13 : state.dataUCSDShared->PosZ_Internal((ZNum - 1) * 2 + 1) = state.dataRoomAirModelMgr->contInternalBegin;
2140 13 : state.dataUCSDShared->PosZ_Internal((ZNum - 1) * 2 + 2) = state.dataRoomAirModelMgr->contInternalLast;
2141 : // Save the highest and lowest height for this zone
2142 13 : state.dataRoomAirMod->ZoneCeilingHeight((ZNum - 1) * 2 + 1) = state.dataRoomAirModelMgr->Z1ofZone;
2143 13 : state.dataRoomAirMod->ZoneCeilingHeight((ZNum - 1) * 2 + 2) = state.dataRoomAirModelMgr->Z2ofZone;
2144 :
2145 39 : if (std::abs((state.dataRoomAirModelMgr->Z2ofZone - state.dataRoomAirModelMgr->Z1ofZone) -
2146 26 : state.dataHeatBal->Zone(ZNum).CeilingHeight) > state.dataRoomAirModelMgr->CeilingHeightDiffMaximum) {
2147 0 : ShowWarningError(state, "RoomAirManager: Inconsistent ceiling heights in Zone: " + state.dataHeatBal->Zone(ZNum).Name);
2148 0 : ShowContinueError(state, format("Lowest height=[{:.3R}].", state.dataRoomAirModelMgr->Z1ofZone));
2149 0 : ShowContinueError(state, format("Highest height=[{:.3R}].", state.dataRoomAirModelMgr->Z2ofZone));
2150 0 : ShowContinueError(state, format("Ceiling height=[{:.3R}].", state.dataHeatBal->Zone(ZNum).CeilingHeight));
2151 : }
2152 : } // Zones
2153 :
2154 7 : AuxSurf = 0;
2155 7 : state.dataRoomAirMod->CVNumAirflowNetworkSurfaces = 0;
2156 :
2157 : // calculate maximum number of airflow network surfaces in each zone
2158 19 : for (state.dataRoomAirModelMgr->Loop = 1; state.dataRoomAirModelMgr->Loop <= state.afn->NumOfLinksMultiZone;
2159 12 : ++state.dataRoomAirModelMgr->Loop) {
2160 12 : ++AuxSurf(state.dataSurface->Surface(state.afn->MultizoneSurfaceData(state.dataRoomAirModelMgr->Loop).SurfNum).Zone);
2161 12 : ++state.dataRoomAirMod->CVNumAirflowNetworkSurfaces;
2162 : // Check if this is an interzone airflow network surface
2163 12 : if (state.dataSurface->Surface(state.afn->MultizoneSurfaceData(state.dataRoomAirModelMgr->Loop).SurfNum).ExtBoundCond > 0 &&
2164 0 : (state.afn->MultizoneSurfaceData(state.dataRoomAirModelMgr->Loop).SurfNum !=
2165 0 : state.dataSurface->Surface(state.afn->MultizoneSurfaceData(state.dataRoomAirModelMgr->Loop).SurfNum).ExtBoundCond)) {
2166 0 : ++AuxSurf(
2167 : state.dataSurface
2168 0 : ->Surface(
2169 0 : state.dataSurface->Surface(state.afn->MultizoneSurfaceData(state.dataRoomAirModelMgr->Loop).SurfNum).ExtBoundCond)
2170 0 : .Zone);
2171 0 : ++state.dataRoomAirMod->CVNumAirflowNetworkSurfaces;
2172 : }
2173 : }
2174 : // calculate maximum number of airflow network surfaces in a single zone
2175 7 : MaxSurf = AuxSurf(1);
2176 13 : for (state.dataRoomAirModelMgr->Loop = 2; state.dataRoomAirModelMgr->Loop <= state.dataGlobal->NumOfZones;
2177 6 : ++state.dataRoomAirModelMgr->Loop) {
2178 6 : if (AuxSurf(state.dataRoomAirModelMgr->Loop) > MaxSurf) MaxSurf = AuxSurf(state.dataRoomAirModelMgr->Loop);
2179 : }
2180 :
2181 7 : if (!allocated(state.dataRoomAirMod->AirflowNetworkSurfaceUCSDCV)) {
2182 7 : state.dataRoomAirMod->AirflowNetworkSurfaceUCSDCV.allocate({0, MaxSurf}, state.dataGlobal->NumOfZones);
2183 : }
2184 7 : if (!allocated(state.dataRoomAirMod->CVJetRecFlows)) {
2185 7 : state.dataRoomAirMod->CVJetRecFlows.allocate({0, MaxSurf}, state.dataGlobal->NumOfZones);
2186 : }
2187 7 : AuxAirflowNetworkSurf.allocate({0, MaxSurf}, state.dataGlobal->NumOfZones);
2188 : // Width and Height for airflow network surfaces
2189 7 : if (!allocated(state.dataRoomAirMod->SurfParametersCVDV)) {
2190 7 : state.dataRoomAirMod->SurfParametersCVDV.allocate(state.afn->NumOfLinksMultiZone);
2191 : }
2192 :
2193 7 : state.dataRoomAirMod->AirflowNetworkSurfaceUCSDCV = 0;
2194 : // Organize surfaces in vector AirflowNetworkSurfaceUCSDCV(Zone, surface indexes)
2195 20 : for (state.dataRoomAirModelMgr->Loop = 1; state.dataRoomAirModelMgr->Loop <= state.dataGlobal->NumOfZones;
2196 13 : ++state.dataRoomAirModelMgr->Loop) {
2197 : // the 0 component of the array has the number of relevant AirflowNetwork surfaces for the zone
2198 13 : state.dataRoomAirMod->AirflowNetworkSurfaceUCSDCV(0, state.dataRoomAirModelMgr->Loop) = AuxSurf(state.dataRoomAirModelMgr->Loop);
2199 13 : if (AuxSurf(state.dataRoomAirModelMgr->Loop) != 0) {
2200 4 : Real64 const ceilingHeight(state.dataRoomAirMod->ZoneCeilingHeight((state.dataRoomAirModelMgr->Loop - 1) * 2 + 1));
2201 4 : int SurfNum = 1;
2202 16 : for (state.dataRoomAirModelMgr->Loop2 = 1; state.dataRoomAirModelMgr->Loop2 <= state.afn->NumOfLinksMultiZone;
2203 12 : ++state.dataRoomAirModelMgr->Loop2) {
2204 24 : if (state.dataSurface->Surface(state.afn->MultizoneSurfaceData(state.dataRoomAirModelMgr->Loop2).SurfNum).Zone ==
2205 12 : state.dataRoomAirModelMgr->Loop) {
2206 : // SurfNum has the reference surface number relative to AirflowNetworkSurfaceData
2207 12 : state.dataRoomAirMod->AirflowNetworkSurfaceUCSDCV(SurfNum, state.dataRoomAirModelMgr->Loop) =
2208 12 : state.dataRoomAirModelMgr->Loop2;
2209 : // calculate the surface width and height
2210 12 : state.dataRoomAirModelMgr->CompNumber = state.afn->AirflowNetworkLinkageData(state.dataRoomAirModelMgr->Loop2).CompNum;
2211 12 : state.dataRoomAirModelMgr->TypeNumber = state.afn->AirflowNetworkCompData(state.dataRoomAirModelMgr->CompNumber).TypeNum;
2212 12 : if (state.afn->AirflowNetworkCompData(state.dataRoomAirModelMgr->CompNumber).CompTypeNum ==
2213 : AirflowNetwork::iComponentTypeNum::DOP) {
2214 10 : WidthFactMax = 0.0;
2215 10 : HeightFactMax = 0.0;
2216 30 : for (state.dataRoomAirModelMgr->Loop3 = 1;
2217 60 : state.dataRoomAirModelMgr->Loop3 <=
2218 30 : state.afn->MultizoneCompDetOpeningData(state.dataRoomAirModelMgr->TypeNumber).NumFac;
2219 20 : ++state.dataRoomAirModelMgr->Loop3) {
2220 20 : if (state.dataRoomAirModelMgr->Loop3 == 1) {
2221 10 : WidthFact = state.afn->MultizoneCompDetOpeningData(state.dataRoomAirModelMgr->TypeNumber).WidthFac1;
2222 10 : HeightFact = state.afn->MultizoneCompDetOpeningData(state.dataRoomAirModelMgr->TypeNumber).HeightFac1;
2223 : }
2224 20 : if (state.dataRoomAirModelMgr->Loop3 == 2) {
2225 10 : WidthFact = state.afn->MultizoneCompDetOpeningData(state.dataRoomAirModelMgr->TypeNumber).WidthFac2;
2226 10 : HeightFact = state.afn->MultizoneCompDetOpeningData(state.dataRoomAirModelMgr->TypeNumber).HeightFac2;
2227 : }
2228 20 : if (state.dataRoomAirModelMgr->Loop3 == 3) {
2229 0 : WidthFact = state.afn->MultizoneCompDetOpeningData(state.dataRoomAirModelMgr->TypeNumber).WidthFac3;
2230 0 : HeightFact = state.afn->MultizoneCompDetOpeningData(state.dataRoomAirModelMgr->TypeNumber).HeightFac3;
2231 : }
2232 20 : if (state.dataRoomAirModelMgr->Loop3 == 4) {
2233 0 : WidthFact = state.afn->MultizoneCompDetOpeningData(state.dataRoomAirModelMgr->TypeNumber).WidthFac4;
2234 0 : HeightFact = state.afn->MultizoneCompDetOpeningData(state.dataRoomAirModelMgr->TypeNumber).HeightFac4;
2235 : }
2236 20 : if (WidthFact > WidthFactMax) {
2237 10 : WidthFactMax = WidthFact;
2238 : }
2239 20 : if (HeightFact > HeightFactMax) {
2240 12 : HeightFactMax = HeightFact;
2241 : }
2242 : }
2243 10 : state.dataRoomAirMod->SurfParametersCVDV(state.dataRoomAirModelMgr->Loop2).Width =
2244 10 : WidthFactMax *
2245 10 : state.dataSurface->Surface(state.afn->MultizoneSurfaceData(state.dataRoomAirModelMgr->Loop2).SurfNum).Width;
2246 10 : state.dataRoomAirMod->SurfParametersCVDV(state.dataRoomAirModelMgr->Loop2).Height =
2247 10 : HeightFactMax *
2248 10 : state.dataSurface->Surface(state.afn->MultizoneSurfaceData(state.dataRoomAirModelMgr->Loop2).SurfNum).Height;
2249 2 : } else if (state.afn->AirflowNetworkCompData(state.dataRoomAirModelMgr->CompNumber).CompTypeNum ==
2250 : AirflowNetwork::iComponentTypeNum::SCR) { // surface type = CRACK
2251 2 : state.dataRoomAirMod->SurfParametersCVDV(state.dataRoomAirModelMgr->Loop2).Width =
2252 2 : state.dataSurface->Surface(state.afn->MultizoneSurfaceData(state.dataRoomAirModelMgr->Loop2).SurfNum).Width / 2;
2253 2 : AinCV =
2254 2 : state.afn->MultizoneSurfaceCrackData(state.dataRoomAirModelMgr->TypeNumber).coefficient /
2255 2 : (BaseDischargeCoef *
2256 2 : std::sqrt(
2257 : 2.0 /
2258 8 : PsyRhoAirFnPbTdbW(
2259 : state,
2260 2 : state.dataEnvrn->OutBaroPress,
2261 2 : state.dataZoneTempPredictorCorrector->zoneHeatBalance(state.dataRoomAirModelMgr->Loop).MAT,
2262 2 : state.dataZoneTempPredictorCorrector->zoneHeatBalance(state.dataRoomAirModelMgr->Loop).ZoneAirHumRat)));
2263 2 : state.dataRoomAirMod->SurfParametersCVDV(state.dataRoomAirModelMgr->Loop2).Height =
2264 2 : AinCV / state.dataRoomAirMod->SurfParametersCVDV(state.dataRoomAirModelMgr->Loop2).Width;
2265 : }
2266 : // calculate the surface Zmin and Zmax
2267 12 : if (state.afn->AirflowNetworkCompData(state.dataRoomAirModelMgr->CompNumber).CompTypeNum ==
2268 : AirflowNetwork::iComponentTypeNum::DOP) {
2269 10 : AirflowNetworkSurfPtr = state.afn->MultizoneSurfaceData(state.dataRoomAirModelMgr->Loop2).SurfNum;
2270 10 : NSides = state.dataSurface->Surface(state.afn->MultizoneSurfaceData(state.dataRoomAirModelMgr->Loop2).SurfNum).Sides;
2271 10 : Real64 z_min(std::numeric_limits<Real64>::max()), z_max(std::numeric_limits<Real64>::lowest());
2272 50 : for (int i = 1; i <= NSides; ++i) {
2273 40 : Real64 const z_i(state.dataSurface->Surface(AirflowNetworkSurfPtr).Vertex(i).z);
2274 40 : z_min = std::min(z_min, z_i);
2275 40 : z_max = std::max(z_max, z_i);
2276 : }
2277 10 : state.dataRoomAirMod->SurfParametersCVDV(state.dataRoomAirModelMgr->Loop2).Zmin = z_min - ceilingHeight;
2278 10 : state.dataRoomAirMod->SurfParametersCVDV(state.dataRoomAirModelMgr->Loop2).Zmax = z_max - ceilingHeight;
2279 2 : } else if (state.afn->AirflowNetworkCompData(state.dataRoomAirModelMgr->CompNumber).CompTypeNum ==
2280 : AirflowNetwork::iComponentTypeNum::SCR) { // surface type = CRACK
2281 2 : AirflowNetworkSurfPtr = state.afn->MultizoneSurfaceData(state.dataRoomAirModelMgr->Loop2).SurfNum;
2282 2 : NSides = state.dataSurface->Surface(state.afn->MultizoneSurfaceData(state.dataRoomAirModelMgr->Loop2).SurfNum).Sides;
2283 2 : Real64 z_min(std::numeric_limits<Real64>::max()), z_max(std::numeric_limits<Real64>::lowest());
2284 10 : for (int i = 1; i <= NSides; ++i) {
2285 8 : Real64 const z_i(state.dataSurface->Surface(AirflowNetworkSurfPtr).Vertex(i).z);
2286 8 : z_min = std::min(z_min, z_i);
2287 8 : z_max = std::max(z_max, z_i);
2288 : }
2289 2 : state.dataRoomAirMod->SurfParametersCVDV(state.dataRoomAirModelMgr->Loop2).Zmin = z_min - ceilingHeight;
2290 2 : state.dataRoomAirMod->SurfParametersCVDV(state.dataRoomAirModelMgr->Loop2).Zmax = z_max - ceilingHeight;
2291 : }
2292 :
2293 12 : ++SurfNum;
2294 : // Check if airflow network Surface is an interzone surface:
2295 : } else {
2296 0 : state.dataRoomAirModelMgr->NodeNumber1 = state.afn->MultizoneSurfaceData(state.dataRoomAirModelMgr->Loop2).NodeNums[0];
2297 0 : state.dataRoomAirModelMgr->NodeNumber2 = state.afn->MultizoneSurfaceData(state.dataRoomAirModelMgr->Loop2).NodeNums[1];
2298 0 : if ((state.afn->AirflowNetworkNodeData(state.dataRoomAirModelMgr->NodeNumber2).EPlusZoneNum ==
2299 0 : state.dataRoomAirModelMgr->Loop &&
2300 0 : state.afn->AirflowNetworkNodeData(state.dataRoomAirModelMgr->NodeNumber1).EPlusZoneNum > 0) ||
2301 0 : (state.afn->AirflowNetworkNodeData(state.dataRoomAirModelMgr->NodeNumber2).EPlusZoneNum > 0 &&
2302 0 : state.afn->AirflowNetworkNodeData(state.dataRoomAirModelMgr->NodeNumber1).EPlusZoneNum ==
2303 0 : state.dataRoomAirModelMgr->Loop)) {
2304 0 : state.dataRoomAirMod->AirflowNetworkSurfaceUCSDCV(SurfNum, state.dataRoomAirModelMgr->Loop) =
2305 0 : state.dataRoomAirModelMgr->Loop2;
2306 0 : ++SurfNum;
2307 : }
2308 : }
2309 : }
2310 : }
2311 : }
2312 :
2313 7 : AuxSurf.deallocate();
2314 :
2315 7 : if (any(state.dataRoomAirMod->IsZoneDV) || any(state.dataRoomAirMod->IsZoneUI)) {
2316 5 : state.dataRoomAirMod->MaxTempGrad.allocate(state.dataGlobal->NumOfZones);
2317 5 : state.dataRoomAirMod->AvgTempGrad.allocate(state.dataGlobal->NumOfZones);
2318 5 : state.dataRoomAirMod->TCMF.allocate(state.dataGlobal->NumOfZones);
2319 5 : state.dataRoomAirMod->FracMinFlow.allocate(state.dataGlobal->NumOfZones);
2320 5 : state.dataRoomAirMod->ZoneAirSystemON.allocate(state.dataGlobal->NumOfZones);
2321 : // Allocate histories of displacement ventilation temperatures PH 3/5/04
2322 5 : state.dataRoomAirMod->MATFloor.allocate(state.dataGlobal->NumOfZones);
2323 5 : state.dataRoomAirMod->XMATFloor.allocate(state.dataGlobal->NumOfZones);
2324 5 : state.dataRoomAirMod->XM2TFloor.allocate(state.dataGlobal->NumOfZones);
2325 5 : state.dataRoomAirMod->XM3TFloor.allocate(state.dataGlobal->NumOfZones);
2326 5 : state.dataRoomAirMod->XM4TFloor.allocate(state.dataGlobal->NumOfZones);
2327 5 : state.dataRoomAirMod->DSXMATFloor.allocate(state.dataGlobal->NumOfZones);
2328 5 : state.dataRoomAirMod->DSXM2TFloor.allocate(state.dataGlobal->NumOfZones);
2329 5 : state.dataRoomAirMod->DSXM3TFloor.allocate(state.dataGlobal->NumOfZones);
2330 5 : state.dataRoomAirMod->DSXM4TFloor.allocate(state.dataGlobal->NumOfZones);
2331 5 : state.dataRoomAirMod->MATOC.allocate(state.dataGlobal->NumOfZones);
2332 5 : state.dataRoomAirMod->XMATOC.allocate(state.dataGlobal->NumOfZones);
2333 5 : state.dataRoomAirMod->XM2TOC.allocate(state.dataGlobal->NumOfZones);
2334 5 : state.dataRoomAirMod->XM3TOC.allocate(state.dataGlobal->NumOfZones);
2335 5 : state.dataRoomAirMod->XM4TOC.allocate(state.dataGlobal->NumOfZones);
2336 5 : state.dataRoomAirMod->DSXMATOC.allocate(state.dataGlobal->NumOfZones);
2337 5 : state.dataRoomAirMod->DSXM2TOC.allocate(state.dataGlobal->NumOfZones);
2338 5 : state.dataRoomAirMod->DSXM3TOC.allocate(state.dataGlobal->NumOfZones);
2339 5 : state.dataRoomAirMod->DSXM4TOC.allocate(state.dataGlobal->NumOfZones);
2340 5 : state.dataRoomAirMod->MATMX.allocate(state.dataGlobal->NumOfZones);
2341 5 : state.dataRoomAirMod->XMATMX.allocate(state.dataGlobal->NumOfZones);
2342 5 : state.dataRoomAirMod->XM2TMX.allocate(state.dataGlobal->NumOfZones);
2343 5 : state.dataRoomAirMod->XM3TMX.allocate(state.dataGlobal->NumOfZones);
2344 5 : state.dataRoomAirMod->XM4TMX.allocate(state.dataGlobal->NumOfZones);
2345 5 : state.dataRoomAirMod->DSXMATMX.allocate(state.dataGlobal->NumOfZones);
2346 5 : state.dataRoomAirMod->DSXM2TMX.allocate(state.dataGlobal->NumOfZones);
2347 5 : state.dataRoomAirMod->DSXM3TMX.allocate(state.dataGlobal->NumOfZones);
2348 5 : state.dataRoomAirMod->DSXM4TMX.allocate(state.dataGlobal->NumOfZones);
2349 5 : state.dataRoomAirMod->ZTM1Floor.allocate(state.dataGlobal->NumOfZones);
2350 5 : state.dataRoomAirMod->ZTM2Floor.allocate(state.dataGlobal->NumOfZones);
2351 5 : state.dataRoomAirMod->ZTM3Floor.allocate(state.dataGlobal->NumOfZones);
2352 5 : state.dataRoomAirMod->ZTM1OC.allocate(state.dataGlobal->NumOfZones);
2353 5 : state.dataRoomAirMod->ZTM2OC.allocate(state.dataGlobal->NumOfZones);
2354 5 : state.dataRoomAirMod->ZTM3OC.allocate(state.dataGlobal->NumOfZones);
2355 5 : state.dataRoomAirMod->ZTM1MX.allocate(state.dataGlobal->NumOfZones);
2356 5 : state.dataRoomAirMod->ZTM2MX.allocate(state.dataGlobal->NumOfZones);
2357 5 : state.dataRoomAirMod->ZTM3MX.allocate(state.dataGlobal->NumOfZones);
2358 5 : state.dataRoomAirMod->AIRRATFloor.allocate(state.dataGlobal->NumOfZones);
2359 5 : state.dataRoomAirMod->AIRRATOC.allocate(state.dataGlobal->NumOfZones);
2360 5 : state.dataRoomAirMod->AIRRATMX.allocate(state.dataGlobal->NumOfZones);
2361 5 : state.dataRoomAirMod->ZTOC.allocate(state.dataGlobal->NumOfZones);
2362 5 : state.dataRoomAirMod->ZTMX.allocate(state.dataGlobal->NumOfZones);
2363 5 : state.dataRoomAirMod->ZTFloor.allocate(state.dataGlobal->NumOfZones);
2364 5 : state.dataRoomAirMod->HeightTransition.allocate(state.dataGlobal->NumOfZones);
2365 5 : state.dataRoomAirMod->Phi.allocate(state.dataGlobal->NumOfZones);
2366 5 : state.dataRoomAirMod->Zone1Floor.allocate(state.dataGlobal->NumOfZones);
2367 5 : state.dataRoomAirMod->ZoneMXFloor.allocate(state.dataGlobal->NumOfZones);
2368 5 : state.dataRoomAirMod->ZoneM2Floor.allocate(state.dataGlobal->NumOfZones);
2369 5 : state.dataRoomAirMod->Zone1OC.allocate(state.dataGlobal->NumOfZones);
2370 5 : state.dataRoomAirMod->ZoneMXOC.allocate(state.dataGlobal->NumOfZones);
2371 5 : state.dataRoomAirMod->ZoneM2OC.allocate(state.dataGlobal->NumOfZones);
2372 5 : state.dataRoomAirMod->Zone1MX.allocate(state.dataGlobal->NumOfZones);
2373 5 : state.dataRoomAirMod->ZoneMXMX.allocate(state.dataGlobal->NumOfZones);
2374 5 : state.dataRoomAirMod->ZoneM2MX.allocate(state.dataGlobal->NumOfZones);
2375 :
2376 5 : state.dataRoomAirMod->MaxTempGrad = 0.0;
2377 5 : state.dataRoomAirMod->AvgTempGrad = 0.0;
2378 5 : state.dataRoomAirMod->TCMF = 23.0;
2379 5 : state.dataRoomAirMod->FracMinFlow = 0.0;
2380 : // ZoneDVMixedFlagRep = 0.0
2381 5 : state.dataRoomAirMod->ZoneAirSystemON = false;
2382 : // ZoneDVMixedFlag=0
2383 5 : state.dataRoomAirMod->MATFloor = 23.0;
2384 5 : state.dataRoomAirMod->XMATFloor = 23.0;
2385 5 : state.dataRoomAirMod->XM2TFloor = 23.0;
2386 5 : state.dataRoomAirMod->XM3TFloor = 23.0;
2387 5 : state.dataRoomAirMod->XM4TFloor = 23.0;
2388 5 : state.dataRoomAirMod->DSXMATFloor = 23.0;
2389 5 : state.dataRoomAirMod->DSXM2TFloor = 23.0;
2390 5 : state.dataRoomAirMod->DSXM3TFloor = 23.0;
2391 5 : state.dataRoomAirMod->DSXM4TFloor = 23.0;
2392 5 : state.dataRoomAirMod->MATOC = 23.0;
2393 5 : state.dataRoomAirMod->XMATOC = 23.0;
2394 5 : state.dataRoomAirMod->XM2TOC = 23.0;
2395 5 : state.dataRoomAirMod->XM3TOC = 23.0;
2396 5 : state.dataRoomAirMod->XM4TOC = 23.0;
2397 5 : state.dataRoomAirMod->DSXMATOC = 23.0;
2398 5 : state.dataRoomAirMod->DSXM2TOC = 23.0;
2399 5 : state.dataRoomAirMod->DSXM3TOC = 23.0;
2400 5 : state.dataRoomAirMod->DSXM4TOC = 23.0;
2401 5 : state.dataRoomAirMod->MATMX = 23.0;
2402 5 : state.dataRoomAirMod->XMATMX = 23.0;
2403 5 : state.dataRoomAirMod->XM2TMX = 23.0;
2404 5 : state.dataRoomAirMod->XM3TMX = 23.0;
2405 5 : state.dataRoomAirMod->XM4TMX = 23.0;
2406 5 : state.dataRoomAirMod->DSXMATMX = 23.0;
2407 5 : state.dataRoomAirMod->DSXM2TMX = 23.0;
2408 5 : state.dataRoomAirMod->DSXM3TMX = 23.0;
2409 5 : state.dataRoomAirMod->DSXM4TMX = 23.0;
2410 5 : state.dataRoomAirMod->ZTM1Floor = 23.0;
2411 5 : state.dataRoomAirMod->ZTM2Floor = 23.0;
2412 5 : state.dataRoomAirMod->ZTM3Floor = 23.0;
2413 5 : state.dataRoomAirMod->ZTM1OC = 23.0;
2414 5 : state.dataRoomAirMod->ZTM2OC = 23.0;
2415 5 : state.dataRoomAirMod->ZTM3OC = 23.0;
2416 5 : state.dataRoomAirMod->ZTM1MX = 23.0;
2417 5 : state.dataRoomAirMod->ZTM2MX = 23.0;
2418 5 : state.dataRoomAirMod->ZTM3MX = 23.0;
2419 5 : state.dataRoomAirMod->Zone1Floor = 23.0;
2420 5 : state.dataRoomAirMod->ZoneMXFloor = 23.0;
2421 5 : state.dataRoomAirMod->ZoneM2Floor = 23.0;
2422 5 : state.dataRoomAirMod->Zone1OC = 23.0;
2423 5 : state.dataRoomAirMod->ZoneMXOC = 23.0;
2424 5 : state.dataRoomAirMod->ZoneM2OC = 23.0;
2425 5 : state.dataRoomAirMod->Zone1MX = 23.0;
2426 5 : state.dataRoomAirMod->ZoneMXMX = 23.0;
2427 5 : state.dataRoomAirMod->ZoneM2MX = 23.0;
2428 5 : state.dataRoomAirMod->AIRRATFloor = 0.0;
2429 5 : state.dataRoomAirMod->AIRRATOC = 0.0;
2430 5 : state.dataRoomAirMod->AIRRATMX = 0.0;
2431 5 : state.dataRoomAirMod->ZTOC = 23.0;
2432 5 : state.dataRoomAirMod->ZTMX = 23.0;
2433 5 : state.dataRoomAirMod->ZTFloor = 23.0;
2434 5 : state.dataRoomAirMod->HeightTransition = 0.0;
2435 5 : state.dataRoomAirMod->Phi = 0.0;
2436 5 : state.dataUCSDShared->HCeiling = 0.0;
2437 5 : state.dataUCSDShared->HWall = 0.0;
2438 5 : state.dataUCSDShared->HFloor = 0.0;
2439 5 : state.dataUCSDShared->HInternal = 0.0;
2440 5 : state.dataUCSDShared->HWindow = 0.0;
2441 5 : state.dataUCSDShared->HDoor = 0.0;
2442 : }
2443 :
2444 7 : if (any(state.dataRoomAirMod->IsZoneDV)) {
2445 :
2446 4 : state.dataRoomAirMod->DVHcIn.allocate(state.dataSurface->TotSurfaces);
2447 4 : state.dataRoomAirMod->ZoneDVMixedFlagRep.allocate(state.dataGlobal->NumOfZones);
2448 4 : state.dataRoomAirMod->ZoneDVMixedFlag.allocate(state.dataGlobal->NumOfZones);
2449 4 : state.dataRoomAirMod->DVHcIn = 0.0;
2450 4 : state.dataRoomAirMod->ZoneDVMixedFlagRep = 0.0;
2451 4 : state.dataRoomAirMod->ZoneDVMixedFlag = 0;
2452 : // Output variables and DV zone flag
2453 8 : for (state.dataRoomAirModelMgr->Loop = 1; state.dataRoomAirModelMgr->Loop <= state.dataGlobal->NumOfZones;
2454 4 : ++state.dataRoomAirModelMgr->Loop) {
2455 4 : if (state.dataRoomAirMod->AirModel(state.dataRoomAirModelMgr->Loop).AirModelType != DataRoomAirModel::RoomAirModel::UCSDDV)
2456 0 : continue; // don't set these up if they don't make sense
2457 : // CurrentModuleObject='RoomAirSettings:ThreeNodeDisplacementVentilation'
2458 12 : SetupOutputVariable(state,
2459 : "Room Air Zone Mixed Subzone Temperature",
2460 : OutputProcessor::Unit::C,
2461 4 : state.dataRoomAirMod->ZTMX(state.dataRoomAirModelMgr->Loop),
2462 : OutputProcessor::SOVTimeStepType::HVAC,
2463 : OutputProcessor::SOVStoreType::State,
2464 8 : state.dataHeatBal->Zone(state.dataRoomAirModelMgr->Loop).Name);
2465 12 : SetupOutputVariable(state,
2466 : "Room Air Zone Occupied Subzone Temperature",
2467 : OutputProcessor::Unit::C,
2468 4 : state.dataRoomAirMod->ZTOC(state.dataRoomAirModelMgr->Loop),
2469 : OutputProcessor::SOVTimeStepType::HVAC,
2470 : OutputProcessor::SOVStoreType::State,
2471 8 : state.dataHeatBal->Zone(state.dataRoomAirModelMgr->Loop).Name);
2472 12 : SetupOutputVariable(state,
2473 : "Room Air Zone Floor Subzone Temperature",
2474 : OutputProcessor::Unit::C,
2475 4 : state.dataRoomAirMod->ZTFloor(state.dataRoomAirModelMgr->Loop),
2476 : OutputProcessor::SOVTimeStepType::HVAC,
2477 : OutputProcessor::SOVStoreType::State,
2478 8 : state.dataHeatBal->Zone(state.dataRoomAirModelMgr->Loop).Name);
2479 12 : SetupOutputVariable(state,
2480 : "Room Air Zone Transition Height",
2481 : OutputProcessor::Unit::m,
2482 4 : state.dataRoomAirMod->HeightTransition(state.dataRoomAirModelMgr->Loop),
2483 : OutputProcessor::SOVTimeStepType::HVAC,
2484 : OutputProcessor::SOVStoreType::State,
2485 8 : state.dataHeatBal->Zone(state.dataRoomAirModelMgr->Loop).Name);
2486 12 : SetupOutputVariable(state,
2487 : "Room Air Zone Recommended Minimum Flow Fraction",
2488 : OutputProcessor::Unit::None,
2489 4 : state.dataRoomAirMod->FracMinFlow(state.dataRoomAirModelMgr->Loop),
2490 : OutputProcessor::SOVTimeStepType::HVAC,
2491 : OutputProcessor::SOVStoreType::State,
2492 8 : state.dataHeatBal->Zone(state.dataRoomAirModelMgr->Loop).Name);
2493 12 : SetupOutputVariable(state,
2494 : "Room Air Zone Is Mixed Status",
2495 : OutputProcessor::Unit::None,
2496 4 : state.dataRoomAirMod->ZoneDVMixedFlagRep(state.dataRoomAirModelMgr->Loop),
2497 : OutputProcessor::SOVTimeStepType::HVAC,
2498 : OutputProcessor::SOVStoreType::State,
2499 8 : state.dataHeatBal->Zone(state.dataRoomAirModelMgr->Loop).Name);
2500 12 : SetupOutputVariable(state,
2501 : "Room Air Zone Average Temperature Gradient",
2502 : OutputProcessor::Unit::K_m,
2503 4 : state.dataRoomAirMod->AvgTempGrad(state.dataRoomAirModelMgr->Loop),
2504 : OutputProcessor::SOVTimeStepType::HVAC,
2505 : OutputProcessor::SOVStoreType::State,
2506 8 : state.dataHeatBal->Zone(state.dataRoomAirModelMgr->Loop).Name);
2507 12 : SetupOutputVariable(state,
2508 : "Room Air Zone Maximum Temperature Gradient",
2509 : OutputProcessor::Unit::K_m,
2510 4 : state.dataRoomAirMod->MaxTempGrad(state.dataRoomAirModelMgr->Loop),
2511 : OutputProcessor::SOVTimeStepType::HVAC,
2512 : OutputProcessor::SOVStoreType::State,
2513 8 : state.dataHeatBal->Zone(state.dataRoomAirModelMgr->Loop).Name);
2514 12 : SetupOutputVariable(state,
2515 : "Room Air Zone Thermal Comfort Effective Air Temperature",
2516 : OutputProcessor::Unit::C,
2517 4 : state.dataRoomAirMod->TCMF(state.dataRoomAirModelMgr->Loop),
2518 : OutputProcessor::SOVTimeStepType::HVAC,
2519 : OutputProcessor::SOVStoreType::State,
2520 8 : state.dataHeatBal->Zone(state.dataRoomAirModelMgr->Loop).Name);
2521 12 : SetupOutputVariable(state,
2522 : "Room Air Zone Thermostat Temperature",
2523 : OutputProcessor::Unit::C,
2524 4 : state.dataHeatBalFanSys->TempTstatAir(state.dataRoomAirModelMgr->Loop),
2525 : OutputProcessor::SOVTimeStepType::HVAC,
2526 : OutputProcessor::SOVStoreType::State,
2527 8 : state.dataHeatBal->Zone(state.dataRoomAirModelMgr->Loop).Name);
2528 : }
2529 : }
2530 :
2531 7 : if (any(state.dataRoomAirMod->IsZoneUI)) {
2532 1 : state.dataRoomAirMod->ZoneUFMixedFlag.allocate(state.dataGlobal->NumOfZones);
2533 1 : state.dataRoomAirMod->ZoneUFMixedFlagRep.allocate(state.dataGlobal->NumOfZones);
2534 1 : state.dataRoomAirMod->UFHcIn.allocate(state.dataSurface->TotSurfaces);
2535 1 : state.dataRoomAirMod->ZoneUFGamma.allocate(state.dataGlobal->NumOfZones);
2536 1 : state.dataRoomAirMod->ZoneUFPowInPlumes.allocate(state.dataGlobal->NumOfZones);
2537 1 : state.dataRoomAirMod->ZoneUFPowInPlumesfromWindows.allocate(state.dataGlobal->NumOfZones);
2538 1 : state.dataRoomAirMod->ZoneUFMixedFlag = 0;
2539 1 : state.dataRoomAirMod->ZoneUFMixedFlagRep = 0.0;
2540 1 : state.dataRoomAirMod->UFHcIn = 0.0;
2541 1 : state.dataRoomAirMod->ZoneUFGamma = 0.0;
2542 1 : state.dataRoomAirMod->ZoneUFPowInPlumes = 0.0;
2543 1 : state.dataRoomAirMod->ZoneUFPowInPlumesfromWindows = 0.0;
2544 : // Output variables and UF zone flag
2545 8 : for (state.dataRoomAirModelMgr->Loop = 1; state.dataRoomAirModelMgr->Loop <= state.dataGlobal->NumOfZones;
2546 7 : ++state.dataRoomAirModelMgr->Loop) {
2547 7 : if (state.dataRoomAirMod->AirModel(state.dataRoomAirModelMgr->Loop).AirModelType != DataRoomAirModel::RoomAirModel::UCSDUFI)
2548 6 : continue; // don't set these up if they don't make sense
2549 : // CurrentModuleObject='RoomAirSettings:UnderFloorAirDistributionInterior'
2550 3 : SetupOutputVariable(state,
2551 : "Room Air Zone Mixed Subzone Temperature",
2552 : OutputProcessor::Unit::C,
2553 1 : state.dataRoomAirMod->ZTMX(state.dataRoomAirModelMgr->Loop),
2554 : OutputProcessor::SOVTimeStepType::HVAC,
2555 : OutputProcessor::SOVStoreType::State,
2556 2 : state.dataHeatBal->Zone(state.dataRoomAirModelMgr->Loop).Name);
2557 3 : SetupOutputVariable(state,
2558 : "Room Air Zone Occupied Subzone Temperature",
2559 : OutputProcessor::Unit::C,
2560 1 : state.dataRoomAirMod->ZTOC(state.dataRoomAirModelMgr->Loop),
2561 : OutputProcessor::SOVTimeStepType::HVAC,
2562 : OutputProcessor::SOVStoreType::State,
2563 2 : state.dataHeatBal->Zone(state.dataRoomAirModelMgr->Loop).Name);
2564 3 : SetupOutputVariable(state,
2565 : "Room Air Zone Transition Height",
2566 : OutputProcessor::Unit::m,
2567 1 : state.dataRoomAirMod->HeightTransition(state.dataRoomAirModelMgr->Loop),
2568 : OutputProcessor::SOVTimeStepType::HVAC,
2569 : OutputProcessor::SOVStoreType::State,
2570 2 : state.dataHeatBal->Zone(state.dataRoomAirModelMgr->Loop).Name);
2571 3 : SetupOutputVariable(state,
2572 : "Room Air Zone Is Mixed Status",
2573 : OutputProcessor::Unit::None,
2574 1 : state.dataRoomAirMod->ZoneUFMixedFlagRep(state.dataRoomAirModelMgr->Loop),
2575 : OutputProcessor::SOVTimeStepType::HVAC,
2576 : OutputProcessor::SOVStoreType::State,
2577 2 : state.dataHeatBal->Zone(state.dataRoomAirModelMgr->Loop).Name);
2578 3 : SetupOutputVariable(state,
2579 : "Room Air Zone Average Temperature Gradient",
2580 : OutputProcessor::Unit::K_m,
2581 1 : state.dataRoomAirMod->AvgTempGrad(state.dataRoomAirModelMgr->Loop),
2582 : OutputProcessor::SOVTimeStepType::HVAC,
2583 : OutputProcessor::SOVStoreType::State,
2584 2 : state.dataHeatBal->Zone(state.dataRoomAirModelMgr->Loop).Name);
2585 3 : SetupOutputVariable(state,
2586 : "Room Air Zone Effective Comfort Air Temperature",
2587 : OutputProcessor::Unit::C,
2588 1 : state.dataRoomAirMod->TCMF(state.dataRoomAirModelMgr->Loop),
2589 : OutputProcessor::SOVTimeStepType::HVAC,
2590 : OutputProcessor::SOVStoreType::State,
2591 2 : state.dataHeatBal->Zone(state.dataRoomAirModelMgr->Loop).Name);
2592 3 : SetupOutputVariable(state,
2593 : "Room Air Zone Thermostat Temperature",
2594 : OutputProcessor::Unit::C,
2595 1 : state.dataHeatBalFanSys->TempTstatAir(state.dataRoomAirModelMgr->Loop),
2596 : OutputProcessor::SOVTimeStepType::HVAC,
2597 : OutputProcessor::SOVStoreType::State,
2598 2 : state.dataHeatBal->Zone(state.dataRoomAirModelMgr->Loop).Name);
2599 3 : SetupOutputVariable(state,
2600 : "Room Air Zone Transition Height Gamma Value",
2601 : OutputProcessor::Unit::None,
2602 1 : state.dataRoomAirMod->ZoneUFGamma(state.dataRoomAirModelMgr->Loop),
2603 : OutputProcessor::SOVTimeStepType::HVAC,
2604 : OutputProcessor::SOVStoreType::State,
2605 2 : state.dataHeatBal->Zone(state.dataRoomAirModelMgr->Loop).Name);
2606 3 : SetupOutputVariable(state,
2607 : "Room Air Zone Plume Heat Transfer Rate",
2608 : OutputProcessor::Unit::W,
2609 1 : state.dataRoomAirMod->ZoneUFPowInPlumes(state.dataRoomAirModelMgr->Loop),
2610 : OutputProcessor::SOVTimeStepType::HVAC,
2611 : OutputProcessor::SOVStoreType::State,
2612 2 : state.dataHeatBal->Zone(state.dataRoomAirModelMgr->Loop).Name);
2613 3 : SetupOutputVariable(state,
2614 : "Room Air Zone Temperature Stratification Fraction",
2615 : OutputProcessor::Unit::None,
2616 1 : state.dataRoomAirMod->Phi(state.dataRoomAirModelMgr->Loop),
2617 : OutputProcessor::SOVTimeStepType::HVAC,
2618 : OutputProcessor::SOVStoreType::State,
2619 2 : state.dataHeatBal->Zone(state.dataRoomAirModelMgr->Loop).Name);
2620 :
2621 : // set zone equip pointer in the UCSDUI data structure
2622 1 : state.dataRoomAirMod->ZoneUCSDUI(state.dataRoomAirMod->ZoneUFPtr(state.dataRoomAirModelMgr->Loop)).ZoneEquipPtr =
2623 1 : state.dataRoomAirModelMgr->Loop;
2624 : }
2625 8 : for (state.dataRoomAirModelMgr->Loop = 1; state.dataRoomAirModelMgr->Loop <= state.dataGlobal->NumOfZones;
2626 7 : ++state.dataRoomAirModelMgr->Loop) {
2627 7 : if (state.dataRoomAirMod->AirModel(state.dataRoomAirModelMgr->Loop).AirModelType != DataRoomAirModel::RoomAirModel::UCSDUFE)
2628 3 : continue; // don't set these up if they don't make sense
2629 : // CurrentModuleObject='RoomAirSettings:UnderFloorAirDistributionExterior'
2630 12 : SetupOutputVariable(state,
2631 : "Room Air Zone Mixed Subzone Temperature",
2632 : OutputProcessor::Unit::C,
2633 4 : state.dataRoomAirMod->ZTMX(state.dataRoomAirModelMgr->Loop),
2634 : OutputProcessor::SOVTimeStepType::HVAC,
2635 : OutputProcessor::SOVStoreType::State,
2636 8 : state.dataHeatBal->Zone(state.dataRoomAirModelMgr->Loop).Name);
2637 12 : SetupOutputVariable(state,
2638 : "Room Air Zone Occupied Subzone Temperature",
2639 : OutputProcessor::Unit::C,
2640 4 : state.dataRoomAirMod->ZTOC(state.dataRoomAirModelMgr->Loop),
2641 : OutputProcessor::SOVTimeStepType::HVAC,
2642 : OutputProcessor::SOVStoreType::State,
2643 8 : state.dataHeatBal->Zone(state.dataRoomAirModelMgr->Loop).Name);
2644 12 : SetupOutputVariable(state,
2645 : "Room Air Zone Transition Height",
2646 : OutputProcessor::Unit::m,
2647 4 : state.dataRoomAirMod->HeightTransition(state.dataRoomAirModelMgr->Loop),
2648 : OutputProcessor::SOVTimeStepType::HVAC,
2649 : OutputProcessor::SOVStoreType::State,
2650 8 : state.dataHeatBal->Zone(state.dataRoomAirModelMgr->Loop).Name);
2651 12 : SetupOutputVariable(state,
2652 : "Room Air Zone Is Mixed Status",
2653 : OutputProcessor::Unit::None,
2654 4 : state.dataRoomAirMod->ZoneUFMixedFlagRep(state.dataRoomAirModelMgr->Loop),
2655 : OutputProcessor::SOVTimeStepType::HVAC,
2656 : OutputProcessor::SOVStoreType::State,
2657 8 : state.dataHeatBal->Zone(state.dataRoomAirModelMgr->Loop).Name);
2658 12 : SetupOutputVariable(state,
2659 : "Room Air Zone Average Temperature Gradient",
2660 : OutputProcessor::Unit::K_m,
2661 4 : state.dataRoomAirMod->AvgTempGrad(state.dataRoomAirModelMgr->Loop),
2662 : OutputProcessor::SOVTimeStepType::HVAC,
2663 : OutputProcessor::SOVStoreType::State,
2664 8 : state.dataHeatBal->Zone(state.dataRoomAirModelMgr->Loop).Name);
2665 12 : SetupOutputVariable(state,
2666 : "Room Air Zone Effective Comfort Air Temperature",
2667 : OutputProcessor::Unit::C,
2668 4 : state.dataRoomAirMod->TCMF(state.dataRoomAirModelMgr->Loop),
2669 : OutputProcessor::SOVTimeStepType::HVAC,
2670 : OutputProcessor::SOVStoreType::State,
2671 8 : state.dataHeatBal->Zone(state.dataRoomAirModelMgr->Loop).Name);
2672 12 : SetupOutputVariable(state,
2673 : "Room Air Zone Thermostat Temperature",
2674 : OutputProcessor::Unit::C,
2675 4 : state.dataHeatBalFanSys->TempTstatAir(state.dataRoomAirModelMgr->Loop),
2676 : OutputProcessor::SOVTimeStepType::HVAC,
2677 : OutputProcessor::SOVStoreType::State,
2678 8 : state.dataHeatBal->Zone(state.dataRoomAirModelMgr->Loop).Name);
2679 12 : SetupOutputVariable(state,
2680 : "Room Air Zone Transition Height Gamma Value",
2681 : OutputProcessor::Unit::None,
2682 4 : state.dataRoomAirMod->ZoneUFGamma(state.dataRoomAirModelMgr->Loop),
2683 : OutputProcessor::SOVTimeStepType::HVAC,
2684 : OutputProcessor::SOVStoreType::State,
2685 8 : state.dataHeatBal->Zone(state.dataRoomAirModelMgr->Loop).Name);
2686 12 : SetupOutputVariable(state,
2687 : "Room Air Zone Plume Heat Transfer Rate",
2688 : OutputProcessor::Unit::W,
2689 4 : state.dataRoomAirMod->ZoneUFPowInPlumes(state.dataRoomAirModelMgr->Loop),
2690 : OutputProcessor::SOVTimeStepType::HVAC,
2691 : OutputProcessor::SOVStoreType::State,
2692 8 : state.dataHeatBal->Zone(state.dataRoomAirModelMgr->Loop).Name);
2693 12 : SetupOutputVariable(state,
2694 : "Room Air Zone Window Plume Heat Transfer Rate",
2695 : OutputProcessor::Unit::W,
2696 4 : state.dataRoomAirMod->ZoneUFPowInPlumesfromWindows(state.dataRoomAirModelMgr->Loop),
2697 : OutputProcessor::SOVTimeStepType::HVAC,
2698 : OutputProcessor::SOVStoreType::State,
2699 8 : state.dataHeatBal->Zone(state.dataRoomAirModelMgr->Loop).Name);
2700 12 : SetupOutputVariable(state,
2701 : "Room Air Zone Temperature Stratification Fraction",
2702 : OutputProcessor::Unit::None,
2703 4 : state.dataRoomAirMod->Phi(state.dataRoomAirModelMgr->Loop),
2704 : OutputProcessor::SOVTimeStepType::HVAC,
2705 : OutputProcessor::SOVStoreType::State,
2706 8 : state.dataHeatBal->Zone(state.dataRoomAirModelMgr->Loop).Name);
2707 : // set zone equip pointer in the UCSDUE data structure
2708 4 : state.dataRoomAirMod->ZoneUCSDUE(state.dataRoomAirMod->ZoneUFPtr(state.dataRoomAirModelMgr->Loop)).ZoneEquipPtr =
2709 4 : state.dataRoomAirModelMgr->Loop;
2710 : }
2711 : }
2712 :
2713 7 : if (any(state.dataRoomAirMod->IsZoneCV)) {
2714 2 : state.dataRoomAirMod->CVHcIn.allocate(state.dataSurface->TotSurfaces);
2715 2 : state.dataRoomAirMod->ZTJET.allocate(state.dataGlobal->NumOfZones);
2716 : // Most ZTJet takes defaults
2717 2 : state.dataRoomAirMod->ZTREC.allocate(state.dataGlobal->NumOfZones);
2718 2 : state.dataRoomAirMod->RoomOutflowTemp.allocate(state.dataGlobal->NumOfZones);
2719 : // Most ZTREC takes defaults
2720 2 : state.dataRoomAirMod->JetRecAreaRatio.allocate(state.dataGlobal->NumOfZones);
2721 2 : state.dataRoomAirMod->Urec.allocate(state.dataGlobal->NumOfZones);
2722 2 : state.dataRoomAirMod->Ujet.allocate(state.dataGlobal->NumOfZones);
2723 2 : state.dataRoomAirMod->Qrec.allocate(state.dataGlobal->NumOfZones);
2724 2 : state.dataRoomAirMod->Qtot.allocate(state.dataGlobal->NumOfZones);
2725 2 : state.dataRoomAirMod->RecInflowRatio.allocate(state.dataGlobal->NumOfZones);
2726 2 : state.dataRoomAirMod->Uhc.allocate(state.dataGlobal->NumOfZones);
2727 2 : state.dataRoomAirMod->Ain.allocate(state.dataGlobal->NumOfZones);
2728 2 : state.dataRoomAirMod->Tin.allocate(state.dataGlobal->NumOfZones);
2729 2 : state.dataRoomAirMod->Droom.allocate(state.dataGlobal->NumOfZones);
2730 2 : state.dataRoomAirMod->Dstar.allocate(state.dataGlobal->NumOfZones);
2731 2 : state.dataRoomAirMod->ZoneCVisMixing.allocate(state.dataGlobal->NumOfZones);
2732 2 : state.dataRoomAirMod->Rfr.allocate(state.dataGlobal->NumOfZones);
2733 2 : state.dataRoomAirMod->ZoneCVhasREC.allocate(state.dataGlobal->NumOfZones);
2734 :
2735 2 : state.dataRoomAirMod->ZTJET = 23.0;
2736 2 : state.dataRoomAirMod->RoomOutflowTemp = 23.0;
2737 2 : state.dataRoomAirMod->ZTREC = 23.0;
2738 2 : state.dataRoomAirMod->CVHcIn = 0.0;
2739 2 : state.dataRoomAirMod->JetRecAreaRatio = 0.2;
2740 2 : state.dataRoomAirMod->Urec = 0.2;
2741 2 : state.dataRoomAirMod->Ujet = 0.2;
2742 2 : state.dataRoomAirMod->Qrec = 0.2;
2743 2 : state.dataRoomAirMod->Uhc = 0.2;
2744 2 : state.dataRoomAirMod->Ain = 1.0;
2745 2 : state.dataRoomAirMod->Tin = 23.0;
2746 2 : state.dataRoomAirMod->Droom = 6.0;
2747 2 : state.dataRoomAirMod->ZoneCVisMixing = 0.0;
2748 2 : state.dataRoomAirMod->Rfr = 10.0;
2749 2 : state.dataRoomAirMod->ZoneCVhasREC = 1.0;
2750 2 : state.dataUCSDShared->HCeiling = 0.0;
2751 2 : state.dataUCSDShared->HWall = 0.0;
2752 2 : state.dataUCSDShared->HFloor = 0.0;
2753 2 : state.dataUCSDShared->HInternal = 0.0;
2754 2 : state.dataUCSDShared->HWindow = 0.0;
2755 2 : state.dataUCSDShared->HDoor = 0.0;
2756 :
2757 4 : for (state.dataRoomAirModelMgr->Loop = 1; state.dataRoomAirModelMgr->Loop <= state.dataGlobal->NumOfZones;
2758 2 : ++state.dataRoomAirModelMgr->Loop) {
2759 2 : if (state.dataRoomAirMod->AirModel(state.dataRoomAirModelMgr->Loop).AirModelType != DataRoomAirModel::RoomAirModel::UCSDCV)
2760 0 : continue; // don't set these up if they don't make sense
2761 2 : ZoneEquipConfigNum = ZoneNum;
2762 : // check whether this zone is a controlled zone or not
2763 2 : if (state.dataZoneEquip->ZoneEquipConfig(ZoneEquipConfigNum).IsControlled) {
2764 0 : state.dataRoomAirMod->IsZoneCV(state.dataRoomAirModelMgr->Loop) = false;
2765 0 : state.dataRoomAirMod->AirModel(state.dataRoomAirModelMgr->Loop).SimAirModel = false;
2766 0 : ShowSevereError(state,
2767 0 : "Unmixed Flow: Cross Ventilation cannot be applied for Zone=" +
2768 0 : state.dataHeatBal->Zone(state.dataRoomAirModelMgr->Loop).Name);
2769 0 : ShowContinueError(state,
2770 0 : "An HVAC system is present in the zone. Fully mixed airflow model will be used for Zone=" +
2771 0 : state.dataHeatBal->Zone(state.dataRoomAirModelMgr->Loop).Name);
2772 0 : continue;
2773 : }
2774 : // CurrentModuleObject='RoomAirSettings:CrossVentilation'
2775 6 : SetupOutputVariable(state,
2776 : "Room Air Zone Jet Region Temperature",
2777 : OutputProcessor::Unit::C,
2778 2 : state.dataRoomAirMod->ZTJET(state.dataRoomAirModelMgr->Loop),
2779 : OutputProcessor::SOVTimeStepType::Zone,
2780 : OutputProcessor::SOVStoreType::Average,
2781 4 : state.dataHeatBal->Zone(state.dataRoomAirModelMgr->Loop).Name);
2782 6 : SetupOutputVariable(state,
2783 : "Room Air Zone Recirculation Region Temperature",
2784 : OutputProcessor::Unit::C,
2785 2 : state.dataRoomAirMod->ZTREC(state.dataRoomAirModelMgr->Loop),
2786 : OutputProcessor::SOVTimeStepType::Zone,
2787 : OutputProcessor::SOVStoreType::Average,
2788 4 : state.dataHeatBal->Zone(state.dataRoomAirModelMgr->Loop).Name);
2789 6 : SetupOutputVariable(state,
2790 : "Room Air Zone Jet Region Average Air Velocity",
2791 : OutputProcessor::Unit::m_s,
2792 2 : state.dataRoomAirMod->Ujet(state.dataRoomAirModelMgr->Loop),
2793 : OutputProcessor::SOVTimeStepType::Zone,
2794 : OutputProcessor::SOVStoreType::Average,
2795 4 : state.dataHeatBal->Zone(state.dataRoomAirModelMgr->Loop).Name);
2796 6 : SetupOutputVariable(state,
2797 : "Room Air Zone Recirculation Region Average Air Velocity",
2798 : OutputProcessor::Unit::m_s,
2799 2 : state.dataRoomAirMod->Urec(state.dataRoomAirModelMgr->Loop),
2800 : OutputProcessor::SOVTimeStepType::Zone,
2801 : OutputProcessor::SOVStoreType::Average,
2802 4 : state.dataHeatBal->Zone(state.dataRoomAirModelMgr->Loop).Name);
2803 6 : SetupOutputVariable(state,
2804 : "Room Air Zone Recirculation and Inflow Rate Ratio",
2805 : OutputProcessor::Unit::None,
2806 2 : state.dataRoomAirMod->RecInflowRatio(state.dataRoomAirModelMgr->Loop),
2807 : OutputProcessor::SOVTimeStepType::Zone,
2808 : OutputProcessor::SOVStoreType::Average,
2809 4 : state.dataHeatBal->Zone(state.dataRoomAirModelMgr->Loop).Name);
2810 6 : SetupOutputVariable(state,
2811 : "Room Air Zone Inflow Opening Area",
2812 : OutputProcessor::Unit::m2,
2813 2 : state.dataRoomAirMod->Ain(state.dataRoomAirModelMgr->Loop),
2814 : OutputProcessor::SOVTimeStepType::Zone,
2815 : OutputProcessor::SOVStoreType::Average,
2816 4 : state.dataHeatBal->Zone(state.dataRoomAirModelMgr->Loop).Name);
2817 6 : SetupOutputVariable(state,
2818 : "Room Air Zone Room Length",
2819 : OutputProcessor::Unit::m,
2820 2 : state.dataRoomAirMod->Dstar(state.dataRoomAirModelMgr->Loop),
2821 : OutputProcessor::SOVTimeStepType::Zone,
2822 : OutputProcessor::SOVStoreType::Average,
2823 4 : state.dataHeatBal->Zone(state.dataRoomAirModelMgr->Loop).Name);
2824 6 : SetupOutputVariable(state,
2825 : "Room Air Zone Is Mixing Status",
2826 : OutputProcessor::Unit::None,
2827 2 : state.dataRoomAirMod->ZoneCVisMixing(state.dataRoomAirModelMgr->Loop),
2828 : OutputProcessor::SOVTimeStepType::Zone,
2829 : OutputProcessor::SOVStoreType::State,
2830 4 : state.dataHeatBal->Zone(state.dataRoomAirModelMgr->Loop).Name);
2831 6 : SetupOutputVariable(state,
2832 : "Room Air Zone Is Recirculating Status",
2833 : OutputProcessor::Unit::None,
2834 2 : state.dataRoomAirMod->ZoneCVhasREC(state.dataRoomAirModelMgr->Loop),
2835 : OutputProcessor::SOVTimeStepType::Zone,
2836 : OutputProcessor::SOVStoreType::State,
2837 4 : state.dataHeatBal->Zone(state.dataRoomAirModelMgr->Loop).Name);
2838 8 : for (state.dataRoomAirModelMgr->i = 1;
2839 8 : state.dataRoomAirModelMgr->i <= state.dataRoomAirMod->AirflowNetworkSurfaceUCSDCV(0, ZoneNum);
2840 6 : ++state.dataRoomAirModelMgr->i) {
2841 6 : state.dataRoomAirModelMgr->N = state.afn->AirflowNetworkLinkageData(state.dataRoomAirModelMgr->i).CompNum;
2842 6 : if (state.afn->AirflowNetworkCompData(state.dataRoomAirModelMgr->N).CompTypeNum == AirflowNetwork::iComponentTypeNum::DOP) {
2843 24 : SetupOutputVariable(
2844 : state,
2845 : "Room Air Window Jet Region Average Air Velocity",
2846 : OutputProcessor::Unit::m_s,
2847 6 : state.dataRoomAirMod->CVJetRecFlows(state.dataRoomAirModelMgr->i, state.dataRoomAirModelMgr->Loop).Ujet,
2848 : OutputProcessor::SOVTimeStepType::Zone,
2849 : OutputProcessor::SOVStoreType::Average,
2850 12 : state.afn->MultizoneSurfaceData(state.dataRoomAirModelMgr->i).SurfName);
2851 : }
2852 : }
2853 : }
2854 : }
2855 :
2856 7 : state.dataRoomAirModelMgr->MyEnvrnFlag = true;
2857 :
2858 7 : state.dataRoomAirModelMgr->MyOneTimeFlag = false;
2859 : }
2860 :
2861 : // Do the Begin Environment initializations
2862 43671 : if (state.dataGlobal->BeginEnvrnFlag && state.dataRoomAirModelMgr->MyEnvrnFlag(ZoneNum)) {
2863 :
2864 110 : if (state.dataRoomAirMod->IsZoneDV(ZoneNum) || state.dataRoomAirMod->IsZoneUI(ZoneNum)) {
2865 :
2866 78 : state.dataRoomAirMod->MaxTempGrad(ZoneNum) = 0.0;
2867 78 : state.dataRoomAirMod->AvgTempGrad(ZoneNum) = 0.0;
2868 78 : state.dataRoomAirMod->TCMF(ZoneNum) = 23.0;
2869 78 : state.dataRoomAirMod->FracMinFlow(ZoneNum) = 0.0;
2870 78 : state.dataRoomAirMod->ZoneAirSystemON(ZoneNum) = false;
2871 78 : state.dataRoomAirMod->MATFloor(ZoneNum) = 23.0;
2872 78 : state.dataRoomAirMod->XMATFloor(ZoneNum) = 23.0;
2873 78 : state.dataRoomAirMod->XM2TFloor(ZoneNum) = 23.0;
2874 78 : state.dataRoomAirMod->XM3TFloor(ZoneNum) = 23.0;
2875 78 : state.dataRoomAirMod->XM4TFloor(ZoneNum) = 23.0;
2876 78 : state.dataRoomAirMod->DSXMATFloor(ZoneNum) = 23.0;
2877 78 : state.dataRoomAirMod->DSXM2TFloor(ZoneNum) = 23.0;
2878 78 : state.dataRoomAirMod->DSXM3TFloor(ZoneNum) = 23.0;
2879 78 : state.dataRoomAirMod->DSXM4TFloor(ZoneNum) = 23.0;
2880 78 : state.dataRoomAirMod->MATOC(ZoneNum) = 23.0;
2881 78 : state.dataRoomAirMod->XMATOC(ZoneNum) = 23.0;
2882 78 : state.dataRoomAirMod->XM2TOC(ZoneNum) = 23.0;
2883 78 : state.dataRoomAirMod->XM3TOC(ZoneNum) = 23.0;
2884 78 : state.dataRoomAirMod->XM4TOC(ZoneNum) = 23.0;
2885 78 : state.dataRoomAirMod->DSXMATOC(ZoneNum) = 23.0;
2886 78 : state.dataRoomAirMod->DSXM2TOC(ZoneNum) = 23.0;
2887 78 : state.dataRoomAirMod->DSXM3TOC(ZoneNum) = 23.0;
2888 78 : state.dataRoomAirMod->DSXM4TOC(ZoneNum) = 23.0;
2889 78 : state.dataRoomAirMod->MATMX(ZoneNum) = 23.0;
2890 78 : state.dataRoomAirMod->XMATMX(ZoneNum) = 23.0;
2891 78 : state.dataRoomAirMod->XM2TMX(ZoneNum) = 23.0;
2892 78 : state.dataRoomAirMod->XM3TMX(ZoneNum) = 23.0;
2893 78 : state.dataRoomAirMod->XM4TMX(ZoneNum) = 23.0;
2894 78 : state.dataRoomAirMod->DSXMATMX(ZoneNum) = 23.0;
2895 78 : state.dataRoomAirMod->DSXM2TMX(ZoneNum) = 23.0;
2896 78 : state.dataRoomAirMod->DSXM3TMX(ZoneNum) = 23.0;
2897 78 : state.dataRoomAirMod->DSXM4TMX(ZoneNum) = 23.0;
2898 78 : state.dataRoomAirMod->ZTM1Floor(ZoneNum) = 23.0;
2899 78 : state.dataRoomAirMod->ZTM2Floor(ZoneNum) = 23.0;
2900 78 : state.dataRoomAirMod->ZTM3Floor(ZoneNum) = 23.0;
2901 78 : state.dataRoomAirMod->Zone1Floor(ZoneNum) = 23.0;
2902 78 : state.dataRoomAirMod->ZoneMXFloor(ZoneNum) = 23.0;
2903 78 : state.dataRoomAirMod->ZoneM2Floor(ZoneNum) = 23.0;
2904 78 : state.dataRoomAirMod->ZTM1OC(ZoneNum) = 23.0;
2905 78 : state.dataRoomAirMod->ZTM2OC(ZoneNum) = 23.0;
2906 78 : state.dataRoomAirMod->ZTM3OC(ZoneNum) = 23.0;
2907 78 : state.dataRoomAirMod->Zone1OC(ZoneNum) = 23.0;
2908 78 : state.dataRoomAirMod->ZoneMXOC(ZoneNum) = 23.0;
2909 78 : state.dataRoomAirMod->ZoneM2OC(ZoneNum) = 23.0;
2910 78 : state.dataRoomAirMod->ZTM1MX(ZoneNum) = 23.0;
2911 78 : state.dataRoomAirMod->ZTM2MX(ZoneNum) = 23.0;
2912 78 : state.dataRoomAirMod->ZTM3MX(ZoneNum) = 23.0;
2913 78 : state.dataRoomAirMod->Zone1MX(ZoneNum) = 23.0;
2914 78 : state.dataRoomAirMod->ZoneMXMX(ZoneNum) = 23.0;
2915 78 : state.dataRoomAirMod->ZoneM2MX(ZoneNum) = 23.0;
2916 78 : state.dataRoomAirMod->AIRRATFloor(ZoneNum) = 0.0;
2917 78 : state.dataRoomAirMod->AIRRATOC(ZoneNum) = 0.0;
2918 78 : state.dataRoomAirMod->AIRRATMX(ZoneNum) = 0.0;
2919 78 : state.dataRoomAirMod->ZTOC(ZoneNum) = 23.0;
2920 78 : state.dataRoomAirMod->ZTMX(ZoneNum) = 23.0;
2921 78 : state.dataRoomAirMod->ZTFloor(ZoneNum) = 23.0;
2922 78 : state.dataRoomAirMod->HeightTransition(ZoneNum) = 0.0;
2923 78 : state.dataRoomAirMod->Phi(ZoneNum) = 0.0;
2924 78 : state.dataUCSDShared->HCeiling = 0.0;
2925 78 : state.dataUCSDShared->HWall = 0.0;
2926 78 : state.dataUCSDShared->HFloor = 0.0;
2927 78 : state.dataUCSDShared->HInternal = 0.0;
2928 78 : state.dataUCSDShared->HWindow = 0.0;
2929 78 : state.dataUCSDShared->HDoor = 0.0;
2930 : }
2931 :
2932 110 : if (state.dataRoomAirMod->IsZoneDV(ZoneNum)) {
2933 :
2934 28 : state.dataRoomAirMod->DVHcIn = 0.0;
2935 28 : state.dataRoomAirMod->ZoneDVMixedFlagRep(ZoneNum) = 0.0;
2936 28 : state.dataRoomAirMod->ZoneDVMixedFlag(ZoneNum) = 0;
2937 : }
2938 :
2939 110 : if (state.dataRoomAirMod->IsZoneUI(ZoneNum)) {
2940 :
2941 50 : state.dataRoomAirMod->UFHcIn = 0.0;
2942 50 : state.dataRoomAirMod->ZoneUFMixedFlag(ZoneNum) = 0;
2943 50 : state.dataRoomAirMod->ZoneUFMixedFlagRep(ZoneNum) = 0.0;
2944 50 : state.dataRoomAirMod->ZoneUFGamma(ZoneNum) = 0.0;
2945 50 : state.dataRoomAirMod->ZoneUFPowInPlumes(ZoneNum) = 0.0;
2946 50 : state.dataRoomAirMod->ZoneUFPowInPlumesfromWindows(ZoneNum) = 0.0;
2947 : }
2948 :
2949 110 : if (state.dataRoomAirMod->IsZoneCV(ZoneNum)) {
2950 12 : state.dataRoomAirMod->ZTJET(ZoneNum) = 23.0;
2951 12 : state.dataRoomAirMod->RoomOutflowTemp(ZoneNum) = 23.0;
2952 12 : state.dataRoomAirMod->ZTREC(ZoneNum) = 23.0;
2953 12 : state.dataRoomAirMod->CVHcIn = 0.0;
2954 12 : state.dataRoomAirMod->JetRecAreaRatio(ZoneNum) = 0.2;
2955 12 : state.dataRoomAirMod->Urec(ZoneNum) = 0.2;
2956 12 : state.dataRoomAirMod->Ujet(ZoneNum) = 0.2;
2957 12 : state.dataRoomAirMod->Uhc(ZoneNum) = 0.2;
2958 12 : state.dataRoomAirMod->Ain(ZoneNum) = 1.0;
2959 12 : state.dataRoomAirMod->Tin(ZoneNum) = 23.0;
2960 12 : state.dataRoomAirMod->Droom(ZoneNum) = 6.0;
2961 12 : state.dataRoomAirMod->Dstar(ZoneNum) = 6.0;
2962 12 : state.dataRoomAirMod->ZoneCVisMixing(ZoneNum) = 0.0;
2963 12 : state.dataRoomAirMod->Rfr(ZoneNum) = 10.0;
2964 12 : state.dataRoomAirMod->ZoneCVhasREC(ZoneNum) = 1.0;
2965 12 : state.dataUCSDShared->HCeiling = 0.0;
2966 12 : state.dataUCSDShared->HWall = 0.0;
2967 12 : state.dataUCSDShared->HFloor = 0.0;
2968 12 : state.dataUCSDShared->HInternal = 0.0;
2969 12 : state.dataUCSDShared->HWindow = 0.0;
2970 12 : state.dataUCSDShared->HDoor = 0.0;
2971 : }
2972 :
2973 110 : state.dataRoomAirModelMgr->MyEnvrnFlag(ZoneNum) = false;
2974 : } // end one time inits
2975 :
2976 43671 : if (!state.dataGlobal->BeginEnvrnFlag) {
2977 43363 : state.dataRoomAirModelMgr->MyEnvrnFlag(ZoneNum) = true;
2978 : }
2979 43671 : }
2980 :
2981 6 : void GetRAFNNodeNum(EnergyPlusData &state,
2982 : std::string const &RAFNNodeName, // Name of RoomAir:Node:AirflowNetwork
2983 : int &ZoneNum, // The zone number associate with the node name
2984 : int &RAFNNodeNum, // RoomAir:Node:AirflowNetwork Number
2985 : bool &Errorfound // true if an error is found (TODO: Useless, RAFNodeNum is 0 when Errorfound is true)
2986 : )
2987 : {
2988 :
2989 : // FUNCTION INFORMATION:
2990 : // AUTHOR Lixing Gu
2991 : // DATE WRITTEN November 2014
2992 : // MODIFIED na
2993 : // RE-ENGINEERED na
2994 :
2995 : // PURPOSE OF THIS FUNCTION:
2996 : // This function looks up the given RoomAirNode name and returns the Zone number and RoomAir node
2997 : // number. If incorrect name is given, errorsfound is returned as true and value is returned
2998 : // as zero.
2999 :
3000 : // FUNCTION LOCAL VARIABLE DECLARATIONS:
3001 : int I; // Zone index
3002 :
3003 : // Obtains and Allocates RoomAirSettings : AirflowNetwork
3004 6 : if (state.dataRoomAirModelMgr->GetAirModelData) {
3005 1 : GetAirModelDatas(state);
3006 1 : state.dataRoomAirModelMgr->GetAirModelData = false;
3007 : }
3008 :
3009 6 : Errorfound = false;
3010 6 : RAFNNodeNum = 0;
3011 18 : for (I = 1; I <= state.dataGlobal->NumOfZones; ++I) {
3012 18 : if (state.dataRoomAirMod->RoomAirflowNetworkZoneInfo(I).NumOfAirNodes > 0) {
3013 12 : RAFNNodeNum = UtilityRoutines::FindItemInList(RAFNNodeName,
3014 6 : state.dataRoomAirMod->RoomAirflowNetworkZoneInfo(I).Node,
3015 6 : state.dataRoomAirMod->RoomAirflowNetworkZoneInfo(I).NumOfAirNodes);
3016 6 : if (RAFNNodeNum > 0) {
3017 6 : ZoneNum = I;
3018 6 : break;
3019 : }
3020 : }
3021 : }
3022 :
3023 6 : if (RAFNNodeNum == 0) {
3024 0 : Errorfound = true;
3025 0 : ShowSevereError(state, "Could not find RoomAir:Node:AirflowNetwork number with AirflowNetwork:IntraZone:Node Name='" + RAFNNodeName);
3026 : }
3027 6 : }
3028 :
3029 6 : bool CheckEquipName(EnergyPlusData &state,
3030 : std::string const &EquipType, // Equipment type
3031 : std::string const &EquipName, // Equipment Name
3032 : std::string &SupplyNodeName, // Supply node name
3033 : std::string &ReturnNodeName, // Return node name
3034 : int TotNumEquip, // how many of this equipment type
3035 : int TypeNum // equipment type number
3036 : )
3037 : {
3038 :
3039 : // FUNCTION INFORMATION:
3040 : // AUTHOR Lixing Gu
3041 : // DATE WRITTEN March 2014
3042 : // MODIFIED na
3043 : // RE-ENGINEERED na
3044 :
3045 : // PURPOSE OF THIS FUNCTION:
3046 : // This function looks up the given RoomAirNode name and returns the Zone number and RoomAir node
3047 : // number.If incorrect name is given, errorsfound is returned as true and value is returned
3048 : // as zero.
3049 :
3050 : // Using/Aliasing
3051 : using Fans::GetFanOutletNode;
3052 :
3053 : // Return value
3054 : bool EquipFind; // True if an error is found
3055 :
3056 : // FUNCTION LOCAL VARIABLE DECLARATIONS:
3057 : int NumAlphas;
3058 : int NumNumbers;
3059 : int I;
3060 : int Status; // Used in GetObjectItem
3061 6 : int MaxNums = 0; // Maximum number of numeric input fields
3062 6 : int MaxAlphas = 0; // Maximum number of alpha input fields
3063 6 : int TotalArgs = 0; // Total number of alpha and numeric arguments(max) for a
3064 12 : Array1D_string Alphas; // Alpha input items for object
3065 12 : Array1D<Real64> Numbers; // Numeric input items for object
3066 : bool errorfound;
3067 :
3068 6 : NumAlphas = 1;
3069 6 : NumNumbers = 1;
3070 6 : EquipFind = false;
3071 :
3072 6 : SupplyNodeName = "";
3073 :
3074 6 : if (TypeNum == 0) return EquipFind;
3075 :
3076 6 : state.dataInputProcessing->inputProcessor->getObjectDefMaxArgs(state, EquipType, TotalArgs, NumAlphas, NumNumbers);
3077 :
3078 6 : MaxNums = max(MaxNums, NumNumbers);
3079 6 : MaxAlphas = max(MaxAlphas, NumAlphas);
3080 :
3081 6 : if (MaxNums > NumNumbers) {
3082 0 : Numbers.allocate(MaxNums);
3083 0 : Numbers = 0.0;
3084 6 : } else if (!allocated(Numbers)) {
3085 6 : Numbers.allocate(MaxNums);
3086 : }
3087 :
3088 6 : if (MaxAlphas > NumAlphas) {
3089 0 : Alphas.allocate(MaxAlphas);
3090 0 : Alphas = "";
3091 6 : } else if (!allocated(Alphas)) {
3092 6 : Alphas.allocate(NumAlphas);
3093 : }
3094 :
3095 6 : for (I = 1; I <= TotNumEquip; ++I) {
3096 6 : state.dataInputProcessing->inputProcessor->getObjectItem(state, EquipType, I, Alphas, NumAlphas, Numbers, NumNumbers, Status);
3097 6 : if (UtilityRoutines::SameString(Alphas(1), EquipName)) {
3098 6 : EquipFind = true;
3099 6 : break;
3100 : }
3101 : }
3102 :
3103 6 : if (TypeNum == DataHVACGlobals::ZoneEquipTypeOf_VariableRefrigerantFlow) { // ZoneHVAC:TerminalUnit : VariableRefrigerantFlow
3104 0 : SupplyNodeName = Alphas(4);
3105 0 : ReturnNodeName = ""; // Zone return node
3106 6 : } else if (TypeNum == DataHVACGlobals::ZoneEquipTypeOf_EnergyRecoveryVentilator) { // ZoneHVAC : EnergyRecoveryVentilator
3107 0 : I = GetFanOutletNode(state, "Fan:OnOff", Alphas(4), errorfound);
3108 0 : if (errorfound) {
3109 : }
3110 0 : SupplyNodeName = state.dataLoopNodes->NodeID(I); // ?????
3111 0 : ReturnNodeName = ""; // Zone exhaust node
3112 6 : } else if (TypeNum == DataHVACGlobals::ZoneEquipTypeOf_FourPipeFanCoil) { // ZoneHVAC : FourPipeFanCoil
3113 0 : SupplyNodeName = Alphas(6);
3114 0 : ReturnNodeName = Alphas(5);
3115 6 : } else if (TypeNum == DataHVACGlobals::ZoneEquipTypeOf_OutdoorAirUnit) { // ZoneHVAC : OutdoorAirUnit
3116 0 : SupplyNodeName = Alphas(13);
3117 0 : ReturnNodeName = Alphas(14);
3118 6 : } else if (TypeNum == DataHVACGlobals::ZoneEquipTypeOf_PackagedTerminalAirConditioner) { // ZoneHVAC : PackagedTerminalAirConditioner
3119 6 : SupplyNodeName = Alphas(4);
3120 6 : ReturnNodeName = Alphas(3);
3121 0 : } else if (TypeNum == DataHVACGlobals::ZoneEquipTypeOf_PackagedTerminalHeatPump) { // ZoneHVAC : PackagedTerminalHeatPump
3122 0 : SupplyNodeName = Alphas(4);
3123 0 : ReturnNodeName = Alphas(3);
3124 0 : } else if (TypeNum == DataHVACGlobals::ZoneEquipTypeOf_UnitHeater) { // ZoneHVAC : UnitHeater
3125 0 : SupplyNodeName = Alphas(4);
3126 0 : ReturnNodeName = Alphas(3);
3127 0 : } else if (TypeNum == DataHVACGlobals::ZoneEquipTypeOf_UnitVentilator) { // ZoneHVAC : UnitVentilator
3128 0 : SupplyNodeName = Alphas(7);
3129 0 : ReturnNodeName = Alphas(6);
3130 0 : } else if (TypeNum == DataHVACGlobals::ZoneEquipTypeOf_VentilatedSlab) { // ZoneHVAC : VentilatedSlab
3131 0 : SupplyNodeName = Alphas(20);
3132 0 : ReturnNodeName = Alphas(18);
3133 0 : } else if (TypeNum == DataHVACGlobals::ZoneEquipTypeOf_WaterToAirHeatPump) { // ZoneHVAC : WaterToAirHeatPump
3134 0 : SupplyNodeName = Alphas(4);
3135 0 : ReturnNodeName = Alphas(3);
3136 0 : } else if (TypeNum == DataHVACGlobals::ZoneEquipTypeOf_WindowAirConditioner) { // ZoneHVAC : WindowAirConditioner
3137 0 : SupplyNodeName = Alphas(4);
3138 0 : ReturnNodeName = Alphas(3);
3139 0 : } else if (TypeNum ==
3140 : DataHVACGlobals::ZoneEquipTypeOf_BaseboardRadiantConvectiveElectric) { // ZoneHVAC : Baseboard : RadiantConvective : Electric
3141 0 : SupplyNodeName = ""; // convection only
3142 0 : } else if (TypeNum == DataHVACGlobals::ZoneEquipTypeOf_BaseboardRadiantConvectiveWater) { // ZoneHVAC : Baseboard : RadiantConvective : Water
3143 0 : SupplyNodeName = "";
3144 0 : } else if (TypeNum == DataHVACGlobals::ZoneEquipTypeOf_BaseboardRadiantConvectiveSteam) { // ZoneHVAC : Baseboard : RadiantConvective : Steam
3145 0 : SupplyNodeName = "";
3146 0 : } else if (TypeNum == DataHVACGlobals::ZoneEquipTypeOf_BaseboardConvectiveElectric) { // ZoneHVAC : Baseboard : Convective : Electric
3147 0 : SupplyNodeName = "";
3148 0 : } else if (TypeNum == DataHVACGlobals::ZoneEquipTypeOf_BaseboardConvectiveWater) { // ZoneHVAC : Baseboard : Convective : Water
3149 0 : SupplyNodeName = "";
3150 0 : } else if (TypeNum == DataHVACGlobals::ZoneEquipTypeOf_HighTemperatureRadiant) { // ZoneHVAC : HighTemperatureRadiant
3151 0 : SupplyNodeName = "";
3152 0 : } else if (TypeNum == DataHVACGlobals::ZoneEquipTypeOf_DehumidifierDX) { // ZoneHVAC : Dehumidifier : DX
3153 0 : SupplyNodeName = Alphas(4);
3154 0 : ReturnNodeName = Alphas(3);
3155 0 : } else if (TypeNum == DataHVACGlobals::ZoneEquipTypeOf_IdealLoadsAirSystem) { // ZoneHVAC : IdealLoadsAirSystem
3156 0 : SupplyNodeName = Alphas(3);
3157 0 : ReturnNodeName = Alphas(4);
3158 0 : } else if (TypeNum == DataHVACGlobals::ZoneEquipTypeOf_RefrigerationChillerSet) { // ZoneHVAC : RefrigerationChillerSet
3159 0 : SupplyNodeName = Alphas(5);
3160 0 : ReturnNodeName = Alphas(4);
3161 0 : } else if (TypeNum == DataHVACGlobals::ZoneEquipTypeOf_HybridUnitaryAirConditioners) { // ZoneHVAC : HybridUnitaryAirConditioners
3162 0 : SupplyNodeName = Alphas(11);
3163 0 : ReturnNodeName = Alphas(9);
3164 0 : } else if (TypeNum == DataHVACGlobals::ZoneEquipTypeOf_FanZoneExhaust) { // Fan : ZoneExhaust
3165 0 : SupplyNodeName = ""; // ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? May not use
3166 0 : } else if (TypeNum == DataHVACGlobals::ZoneEquipTypeOf_WaterHeaterHeatPump) { // WaterHeater : HeatPump
3167 0 : SupplyNodeName = Alphas(8);
3168 0 : ReturnNodeName = Alphas(7);
3169 : // For AirTerminals, find matching return node later
3170 0 : } else if (TypeNum == DataHVACGlobals::ZoneEquipTypeOf_AirTerminalDualDuctConstantVolume) { // AirTerminal : DualDuct : ConstantVolume
3171 0 : SupplyNodeName = Alphas(1);
3172 0 : ReturnNodeName = "";
3173 0 : } else if (TypeNum == DataHVACGlobals::ZoneEquipTypeOf_AirTerminalDualDuctVAV) { // AirTerminal : DualDuct : VAV
3174 0 : SupplyNodeName = Alphas(1);
3175 0 : ReturnNodeName = "";
3176 0 : } else if (TypeNum ==
3177 : DataHVACGlobals::ZoneEquipTypeOf_AirTerminalSingleDuctConstantVolumeReheat) { // AirTerminal : SingleDuct : ConstantVolume : Reheat
3178 0 : SupplyNodeName = Alphas(1);
3179 0 : ReturnNodeName = "";
3180 0 : } else if (TypeNum == DataHVACGlobals::ZoneEquipTypeOf_AirTerminalSingleDuctConstantVolumeNoReheat) { // AirTerminal : SingleDuct :
3181 : // ConstantVolume : NoReheat
3182 0 : SupplyNodeName = Alphas(4);
3183 0 : ReturnNodeName = "";
3184 0 : } else if (TypeNum == DataHVACGlobals::ZoneEquipTypeOf_AirTerminalSingleDuctVAVReheat) { // AirTerminal : SingleDuct : VAV : Reheat
3185 0 : SupplyNodeName = Alphas(1);
3186 0 : ReturnNodeName = "";
3187 0 : } else if (TypeNum == DataHVACGlobals::ZoneEquipTypeOf_AirTerminalSingleDuctVAVNoReheat) { // AirTerminal : SingleDuct : VAV : NoReheat
3188 0 : SupplyNodeName = Alphas(1);
3189 0 : ReturnNodeName = "";
3190 0 : } else if (TypeNum ==
3191 : DataHVACGlobals::ZoneEquipTypeOf_AirTerminalSingleDuctSeriesPIUReheat) { // AirTerminal : SingleDuct : SeriesPIU : Reheat
3192 0 : SupplyNodeName = Alphas(1);
3193 0 : ReturnNodeName = "";
3194 0 : } else if (TypeNum ==
3195 : DataHVACGlobals::ZoneEquipTypeOf_AirTerminalSingleDuctParallelPIUReheat) { // AirTerminal : SingleDuct : ParallelPIU : Reheat
3196 0 : SupplyNodeName = Alphas(1);
3197 0 : ReturnNodeName = "";
3198 0 : } else if (TypeNum == DataHVACGlobals::ZoneEquipTypeOf_AirTerminalSingleDuctCAVFourPipeInduction) { // AirTerminal : SingleDuct :
3199 : // ConstantVolume : FourPipeInduction
3200 0 : SupplyNodeName = Alphas(1);
3201 0 : ReturnNodeName = "";
3202 0 : } else if (TypeNum == DataHVACGlobals::ZoneEquipTypeOf_AirTerminalSingleDuctVAVReheatVariableSpeedFan) { // AirTerminal : SingleDuct : VAV
3203 : // : Reheat : VariableSpeedFan
3204 0 : SupplyNodeName = Alphas(1);
3205 0 : ReturnNodeName = "";
3206 0 : } else if (TypeNum == DataHVACGlobals::ZoneEquipTypeOf_AirTerminalSingleDuctVAVHeatAndCoolReheat) { // AirTerminal : SingleDuct : VAV :
3207 : // HeatAndCool : Reheat
3208 0 : SupplyNodeName = Alphas(1);
3209 0 : ReturnNodeName = "";
3210 0 : } else if (TypeNum == DataHVACGlobals::ZoneEquipTypeOf_AirTerminalSingleDuctVAVHeatAndCoolNoReheat) { // AirTerminal : SingleDuct : VAV :
3211 : // HeatAndCool : NoReheat
3212 0 : SupplyNodeName = Alphas(1);
3213 0 : ReturnNodeName = "";
3214 0 : } else if (TypeNum == DataHVACGlobals::ZoneEquipTypeOf_AirTerminalSingleDuctConstantVolumeCooledBeam) { // AirTerminal : SingleDuct :
3215 : // ConstantVolume : CooledBeam
3216 0 : SupplyNodeName = Alphas(5);
3217 0 : ReturnNodeName = "";
3218 0 : } else if (TypeNum == DataHVACGlobals::ZoneEquipTypeOf_AirTerminalDualDuctVAVOutdoorAir) { // AirTerminal : DualDuct : VAV : OutdoorAir
3219 0 : SupplyNodeName = Alphas(3);
3220 0 : ReturnNodeName = "";
3221 0 : } else if (TypeNum == DataHVACGlobals::ZoneEquipTypeOf_AirLoopHVACReturnAir) { // AirLoopHVACReturnAir
3222 0 : SupplyNodeName = Alphas(4); //
3223 0 : ReturnNodeName = ""; //
3224 : }
3225 :
3226 : // Need to find a better to handle allocate and deallocate
3227 6 : if (MaxAlphas > NumAlphas) {
3228 6 : Alphas.deallocate();
3229 : }
3230 6 : if (MaxNums > NumNumbers) {
3231 6 : Numbers.deallocate();
3232 : }
3233 :
3234 6 : return EquipFind;
3235 : }
3236 :
3237 : //*****************************************************************************************
3238 :
3239 : } // namespace RoomAirModelManager
3240 :
3241 2313 : } // namespace EnergyPlus
|
