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 <cmath>
50 :
51 : // ObjexxFCL Headers
52 : #include <ObjexxFCL/Array1D.hh>
53 : #include <ObjexxFCL/Fmath.hh>
54 : #include <ObjexxFCL/member.functions.hh>
55 :
56 : // EnergyPlus Headers
57 : #include <EnergyPlus/Autosizing/Base.hh>
58 : #include <EnergyPlus/ConvectionCoefficients.hh>
59 : #include <EnergyPlus/Data/EnergyPlusData.hh>
60 : #include <EnergyPlus/DataEnvironment.hh>
61 : #include <EnergyPlus/DataHVACGlobals.hh>
62 : #include <EnergyPlus/DataHeatBalFanSys.hh>
63 : #include <EnergyPlus/DataHeatBalSurface.hh>
64 : #include <EnergyPlus/DataHeatBalance.hh>
65 : #include <EnergyPlus/DataLoopNode.hh>
66 : #include <EnergyPlus/DataRoomAirModel.hh>
67 : #include <EnergyPlus/DataSizing.hh>
68 : #include <EnergyPlus/DataSurfaces.hh>
69 : #include <EnergyPlus/DataUCSDSharedData.hh>
70 : #include <EnergyPlus/DataZoneEquipment.hh>
71 : #include <EnergyPlus/General.hh>
72 : #include <EnergyPlus/InternalHeatGains.hh>
73 : #include <EnergyPlus/Psychrometrics.hh>
74 : #include <EnergyPlus/UFADManager.hh>
75 : #include <EnergyPlus/UtilityRoutines.hh>
76 : #include <EnergyPlus/ZoneTempPredictorCorrector.hh>
77 :
78 : namespace EnergyPlus::UFADManager {
79 :
80 : // Module containing the routines dealing with the UnderFloor Air
81 : // Distribution zone model
82 :
83 : // MODULE INFORMATION:
84 : // AUTHOR Fred Buhl
85 : // DATE WRITTEN August 2005
86 : // MODIFIED na
87 : // RE-ENGINEERED na
88 :
89 : // PURPOSE OF THIS MODULE:
90 : // Encapsulate the routines that do the simulation of the UCSD UFAD non-uniform
91 : // zone models
92 :
93 : // METHODOLOGY EMPLOYED:
94 : // 2-node zone model with the node heights varying as a function of internal loads
95 : // and supply air flow (and other factors)
96 :
97 : // REFERENCES:
98 : // See the EnergyPlus Engineering Reference and the PhD thesis of Anna Liu, UC San Diego
99 :
100 : // OTHER NOTES:
101 : // na
102 :
103 : // Using/Aliasing
104 : using namespace DataLoopNode;
105 : using namespace DataEnvironment;
106 : using namespace DataHeatBalance;
107 : using namespace DataHeatBalSurface;
108 : using namespace DataSurfaces;
109 : using namespace DataRoomAirModel;
110 : using ConvectionCoefficients::CalcDetailedHcInForDVModel;
111 :
112 17580 : void ManageUCSDUFModels(EnergyPlusData &state,
113 : int const ZoneNum, // index number for the specified zone
114 : DataRoomAirModel::RoomAirModel const ZoneModelType // type of zone model; UCSDUFI = 6
115 : )
116 : {
117 :
118 : // SUBROUTINE INFORMATION:
119 : // AUTHOR Fred Buhl
120 : // DATE WRITTEN August, 2005
121 : // MODIFIED na
122 : // RE-ENGINEERED na
123 :
124 : // PURPOSE OF THIS SUBROUTINE:
125 : // Manages the simulation of the 2-node nonuniform zone models for underfloor air
126 : // distribution systems (UFAD). Called from RoomAirManager, ManageAirModel
127 :
128 : // METHODOLOGY EMPLOYED:
129 : // uses Init and Calc routines in the standard EPlus manner to manage the calculation
130 : // Note that much of the initialization is done in RoomAirManager, SharedDVCVUFDataInit
131 :
132 : // Using/Aliasing
133 : using namespace DataLoopNode;
134 : using namespace DataEnvironment;
135 : using namespace DataHeatBalance;
136 : using namespace DataHeatBalSurface;
137 : using namespace DataSurfaces;
138 : using namespace DataRoomAirModel;
139 : using ConvectionCoefficients::CalcDetailedHcInForDVModel;
140 :
141 : // input was obtained in RoomAirManager, GetUFADIntZoneData
142 :
143 17580 : InitUCSDUF(state, ZoneNum, ZoneModelType); // initialize some module variables
144 :
145 17580 : switch (ZoneModelType) {
146 3516 : case DataRoomAirModel::RoomAirModel::UCSDUFI: { // UCSD UFAD interior zone model
147 : // simulate room airflow using the UCSDUFI model
148 3516 : CalcUCSDUI(state, ZoneNum);
149 3516 : } break;
150 14064 : case DataRoomAirModel::RoomAirModel::UCSDUFE: { // UCSD UFAD interior zone model
151 : // simulate room airflow using the UCSDUFI model
152 14064 : CalcUCSDUE(state, ZoneNum);
153 14064 : } break;
154 0 : default:
155 0 : break;
156 : }
157 17580 : }
158 :
159 17580 : void InitUCSDUF(EnergyPlusData &state,
160 : int const ZoneNum,
161 : DataRoomAirModel::RoomAirModel const ZoneModelType // type of zone model; UCSDUFI = 6
162 : )
163 : {
164 :
165 : // SUBROUTINE INFORMATION:
166 : // AUTHOR Fred Buhl
167 : // DATE WRITTEN August 2005
168 : // MODIFIED na
169 : // RE-ENGINEERED na
170 :
171 : // PURPOSE OF THIS SUBROUTINE:
172 : // initialize arrays & variables used by the UCSD UFAD zone models
173 :
174 : // METHODOLOGY EMPLOYED:
175 : // Note that much of the initialization is done in RoomAirManager, SharedDVCVUFDataInit
176 :
177 17580 : Real64 NumShadesDown(0.0);
178 : int UINum; // index to underfloor interior zone model data
179 :
180 : // Do the one time initializations
181 17580 : if (state.dataUFADManager->MyOneTimeFlag) {
182 1 : state.dataUFADManager->HeightFloorSubzoneTop = 0.2;
183 1 : state.dataUFADManager->ThickOccupiedSubzoneMin = 0.2;
184 1 : state.dataUFADManager->HeightIntMassDefault = 2.0;
185 1 : state.dataUFADManager->MyOneTimeFlag = false;
186 1 : state.dataUFADManager->MySizeFlag.dimension(state.dataGlobal->NumOfZones, true);
187 : }
188 :
189 17580 : if (state.dataUFADManager->MySizeFlag(ZoneNum)) {
190 5 : SizeUCSDUF(state, ZoneNum, ZoneModelType);
191 5 : state.dataUFADManager->MySizeFlag(ZoneNum) = false;
192 : }
193 :
194 : // initialize these variables every timestep
195 :
196 17580 : state.dataUFADManager->HeightIntMass = state.dataUFADManager->HeightIntMassDefault;
197 17580 : state.dataRoomAirMod->ZoneUFGamma(ZoneNum) = 0.0;
198 17580 : state.dataRoomAirMod->ZoneUFPowInPlumes(ZoneNum) = 0.0;
199 17580 : NumShadesDown = 0.0;
200 38676 : for (int Ctd = state.dataUCSDShared->PosZ_Window((ZoneNum - 1) * 2 + 1); Ctd <= state.dataUCSDShared->PosZ_Window((ZoneNum - 1) * 2 + 2); ++Ctd) {
201 21096 : int SurfNum = state.dataUCSDShared->APos_Window(Ctd);
202 21096 : if (SurfNum == 0) continue;
203 42192 : if (state.dataSurface->Surface(SurfNum).ExtBoundCond == ExternalEnvironment ||
204 0 : state.dataSurface->Surface(SurfNum).ExtBoundCond == OtherSideCoefNoCalcExt ||
205 21096 : state.dataSurface->Surface(SurfNum).ExtBoundCond == OtherSideCoefCalcExt ||
206 0 : state.dataSurface->Surface(SurfNum).ExtBoundCond == OtherSideCondModeledExt) {
207 21096 : if (ANY_INTERIOR_SHADE_BLIND(state.dataSurface->SurfWinShadingFlag(SurfNum))) {
208 0 : ++NumShadesDown;
209 : }
210 : }
211 : }
212 17580 : if (ZoneModelType == DataRoomAirModel::RoomAirModel::UCSDUFE) {
213 14064 : UINum = state.dataRoomAirMod->ZoneUFPtr(ZoneNum);
214 14064 : if (state.dataRoomAirMod->ZoneUCSDUE(UINum).NumExtWin > 1.0) {
215 7032 : if (NumShadesDown / state.dataRoomAirMod->ZoneUCSDUE(UINum).NumExtWin >= 0.5) {
216 0 : state.dataRoomAirMod->ZoneUCSDUE(UINum).ShadeDown = true;
217 : } else {
218 7032 : state.dataRoomAirMod->ZoneUCSDUE(UINum).ShadeDown = false;
219 : }
220 : } else {
221 7032 : state.dataRoomAirMod->ZoneUCSDUE(UINum).ShadeDown = false;
222 : }
223 : }
224 17580 : }
225 :
226 5 : void SizeUCSDUF(EnergyPlusData &state,
227 : int const ZoneNum,
228 : DataRoomAirModel::RoomAirModel const ZoneModelType // type of zone model; UCSDUFI = 6
229 : )
230 : {
231 :
232 : // SUBROUTINE INFORMATION:
233 : // AUTHOR Fred Buhl
234 : // DATE WRITTEN August 2005
235 : // MODIFIED na
236 : // RE-ENGINEERED na
237 :
238 : // PURPOSE OF THIS SUBROUTINE:
239 : // set some smart defaults for UFAD systems
240 :
241 : // METHODOLOGY EMPLOYED:
242 : // use data from Center for Built Environment
243 :
244 : using DataSizing::AutoSize;
245 :
246 : int UINum; // index to underfloor interior zone model data
247 5 : Real64 NumberOfOccupants(0.0); // design number of occupants in the zone
248 5 : Real64 NumberOfPlumes(0.0); // design number of plumes in the zone
249 5 : Real64 ZoneElecConv(0.0); // zone elec equip design convective gain [W]
250 5 : Real64 ZoneGasConv(0.0); // zone gas equip design convective gain [W]
251 5 : Real64 ZoneOthEqConv(0.0); // zone other equip design convective gain [W]
252 5 : Real64 ZoneHWEqConv(0.0); // zone hot water equip design convective gain [W]
253 5 : Real64 ZoneSteamEqConv(0.0); // zone steam equip design convective gain [W]
254 :
255 5 : if (ZoneModelType == DataRoomAirModel::RoomAirModel::UCSDUFI) {
256 1 : UINum = state.dataRoomAirMod->ZoneUFPtr(ZoneNum);
257 1 : NumberOfOccupants = 0.0;
258 6 : for (int Ctd = 1; Ctd <= state.dataHeatBal->TotPeople; ++Ctd) {
259 5 : if (state.dataHeatBal->People(Ctd).ZonePtr == ZoneNum) {
260 1 : NumberOfOccupants += state.dataHeatBal->People(Ctd).NumberOfPeople;
261 : }
262 : }
263 1 : if (state.dataRoomAirMod->ZoneUCSDUI(UINum).DiffArea == AutoSize) {
264 1 : if (state.dataRoomAirMod->ZoneUCSDUI(UINum).DiffuserType == Diffuser::Swirl) {
265 1 : state.dataRoomAirMod->ZoneUCSDUI(UINum).DiffArea = 0.0075;
266 0 : } else if (state.dataRoomAirMod->ZoneUCSDUI(UINum).DiffuserType == Diffuser::VarArea) {
267 0 : state.dataRoomAirMod->ZoneUCSDUI(UINum).DiffArea = 0.035;
268 0 : } else if (state.dataRoomAirMod->ZoneUCSDUI(UINum).DiffuserType == Diffuser::DisplVent) {
269 0 : state.dataRoomAirMod->ZoneUCSDUI(UINum).DiffArea = 0.0060;
270 0 : } else if (state.dataRoomAirMod->ZoneUCSDUI(UINum).DiffuserType == Diffuser::LinBarGrille) {
271 : // 4 ft x 4 inches; 75 cfm per linear foot; area is .025 m2/m
272 0 : state.dataRoomAirMod->ZoneUCSDUI(UINum).DiffArea = 0.03;
273 : } else {
274 0 : state.dataRoomAirMod->ZoneUCSDUI(UINum).DiffArea = 0.0075;
275 : }
276 4 : BaseSizer::reportSizerOutput(state,
277 : "RoomAirSettings:UnderFloorAirDistributionInterior",
278 1 : state.dataRoomAirMod->ZoneUCSDUI(UINum).ZoneName,
279 : "Design effective area of diffuser",
280 3 : state.dataRoomAirMod->ZoneUCSDUI(UINum).DiffArea);
281 : }
282 1 : if (state.dataRoomAirMod->ZoneUCSDUI(UINum).DiffAngle == AutoSize) {
283 1 : if (state.dataRoomAirMod->ZoneUCSDUI(UINum).DiffuserType == Diffuser::Swirl) {
284 1 : state.dataRoomAirMod->ZoneUCSDUI(UINum).DiffAngle = 28.0;
285 0 : } else if (state.dataRoomAirMod->ZoneUCSDUI(UINum).DiffuserType == Diffuser::VarArea) {
286 0 : state.dataRoomAirMod->ZoneUCSDUI(UINum).DiffAngle = 45.0;
287 0 : } else if (state.dataRoomAirMod->ZoneUCSDUI(UINum).DiffuserType == Diffuser::DisplVent) {
288 0 : state.dataRoomAirMod->ZoneUCSDUI(UINum).DiffAngle = 73.0;
289 0 : } else if (state.dataRoomAirMod->ZoneUCSDUI(UINum).DiffuserType == Diffuser::LinBarGrille) {
290 0 : state.dataRoomAirMod->ZoneUCSDUI(UINum).DiffAngle = 15.0;
291 : } else {
292 0 : state.dataRoomAirMod->ZoneUCSDUI(UINum).DiffAngle = 28.0;
293 : }
294 4 : BaseSizer::reportSizerOutput(state,
295 : "RoomAirSettings:UnderFloorAirDistributionInterior",
296 1 : state.dataRoomAirMod->ZoneUCSDUI(UINum).ZoneName,
297 : "Angle between diffuser slots and the vertical",
298 3 : state.dataRoomAirMod->ZoneUCSDUI(UINum).DiffAngle);
299 : }
300 1 : if (state.dataRoomAirMod->ZoneUCSDUI(UINum).TransHeight == AutoSize) {
301 0 : state.dataRoomAirMod->ZoneUCSDUI(UINum).CalcTransHeight = true;
302 0 : state.dataRoomAirMod->ZoneUCSDUI(UINum).TransHeight = 0.0;
303 : } else {
304 1 : state.dataRoomAirMod->ZoneUCSDUI(UINum).CalcTransHeight = false;
305 : }
306 1 : if (state.dataRoomAirMod->ZoneUCSDUI(UINum).DiffuserType == Diffuser::Swirl) {
307 3 : if (state.dataRoomAirMod->ZoneUCSDUI(UINum).A_Kc != DataGlobalConstants::AutoCalculate ||
308 2 : state.dataRoomAirMod->ZoneUCSDUI(UINum).B_Kc != DataGlobalConstants::AutoCalculate ||
309 2 : state.dataRoomAirMod->ZoneUCSDUI(UINum).C_Kc != DataGlobalConstants::AutoCalculate ||
310 3 : state.dataRoomAirMod->ZoneUCSDUI(UINum).D_Kc != DataGlobalConstants::AutoCalculate ||
311 1 : state.dataRoomAirMod->ZoneUCSDUI(UINum).E_Kc != DataGlobalConstants::AutoCalculate) {
312 0 : ShowWarningError(state,
313 0 : "For RoomAirSettings:UnderFloorAirDistributionInterior for Zone " +
314 0 : state.dataRoomAirMod->ZoneUCSDUI(UINum).ZoneName +
315 : ", input for Coefficients A - E will be ignored when Floor Diffuser Type = Swirl.");
316 0 : ShowContinueError(state, " To input these Coefficients, use Floor Diffuser Type = Custom.");
317 : }
318 1 : state.dataRoomAirMod->ZoneUCSDUI(UINum).A_Kc = 0.0;
319 1 : state.dataRoomAirMod->ZoneUCSDUI(UINum).B_Kc = 0.0;
320 1 : state.dataRoomAirMod->ZoneUCSDUI(UINum).C_Kc = 0.6531;
321 1 : state.dataRoomAirMod->ZoneUCSDUI(UINum).D_Kc = 0.0069;
322 1 : state.dataRoomAirMod->ZoneUCSDUI(UINum).E_Kc = -0.00004;
323 0 : } else if (state.dataRoomAirMod->ZoneUCSDUI(UINum).DiffuserType == Diffuser::VarArea) {
324 0 : if (state.dataRoomAirMod->ZoneUCSDUI(UINum).A_Kc != DataGlobalConstants::AutoCalculate ||
325 0 : state.dataRoomAirMod->ZoneUCSDUI(UINum).B_Kc != DataGlobalConstants::AutoCalculate ||
326 0 : state.dataRoomAirMod->ZoneUCSDUI(UINum).C_Kc != DataGlobalConstants::AutoCalculate ||
327 0 : state.dataRoomAirMod->ZoneUCSDUI(UINum).D_Kc != DataGlobalConstants::AutoCalculate ||
328 0 : state.dataRoomAirMod->ZoneUCSDUI(UINum).E_Kc != DataGlobalConstants::AutoCalculate) {
329 0 : ShowWarningError(state,
330 0 : "For RoomAirSettings:UnderFloorAirDistributionInterior for Zone " +
331 0 : state.dataRoomAirMod->ZoneUCSDUI(UINum).ZoneName +
332 : ", input for Coefficients A - E will be ignored when Floor Diffuser Type = VariableArea.");
333 0 : ShowContinueError(state, " To input these Coefficients, use Floor Diffuser Type = Custom.");
334 : }
335 0 : state.dataRoomAirMod->ZoneUCSDUI(UINum).A_Kc = 0.0;
336 0 : state.dataRoomAirMod->ZoneUCSDUI(UINum).B_Kc = 0.0;
337 0 : state.dataRoomAirMod->ZoneUCSDUI(UINum).C_Kc = 0.88;
338 0 : state.dataRoomAirMod->ZoneUCSDUI(UINum).D_Kc = 0.0;
339 0 : state.dataRoomAirMod->ZoneUCSDUI(UINum).E_Kc = 0.0;
340 0 : } else if (state.dataRoomAirMod->ZoneUCSDUI(UINum).DiffuserType == Diffuser::DisplVent) {
341 0 : if (state.dataRoomAirMod->ZoneUCSDUI(UINum).A_Kc != DataGlobalConstants::AutoCalculate ||
342 0 : state.dataRoomAirMod->ZoneUCSDUI(UINum).B_Kc != DataGlobalConstants::AutoCalculate ||
343 0 : state.dataRoomAirMod->ZoneUCSDUI(UINum).C_Kc != DataGlobalConstants::AutoCalculate ||
344 0 : state.dataRoomAirMod->ZoneUCSDUI(UINum).D_Kc != DataGlobalConstants::AutoCalculate ||
345 0 : state.dataRoomAirMod->ZoneUCSDUI(UINum).E_Kc != DataGlobalConstants::AutoCalculate) {
346 0 : ShowWarningError(state,
347 0 : "For RoomAirSettings:UnderFloorAirDistributionInterior for Zone " +
348 0 : state.dataRoomAirMod->ZoneUCSDUI(UINum).ZoneName +
349 : ", input for Coefficients A - E will be ignored when Floor Diffuser Type = HorizontalDisplacement.");
350 0 : ShowContinueError(state, " To input these Coefficients, use Floor Diffuser Type = Custom.");
351 : }
352 0 : state.dataRoomAirMod->ZoneUCSDUI(UINum).A_Kc = 0.0;
353 0 : state.dataRoomAirMod->ZoneUCSDUI(UINum).B_Kc = 0.0;
354 0 : state.dataRoomAirMod->ZoneUCSDUI(UINum).C_Kc = 0.67;
355 0 : state.dataRoomAirMod->ZoneUCSDUI(UINum).D_Kc = 0.0;
356 0 : state.dataRoomAirMod->ZoneUCSDUI(UINum).E_Kc = 0.0;
357 0 : } else if (state.dataRoomAirMod->ZoneUCSDUI(UINum).DiffuserType == Diffuser::LinBarGrille) {
358 0 : if (state.dataRoomAirMod->ZoneUCSDUI(UINum).A_Kc != DataGlobalConstants::AutoCalculate ||
359 0 : state.dataRoomAirMod->ZoneUCSDUI(UINum).B_Kc != DataGlobalConstants::AutoCalculate ||
360 0 : state.dataRoomAirMod->ZoneUCSDUI(UINum).C_Kc != DataGlobalConstants::AutoCalculate ||
361 0 : state.dataRoomAirMod->ZoneUCSDUI(UINum).D_Kc != DataGlobalConstants::AutoCalculate ||
362 0 : state.dataRoomAirMod->ZoneUCSDUI(UINum).E_Kc != DataGlobalConstants::AutoCalculate) {
363 0 : ShowWarningError(state,
364 0 : "For RoomAirSettings:UnderFloorAirDistributionInterior for Zone " +
365 0 : state.dataRoomAirMod->ZoneUCSDUI(UINum).ZoneName +
366 : ", input for Coefficients A - E will be ignored when Floor Diffuser Type = LinearBarGrille.");
367 0 : ShowContinueError(state, " To input these Coefficients, use Floor Diffuser Type = Custom.");
368 : }
369 0 : state.dataRoomAirMod->ZoneUCSDUI(UINum).A_Kc = 0.0;
370 0 : state.dataRoomAirMod->ZoneUCSDUI(UINum).B_Kc = 0.0;
371 0 : state.dataRoomAirMod->ZoneUCSDUI(UINum).C_Kc = 0.8;
372 0 : state.dataRoomAirMod->ZoneUCSDUI(UINum).D_Kc = 0.0;
373 0 : state.dataRoomAirMod->ZoneUCSDUI(UINum).E_Kc = 0.0;
374 : } else {
375 0 : if (state.dataRoomAirMod->ZoneUCSDUI(UINum).A_Kc == DataGlobalConstants::AutoCalculate ||
376 0 : state.dataRoomAirMod->ZoneUCSDUI(UINum).B_Kc == DataGlobalConstants::AutoCalculate ||
377 0 : state.dataRoomAirMod->ZoneUCSDUI(UINum).C_Kc == DataGlobalConstants::AutoCalculate ||
378 0 : state.dataRoomAirMod->ZoneUCSDUI(UINum).D_Kc == DataGlobalConstants::AutoCalculate ||
379 0 : state.dataRoomAirMod->ZoneUCSDUI(UINum).E_Kc == DataGlobalConstants::AutoCalculate) {
380 0 : ShowFatalError(state,
381 0 : "For RoomAirSettings:UnderFloorAirDistributionInterior for Zone " + state.dataRoomAirMod->ZoneUCSDUI(UINum).ZoneName +
382 : ", input for Coefficients A - E must be specified when Floor Diffuser Type = Custom.");
383 : }
384 : }
385 1 : if (state.dataRoomAirMod->ZoneUCSDUI(UINum).PowerPerPlume == DataGlobalConstants::AutoCalculate) {
386 1 : NumberOfPlumes = 0.0;
387 1 : if (NumberOfOccupants > 0.0) {
388 1 : NumberOfPlumes = NumberOfOccupants;
389 : } else {
390 0 : NumberOfPlumes = 1.0;
391 : }
392 1 : ZoneElecConv = 0.0;
393 6 : for (int Ctd = 1; Ctd <= state.dataHeatBal->TotElecEquip; ++Ctd) {
394 5 : if (state.dataHeatBal->ZoneElectric(Ctd).ZonePtr == ZoneNum) {
395 1 : ZoneElecConv += state.dataHeatBal->ZoneElectric(Ctd).DesignLevel * state.dataHeatBal->ZoneElectric(Ctd).FractionConvected;
396 : }
397 : }
398 1 : ZoneGasConv = 0.0;
399 1 : for (int Ctd = 1; Ctd <= state.dataHeatBal->TotGasEquip; ++Ctd) {
400 0 : if (state.dataHeatBal->ZoneGas(Ctd).ZonePtr == ZoneNum) {
401 0 : ZoneGasConv += state.dataHeatBal->ZoneGas(Ctd).DesignLevel * state.dataHeatBal->ZoneGas(Ctd).FractionConvected;
402 : }
403 : }
404 1 : ZoneOthEqConv = 0.0;
405 1 : for (int Ctd = 1; Ctd <= state.dataHeatBal->TotOthEquip; ++Ctd) {
406 0 : if (state.dataHeatBal->ZoneOtherEq(Ctd).ZonePtr == ZoneNum) {
407 0 : ZoneOthEqConv += state.dataHeatBal->ZoneOtherEq(Ctd).DesignLevel * state.dataHeatBal->ZoneOtherEq(Ctd).FractionConvected;
408 : }
409 : }
410 1 : ZoneHWEqConv = 0.0;
411 1 : for (int Ctd = 1; Ctd <= state.dataHeatBal->TotHWEquip; ++Ctd) {
412 0 : if (state.dataHeatBal->ZoneHWEq(Ctd).ZonePtr == ZoneNum) {
413 0 : ZoneHWEqConv += state.dataHeatBal->ZoneHWEq(Ctd).DesignLevel * state.dataHeatBal->ZoneHWEq(Ctd).FractionConvected;
414 : }
415 : }
416 1 : for (int Ctd = 1; Ctd <= state.dataHeatBal->TotStmEquip; ++Ctd) {
417 0 : ZoneSteamEqConv = 0.0;
418 0 : if (state.dataHeatBal->ZoneSteamEq(Ctd).ZonePtr == ZoneNum) {
419 0 : ZoneSteamEqConv += state.dataHeatBal->ZoneSteamEq(Ctd).DesignLevel * state.dataHeatBal->ZoneSteamEq(Ctd).FractionConvected;
420 : }
421 : }
422 1 : state.dataRoomAirMod->ZoneUCSDUI(UINum).PowerPerPlume =
423 1 : (NumberOfOccupants * 73.0 + ZoneElecConv + ZoneGasConv + ZoneOthEqConv + ZoneHWEqConv + ZoneSteamEqConv) / NumberOfPlumes;
424 4 : BaseSizer::reportSizerOutput(state,
425 : "RoomAirSettings:UnderFloorAirDistributionInterior",
426 1 : state.dataRoomAirMod->ZoneUCSDUI(UINum).ZoneName,
427 : "Power per plume [W]",
428 3 : state.dataRoomAirMod->ZoneUCSDUI(UINum).PowerPerPlume);
429 : }
430 1 : if (state.dataRoomAirMod->ZoneUCSDUI(UINum).DiffusersPerZone == AutoSize) {
431 1 : if (NumberOfOccupants > 0.0) {
432 1 : state.dataRoomAirMod->ZoneUCSDUI(UINum).DiffusersPerZone = NumberOfOccupants;
433 : } else {
434 0 : state.dataRoomAirMod->ZoneUCSDUI(UINum).DiffusersPerZone = 1.0;
435 : }
436 4 : BaseSizer::reportSizerOutput(state,
437 : "RoomAirSettings:UnderFloorAirDistributionInterior",
438 1 : state.dataRoomAirMod->ZoneUCSDUI(UINum).ZoneName,
439 : "Number of diffusers per zone",
440 3 : state.dataRoomAirMod->ZoneUCSDUI(UINum).DiffusersPerZone);
441 : }
442 : }
443 :
444 5 : if (ZoneModelType == DataRoomAirModel::RoomAirModel::UCSDUFE) {
445 4 : UINum = state.dataRoomAirMod->ZoneUFPtr(ZoneNum);
446 : // calculate total window width in zone
447 10 : for (int Ctd = state.dataUCSDShared->PosZ_Window((ZoneNum - 1) * 2 + 1); Ctd <= state.dataUCSDShared->PosZ_Window((ZoneNum - 1) * 2 + 2);
448 : ++Ctd) {
449 6 : int SurfNum = state.dataUCSDShared->APos_Window(Ctd);
450 6 : if (SurfNum == 0) continue;
451 12 : if (state.dataSurface->Surface(SurfNum).ExtBoundCond == ExternalEnvironment ||
452 0 : state.dataSurface->Surface(SurfNum).ExtBoundCond == OtherSideCoefNoCalcExt ||
453 6 : state.dataSurface->Surface(SurfNum).ExtBoundCond == OtherSideCoefCalcExt ||
454 0 : state.dataSurface->Surface(SurfNum).ExtBoundCond == OtherSideCondModeledExt) {
455 6 : state.dataRoomAirMod->ZoneUCSDUE(UINum).WinWidth += state.dataSurface->Surface(SurfNum).Width;
456 6 : ++state.dataRoomAirMod->ZoneUCSDUE(UINum).NumExtWin;
457 : }
458 : }
459 4 : if (state.dataRoomAirMod->ZoneUCSDUE(UINum).WinWidth <= 0.0) {
460 0 : ShowWarningError(state,
461 0 : "For RoomAirSettings:UnderFloorAirDistributionExterior for Zone " + state.dataRoomAirMod->ZoneUCSDUE(UINum).ZoneName +
462 : " there are no exterior windows.");
463 0 : ShowContinueError(state, " The zone will be treated as a UFAD interior zone");
464 : }
465 4 : NumberOfOccupants = 0.0;
466 24 : for (int Ctd = 1; Ctd <= state.dataHeatBal->TotPeople; ++Ctd) {
467 20 : if (state.dataHeatBal->People(Ctd).ZonePtr == ZoneNum) {
468 4 : NumberOfOccupants += state.dataHeatBal->People(Ctd).NumberOfPeople;
469 : }
470 : }
471 4 : if (state.dataRoomAirMod->ZoneUCSDUE(UINum).DiffArea == AutoSize) {
472 4 : if (state.dataRoomAirMod->ZoneUCSDUE(UINum).DiffuserType == Diffuser::Swirl) {
473 0 : state.dataRoomAirMod->ZoneUCSDUE(UINum).DiffArea = 0.0075;
474 4 : } else if (state.dataRoomAirMod->ZoneUCSDUE(UINum).DiffuserType == Diffuser::VarArea) {
475 0 : state.dataRoomAirMod->ZoneUCSDUE(UINum).DiffArea = 0.035;
476 4 : } else if (state.dataRoomAirMod->ZoneUCSDUE(UINum).DiffuserType == Diffuser::DisplVent) {
477 0 : state.dataRoomAirMod->ZoneUCSDUE(UINum).DiffArea = 0.0060;
478 4 : } else if (state.dataRoomAirMod->ZoneUCSDUE(UINum).DiffuserType == Diffuser::LinBarGrille) {
479 : // 4 ft x 4 inches; eff area is 50% of total area; 75 cfm per linear foot.
480 4 : state.dataRoomAirMod->ZoneUCSDUE(UINum).DiffArea = 0.03;
481 : } else {
482 0 : state.dataRoomAirMod->ZoneUCSDUE(UINum).DiffArea = 0.0075;
483 : }
484 16 : BaseSizer::reportSizerOutput(state,
485 : "RoomAirSettings:UnderFloorAirDistributionExterior",
486 4 : state.dataRoomAirMod->ZoneUCSDUE(UINum).ZoneName,
487 : "Design effective area of diffuser",
488 12 : state.dataRoomAirMod->ZoneUCSDUE(UINum).DiffArea);
489 : }
490 4 : if (state.dataRoomAirMod->ZoneUCSDUE(UINum).DiffAngle == AutoSize) {
491 4 : if (state.dataRoomAirMod->ZoneUCSDUE(UINum).DiffuserType == Diffuser::Swirl) {
492 0 : state.dataRoomAirMod->ZoneUCSDUE(UINum).DiffAngle = 28.0;
493 4 : } else if (state.dataRoomAirMod->ZoneUCSDUE(UINum).DiffuserType == Diffuser::VarArea) {
494 0 : state.dataRoomAirMod->ZoneUCSDUE(UINum).DiffAngle = 45.0;
495 4 : } else if (state.dataRoomAirMod->ZoneUCSDUE(UINum).DiffuserType == Diffuser::DisplVent) {
496 0 : state.dataRoomAirMod->ZoneUCSDUE(UINum).DiffAngle = 73.0;
497 4 : } else if (state.dataRoomAirMod->ZoneUCSDUE(UINum).DiffuserType == Diffuser::LinBarGrille) {
498 4 : state.dataRoomAirMod->ZoneUCSDUE(UINum).DiffAngle = 15.0;
499 : } else {
500 0 : state.dataRoomAirMod->ZoneUCSDUE(UINum).DiffAngle = 28.0;
501 : }
502 16 : BaseSizer::reportSizerOutput(state,
503 : "RoomAirSettings:UnderFloorAirDistributionExterior",
504 4 : state.dataRoomAirMod->ZoneUCSDUE(UINum).ZoneName,
505 : "Angle between diffuser slots and the vertical",
506 12 : state.dataRoomAirMod->ZoneUCSDUE(UINum).DiffAngle);
507 : }
508 4 : if (state.dataRoomAirMod->ZoneUCSDUE(UINum).TransHeight == AutoSize) {
509 0 : state.dataRoomAirMod->ZoneUCSDUE(UINum).CalcTransHeight = true;
510 0 : state.dataRoomAirMod->ZoneUCSDUE(UINum).TransHeight = 0.0;
511 : } else {
512 4 : state.dataRoomAirMod->ZoneUCSDUE(UINum).CalcTransHeight = false;
513 : }
514 4 : if (state.dataRoomAirMod->ZoneUCSDUE(UINum).DiffuserType == Diffuser::Swirl) {
515 0 : if (state.dataRoomAirMod->ZoneUCSDUE(UINum).A_Kc != DataGlobalConstants::AutoCalculate ||
516 0 : state.dataRoomAirMod->ZoneUCSDUE(UINum).B_Kc != DataGlobalConstants::AutoCalculate ||
517 0 : state.dataRoomAirMod->ZoneUCSDUE(UINum).C_Kc != DataGlobalConstants::AutoCalculate ||
518 0 : state.dataRoomAirMod->ZoneUCSDUE(UINum).D_Kc != DataGlobalConstants::AutoCalculate ||
519 0 : state.dataRoomAirMod->ZoneUCSDUE(UINum).E_Kc != DataGlobalConstants::AutoCalculate) {
520 0 : ShowWarningError(state,
521 0 : "For RoomAirSettings:UnderFloorAirDistributionExterior for Zone " +
522 0 : state.dataRoomAirMod->ZoneUCSDUE(UINum).ZoneName +
523 : ", input for Coefficients A - E will be ignored when Floor Diffuser Type = Swirl.");
524 0 : ShowContinueError(state, " To input these Coefficients, use Floor Diffuser Type = Custom.");
525 : }
526 0 : state.dataRoomAirMod->ZoneUCSDUE(UINum).A_Kc = 0.0;
527 0 : state.dataRoomAirMod->ZoneUCSDUE(UINum).B_Kc = 0.0;
528 0 : state.dataRoomAirMod->ZoneUCSDUE(UINum).C_Kc = 0.6531;
529 0 : state.dataRoomAirMod->ZoneUCSDUE(UINum).D_Kc = 0.0069;
530 0 : state.dataRoomAirMod->ZoneUCSDUE(UINum).E_Kc = -0.00004;
531 4 : } else if (state.dataRoomAirMod->ZoneUCSDUE(UINum).DiffuserType == Diffuser::VarArea) {
532 0 : if (state.dataRoomAirMod->ZoneUCSDUE(UINum).A_Kc != DataGlobalConstants::AutoCalculate ||
533 0 : state.dataRoomAirMod->ZoneUCSDUE(UINum).B_Kc != DataGlobalConstants::AutoCalculate ||
534 0 : state.dataRoomAirMod->ZoneUCSDUE(UINum).C_Kc != DataGlobalConstants::AutoCalculate ||
535 0 : state.dataRoomAirMod->ZoneUCSDUE(UINum).D_Kc != DataGlobalConstants::AutoCalculate ||
536 0 : state.dataRoomAirMod->ZoneUCSDUE(UINum).E_Kc != DataGlobalConstants::AutoCalculate) {
537 0 : ShowWarningError(state,
538 0 : "For RoomAirSettings:UnderFloorAirDistributionExterior for Zone " +
539 0 : state.dataRoomAirMod->ZoneUCSDUE(UINum).ZoneName +
540 : ", input for Coefficients A - E will be ignored when Floor Diffuser Type = VariableArea.");
541 0 : ShowContinueError(state, " To input these Coefficients, use Floor Diffuser Type = Custom.");
542 : }
543 0 : state.dataRoomAirMod->ZoneUCSDUE(UINum).A_Kc = 0.0;
544 0 : state.dataRoomAirMod->ZoneUCSDUE(UINum).B_Kc = 0.0;
545 0 : state.dataRoomAirMod->ZoneUCSDUE(UINum).C_Kc = 0.83;
546 0 : state.dataRoomAirMod->ZoneUCSDUE(UINum).D_Kc = 0.0;
547 0 : state.dataRoomAirMod->ZoneUCSDUE(UINum).E_Kc = 0.0;
548 4 : } else if (state.dataRoomAirMod->ZoneUCSDUE(UINum).DiffuserType == Diffuser::DisplVent) {
549 0 : if (state.dataRoomAirMod->ZoneUCSDUE(UINum).A_Kc != DataGlobalConstants::AutoCalculate ||
550 0 : state.dataRoomAirMod->ZoneUCSDUE(UINum).B_Kc != DataGlobalConstants::AutoCalculate ||
551 0 : state.dataRoomAirMod->ZoneUCSDUE(UINum).C_Kc != DataGlobalConstants::AutoCalculate ||
552 0 : state.dataRoomAirMod->ZoneUCSDUE(UINum).D_Kc != DataGlobalConstants::AutoCalculate ||
553 0 : state.dataRoomAirMod->ZoneUCSDUE(UINum).E_Kc != DataGlobalConstants::AutoCalculate) {
554 0 : ShowWarningError(state,
555 0 : "For RoomAirSettings:UnderFloorAirDistributionExterior for Zone " +
556 0 : state.dataRoomAirMod->ZoneUCSDUE(UINum).ZoneName +
557 : ", input for Coefficients A - E will be ignored when Floor Diffuser Type = HorizontalDisplacement.");
558 0 : ShowContinueError(state, " To input these Coefficients, use Floor Diffuser Type = Custom.");
559 : }
560 0 : state.dataRoomAirMod->ZoneUCSDUE(UINum).A_Kc = 0.0;
561 0 : state.dataRoomAirMod->ZoneUCSDUE(UINum).B_Kc = 0.0;
562 0 : state.dataRoomAirMod->ZoneUCSDUE(UINum).C_Kc = 0.67;
563 0 : state.dataRoomAirMod->ZoneUCSDUE(UINum).D_Kc = 0.0;
564 0 : state.dataRoomAirMod->ZoneUCSDUE(UINum).E_Kc = 0.0;
565 4 : } else if (state.dataRoomAirMod->ZoneUCSDUE(UINum).DiffuserType == Diffuser::LinBarGrille) {
566 12 : if (state.dataRoomAirMod->ZoneUCSDUE(UINum).A_Kc != DataGlobalConstants::AutoCalculate ||
567 8 : state.dataRoomAirMod->ZoneUCSDUE(UINum).B_Kc != DataGlobalConstants::AutoCalculate ||
568 8 : state.dataRoomAirMod->ZoneUCSDUE(UINum).C_Kc != DataGlobalConstants::AutoCalculate ||
569 12 : state.dataRoomAirMod->ZoneUCSDUE(UINum).D_Kc != DataGlobalConstants::AutoCalculate ||
570 4 : state.dataRoomAirMod->ZoneUCSDUE(UINum).E_Kc != DataGlobalConstants::AutoCalculate) {
571 0 : ShowWarningError(state,
572 0 : "For RoomAirSettings:UnderFloorAirDistributionExterior for Zone " +
573 0 : state.dataRoomAirMod->ZoneUCSDUE(UINum).ZoneName +
574 : ", input for Coefficients A - E will be ignored when Floor Diffuser Type = LinearBarGrille.");
575 0 : ShowContinueError(state, " To input these Coefficients, use Floor Diffuser Type = Custom.");
576 : }
577 4 : state.dataRoomAirMod->ZoneUCSDUE(UINum).A_Kc = 0.0;
578 4 : state.dataRoomAirMod->ZoneUCSDUE(UINum).B_Kc = 0.0;
579 4 : state.dataRoomAirMod->ZoneUCSDUE(UINum).C_Kc = 0.8214;
580 4 : state.dataRoomAirMod->ZoneUCSDUE(UINum).D_Kc = -0.0263;
581 4 : state.dataRoomAirMod->ZoneUCSDUE(UINum).E_Kc = 0.0014;
582 : } else {
583 0 : if (state.dataRoomAirMod->ZoneUCSDUE(UINum).A_Kc == DataGlobalConstants::AutoCalculate ||
584 0 : state.dataRoomAirMod->ZoneUCSDUE(UINum).B_Kc == DataGlobalConstants::AutoCalculate ||
585 0 : state.dataRoomAirMod->ZoneUCSDUE(UINum).C_Kc == DataGlobalConstants::AutoCalculate ||
586 0 : state.dataRoomAirMod->ZoneUCSDUE(UINum).D_Kc == DataGlobalConstants::AutoCalculate ||
587 0 : state.dataRoomAirMod->ZoneUCSDUE(UINum).E_Kc == DataGlobalConstants::AutoCalculate) {
588 0 : ShowFatalError(state,
589 0 : "For RoomAirSettings:UnderFloorAirDistributionExterior for Zone " + state.dataRoomAirMod->ZoneUCSDUE(UINum).ZoneName +
590 : ", input for Coefficients A - E must be specified when Floor Diffuser Type = Custom.");
591 : }
592 : }
593 4 : if (state.dataRoomAirMod->ZoneUCSDUE(UINum).PowerPerPlume == DataGlobalConstants::AutoCalculate) {
594 4 : if (NumberOfOccupants > 0) {
595 4 : NumberOfPlumes = NumberOfOccupants;
596 : } else {
597 0 : NumberOfPlumes = 1.0;
598 : }
599 4 : ZoneElecConv = 0.0;
600 24 : for (int Ctd = 1; Ctd <= state.dataHeatBal->TotElecEquip; ++Ctd) {
601 20 : if (state.dataHeatBal->ZoneElectric(Ctd).ZonePtr == ZoneNum) {
602 4 : ZoneElecConv += state.dataHeatBal->ZoneElectric(Ctd).DesignLevel;
603 : }
604 : }
605 4 : ZoneGasConv = 0.0;
606 4 : for (int Ctd = 1; Ctd <= state.dataHeatBal->TotGasEquip; ++Ctd) {
607 0 : if (state.dataHeatBal->ZoneGas(Ctd).ZonePtr == ZoneNum) {
608 0 : ZoneGasConv += state.dataHeatBal->ZoneGas(Ctd).DesignLevel;
609 : }
610 : }
611 4 : ZoneOthEqConv = 0.0;
612 4 : for (int Ctd = 1; Ctd <= state.dataHeatBal->TotOthEquip; ++Ctd) {
613 0 : if (state.dataHeatBal->ZoneOtherEq(Ctd).ZonePtr == ZoneNum) {
614 0 : ZoneOthEqConv += state.dataHeatBal->ZoneOtherEq(Ctd).DesignLevel;
615 : }
616 : }
617 4 : ZoneHWEqConv = 0.0;
618 4 : for (int Ctd = 1; Ctd <= state.dataHeatBal->TotHWEquip; ++Ctd) {
619 0 : if (state.dataHeatBal->ZoneHWEq(Ctd).ZonePtr == ZoneNum) {
620 0 : ZoneHWEqConv += state.dataHeatBal->ZoneHWEq(Ctd).DesignLevel;
621 : }
622 : }
623 4 : for (int Ctd = 1; Ctd <= state.dataHeatBal->TotStmEquip; ++Ctd) {
624 0 : ZoneSteamEqConv = 0.0;
625 0 : if (state.dataHeatBal->ZoneSteamEq(Ctd).ZonePtr == ZoneNum) {
626 0 : ZoneSteamEqConv += state.dataHeatBal->ZoneSteamEq(Ctd).DesignLevel;
627 : }
628 : }
629 4 : state.dataRoomAirMod->ZoneUCSDUE(UINum).PowerPerPlume =
630 4 : (NumberOfOccupants * 73.0 + ZoneElecConv + ZoneGasConv + ZoneOthEqConv + ZoneHWEqConv + ZoneSteamEqConv) / NumberOfPlumes;
631 16 : BaseSizer::reportSizerOutput(state,
632 : "RoomAirSettings:UnderFloorAirDistributionExterior",
633 4 : state.dataRoomAirMod->ZoneUCSDUE(UINum).ZoneName,
634 : "Power per plume [W]",
635 12 : state.dataRoomAirMod->ZoneUCSDUE(UINum).PowerPerPlume);
636 : }
637 4 : if (state.dataRoomAirMod->ZoneUCSDUE(UINum).DiffusersPerZone == AutoSize) {
638 4 : if (NumberOfOccupants > 0.0) {
639 4 : state.dataRoomAirMod->ZoneUCSDUE(UINum).DiffusersPerZone = NumberOfOccupants;
640 : } else {
641 0 : state.dataRoomAirMod->ZoneUCSDUE(UINum).DiffusersPerZone = 1.0;
642 : }
643 16 : BaseSizer::reportSizerOutput(state,
644 : "RoomAirSettings:UnderFloorAirDistributionExterior",
645 4 : state.dataRoomAirMod->ZoneUCSDUE(UINum).ZoneName,
646 : "Number of diffusers per zone",
647 12 : state.dataRoomAirMod->ZoneUCSDUE(UINum).DiffusersPerZone);
648 : }
649 : }
650 5 : }
651 :
652 79562 : void HcUCSDUF(EnergyPlusData &state, int const ZoneNum, Real64 const FractionHeight)
653 : {
654 :
655 : // SUBROUTINE INFORMATION:
656 : // AUTHOR G. Carrilho da Graca
657 : // DATE WRITTEN February 2004
658 : // MODIFIED -
659 : // RE-ENGINEERED -
660 :
661 : // PURPOSE OF THIS SUBROUTINE:
662 : // Main subroutine for convection calculation in the UCSD Displacement Ventilation model.
663 : // It calls CalcDetailedHcInForDVModel for convection coefficient
664 : // initial calculations and averages the final result comparing the position of the surface with
665 : // the interface subzone height.
666 :
667 : // Using/Aliasing
668 : using namespace DataEnvironment;
669 : using namespace DataHeatBalance;
670 :
671 : // SUBROUTINE LOCAL VARIABLE DECLARATIONS:
672 : int Ctd; // DO loop counter for surfaces
673 : Real64 HLD; // Convection coefficient for the lower area of surface
674 : Real64 TmedDV; // Average temperature for DV
675 : Real64 Z1; // auxiliary var for lowest height
676 : Real64 Z2; // auxiliary var for highest height
677 : Real64 ZSupSurf; // highest height for this surface
678 : Real64 ZInfSurf; // lowest height for this surface
679 : Real64 HLU; // Convection coefficient for the upper area of surface
680 : Real64 LayH; // Height of the Occupied/Mixed subzone interface
681 : Real64 LayFrac; // Fraction height of the Occupied/Mixed subzone interface
682 : int SurfNum; // Surface number
683 : // Initialize HAT and HA
684 :
685 79562 : state.dataUFADManager->HAT_MX = 0.0;
686 79562 : state.dataUFADManager->HAT_OC = 0.0;
687 79562 : state.dataUFADManager->HA_MX = 0.0;
688 79562 : state.dataUFADManager->HA_OC = 0.0;
689 79562 : state.dataUFADManager->HAT_FLOOR = 0.0;
690 79562 : state.dataUFADManager->HA_FLOOR = 0.0;
691 79562 : state.dataUFADManager->HAT_MXWin = 0.0;
692 79562 : state.dataUFADManager->HAT_OCWin = 0.0;
693 79562 : state.dataUFADManager->HA_MXWin = 0.0;
694 79562 : state.dataUFADManager->HA_OCWin = 0.0;
695 :
696 : // Is the air flow model for this zone set to UCSDDV Displacement Ventilation?
697 79562 : if (state.dataRoomAirMod->IsZoneUI(ZoneNum)) {
698 79562 : LayFrac = FractionHeight;
699 79562 : LayH = FractionHeight *
700 79562 : (state.dataRoomAirMod->ZoneCeilingHeight((ZoneNum - 1) * 2 + 2) - state.dataRoomAirMod->ZoneCeilingHeight((ZoneNum - 1) * 2 + 1));
701 : // WALL Hc, HA and HAT calculation
702 397810 : for (Ctd = state.dataUCSDShared->PosZ_Wall((ZoneNum - 1) * 2 + 1); Ctd <= state.dataUCSDShared->PosZ_Wall((ZoneNum - 1) * 2 + 2); ++Ctd) {
703 318248 : SurfNum = state.dataUCSDShared->APos_Wall(Ctd);
704 318248 : state.dataSurface->SurfTAirRef(SurfNum) = DataSurfaces::RefAirTemp::AdjacentAirTemp;
705 318248 : state.dataSurface->SurfTAirRefRpt(SurfNum) = DataSurfaces::SurfTAirRefReportVals[state.dataSurface->SurfTAirRef(SurfNum)];
706 318248 : if (SurfNum == 0) continue;
707 318248 : Z1 = minval(state.dataSurface->Surface(SurfNum).Vertex({1, state.dataSurface->Surface(SurfNum).Sides}), &Vector::z);
708 318248 : Z2 = maxval(state.dataSurface->Surface(SurfNum).Vertex({1, state.dataSurface->Surface(SurfNum).Sides}), &Vector::z);
709 318248 : ZSupSurf = Z2 - state.dataRoomAirMod->ZoneCeilingHeight((ZoneNum - 1) * 2 + 1);
710 318248 : ZInfSurf = Z1 - state.dataRoomAirMod->ZoneCeilingHeight((ZoneNum - 1) * 2 + 1);
711 :
712 : // The Wall surface is in the upper subzone
713 318248 : if (ZInfSurf > LayH) {
714 0 : state.dataHeatBal->SurfTempEffBulkAir(SurfNum) = state.dataRoomAirMod->ZTMX(ZoneNum);
715 0 : CalcDetailedHcInForDVModel(state, SurfNum, state.dataHeatBalSurf->SurfTempIn, state.dataRoomAirMod->UFHcIn);
716 0 : state.dataUCSDShared->HWall(Ctd) = state.dataRoomAirMod->UFHcIn(SurfNum);
717 0 : state.dataUFADManager->HAT_MX +=
718 0 : state.dataSurface->Surface(SurfNum).Area * state.dataHeatBalSurf->SurfTempIn(SurfNum) * state.dataUCSDShared->HWall(Ctd);
719 0 : state.dataUFADManager->HA_MX += state.dataSurface->Surface(SurfNum).Area * state.dataUCSDShared->HWall(Ctd);
720 : }
721 :
722 : // The Wall surface is in the lower subzone
723 318248 : if (ZSupSurf < LayH) {
724 0 : state.dataHeatBal->SurfTempEffBulkAir(SurfNum) = state.dataRoomAirMod->ZTOC(ZoneNum);
725 0 : CalcDetailedHcInForDVModel(state, SurfNum, state.dataHeatBalSurf->SurfTempIn, state.dataRoomAirMod->UFHcIn);
726 0 : state.dataUCSDShared->HWall(Ctd) = state.dataRoomAirMod->UFHcIn(SurfNum);
727 0 : state.dataUFADManager->HAT_OC +=
728 0 : state.dataSurface->Surface(SurfNum).Area * state.dataHeatBalSurf->SurfTempIn(SurfNum) * state.dataUCSDShared->HWall(Ctd);
729 0 : state.dataUFADManager->HA_OC += state.dataSurface->Surface(SurfNum).Area * state.dataUCSDShared->HWall(Ctd);
730 : }
731 :
732 318248 : if (std::abs(ZInfSurf - ZSupSurf) < 1.e-10) {
733 0 : ShowSevereError(state, "RoomAirModelUFAD:HcUCSDUF: Surface values will cause divide by zero.");
734 0 : ShowContinueError(state,
735 0 : "Zone=\"" + state.dataHeatBal->Zone(state.dataSurface->Surface(SurfNum).Zone).Name + "\", Surface=\"" +
736 0 : state.dataSurface->Surface(SurfNum).Name + "\".");
737 0 : ShowContinueError(state, format("ZInfSurf=[{:.4R}], LayH=[{:.4R}].", ZInfSurf, LayH));
738 0 : ShowContinueError(state, format("ZSupSurf=[{:.4R}], LayH=[{:.4R}].", ZSupSurf, LayH));
739 0 : ShowFatalError(state, "...Previous condition causes termination.");
740 : }
741 :
742 : // The Wall surface is partially in upper and partially in lower subzone
743 318248 : if (ZInfSurf <= LayH && ZSupSurf >= LayH) {
744 318248 : state.dataHeatBal->SurfTempEffBulkAir(SurfNum) = state.dataRoomAirMod->ZTMX(ZoneNum);
745 318248 : CalcDetailedHcInForDVModel(state, SurfNum, state.dataHeatBalSurf->SurfTempIn, state.dataRoomAirMod->UFHcIn);
746 318248 : HLU = state.dataRoomAirMod->UFHcIn(SurfNum);
747 318248 : state.dataHeatBal->SurfTempEffBulkAir(SurfNum) = state.dataRoomAirMod->ZTOC(ZoneNum);
748 318248 : CalcDetailedHcInForDVModel(state, SurfNum, state.dataHeatBalSurf->SurfTempIn, state.dataRoomAirMod->UFHcIn);
749 318248 : HLD = state.dataRoomAirMod->UFHcIn(SurfNum);
750 636496 : TmedDV = ((ZSupSurf - LayH) * state.dataRoomAirMod->ZTMX(ZoneNum) + (LayH - ZInfSurf) * state.dataRoomAirMod->ZTOC(ZoneNum)) /
751 318248 : (ZSupSurf - ZInfSurf);
752 318248 : state.dataUCSDShared->HWall(Ctd) = ((LayH - ZInfSurf) * HLD + (ZSupSurf - LayH) * HLU) / (ZSupSurf - ZInfSurf);
753 954744 : state.dataUFADManager->HAT_MX += state.dataSurface->Surface(SurfNum).Area * (ZSupSurf - LayH) / (ZSupSurf - ZInfSurf) *
754 636496 : state.dataHeatBalSurf->SurfTempIn(SurfNum) * HLU;
755 318248 : state.dataUFADManager->HA_MX += state.dataSurface->Surface(SurfNum).Area * (ZSupSurf - LayH) / (ZSupSurf - ZInfSurf) * HLU;
756 954744 : state.dataUFADManager->HAT_OC += state.dataSurface->Surface(SurfNum).Area * (LayH - ZInfSurf) / (ZSupSurf - ZInfSurf) *
757 636496 : state.dataHeatBalSurf->SurfTempIn(SurfNum) * HLD;
758 318248 : state.dataUFADManager->HA_OC += state.dataSurface->Surface(SurfNum).Area * (LayH - ZInfSurf) / (ZSupSurf - ZInfSurf) * HLD;
759 318248 : state.dataHeatBal->SurfTempEffBulkAir(SurfNum) = TmedDV;
760 : }
761 :
762 318248 : state.dataRoomAirMod->UFHcIn(SurfNum) = state.dataUCSDShared->HWall(Ctd);
763 :
764 : } // END WALL
765 :
766 : // WINDOW Hc, HA and HAT CALCULATION
767 175238 : for (Ctd = state.dataUCSDShared->PosZ_Window((ZoneNum - 1) * 2 + 1); Ctd <= state.dataUCSDShared->PosZ_Window((ZoneNum - 1) * 2 + 2); ++Ctd) {
768 95676 : SurfNum = state.dataUCSDShared->APos_Window(Ctd);
769 95676 : state.dataSurface->SurfTAirRef(SurfNum) = DataSurfaces::RefAirTemp::AdjacentAirTemp;
770 95676 : state.dataSurface->SurfTAirRefRpt(SurfNum) = DataSurfaces::SurfTAirRefReportVals[state.dataSurface->SurfTAirRef(SurfNum)];
771 95676 : if (SurfNum == 0) continue;
772 95676 : if (state.dataSurface->Surface(SurfNum).Tilt > 10.0 && state.dataSurface->Surface(SurfNum).Tilt < 170.0) { // Window Wall
773 95676 : Z1 = minval(state.dataSurface->Surface(SurfNum).Vertex({1, state.dataSurface->Surface(SurfNum).Sides}), &Vector::z);
774 95676 : Z2 = maxval(state.dataSurface->Surface(SurfNum).Vertex({1, state.dataSurface->Surface(SurfNum).Sides}), &Vector::z);
775 95676 : ZSupSurf = Z2 - state.dataRoomAirMod->ZoneCeilingHeight((ZoneNum - 1) * 2 + 1);
776 95676 : ZInfSurf = Z1 - state.dataRoomAirMod->ZoneCeilingHeight((ZoneNum - 1) * 2 + 1);
777 :
778 95676 : if (ZInfSurf > LayH) {
779 21735 : state.dataHeatBal->SurfTempEffBulkAir(SurfNum) = state.dataRoomAirMod->ZTMX(ZoneNum);
780 21735 : CalcDetailedHcInForDVModel(state, SurfNum, state.dataHeatBalSurf->SurfTempIn, state.dataRoomAirMod->UFHcIn);
781 21735 : state.dataUCSDShared->HWindow(Ctd) = state.dataRoomAirMod->UFHcIn(SurfNum);
782 21735 : state.dataUFADManager->HAT_MX +=
783 21735 : state.dataSurface->Surface(SurfNum).Area * state.dataHeatBalSurf->SurfTempIn(SurfNum) * state.dataUCSDShared->HWindow(Ctd);
784 21735 : state.dataUFADManager->HA_MX += state.dataSurface->Surface(SurfNum).Area * state.dataUCSDShared->HWindow(Ctd);
785 21735 : state.dataUFADManager->HAT_MXWin +=
786 21735 : state.dataSurface->Surface(SurfNum).Area * state.dataHeatBalSurf->SurfTempIn(SurfNum) * state.dataUCSDShared->HWindow(Ctd);
787 21735 : state.dataUFADManager->HA_MXWin += state.dataSurface->Surface(SurfNum).Area * state.dataUCSDShared->HWindow(Ctd);
788 : }
789 :
790 95676 : if (ZSupSurf < LayH) {
791 0 : state.dataHeatBal->SurfTempEffBulkAir(SurfNum) = state.dataRoomAirMod->ZTOC(ZoneNum);
792 0 : CalcDetailedHcInForDVModel(state, SurfNum, state.dataHeatBalSurf->SurfTempIn, state.dataRoomAirMod->UFHcIn);
793 0 : state.dataUCSDShared->HWindow(Ctd) = state.dataRoomAirMod->UFHcIn(SurfNum);
794 0 : state.dataUFADManager->HAT_OC +=
795 0 : state.dataSurface->Surface(SurfNum).Area * state.dataHeatBalSurf->SurfTempIn(SurfNum) * state.dataUCSDShared->HWindow(Ctd);
796 0 : state.dataUFADManager->HA_OC += state.dataSurface->Surface(SurfNum).Area * state.dataUCSDShared->HWindow(Ctd);
797 0 : state.dataUFADManager->HAT_OCWin +=
798 0 : state.dataSurface->Surface(SurfNum).Area * state.dataHeatBalSurf->SurfTempIn(SurfNum) * state.dataUCSDShared->HWindow(Ctd);
799 0 : state.dataUFADManager->HA_OCWin += state.dataSurface->Surface(SurfNum).Area * state.dataUCSDShared->HWindow(Ctd);
800 : }
801 :
802 95676 : if (ZInfSurf <= LayH && ZSupSurf >= LayH) {
803 73941 : state.dataHeatBal->SurfTempEffBulkAir(SurfNum) = state.dataRoomAirMod->ZTMX(ZoneNum);
804 73941 : CalcDetailedHcInForDVModel(state, SurfNum, state.dataHeatBalSurf->SurfTempIn, state.dataRoomAirMod->UFHcIn);
805 73941 : HLU = state.dataRoomAirMod->UFHcIn(SurfNum);
806 73941 : state.dataHeatBal->SurfTempEffBulkAir(SurfNum) = state.dataRoomAirMod->ZTOC(ZoneNum);
807 73941 : CalcDetailedHcInForDVModel(state, SurfNum, state.dataHeatBalSurf->SurfTempIn, state.dataRoomAirMod->UFHcIn);
808 73941 : HLD = state.dataRoomAirMod->UFHcIn(SurfNum);
809 147882 : TmedDV = ((ZSupSurf - LayH) * state.dataRoomAirMod->ZTMX(ZoneNum) + (LayH - ZInfSurf) * state.dataRoomAirMod->ZTOC(ZoneNum)) /
810 73941 : (ZSupSurf - ZInfSurf);
811 73941 : state.dataUCSDShared->HWindow(Ctd) = ((LayH - ZInfSurf) * HLD + (ZSupSurf - LayH) * HLU) / (ZSupSurf - ZInfSurf);
812 221823 : state.dataUFADManager->HAT_MX += state.dataSurface->Surface(SurfNum).Area * (ZSupSurf - LayH) / (ZSupSurf - ZInfSurf) *
813 147882 : state.dataHeatBalSurf->SurfTempIn(SurfNum) * HLU;
814 73941 : state.dataUFADManager->HA_MX += state.dataSurface->Surface(SurfNum).Area * (ZSupSurf - LayH) / (ZSupSurf - ZInfSurf) * HLU;
815 221823 : state.dataUFADManager->HAT_MXWin += state.dataSurface->Surface(SurfNum).Area * (ZSupSurf - LayH) / (ZSupSurf - ZInfSurf) *
816 147882 : state.dataHeatBalSurf->SurfTempIn(SurfNum) * HLU;
817 73941 : state.dataUFADManager->HA_MXWin += state.dataSurface->Surface(SurfNum).Area * (ZSupSurf - LayH) / (ZSupSurf - ZInfSurf) * HLU;
818 221823 : state.dataUFADManager->HAT_OC += state.dataSurface->Surface(SurfNum).Area * (LayH - ZInfSurf) / (ZSupSurf - ZInfSurf) *
819 147882 : state.dataHeatBalSurf->SurfTempIn(SurfNum) * HLD;
820 73941 : state.dataUFADManager->HA_OC += state.dataSurface->Surface(SurfNum).Area * (LayH - ZInfSurf) / (ZSupSurf - ZInfSurf) * HLD;
821 221823 : state.dataUFADManager->HAT_OCWin += state.dataSurface->Surface(SurfNum).Area * (LayH - ZInfSurf) / (ZSupSurf - ZInfSurf) *
822 147882 : state.dataHeatBalSurf->SurfTempIn(SurfNum) * HLD;
823 73941 : state.dataUFADManager->HA_OCWin += state.dataSurface->Surface(SurfNum).Area * (LayH - ZInfSurf) / (ZSupSurf - ZInfSurf) * HLD;
824 73941 : state.dataHeatBal->SurfTempEffBulkAir(SurfNum) = TmedDV;
825 : }
826 : }
827 :
828 95676 : if (state.dataSurface->Surface(SurfNum).Tilt <= 10.0) { // Window Ceiling
829 0 : state.dataHeatBal->SurfTempEffBulkAir(SurfNum) = state.dataRoomAirMod->ZTMX(ZoneNum);
830 0 : CalcDetailedHcInForDVModel(state, SurfNum, state.dataHeatBalSurf->SurfTempIn, state.dataRoomAirMod->UFHcIn);
831 0 : state.dataUCSDShared->HWindow(Ctd) = state.dataRoomAirMod->UFHcIn(SurfNum);
832 0 : state.dataUFADManager->HAT_MX +=
833 0 : state.dataSurface->Surface(SurfNum).Area * state.dataHeatBalSurf->SurfTempIn(SurfNum) * state.dataUCSDShared->HWindow(Ctd);
834 0 : state.dataUFADManager->HA_MX += state.dataSurface->Surface(SurfNum).Area * state.dataUCSDShared->HWindow(Ctd);
835 : }
836 :
837 95676 : if (state.dataSurface->Surface(SurfNum).Tilt >= 170.0) { // Window Floor
838 0 : state.dataHeatBal->SurfTempEffBulkAir(SurfNum) = state.dataRoomAirMod->ZTOC(ZoneNum);
839 0 : CalcDetailedHcInForDVModel(state, SurfNum, state.dataHeatBalSurf->SurfTempIn, state.dataRoomAirMod->UFHcIn);
840 0 : state.dataUCSDShared->HWindow(Ctd) = state.dataRoomAirMod->UFHcIn(SurfNum);
841 0 : state.dataUFADManager->HAT_OC +=
842 0 : state.dataSurface->Surface(SurfNum).Area * state.dataHeatBalSurf->SurfTempIn(SurfNum) * state.dataUCSDShared->HWindow(Ctd);
843 0 : state.dataUFADManager->HA_OC += state.dataSurface->Surface(SurfNum).Area * state.dataUCSDShared->HWindow(Ctd);
844 : }
845 :
846 95676 : state.dataRoomAirMod->UFHcIn(SurfNum) = state.dataUCSDShared->HWindow(Ctd);
847 :
848 : } // END WINDOW
849 :
850 : // DOOR Hc, HA and HAT CALCULATION
851 79562 : for (Ctd = state.dataUCSDShared->PosZ_Door((ZoneNum - 1) * 2 + 1); Ctd <= state.dataUCSDShared->PosZ_Door((ZoneNum - 1) * 2 + 2);
852 : ++Ctd) { // DOOR
853 0 : SurfNum = state.dataUCSDShared->APos_Door(Ctd);
854 0 : state.dataSurface->SurfTAirRef(SurfNum) = DataSurfaces::RefAirTemp::AdjacentAirTemp;
855 0 : state.dataSurface->SurfTAirRefRpt(SurfNum) = DataSurfaces::SurfTAirRefReportVals[state.dataSurface->SurfTAirRef(SurfNum)];
856 0 : if (SurfNum == 0) continue;
857 0 : Z1 = minval(state.dataSurface->Surface(SurfNum).Vertex({1, state.dataSurface->Surface(SurfNum).Sides}), &Vector::z);
858 0 : Z2 = maxval(state.dataSurface->Surface(SurfNum).Vertex({1, state.dataSurface->Surface(SurfNum).Sides}), &Vector::z);
859 0 : ZSupSurf = Z2 - state.dataRoomAirMod->ZoneCeilingHeight((ZoneNum - 1) * 2 + 1);
860 0 : ZInfSurf = Z1 - state.dataRoomAirMod->ZoneCeilingHeight((ZoneNum - 1) * 2 + 1);
861 :
862 0 : if (ZInfSurf > LayH) {
863 0 : state.dataHeatBal->SurfTempEffBulkAir(SurfNum) = state.dataRoomAirMod->ZTMX(ZoneNum);
864 0 : CalcDetailedHcInForDVModel(state, SurfNum, state.dataHeatBalSurf->SurfTempIn, state.dataRoomAirMod->UFHcIn);
865 0 : state.dataUCSDShared->HDoor(Ctd) = state.dataRoomAirMod->UFHcIn(SurfNum);
866 0 : state.dataUFADManager->HAT_MX +=
867 0 : state.dataSurface->Surface(SurfNum).Area * state.dataHeatBalSurf->SurfTempIn(SurfNum) * state.dataUCSDShared->HDoor(Ctd);
868 0 : state.dataUFADManager->HA_MX += state.dataSurface->Surface(SurfNum).Area * state.dataUCSDShared->HDoor(Ctd);
869 : }
870 :
871 0 : if (ZSupSurf < LayH) {
872 0 : state.dataHeatBal->SurfTempEffBulkAir(SurfNum) = state.dataRoomAirMod->ZTOC(ZoneNum);
873 0 : CalcDetailedHcInForDVModel(state, SurfNum, state.dataHeatBalSurf->SurfTempIn, state.dataRoomAirMod->UFHcIn);
874 0 : state.dataUCSDShared->HDoor(Ctd) = state.dataRoomAirMod->UFHcIn(SurfNum);
875 0 : state.dataUFADManager->HAT_OC +=
876 0 : state.dataSurface->Surface(SurfNum).Area * state.dataHeatBalSurf->SurfTempIn(SurfNum) * state.dataUCSDShared->HDoor(Ctd);
877 0 : state.dataUFADManager->HA_OC += state.dataSurface->Surface(SurfNum).Area * state.dataUCSDShared->HDoor(Ctd);
878 : }
879 :
880 0 : if (ZInfSurf <= LayH && ZSupSurf >= LayH) {
881 0 : state.dataHeatBal->SurfTempEffBulkAir(SurfNum) = state.dataRoomAirMod->ZTMX(ZoneNum);
882 0 : CalcDetailedHcInForDVModel(state, SurfNum, state.dataHeatBalSurf->SurfTempIn, state.dataRoomAirMod->UFHcIn);
883 0 : HLU = state.dataRoomAirMod->UFHcIn(SurfNum);
884 0 : state.dataHeatBal->SurfTempEffBulkAir(SurfNum) = state.dataRoomAirMod->ZTOC(ZoneNum);
885 0 : CalcDetailedHcInForDVModel(state, SurfNum, state.dataHeatBalSurf->SurfTempIn, state.dataRoomAirMod->UFHcIn);
886 0 : HLD = state.dataRoomAirMod->UFHcIn(SurfNum);
887 0 : TmedDV = ((ZSupSurf - LayH) * state.dataRoomAirMod->ZTMX(ZoneNum) + (LayH - ZInfSurf) * state.dataRoomAirMod->ZTOC(ZoneNum)) /
888 0 : (ZSupSurf - ZInfSurf);
889 0 : state.dataUCSDShared->HDoor(Ctd) = ((LayH - ZInfSurf) * HLD + (ZSupSurf - LayH) * HLU) / (ZSupSurf - ZInfSurf);
890 0 : state.dataUFADManager->HAT_MX += state.dataSurface->Surface(SurfNum).Area * (ZSupSurf - LayH) / (ZSupSurf - ZInfSurf) *
891 0 : state.dataHeatBalSurf->SurfTempIn(SurfNum) * HLU;
892 0 : state.dataUFADManager->HA_MX += state.dataSurface->Surface(SurfNum).Area * (ZSupSurf - LayH) / (ZSupSurf - ZInfSurf) * HLU;
893 0 : state.dataUFADManager->HAT_OC += state.dataSurface->Surface(SurfNum).Area * (LayH - ZInfSurf) / (ZSupSurf - ZInfSurf) *
894 0 : state.dataHeatBalSurf->SurfTempIn(SurfNum) * HLD;
895 0 : state.dataUFADManager->HA_OC += state.dataSurface->Surface(SurfNum).Area * (LayH - ZInfSurf) / (ZSupSurf - ZInfSurf) * HLD;
896 0 : state.dataHeatBal->SurfTempEffBulkAir(SurfNum) = TmedDV;
897 : }
898 :
899 0 : state.dataRoomAirMod->UFHcIn(SurfNum) = state.dataUCSDShared->HDoor(Ctd);
900 :
901 : } // END DOOR
902 :
903 : // INTERNAL Hc, HA and HAT CALCULATION
904 79562 : state.dataUFADManager->HeightIntMass =
905 79562 : min(state.dataUFADManager->HeightIntMassDefault,
906 79562 : (state.dataRoomAirMod->ZoneCeilingHeight((ZoneNum - 1) * 2 + 2) - state.dataRoomAirMod->ZoneCeilingHeight((ZoneNum - 1) * 2 + 1)));
907 79562 : for (Ctd = state.dataUCSDShared->PosZ_Internal((ZoneNum - 1) * 2 + 1); Ctd <= state.dataUCSDShared->PosZ_Internal((ZoneNum - 1) * 2 + 2);
908 : ++Ctd) {
909 0 : SurfNum = state.dataUCSDShared->APos_Internal(Ctd);
910 0 : state.dataSurface->SurfTAirRef(SurfNum) = DataSurfaces::RefAirTemp::AdjacentAirTemp;
911 0 : state.dataSurface->SurfTAirRefRpt(SurfNum) = DataSurfaces::SurfTAirRefReportVals[state.dataSurface->SurfTAirRef(SurfNum)];
912 0 : if (SurfNum == 0) continue;
913 0 : ZSupSurf = state.dataUFADManager->HeightIntMass;
914 0 : ZInfSurf = 0.0;
915 :
916 0 : if (ZSupSurf < LayH) {
917 0 : state.dataHeatBal->SurfTempEffBulkAir(SurfNum) = state.dataRoomAirMod->ZTOC(ZoneNum);
918 0 : CalcDetailedHcInForDVModel(state, SurfNum, state.dataHeatBalSurf->SurfTempIn, state.dataRoomAirMod->UFHcIn);
919 0 : state.dataUCSDShared->HInternal(Ctd) = state.dataRoomAirMod->UFHcIn(SurfNum);
920 0 : state.dataUFADManager->HAT_OC +=
921 0 : state.dataSurface->Surface(SurfNum).Area * state.dataHeatBalSurf->SurfTempIn(SurfNum) * state.dataUCSDShared->HInternal(Ctd);
922 0 : state.dataUFADManager->HA_OC += state.dataSurface->Surface(SurfNum).Area * state.dataUCSDShared->HInternal(Ctd);
923 : }
924 :
925 0 : if (ZInfSurf <= LayH && ZSupSurf >= LayH) {
926 0 : state.dataHeatBal->SurfTempEffBulkAir(SurfNum) = state.dataRoomAirMod->ZTMX(ZoneNum);
927 0 : CalcDetailedHcInForDVModel(state, SurfNum, state.dataHeatBalSurf->SurfTempIn, state.dataRoomAirMod->UFHcIn);
928 0 : HLU = state.dataRoomAirMod->UFHcIn(SurfNum);
929 0 : state.dataHeatBal->SurfTempEffBulkAir(SurfNum) = state.dataRoomAirMod->ZTOC(ZoneNum);
930 0 : CalcDetailedHcInForDVModel(state, SurfNum, state.dataHeatBalSurf->SurfTempIn, state.dataRoomAirMod->UFHcIn);
931 0 : HLD = state.dataRoomAirMod->UFHcIn(SurfNum);
932 0 : TmedDV = ((ZSupSurf - LayH) * state.dataRoomAirMod->ZTMX(ZoneNum) + (LayH - ZInfSurf) * state.dataRoomAirMod->ZTOC(ZoneNum)) /
933 0 : (ZSupSurf - ZInfSurf);
934 0 : state.dataUCSDShared->HInternal(Ctd) = ((LayH - ZInfSurf) * HLD + (ZSupSurf - LayH) * HLU) / (ZSupSurf - ZInfSurf);
935 0 : state.dataUFADManager->HAT_MX += state.dataSurface->Surface(SurfNum).Area * (ZSupSurf - LayH) / (ZSupSurf - ZInfSurf) *
936 0 : state.dataHeatBalSurf->SurfTempIn(SurfNum) * HLU;
937 0 : state.dataUFADManager->HA_MX += state.dataSurface->Surface(SurfNum).Area * (ZSupSurf - LayH) / (ZSupSurf - ZInfSurf) * HLU;
938 0 : state.dataUFADManager->HAT_OC += state.dataSurface->Surface(SurfNum).Area * (LayH - ZInfSurf) / (ZSupSurf - ZInfSurf) *
939 0 : state.dataHeatBalSurf->SurfTempIn(SurfNum) * HLD;
940 0 : state.dataUFADManager->HA_OC += state.dataSurface->Surface(SurfNum).Area * (LayH - ZInfSurf) / (ZSupSurf - ZInfSurf) * HLD;
941 0 : state.dataHeatBal->SurfTempEffBulkAir(SurfNum) = TmedDV;
942 : }
943 :
944 0 : state.dataRoomAirMod->UFHcIn(SurfNum) = state.dataUCSDShared->HInternal(Ctd);
945 : } // END INTERNAL
946 :
947 : // CEILING Hc, HA and HAT CALCULATION
948 159124 : for (Ctd = state.dataUCSDShared->PosZ_Ceiling((ZoneNum - 1) * 2 + 1); Ctd <= state.dataUCSDShared->PosZ_Ceiling((ZoneNum - 1) * 2 + 2);
949 : ++Ctd) {
950 79562 : SurfNum = state.dataUCSDShared->APos_Ceiling(Ctd);
951 79562 : state.dataSurface->SurfTAirRef(SurfNum) = DataSurfaces::RefAirTemp::AdjacentAirTemp;
952 79562 : state.dataSurface->SurfTAirRefRpt(SurfNum) = DataSurfaces::SurfTAirRefReportVals[state.dataSurface->SurfTAirRef(SurfNum)];
953 79562 : if (SurfNum == 0) continue;
954 79562 : state.dataHeatBal->SurfTempEffBulkAir(SurfNum) = state.dataRoomAirMod->ZTMX(ZoneNum);
955 79562 : CalcDetailedHcInForDVModel(state, SurfNum, state.dataHeatBalSurf->SurfTempIn, state.dataRoomAirMod->UFHcIn);
956 79562 : state.dataUCSDShared->HCeiling(Ctd) = state.dataRoomAirMod->UFHcIn(SurfNum);
957 79562 : state.dataUFADManager->HAT_MX +=
958 79562 : state.dataSurface->Surface(SurfNum).Area * state.dataHeatBalSurf->SurfTempIn(SurfNum) * state.dataUCSDShared->HCeiling(Ctd);
959 79562 : state.dataUFADManager->HA_MX += state.dataSurface->Surface(SurfNum).Area * state.dataUCSDShared->HCeiling(Ctd);
960 79562 : state.dataRoomAirMod->UFHcIn(SurfNum) = state.dataUCSDShared->HCeiling(Ctd);
961 : } // END CEILING
962 :
963 : // FLOOR Hc, HA and HAT CALCULATION
964 159124 : for (Ctd = state.dataUCSDShared->PosZ_Floor((ZoneNum - 1) * 2 + 1); Ctd <= state.dataUCSDShared->PosZ_Floor((ZoneNum - 1) * 2 + 2); ++Ctd) {
965 79562 : SurfNum = state.dataUCSDShared->APos_Floor(Ctd);
966 79562 : state.dataSurface->SurfTAirRef(SurfNum) = DataSurfaces::RefAirTemp::AdjacentAirTemp;
967 79562 : state.dataSurface->SurfTAirRefRpt(SurfNum) = DataSurfaces::SurfTAirRefReportVals[state.dataSurface->SurfTAirRef(SurfNum)];
968 79562 : if (SurfNum == 0) continue;
969 79562 : state.dataHeatBal->SurfTempEffBulkAir(SurfNum) = state.dataRoomAirMod->ZTFloor(ZoneNum);
970 79562 : CalcDetailedHcInForDVModel(state, SurfNum, state.dataHeatBalSurf->SurfTempIn, state.dataRoomAirMod->UFHcIn);
971 79562 : state.dataUCSDShared->HFloor(Ctd) = state.dataRoomAirMod->UFHcIn(SurfNum);
972 79562 : state.dataUFADManager->HAT_OC +=
973 79562 : state.dataSurface->Surface(SurfNum).Area * state.dataHeatBalSurf->SurfTempIn(SurfNum) * state.dataUCSDShared->HFloor(Ctd);
974 79562 : state.dataUFADManager->HA_OC += state.dataSurface->Surface(SurfNum).Area * state.dataUCSDShared->HFloor(Ctd);
975 79562 : state.dataHeatBal->SurfTempEffBulkAir(SurfNum) = state.dataRoomAirMod->ZTFloor(ZoneNum);
976 79562 : state.dataRoomAirMod->UFHcIn(SurfNum) = state.dataUCSDShared->HFloor(Ctd);
977 : } // END FLOOR
978 : }
979 79562 : }
980 :
981 3516 : void CalcUCSDUI(EnergyPlusData &state, int const ZoneNum) // index number for the specified zone
982 : {
983 :
984 : // SUBROUTINE INFORMATION:
985 : // AUTHOR Fred Buhl
986 : // DATE WRITTEN August 2005
987 : // MODIFIED Brent Griffith June 2008 for new interpolation and time history
988 : // RE-ENGINEERED na
989 :
990 : // PURPOSE OF THIS SUBROUTINE:
991 : // Using the UCSD UFAD interior zone model, this subroutine calculates the occupied subzone height,
992 : // surface heat transfer coefficients, the occupied subzone temperature, and the upper subzone temperature.
993 :
994 : // METHODOLOGY EMPLOYED:
995 : // The zone is divided into 2 subzones with a variable transition height.
996 :
997 : // REFERENCES:
998 : // The model is described in the EnergyPlus Engineering Reference in Anna Liu's UCSD PhD thesis.
999 :
1000 : // Using/Aliasing
1001 : using Psychrometrics::PsyCpAirFnW;
1002 : using Psychrometrics::PsyRhoAirFnPbTdbW;
1003 3516 : auto &TimeStepSys = state.dataHVACGlobal->TimeStepSys;
1004 : using InternalHeatGains::SumInternalConvectionGainsByTypes;
1005 : using InternalHeatGains::SumReturnAirConvectionGainsByTypes;
1006 :
1007 : // Locals
1008 : // SUBROUTINE ARGUMENT DEFINITIONS:
1009 :
1010 : // SUBROUTINE PARAMETER DEFINITIONS:
1011 : // na
1012 :
1013 : // INTERFACE BLOCK SPECIFICATIONS:
1014 : // na
1015 :
1016 : // DERIVED TYPE DEFINITIONS:
1017 : // na
1018 :
1019 : // SUBROUTINE LOCAL VARIABLE DECLARATIONS:
1020 3516 : bool MIXFLAG(false); // if true treat as a mixed zone
1021 : Real64 CeilingHeight; // zone ceiling height above floor [m]
1022 : int UINum; // index to underfloor interior zone model data
1023 : Real64 GainsFrac; // fraction of occupied subzone heat gains that remain in the subzone;
1024 : // that is, don't go into the plumes
1025 : // REAL(r64) :: NumPLPP ! number of plumes per person
1026 : Real64 HeightThermostat; // height of the thermostat above the floor [m]
1027 : Real64 HeightComfort; // height at which comfort temperature is calculated
1028 : Real64 TempDiffCritRep; // Minimum temperature difference between upper and occupied subzones for reporting
1029 : Real64 ConvGainsOccSubzone; // convective heat gains into the lower (occupied) subzone [W]
1030 : Real64 ConvGainsUpSubzone; // convective heat gains into the upper subzone [W]
1031 : Real64 ConvGains; // total zone convective gains (excluding surfaces) [W]
1032 : int ZoneEquipConfigNum; // ZoneEquipConfig index for this UFAD zone
1033 : Real64 SumSysMCp; // Sum of system mass flow rate * specific heat for this zone [W/K]
1034 : Real64 SumSysMCpT; // Sum of system mass flow rate * specific heat * temperature for this zone [W]
1035 : Real64 SumSysM; // Sum of systems mass flow rate [kg/s]
1036 : Real64 NodeTemp; // inlet node temperature [K]
1037 : Real64 MassFlowRate; // system mass flow rate [kg/s]
1038 : Real64 CpAir; // specific heat of air [J/kgK]
1039 : int InNodeIndex; // inlet node index in ZoneEquipConfig
1040 : Real64 SumMCp; // mass flow rate * specific heat for this zone for infiltration, ventilation, mixing [W/K]
1041 : Real64 SumMCpT; // mass flow rate * specific heat* temp for this zone for infiltration, ventilation, mixing [W]
1042 : Real64 MCp_Total; // total mass flow rate * specific heat for this zone [W/K]
1043 : Real64 MCpT_Total; // total mass flow rate * specific heat* temp for this zone [W]
1044 : Real64 NumberOfPlumes;
1045 : Real64 PowerInPlumes; // [W]
1046 3516 : Real64 PowerPerPlume(0.0); // power generating each plume [W]
1047 : Real64 HeightFrac; // Fractional height of transition between occupied and upper subzones
1048 : Real64 TotSysFlow; // [m3/s]
1049 : Real64 NumDiffusersPerPlume;
1050 : Real64 NumDiffusers;
1051 : Real64 TSupK; // supply yemperature [K]
1052 : Real64 Gamma; // dimensionless height parameter; higher gamma means interface height will be
1053 : // higher, smaller gamma means interface height will be lower.
1054 : Real64 DiffArea; // diffuser effective area [m2]
1055 : Real64 ThrowAngle; // diffuser slot angle relative to vertical [radians]
1056 : Real64 SourceHeight; // height of plume sources above the floor [m]
1057 : int Ctd;
1058 : Real64 TempHistTerm;
1059 : Real64 ZTAveraged;
1060 : Real64 HeightUpSubzoneAve; // Height of center of upper air subzone
1061 : Real64 HeightOccupiedSubzoneAve; // Height of center of occupied air subzone
1062 : Real64 ZoneMult; // total zone multiplier
1063 : int ZoneNodeNum; // node number of the HVAC zone node
1064 : static constexpr std::array<DataHeatBalance::IntGainType, 30> IntGainTypesOccupied = {
1065 : DataHeatBalance::IntGainType::People,
1066 : DataHeatBalance::IntGainType::WaterHeaterMixed,
1067 : DataHeatBalance::IntGainType::WaterHeaterStratified,
1068 : DataHeatBalance::IntGainType::ThermalStorageChilledWaterMixed,
1069 : DataHeatBalance::IntGainType::ThermalStorageChilledWaterStratified,
1070 : DataHeatBalance::IntGainType::ElectricEquipment,
1071 : DataHeatBalance::IntGainType::ElectricEquipmentITEAirCooled,
1072 : DataHeatBalance::IntGainType::GasEquipment,
1073 : DataHeatBalance::IntGainType::HotWaterEquipment,
1074 : DataHeatBalance::IntGainType::SteamEquipment,
1075 : DataHeatBalance::IntGainType::OtherEquipment,
1076 : DataHeatBalance::IntGainType::ZoneBaseboardOutdoorTemperatureControlled,
1077 : DataHeatBalance::IntGainType::GeneratorFuelCell,
1078 : DataHeatBalance::IntGainType::WaterUseEquipment,
1079 : DataHeatBalance::IntGainType::GeneratorMicroCHP,
1080 : DataHeatBalance::IntGainType::ElectricLoadCenterTransformer,
1081 : DataHeatBalance::IntGainType::ElectricLoadCenterInverterSimple,
1082 : DataHeatBalance::IntGainType::ElectricLoadCenterInverterFunctionOfPower,
1083 : DataHeatBalance::IntGainType::ElectricLoadCenterInverterLookUpTable,
1084 : DataHeatBalance::IntGainType::ElectricLoadCenterStorageLiIonNmcBattery,
1085 : DataHeatBalance::IntGainType::ElectricLoadCenterStorageBattery,
1086 : DataHeatBalance::IntGainType::ElectricLoadCenterStorageSimple,
1087 : DataHeatBalance::IntGainType::PipeIndoor,
1088 : DataHeatBalance::IntGainType::RefrigerationCase,
1089 : DataHeatBalance::IntGainType::RefrigerationCompressorRack,
1090 : DataHeatBalance::IntGainType::RefrigerationSystemAirCooledCondenser,
1091 : DataHeatBalance::IntGainType::RefrigerationSystemSuctionPipe,
1092 : DataHeatBalance::IntGainType::RefrigerationSecondaryReceiver,
1093 : DataHeatBalance::IntGainType::RefrigerationSecondaryPipe,
1094 : DataHeatBalance::IntGainType::RefrigerationWalkIn};
1095 :
1096 : static constexpr std::array<DataHeatBalance::IntGainType, 2> IntGainTypesUpSubzone = {DataHeatBalance::IntGainType::DaylightingDeviceTubular,
1097 : DataHeatBalance::IntGainType::Lights};
1098 : Real64 RetAirGains;
1099 :
1100 : // Exact solution or Euler method
1101 3516 : if (state.dataHeatBal->ZoneAirSolutionAlgo != DataHeatBalance::SolutionAlgo::ThirdOrder) {
1102 0 : if (state.dataHVACGlobal->ShortenTimeStepSysRoomAir && TimeStepSys < state.dataGlobal->TimeStepZone) {
1103 0 : if (state.dataHVACGlobal->PreviousTimeStep < state.dataGlobal->TimeStepZone) {
1104 0 : state.dataRoomAirMod->Zone1OC(ZoneNum) = state.dataRoomAirMod->ZoneM2OC(ZoneNum);
1105 0 : state.dataRoomAirMod->Zone1MX(ZoneNum) = state.dataRoomAirMod->ZoneM2MX(ZoneNum);
1106 : } else {
1107 0 : state.dataRoomAirMod->Zone1OC(ZoneNum) = state.dataRoomAirMod->ZoneMXOC(ZoneNum);
1108 0 : state.dataRoomAirMod->Zone1MX(ZoneNum) = state.dataRoomAirMod->ZoneMXMX(ZoneNum);
1109 : }
1110 : } else {
1111 0 : state.dataRoomAirMod->Zone1OC(ZoneNum) = state.dataRoomAirMod->ZTOC(ZoneNum);
1112 0 : state.dataRoomAirMod->Zone1MX(ZoneNum) = state.dataRoomAirMod->ZTMX(ZoneNum);
1113 : }
1114 : }
1115 :
1116 3516 : auto &thisZoneHB = state.dataZoneTempPredictorCorrector->zoneHeatBalance(ZoneNum);
1117 3516 : MIXFLAG = false;
1118 3516 : state.dataRoomAirMod->UFHcIn = state.dataHeatBalSurf->SurfHConvInt;
1119 3516 : SumSysMCp = 0.0;
1120 3516 : SumSysMCpT = 0.0;
1121 3516 : TotSysFlow = 0.0;
1122 3516 : TSupK = 0.0;
1123 3516 : SumSysM = 0.0;
1124 3516 : ZoneMult = state.dataHeatBal->Zone(ZoneNum).Multiplier * state.dataHeatBal->Zone(ZoneNum).ListMultiplier;
1125 3516 : CeilingHeight = state.dataRoomAirMod->ZoneCeilingHeight((ZoneNum - 1) * 2 + 2) - state.dataRoomAirMod->ZoneCeilingHeight((ZoneNum - 1) * 2 + 1);
1126 3516 : UINum = state.dataRoomAirMod->ZoneUFPtr(ZoneNum);
1127 3516 : HeightThermostat = state.dataRoomAirMod->ZoneUCSDUI(UINum).ThermostatHeight;
1128 3516 : HeightComfort = state.dataRoomAirMod->ZoneUCSDUI(UINum).ComfortHeight;
1129 3516 : TempDiffCritRep = state.dataRoomAirMod->ZoneUCSDUI(UINum).TempTrigger;
1130 3516 : DiffArea = state.dataRoomAirMod->ZoneUCSDUI(UINum).DiffArea;
1131 3516 : ThrowAngle = DataGlobalConstants::DegToRadians * state.dataRoomAirMod->ZoneUCSDUI(UINum).DiffAngle;
1132 3516 : SourceHeight = 0.0;
1133 3516 : NumDiffusers = state.dataRoomAirMod->ZoneUCSDUI(UINum).DiffusersPerZone;
1134 3516 : PowerPerPlume = state.dataRoomAirMod->ZoneUCSDUI(UINum).PowerPerPlume;
1135 : // gains from occupants, task lighting, elec equip, gas equip, other equip, hot water equip, steam equip,
1136 : // baseboards (nonthermostatic), water heater skin loss
1137 3516 : ConvGainsOccSubzone = SumInternalConvectionGainsByTypes(state, ZoneNum, IntGainTypesOccupied);
1138 :
1139 : // Add heat to return air if zonal system (no return air) or cycling system (return air frequently very
1140 : // low or zero)
1141 3516 : if (state.dataHeatBal->Zone(ZoneNum).NoHeatToReturnAir) {
1142 0 : RetAirGains = SumReturnAirConvectionGainsByTypes(state, ZoneNum, IntGainTypesOccupied);
1143 0 : ConvGainsOccSubzone += RetAirGains;
1144 : }
1145 :
1146 : // Add convection from pool cover to occupied region
1147 3516 : ConvGainsOccSubzone += state.dataHeatBalFanSys->SumConvPool(ZoneNum);
1148 :
1149 : // gains from lights (ceiling), tubular daylighting devices, high temp radiant heaters
1150 :
1151 3516 : ConvGainsUpSubzone = SumInternalConvectionGainsByTypes(state, ZoneNum, IntGainTypesUpSubzone);
1152 3516 : ConvGainsUpSubzone += state.dataHeatBalFanSys->SumConvHTRadSys(ZoneNum);
1153 3516 : if (state.dataHeatBal->Zone(ZoneNum).NoHeatToReturnAir) {
1154 0 : RetAirGains = SumReturnAirConvectionGainsByTypes(state, ZoneNum, IntGainTypesUpSubzone);
1155 0 : ConvGainsUpSubzone += RetAirGains;
1156 : }
1157 3516 : ConvGains = ConvGainsOccSubzone + ConvGainsUpSubzone + thisZoneHB.SysDepZoneLoadsLagged;
1158 3516 : ZoneEquipConfigNum = state.dataRoomAirMod->ZoneUCSDUI(UINum).ZoneEquipPtr;
1159 3516 : if (ZoneEquipConfigNum > 0) {
1160 7032 : for (InNodeIndex = 1; InNodeIndex <= state.dataZoneEquip->ZoneEquipConfig(ZoneEquipConfigNum).NumInletNodes; ++InNodeIndex) {
1161 3516 : NodeTemp = state.dataLoopNodes->Node(state.dataZoneEquip->ZoneEquipConfig(ZoneEquipConfigNum).InletNode(InNodeIndex)).Temp;
1162 3516 : MassFlowRate = state.dataLoopNodes->Node(state.dataZoneEquip->ZoneEquipConfig(ZoneEquipConfigNum).InletNode(InNodeIndex)).MassFlowRate;
1163 3516 : CpAir = PsyCpAirFnW(thisZoneHB.ZoneAirHumRat);
1164 3516 : SumSysMCp += MassFlowRate * CpAir;
1165 3516 : SumSysMCpT += MassFlowRate * CpAir * NodeTemp;
1166 3516 : TotSysFlow += MassFlowRate / PsyRhoAirFnPbTdbW(state, state.dataEnvrn->OutBaroPress, NodeTemp, thisZoneHB.ZoneAirHumRat);
1167 3516 : TSupK += MassFlowRate * NodeTemp;
1168 3516 : SumSysM += MassFlowRate;
1169 : }
1170 3516 : if (TotSysFlow > 0.0) {
1171 3088 : TSupK = TSupK / SumSysM + DataGlobalConstants::KelvinConv;
1172 : } else {
1173 428 : TSupK = 0.0;
1174 : }
1175 : }
1176 : // mass flow times specific heat for infiltration, ventilation, mixing, earth tube
1177 3516 : SumMCp = thisZoneHB.MCPI + thisZoneHB.MCPV + thisZoneHB.MCPM + thisZoneHB.MCPE + thisZoneHB.MCPC + thisZoneHB.MDotCPOA;
1178 : // mass flow times specific heat times temperature for infiltration, ventilation, mixing, earth tube
1179 7032 : SumMCpT = thisZoneHB.MCPTI + thisZoneHB.MCPTV + thisZoneHB.MCPTM + thisZoneHB.MCPTE + thisZoneHB.MCPTC +
1180 3516 : thisZoneHB.MDotCPOA * state.dataHeatBal->Zone(ZoneNum).OutDryBulbTemp;
1181 3516 : MCp_Total = SumMCp + SumSysMCp;
1182 3516 : MCpT_Total = SumMCpT + SumSysMCpT;
1183 : // For the York MIT diffusers (variable area) the area varies with the flow rate. Assume 400 ft/min velocity
1184 : // at the diffuser, and a design flow rate of 150 cfm (.0708 m3/s). Then the design area for each diffuser is
1185 : // 150 ft3/min / 400 ft/min = .375 ft2 = .035 m2. This is adjusted each time step by
1186 : // (TotSysFlow/(NumDiffusers*.0708))*.035
1187 3516 : if (state.dataRoomAirMod->ZoneUCSDUI(UINum).DiffuserType == Diffuser::VarArea) {
1188 0 : DiffArea = 0.035 * TotSysFlow / (0.0708 * NumDiffusers);
1189 : }
1190 : // initial estimate of convective transfer from surfaces; assume HeightFrac is 0.5.
1191 3516 : HcUCSDUF(state, ZoneNum, 0.5);
1192 10548 : PowerInPlumes = ConvGains + state.dataUFADManager->HAT_OC - state.dataUFADManager->HA_OC * state.dataRoomAirMod->ZTOC(ZoneNum) +
1193 7032 : state.dataUFADManager->HAT_MX - state.dataUFADManager->HA_MX * state.dataRoomAirMod->ZTMX(ZoneNum);
1194 3516 : if (PowerPerPlume > 0.0 && PowerInPlumes > 0.0) {
1195 1950 : NumberOfPlumes = PowerInPlumes / PowerPerPlume;
1196 1950 : NumDiffusersPerPlume = NumDiffusers / NumberOfPlumes;
1197 : } else {
1198 1566 : NumberOfPlumes = 1.0;
1199 1566 : NumDiffusersPerPlume = 1.0;
1200 : }
1201 3516 : if ((PowerInPlumes <= 0.0) || (TotSysFlow == 0.0) || (TSupK - DataGlobalConstants::KelvinConv) > thisZoneHB.MAT) {
1202 : // The system will mix
1203 1782 : HeightFrac = 0.0;
1204 : } else {
1205 3468 : Gamma = std::pow(TotSysFlow * std::cos(ThrowAngle), 1.5) /
1206 1734 : (NumberOfPlumes * std::pow(NumDiffusersPerPlume * DiffArea, 1.25) * std::sqrt(0.0281 * 0.001 * PowerInPlumes));
1207 1734 : if (state.dataRoomAirMod->ZoneUCSDUI(UINum).CalcTransHeight) {
1208 0 : HeightFrac = (std::sqrt(NumDiffusersPerPlume * DiffArea) * (7.43 * std::log(Gamma) - 1.35) + 0.5 * SourceHeight) / CeilingHeight;
1209 : } else {
1210 1734 : HeightFrac = state.dataRoomAirMod->ZoneUCSDUI(UINum).TransHeight / CeilingHeight;
1211 : }
1212 1734 : HeightFrac = max(0.0, min(1.0, HeightFrac));
1213 8658 : for (Ctd = 1; Ctd <= 4; ++Ctd) {
1214 6928 : HcUCSDUF(state, ZoneNum, HeightFrac);
1215 20784 : PowerInPlumes = ConvGains + state.dataUFADManager->HAT_OC - state.dataUFADManager->HA_OC * state.dataRoomAirMod->ZTOC(ZoneNum) +
1216 13856 : state.dataUFADManager->HAT_MX - state.dataUFADManager->HA_MX * state.dataRoomAirMod->ZTMX(ZoneNum);
1217 6928 : if (PowerPerPlume > 0.0 && PowerInPlumes > 0.0) {
1218 6924 : NumberOfPlumes = PowerInPlumes / PowerPerPlume;
1219 6924 : NumDiffusersPerPlume = NumDiffusers / NumberOfPlumes;
1220 : } else {
1221 4 : NumberOfPlumes = 1.0;
1222 4 : NumDiffusersPerPlume = 1.0;
1223 : }
1224 6928 : if (PowerInPlumes <= 0.0) break;
1225 13848 : Gamma = std::pow(TotSysFlow * std::cos(ThrowAngle), 1.5) /
1226 6924 : (NumberOfPlumes * std::pow(NumDiffusersPerPlume * DiffArea, 1.25) * std::sqrt(0.0281 * 0.001 * PowerInPlumes));
1227 6924 : if (state.dataRoomAirMod->ZoneUCSDUI(UINum).CalcTransHeight) {
1228 0 : HeightFrac = (std::sqrt(NumDiffusersPerPlume * DiffArea) * (7.43 * std::log(Gamma) - 1.35) + 0.5 * SourceHeight) / CeilingHeight;
1229 : } else {
1230 6924 : HeightFrac = state.dataRoomAirMod->ZoneUCSDUI(UINum).TransHeight / CeilingHeight;
1231 : }
1232 6924 : HeightFrac = max(0.0, min(1.0, HeightFrac));
1233 6924 : state.dataRoomAirMod->HeightTransition(ZoneNum) = HeightFrac * CeilingHeight;
1234 20772 : GainsFrac = state.dataRoomAirMod->ZoneUCSDUI(UINum).A_Kc * std::pow(Gamma, state.dataRoomAirMod->ZoneUCSDUI(UINum).B_Kc) +
1235 13848 : state.dataRoomAirMod->ZoneUCSDUI(UINum).C_Kc + state.dataRoomAirMod->ZoneUCSDUI(UINum).D_Kc * Gamma +
1236 6924 : state.dataRoomAirMod->ZoneUCSDUI(UINum).E_Kc * pow_2(Gamma);
1237 6924 : GainsFrac = max(0.6, min(GainsFrac, 1.0));
1238 6924 : state.dataRoomAirMod->AIRRATOC(ZoneNum) =
1239 13848 : state.dataHeatBal->Zone(ZoneNum).Volume *
1240 20772 : (state.dataRoomAirMod->HeightTransition(ZoneNum) - min(state.dataRoomAirMod->HeightTransition(ZoneNum), 0.2)) / CeilingHeight *
1241 13848 : state.dataHeatBal->Zone(ZoneNum).ZoneVolCapMultpSens *
1242 20772 : PsyRhoAirFnPbTdbW(state, state.dataEnvrn->OutBaroPress, state.dataRoomAirMod->MATOC(ZoneNum), thisZoneHB.ZoneAirHumRat) *
1243 13848 : PsyCpAirFnW(thisZoneHB.ZoneAirHumRat) / (TimeStepSys * DataGlobalConstants::SecInHour);
1244 6924 : state.dataRoomAirMod->AIRRATMX(ZoneNum) =
1245 13848 : state.dataHeatBal->Zone(ZoneNum).Volume * (CeilingHeight - state.dataRoomAirMod->HeightTransition(ZoneNum)) / CeilingHeight *
1246 13848 : state.dataHeatBal->Zone(ZoneNum).ZoneVolCapMultpSens *
1247 20772 : PsyRhoAirFnPbTdbW(state, state.dataEnvrn->OutBaroPress, state.dataRoomAirMod->MATMX(ZoneNum), thisZoneHB.ZoneAirHumRat) *
1248 13848 : PsyCpAirFnW(thisZoneHB.ZoneAirHumRat) / (TimeStepSys * DataGlobalConstants::SecInHour);
1249 :
1250 6924 : if (state.dataHVACGlobal->UseZoneTimeStepHistory) {
1251 4428 : state.dataRoomAirMod->ZTM3OC(ZoneNum) = state.dataRoomAirMod->XM3TOC(ZoneNum);
1252 4428 : state.dataRoomAirMod->ZTM2OC(ZoneNum) = state.dataRoomAirMod->XM2TOC(ZoneNum);
1253 4428 : state.dataRoomAirMod->ZTM1OC(ZoneNum) = state.dataRoomAirMod->XMATOC(ZoneNum);
1254 :
1255 4428 : state.dataRoomAirMod->ZTM3MX(ZoneNum) = state.dataRoomAirMod->XM3TMX(ZoneNum);
1256 4428 : state.dataRoomAirMod->ZTM2MX(ZoneNum) = state.dataRoomAirMod->XM2TMX(ZoneNum);
1257 4428 : state.dataRoomAirMod->ZTM1MX(ZoneNum) = state.dataRoomAirMod->XMATMX(ZoneNum);
1258 :
1259 : } else {
1260 2496 : state.dataRoomAirMod->ZTM3OC(ZoneNum) = state.dataRoomAirMod->DSXM3TOC(ZoneNum);
1261 2496 : state.dataRoomAirMod->ZTM2OC(ZoneNum) = state.dataRoomAirMod->DSXM2TOC(ZoneNum);
1262 2496 : state.dataRoomAirMod->ZTM1OC(ZoneNum) = state.dataRoomAirMod->DSXMATOC(ZoneNum);
1263 :
1264 2496 : state.dataRoomAirMod->ZTM3MX(ZoneNum) = state.dataRoomAirMod->DSXM3TMX(ZoneNum);
1265 2496 : state.dataRoomAirMod->ZTM2MX(ZoneNum) = state.dataRoomAirMod->DSXM2TMX(ZoneNum);
1266 2496 : state.dataRoomAirMod->ZTM1MX(ZoneNum) = state.dataRoomAirMod->DSXMATMX(ZoneNum);
1267 : }
1268 :
1269 6924 : Real64 AirCap = state.dataRoomAirMod->AIRRATOC(ZoneNum);
1270 13848 : TempHistTerm = AirCap * (3.0 * state.dataRoomAirMod->ZTM1OC(ZoneNum) - (3.0 / 2.0) * state.dataRoomAirMod->ZTM2OC(ZoneNum) +
1271 6924 : (1.0 / 3.0) * state.dataRoomAirMod->ZTM3OC(ZoneNum));
1272 : // Formerly CoefSumha, coef in zone temp equation with dimensions of h*A
1273 6924 : Real64 TempDepCoef = GainsFrac * state.dataUFADManager->HA_OC + MCp_Total;
1274 13848 : Real64 TempIndCoef = GainsFrac * (ConvGains + state.dataUFADManager->HAT_OC + state.dataUFADManager->HAT_MX -
1275 13848 : state.dataUFADManager->HA_MX * state.dataRoomAirMod->ZTMX(ZoneNum)) +
1276 6924 : MCpT_Total + thisZoneHB.NonAirSystemResponse / ZoneMult;
1277 6924 : switch (state.dataHeatBal->ZoneAirSolutionAlgo) {
1278 6924 : case DataHeatBalance::SolutionAlgo::ThirdOrder: {
1279 13848 : state.dataRoomAirMod->ZTOC(ZoneNum) = (TempHistTerm +
1280 13848 : GainsFrac * (ConvGains + state.dataUFADManager->HAT_OC + state.dataUFADManager->HAT_MX -
1281 13848 : state.dataUFADManager->HA_MX * state.dataRoomAirMod->ZTMX(ZoneNum)) +
1282 13848 : MCpT_Total + thisZoneHB.NonAirSystemResponse / ZoneMult) /
1283 6924 : ((11.0 / 6.0) * AirCap + GainsFrac * state.dataUFADManager->HA_OC + MCp_Total);
1284 6924 : } break;
1285 0 : case DataHeatBalance::SolutionAlgo::AnalyticalSolution: {
1286 0 : if (TempDepCoef == 0.0) { // B=0
1287 0 : state.dataRoomAirMod->ZTOC(ZoneNum) = state.dataRoomAirMod->Zone1OC(ZoneNum) + TempIndCoef / AirCap;
1288 : } else {
1289 0 : state.dataRoomAirMod->ZTOC(ZoneNum) =
1290 0 : (state.dataRoomAirMod->Zone1OC(ZoneNum) - TempIndCoef / TempDepCoef) * std::exp(min(700.0, -TempDepCoef / AirCap)) +
1291 0 : TempIndCoef / TempDepCoef;
1292 : }
1293 0 : } break;
1294 0 : case DataHeatBalance::SolutionAlgo::EulerMethod: {
1295 0 : state.dataRoomAirMod->ZTOC(ZoneNum) = (AirCap * state.dataRoomAirMod->Zone1OC(ZoneNum) + TempIndCoef) / (AirCap + TempDepCoef);
1296 0 : } break;
1297 0 : default:
1298 0 : break;
1299 : }
1300 6924 : AirCap = state.dataRoomAirMod->AIRRATMX(ZoneNum);
1301 13848 : TempHistTerm = AirCap * (3.0 * state.dataRoomAirMod->ZTM1MX(ZoneNum) - (3.0 / 2.0) * state.dataRoomAirMod->ZTM2MX(ZoneNum) +
1302 6924 : (1.0 / 3.0) * state.dataRoomAirMod->ZTM3MX(ZoneNum));
1303 6924 : TempDepCoef = (1.0 - GainsFrac) * state.dataUFADManager->HA_MX + MCp_Total;
1304 20772 : TempIndCoef = (1.0 - GainsFrac) * (ConvGains + state.dataUFADManager->HAT_OC + state.dataUFADManager->HAT_MX -
1305 6924 : state.dataUFADManager->HA_OC * state.dataRoomAirMod->ZTOC(ZoneNum)) +
1306 6924 : state.dataRoomAirMod->ZTOC(ZoneNum) * MCp_Total;
1307 6924 : switch (state.dataHeatBal->ZoneAirSolutionAlgo) {
1308 6924 : case DataHeatBalance::SolutionAlgo::ThirdOrder: {
1309 6924 : state.dataRoomAirMod->ZTMX(ZoneNum) =
1310 6924 : (TempHistTerm +
1311 13848 : (1.0 - GainsFrac) * (ConvGains + state.dataUFADManager->HAT_OC + state.dataUFADManager->HAT_MX -
1312 13848 : state.dataUFADManager->HA_OC * state.dataRoomAirMod->ZTOC(ZoneNum)) +
1313 13848 : state.dataRoomAirMod->ZTOC(ZoneNum) * MCp_Total) /
1314 6924 : ((11.0 / 6.0) * AirCap + (1.0 - GainsFrac) * state.dataUFADManager->HA_MX + MCp_Total);
1315 6924 : } break;
1316 0 : case DataHeatBalance::SolutionAlgo::AnalyticalSolution: {
1317 0 : if (TempDepCoef == 0.0) { // B=0
1318 0 : state.dataRoomAirMod->ZTMX(ZoneNum) = state.dataRoomAirMod->Zone1MX(ZoneNum) + TempIndCoef / AirCap;
1319 : } else {
1320 0 : state.dataRoomAirMod->ZTMX(ZoneNum) =
1321 0 : (state.dataRoomAirMod->Zone1MX(ZoneNum) - TempIndCoef / TempDepCoef) * std::exp(min(700.0, -TempDepCoef / AirCap)) +
1322 0 : TempIndCoef / TempDepCoef;
1323 : }
1324 0 : } break;
1325 0 : case DataHeatBalance::SolutionAlgo::EulerMethod: {
1326 0 : state.dataRoomAirMod->ZTMX(ZoneNum) = (AirCap * state.dataRoomAirMod->Zone1MX(ZoneNum) + TempIndCoef) / (AirCap + TempDepCoef);
1327 0 : } break;
1328 0 : default:
1329 0 : break;
1330 : }
1331 6924 : state.dataRoomAirMod->ZTFloor(ZoneNum) = state.dataRoomAirMod->ZTOC(ZoneNum);
1332 : }
1333 1734 : if (PowerInPlumes <= 0.0) {
1334 4 : HeightFrac = 0.0;
1335 4 : state.dataRoomAirMod->AirModel(ZoneNum).SimAirModel = false;
1336 4 : state.dataRoomAirMod->ZoneUFGamma(ZoneNum) = 0.0;
1337 4 : state.dataRoomAirMod->ZoneUFPowInPlumes(ZoneNum) = 0.0;
1338 : } else {
1339 1730 : state.dataRoomAirMod->AirModel(ZoneNum).SimAirModel = true;
1340 1730 : state.dataRoomAirMod->ZoneUFGamma(ZoneNum) = Gamma;
1341 1730 : state.dataRoomAirMod->ZoneUFPowInPlumes(ZoneNum) = PowerInPlumes;
1342 : }
1343 : }
1344 :
1345 : //=============================== M I X E D Calculation ==============================================
1346 6630 : if (state.dataRoomAirMod->ZTMX(ZoneNum) < state.dataRoomAirMod->ZTOC(ZoneNum) || MCp_Total <= 0.0 ||
1347 3114 : HeightFrac * CeilingHeight < state.dataUFADManager->ThickOccupiedSubzoneMin) {
1348 1797 : MIXFLAG = true;
1349 1797 : HeightFrac = 0.0;
1350 1797 : state.dataRoomAirMod->AvgTempGrad(ZoneNum) = 0.0;
1351 1797 : state.dataRoomAirMod->MaxTempGrad(ZoneNum) = 0.0;
1352 1797 : state.dataRoomAirMod->AirModel(ZoneNum).SimAirModel = false;
1353 1797 : Real64 AirCap = thisZoneHB.AirPowerCap;
1354 1797 : TempHistTerm = AirCap * (3.0 * thisZoneHB.ZTM[0] - (3.0 / 2.0) * thisZoneHB.ZTM[1] + (1.0 / 3.0) * thisZoneHB.ZTM[2]);
1355 :
1356 7188 : for (Ctd = 1; Ctd <= 3; ++Ctd) {
1357 5391 : Real64 TempDepCoef = state.dataUFADManager->HA_MX + state.dataUFADManager->HA_OC + MCp_Total;
1358 5391 : Real64 const thisZoneT1 = thisZoneHB.ZoneT1;
1359 : // Formerly CoefSumhat, coef in zone temp equation with dimensions of h*A(T1
1360 5391 : Real64 TempIndCoef = ConvGains + state.dataUFADManager->HAT_MX + state.dataUFADManager->HAT_OC + MCpT_Total;
1361 5391 : switch (state.dataHeatBal->ZoneAirSolutionAlgo) {
1362 5391 : case DataHeatBalance::SolutionAlgo::ThirdOrder: {
1363 10782 : ZTAveraged = (TempHistTerm + ConvGains + state.dataUFADManager->HAT_MX + state.dataUFADManager->HAT_OC + MCpT_Total) /
1364 5391 : ((11.0 / 6.0) * AirCap + state.dataUFADManager->HA_MX + state.dataUFADManager->HA_OC + MCp_Total);
1365 5391 : } break;
1366 0 : case DataHeatBalance::SolutionAlgo::AnalyticalSolution: {
1367 0 : if (TempDepCoef == 0.0) { // B=0
1368 0 : ZTAveraged = thisZoneT1 + TempIndCoef / AirCap;
1369 : } else {
1370 0 : ZTAveraged = (thisZoneT1 - TempIndCoef / TempDepCoef) * std::exp(min(700.0, -TempDepCoef / AirCap)) + TempIndCoef / TempDepCoef;
1371 : }
1372 0 : } break;
1373 0 : case DataHeatBalance::SolutionAlgo::EulerMethod: {
1374 0 : ZTAveraged = (AirCap * thisZoneT1 + TempIndCoef) / (AirCap + TempDepCoef);
1375 0 : } break;
1376 0 : default:
1377 0 : break;
1378 : }
1379 5391 : state.dataRoomAirMod->ZTOC(ZoneNum) = ZTAveraged;
1380 5391 : state.dataRoomAirMod->ZTMX(ZoneNum) = ZTAveraged;
1381 5391 : state.dataRoomAirMod->ZTFloor(ZoneNum) = ZTAveraged;
1382 5391 : HcUCSDUF(state, ZoneNum, HeightFrac);
1383 5391 : TempDepCoef = state.dataUFADManager->HA_MX + state.dataUFADManager->HA_OC + MCp_Total;
1384 5391 : TempIndCoef = ConvGains + state.dataUFADManager->HAT_MX + state.dataUFADManager->HAT_OC + MCpT_Total;
1385 5391 : switch (state.dataHeatBal->ZoneAirSolutionAlgo) {
1386 5391 : case DataHeatBalance::SolutionAlgo::ThirdOrder: {
1387 10782 : ZTAveraged = (TempHistTerm + ConvGains + state.dataUFADManager->HAT_MX + state.dataUFADManager->HAT_OC + MCpT_Total) /
1388 5391 : ((11.0 / 6.0) * AirCap + state.dataUFADManager->HA_MX + state.dataUFADManager->HA_OC + MCp_Total);
1389 5391 : } break;
1390 0 : case DataHeatBalance::SolutionAlgo::AnalyticalSolution: {
1391 0 : if (TempDepCoef == 0.0) { // B=0
1392 0 : ZTAveraged = thisZoneT1 + TempIndCoef / AirCap;
1393 : } else {
1394 0 : ZTAveraged = (thisZoneT1 - TempIndCoef / TempDepCoef) * std::exp(min(700.0, -TempDepCoef / AirCap)) + TempIndCoef / TempDepCoef;
1395 : }
1396 0 : } break;
1397 0 : case DataHeatBalance::SolutionAlgo::EulerMethod: {
1398 0 : ZTAveraged = (AirCap * thisZoneT1 + TempIndCoef) / (AirCap + TempDepCoef);
1399 0 : } break;
1400 0 : default:
1401 0 : break;
1402 : }
1403 5391 : state.dataRoomAirMod->ZTOC(ZoneNum) = ZTAveraged;
1404 5391 : state.dataRoomAirMod->ZTMX(ZoneNum) = ZTAveraged;
1405 5391 : state.dataRoomAirMod->ZTFloor(ZoneNum) = ZTAveraged;
1406 : }
1407 : }
1408 : //=========================================================================================
1409 :
1410 : // Comfort temperature and temperature at the thermostat/temperature control sensor
1411 :
1412 3516 : state.dataRoomAirMod->HeightTransition(ZoneNum) = HeightFrac * CeilingHeight;
1413 3516 : HeightUpSubzoneAve = (CeilingHeight + state.dataRoomAirMod->HeightTransition(ZoneNum)) / 2.0;
1414 3516 : HeightOccupiedSubzoneAve = state.dataRoomAirMod->HeightTransition(ZoneNum) / 2.0;
1415 : // Comfort temperature
1416 :
1417 3516 : if (MIXFLAG) {
1418 1797 : state.dataRoomAirMod->TCMF(ZoneNum) = ZTAveraged;
1419 : } else {
1420 1719 : if (HeightComfort < HeightOccupiedSubzoneAve) {
1421 0 : state.dataRoomAirMod->TCMF(ZoneNum) = state.dataRoomAirMod->ZTOC(ZoneNum);
1422 1719 : } else if (HeightComfort >= HeightOccupiedSubzoneAve && HeightComfort < HeightUpSubzoneAve) {
1423 5157 : state.dataRoomAirMod->TCMF(ZoneNum) = (state.dataRoomAirMod->ZTOC(ZoneNum) * (HeightUpSubzoneAve - HeightComfort) +
1424 3438 : state.dataRoomAirMod->ZTMX(ZoneNum) * (HeightComfort - HeightOccupiedSubzoneAve)) /
1425 1719 : (HeightUpSubzoneAve - HeightOccupiedSubzoneAve);
1426 0 : } else if (HeightComfort >= HeightUpSubzoneAve && HeightComfort <= CeilingHeight) {
1427 0 : state.dataRoomAirMod->TCMF(ZoneNum) = state.dataRoomAirMod->ZTMX(ZoneNum);
1428 : } else {
1429 0 : ShowFatalError(state, "UFAD comfort height is above ceiling or below floor in Zone: " + state.dataHeatBal->Zone(ZoneNum).Name);
1430 : }
1431 : }
1432 :
1433 : // Temperature at the thermostat/temperature control sensor
1434 :
1435 3516 : if (MIXFLAG) {
1436 1797 : state.dataHeatBalFanSys->TempTstatAir(ZoneNum) = ZTAveraged;
1437 : } else {
1438 1719 : if (HeightThermostat < HeightOccupiedSubzoneAve) {
1439 0 : state.dataHeatBalFanSys->TempTstatAir(ZoneNum) = state.dataRoomAirMod->ZTOC(ZoneNum);
1440 1719 : } else if (HeightThermostat >= HeightOccupiedSubzoneAve && HeightThermostat < HeightUpSubzoneAve) {
1441 5157 : state.dataHeatBalFanSys->TempTstatAir(ZoneNum) = (state.dataRoomAirMod->ZTOC(ZoneNum) * (HeightUpSubzoneAve - HeightThermostat) +
1442 3438 : state.dataRoomAirMod->ZTMX(ZoneNum) * (HeightThermostat - HeightOccupiedSubzoneAve)) /
1443 1719 : (HeightUpSubzoneAve - HeightOccupiedSubzoneAve);
1444 0 : } else if (HeightThermostat >= HeightUpSubzoneAve && HeightThermostat <= CeilingHeight) {
1445 0 : state.dataHeatBalFanSys->TempTstatAir(ZoneNum) = state.dataRoomAirMod->ZTMX(ZoneNum);
1446 : } else {
1447 0 : ShowFatalError(state,
1448 0 : "Underfloor air distribution thermostat height is above ceiling or below floor in Zone: " +
1449 0 : state.dataHeatBal->Zone(ZoneNum).Name);
1450 : }
1451 : }
1452 :
1453 : // Temperature gradients
1454 3516 : if ((HeightUpSubzoneAve - HeightOccupiedSubzoneAve) > 0.1) {
1455 3516 : state.dataRoomAirMod->AvgTempGrad(ZoneNum) =
1456 3516 : (state.dataRoomAirMod->ZTMX(ZoneNum) - state.dataRoomAirMod->ZTOC(ZoneNum)) / (HeightUpSubzoneAve - HeightOccupiedSubzoneAve);
1457 : } else {
1458 0 : state.dataRoomAirMod->AvgTempGrad(ZoneNum) = 0.0;
1459 : }
1460 :
1461 3516 : if (MIXFLAG) {
1462 1797 : state.dataRoomAirMod->ZoneUFMixedFlag(ZoneNum) = 1;
1463 1797 : state.dataRoomAirMod->AirModel(ZoneNum).SimAirModel = false;
1464 : } else {
1465 1719 : state.dataRoomAirMod->ZoneUFMixedFlag(ZoneNum) = 0;
1466 1719 : state.dataRoomAirMod->AirModel(ZoneNum).SimAirModel = true;
1467 : }
1468 :
1469 3516 : if (ZoneEquipConfigNum > 0) {
1470 3516 : ZoneNodeNum = state.dataHeatBal->Zone(ZoneNum).SystemZoneNodeNumber;
1471 3516 : state.dataLoopNodes->Node(ZoneNodeNum).Temp = state.dataRoomAirMod->ZTMX(ZoneNum);
1472 : }
1473 :
1474 3516 : if (MIXFLAG) {
1475 1797 : state.dataRoomAirMod->Phi(ZoneNum) = 1.0;
1476 : } else {
1477 3438 : state.dataRoomAirMod->Phi(ZoneNum) = (state.dataRoomAirMod->ZTOC(ZoneNum) - (TSupK - DataGlobalConstants::KelvinConv)) /
1478 1719 : (state.dataRoomAirMod->ZTMX(ZoneNum) - (TSupK - DataGlobalConstants::KelvinConv));
1479 : }
1480 :
1481 : // Mixed for reporting purposes
1482 3516 : if ((MIXFLAG) || ((state.dataRoomAirMod->ZTMX(ZoneNum) - state.dataRoomAirMod->ZTOC(ZoneNum)) < TempDiffCritRep)) {
1483 1797 : state.dataRoomAirMod->ZoneUFMixedFlagRep(ZoneNum) = 1.0;
1484 1797 : state.dataRoomAirMod->HeightTransition(ZoneNum) = 0.0;
1485 1797 : state.dataRoomAirMod->AvgTempGrad(ZoneNum) = 0.0;
1486 : } else {
1487 1719 : state.dataRoomAirMod->ZoneUFMixedFlagRep(ZoneNum) = 0.0;
1488 : }
1489 3516 : }
1490 :
1491 14064 : void CalcUCSDUE(EnergyPlusData &state, int const ZoneNum) // index number for the specified zone
1492 : {
1493 :
1494 : // SUBROUTINE INFORMATION:
1495 : // AUTHOR Fred Buhl
1496 : // DATE WRITTEN January 2006
1497 : // MODIFIED Brent Griffith June 2008 for new interpolation and time history
1498 : // RE-ENGINEERED na
1499 :
1500 : // PURPOSE OF THIS SUBROUTINE:
1501 : // Using the UCSD UFAD exterior zone model, this subroutine calculates the occupied subzone height,
1502 : // surface heat transfer coefficients, the occupied subzone temperature, and the upper subzone temperature.
1503 :
1504 : // METHODOLOGY EMPLOYED:
1505 : // The zone is divided into 2 subzones with a variable transition height.
1506 :
1507 : // REFERENCES:
1508 : // The model is described in the EnergyPlus Engineering Reference in Anna Liu's UCSD PhD thesis.
1509 :
1510 : // Using/Aliasing
1511 : using Psychrometrics::PsyCpAirFnW;
1512 : using Psychrometrics::PsyRhoAirFnPbTdbW;
1513 14064 : auto &TimeStepSys = state.dataHVACGlobal->TimeStepSys;
1514 : using InternalHeatGains::SumInternalConvectionGainsByTypes;
1515 : using InternalHeatGains::SumReturnAirConvectionGainsByTypes;
1516 :
1517 : // Locals
1518 : // SUBROUTINE ARGUMENT DEFINITIONS:
1519 :
1520 : // SUBROUTINE PARAMETER DEFINITIONS:
1521 : // na
1522 :
1523 : // INTERFACE BLOCK SPECIFICATIONS:
1524 : // na
1525 :
1526 : // DERIVED TYPE DEFINITIONS:
1527 : // na
1528 :
1529 : // SUBROUTINE LOCAL VARIABLE DECLARATIONS:
1530 14064 : bool MIXFLAG(false); // if true treat as a mixed zone
1531 : Real64 CeilingHeight; // zone ceiling height above floor [m]
1532 : int UINum; // index to underfloor interior zone model data
1533 : Real64 GainsFrac; // fraction of occupied subzone heat gains that remain in the subzone;
1534 : // that is, don't go into the plumes
1535 : Real64 HeightThermostat; // height of the thermostat above the floor [m]
1536 : Real64 HeightComfort; // height at which comfort temperature is calculated
1537 : Real64 TempDiffCritRep; // Minimum temperature difference between upper and occupied subzones for reporting
1538 : Real64 ConvGainsOccSubzone; // convective heat gains into the lower (occupied) subzone [W]
1539 : Real64 ConvGainsUpSubzone; // convective heat gains into the upper subzone [W]
1540 : Real64 ConvGains; // total zone convective gains (excluding surfaces) [W]
1541 : Real64 ConvGainsWindows; // convective gain from windows [W]
1542 : int ZoneEquipConfigNum; // ZoneEquipConfig index for this UFAD zone
1543 : Real64 SumSysMCp; // Sum of system mass flow rate * specific heat for this zone [W/K]
1544 : Real64 SumSysMCpT; // Sum of system mass flow rate * specific heat * temperature for this zone [W]
1545 : Real64 SumSysM; // Sum of systems mass flow rate [kg/s]
1546 : Real64 NodeTemp; // inlet node temperature [K]
1547 : Real64 MassFlowRate; // system mass flow rate [kg/s]
1548 : Real64 CpAir; // specific heat of air [J/kgK]
1549 : int InNodeIndex; // inlet node index in ZoneEquipConfig
1550 : Real64 SumMCp; // mass flow rate * specific heat for this zone for infiltration, ventilation, mixing [W/K]
1551 : Real64 SumMCpT; // mass flow rate * specific heat* temp for this zone for infiltration, ventilation, mixing [W]
1552 : Real64 MCp_Total; // total mass flow rate * specific heat for this zone [W/K]
1553 : Real64 MCpT_Total; // total mass flow rate * specific heat* temp for this zone [W]
1554 : Real64 NumberOfPlumes;
1555 : Real64 PowerInPlumes; // [W]
1556 14064 : Real64 PowerPerPlume(0.0); // power carried by each plume [W]
1557 : Real64 PowerInPlumesPerMeter; // Power in Plumes per meter of window length [W/m]
1558 14064 : Real64 NumDiffusersPerPlume(0.0);
1559 : Real64 HeightFrac; // Fractional height of transition between occupied and upper subzones
1560 : Real64 TotSysFlow; // [m3/s]
1561 : Real64 NumDiffusers;
1562 : Real64 TSupK; // supply yemperature [K]
1563 : Real64 Gamma; // dimensionless height parameter; higher gamma means interface height will be
1564 : // higher, smaller gamma means interface height will be lower.
1565 : Real64 DiffArea; // diffuser effective area [m2]
1566 : Real64 ThrowAngle; // diffuser slot angle relative to vertical [radians]
1567 : Real64 SourceHeight; // height of plume sources above the floor [m]
1568 : int Ctd;
1569 : Real64 AirCap;
1570 : Real64 TempHistTerm;
1571 : Real64 ZTAveraged;
1572 : Real64 HeightUpSubzoneAve; // Height of center of upper air subzone
1573 : Real64 HeightOccupiedSubzoneAve; // Height of center of occupied air subzone
1574 : Real64 ZoneMult; // total zone multiplier
1575 : int ZoneNodeNum; // node number of the HVAC zone node
1576 14064 : Real64 TempDepCoef(0.0); // Formerly CoefSumha, coef in zone temp equation with dimensions of h*A
1577 14064 : Real64 TempIndCoef(0.0); // Formerly CoefSumhat, coef in zone temp equation with dimensions of h*A(T1
1578 : static constexpr std::array<DataHeatBalance::IntGainType, 30> IntGainTypesOccupied = {
1579 : DataHeatBalance::IntGainType::People,
1580 : DataHeatBalance::IntGainType::WaterHeaterMixed,
1581 : DataHeatBalance::IntGainType::WaterHeaterStratified,
1582 : DataHeatBalance::IntGainType::ThermalStorageChilledWaterMixed,
1583 : DataHeatBalance::IntGainType::ThermalStorageChilledWaterStratified,
1584 : DataHeatBalance::IntGainType::ElectricEquipment,
1585 : DataHeatBalance::IntGainType::ElectricEquipmentITEAirCooled,
1586 : DataHeatBalance::IntGainType::GasEquipment,
1587 : DataHeatBalance::IntGainType::HotWaterEquipment,
1588 : DataHeatBalance::IntGainType::SteamEquipment,
1589 : DataHeatBalance::IntGainType::OtherEquipment,
1590 : DataHeatBalance::IntGainType::ZoneBaseboardOutdoorTemperatureControlled,
1591 : DataHeatBalance::IntGainType::GeneratorFuelCell,
1592 : DataHeatBalance::IntGainType::WaterUseEquipment,
1593 : DataHeatBalance::IntGainType::GeneratorMicroCHP,
1594 : DataHeatBalance::IntGainType::ElectricLoadCenterTransformer,
1595 : DataHeatBalance::IntGainType::ElectricLoadCenterInverterSimple,
1596 : DataHeatBalance::IntGainType::ElectricLoadCenterInverterFunctionOfPower,
1597 : DataHeatBalance::IntGainType::ElectricLoadCenterInverterLookUpTable,
1598 : DataHeatBalance::IntGainType::ElectricLoadCenterStorageBattery,
1599 : DataHeatBalance::IntGainType::ElectricLoadCenterStorageLiIonNmcBattery,
1600 : DataHeatBalance::IntGainType::ElectricLoadCenterStorageSimple,
1601 : DataHeatBalance::IntGainType::PipeIndoor,
1602 : DataHeatBalance::IntGainType::RefrigerationCase,
1603 : DataHeatBalance::IntGainType::RefrigerationCompressorRack,
1604 : DataHeatBalance::IntGainType::RefrigerationSystemAirCooledCondenser,
1605 : DataHeatBalance::IntGainType::RefrigerationSystemSuctionPipe,
1606 : DataHeatBalance::IntGainType::RefrigerationSecondaryReceiver,
1607 : DataHeatBalance::IntGainType::RefrigerationSecondaryPipe,
1608 : DataHeatBalance::IntGainType::RefrigerationWalkIn};
1609 :
1610 : static constexpr std::array<DataHeatBalance::IntGainType, 2> IntGainTypesUpSubzone = {DataHeatBalance::IntGainType::DaylightingDeviceTubular,
1611 : DataHeatBalance::IntGainType::Lights};
1612 : Real64 RetAirGains;
1613 :
1614 : // Exact solution or Euler method
1615 14064 : if (state.dataHeatBal->ZoneAirSolutionAlgo != DataHeatBalance::SolutionAlgo::ThirdOrder) {
1616 0 : if (state.dataHVACGlobal->ShortenTimeStepSysRoomAir && TimeStepSys < state.dataGlobal->TimeStepZone) {
1617 0 : if (state.dataHVACGlobal->PreviousTimeStep < state.dataGlobal->TimeStepZone) {
1618 0 : state.dataRoomAirMod->Zone1OC(ZoneNum) = state.dataRoomAirMod->ZoneM2OC(ZoneNum);
1619 0 : state.dataRoomAirMod->Zone1MX(ZoneNum) = state.dataRoomAirMod->ZoneM2MX(ZoneNum);
1620 : } else {
1621 0 : state.dataRoomAirMod->Zone1OC(ZoneNum) = state.dataRoomAirMod->ZoneMXOC(ZoneNum);
1622 0 : state.dataRoomAirMod->Zone1MX(ZoneNum) = state.dataRoomAirMod->ZoneMXMX(ZoneNum);
1623 : }
1624 : } else {
1625 0 : state.dataRoomAirMod->Zone1OC(ZoneNum) = state.dataRoomAirMod->ZTOC(ZoneNum);
1626 0 : state.dataRoomAirMod->Zone1MX(ZoneNum) = state.dataRoomAirMod->ZTMX(ZoneNum);
1627 : }
1628 : }
1629 :
1630 14064 : auto &thisZoneHB = state.dataZoneTempPredictorCorrector->zoneHeatBalance(ZoneNum);
1631 14064 : HeightFrac = 0.0;
1632 14064 : MIXFLAG = false;
1633 14064 : state.dataRoomAirMod->UFHcIn = state.dataHeatBalSurf->SurfHConvInt;
1634 14064 : SumSysMCp = 0.0;
1635 14064 : SumSysMCpT = 0.0;
1636 14064 : TotSysFlow = 0.0;
1637 14064 : TSupK = 0.0;
1638 14064 : SumSysM = 0.0;
1639 14064 : PowerInPlumes = 0.0;
1640 14064 : ConvGainsWindows = 0.0;
1641 14064 : Gamma = 0.0;
1642 14064 : ZoneMult = state.dataHeatBal->Zone(ZoneNum).Multiplier * state.dataHeatBal->Zone(ZoneNum).ListMultiplier;
1643 14064 : CeilingHeight = state.dataRoomAirMod->ZoneCeilingHeight((ZoneNum - 1) * 2 + 2) - state.dataRoomAirMod->ZoneCeilingHeight((ZoneNum - 1) * 2 + 1);
1644 14064 : UINum = state.dataRoomAirMod->ZoneUFPtr(ZoneNum);
1645 14064 : HeightThermostat = state.dataRoomAirMod->ZoneUCSDUE(UINum).ThermostatHeight;
1646 14064 : HeightComfort = state.dataRoomAirMod->ZoneUCSDUE(UINum).ComfortHeight;
1647 14064 : TempDiffCritRep = state.dataRoomAirMod->ZoneUCSDUE(UINum).TempTrigger;
1648 14064 : DiffArea = state.dataRoomAirMod->ZoneUCSDUE(UINum).DiffArea;
1649 14064 : ThrowAngle = DataGlobalConstants::DegToRadians * state.dataRoomAirMod->ZoneUCSDUE(UINum).DiffAngle;
1650 14064 : SourceHeight = state.dataRoomAirMod->ZoneUCSDUE(UINum).HeatSrcHeight;
1651 14064 : NumDiffusers = state.dataRoomAirMod->ZoneUCSDUE(UINum).DiffusersPerZone;
1652 14064 : PowerPerPlume = state.dataRoomAirMod->ZoneUCSDUE(UINum).PowerPerPlume;
1653 : // gains from occupants, task lighting, elec equip, gas equip, other equip, hot water equip, steam equip,
1654 : // baseboards (nonthermostatic), water heater skin loss
1655 14064 : ConvGainsOccSubzone = SumInternalConvectionGainsByTypes(state, ZoneNum, IntGainTypesOccupied);
1656 :
1657 : // Add heat to return air if zonal system (no return air) or cycling system (return air frequently very
1658 : // low or zero)
1659 14064 : if (state.dataHeatBal->Zone(ZoneNum).NoHeatToReturnAir) {
1660 0 : RetAirGains = SumReturnAirConvectionGainsByTypes(state, ZoneNum, IntGainTypesOccupied);
1661 0 : ConvGainsOccSubzone += RetAirGains;
1662 : }
1663 :
1664 : // Add convection from pool cover to occupied region
1665 14064 : ConvGainsOccSubzone += state.dataHeatBalFanSys->SumConvPool(ZoneNum);
1666 :
1667 : // gains from lights (ceiling), tubular daylighting devices, high temp radiant heaters
1668 14064 : ConvGainsUpSubzone = SumInternalConvectionGainsByTypes(state, ZoneNum, IntGainTypesUpSubzone);
1669 14064 : ConvGainsUpSubzone += state.dataHeatBalFanSys->SumConvHTRadSys(ZoneNum);
1670 14064 : if (state.dataHeatBal->Zone(ZoneNum).NoHeatToReturnAir) {
1671 0 : RetAirGains = SumReturnAirConvectionGainsByTypes(state, ZoneNum, IntGainTypesUpSubzone);
1672 0 : ConvGainsUpSubzone += RetAirGains;
1673 : }
1674 14064 : ConvGains = ConvGainsOccSubzone + ConvGainsUpSubzone + thisZoneHB.SysDepZoneLoadsLagged;
1675 14064 : ZoneEquipConfigNum = state.dataRoomAirMod->ZoneUCSDUE(UINum).ZoneEquipPtr;
1676 14064 : if (ZoneEquipConfigNum > 0) {
1677 28128 : for (InNodeIndex = 1; InNodeIndex <= state.dataZoneEquip->ZoneEquipConfig(ZoneEquipConfigNum).NumInletNodes; ++InNodeIndex) {
1678 14064 : NodeTemp = state.dataLoopNodes->Node(state.dataZoneEquip->ZoneEquipConfig(ZoneEquipConfigNum).InletNode(InNodeIndex)).Temp;
1679 14064 : MassFlowRate = state.dataLoopNodes->Node(state.dataZoneEquip->ZoneEquipConfig(ZoneEquipConfigNum).InletNode(InNodeIndex)).MassFlowRate;
1680 14064 : CpAir = PsyCpAirFnW(thisZoneHB.ZoneAirHumRat);
1681 14064 : SumSysMCp += MassFlowRate * CpAir;
1682 14064 : SumSysMCpT += MassFlowRate * CpAir * NodeTemp;
1683 14064 : TotSysFlow += MassFlowRate / PsyRhoAirFnPbTdbW(state, state.dataEnvrn->OutBaroPress, NodeTemp, thisZoneHB.ZoneAirHumRat);
1684 14064 : TSupK += MassFlowRate * NodeTemp;
1685 14064 : SumSysM += MassFlowRate;
1686 : }
1687 14064 : if (TotSysFlow > 0.0) {
1688 12856 : TSupK = TSupK / SumSysM + DataGlobalConstants::KelvinConv;
1689 : } else {
1690 1208 : TSupK = 0.0;
1691 : }
1692 : }
1693 : // mass flow times specific heat for infiltration, ventilation, mixing
1694 14064 : SumMCp = thisZoneHB.MCPI + thisZoneHB.MCPV + thisZoneHB.MCPM + thisZoneHB.MDotCPOA;
1695 : // mass flow times specific heat times temperature for infiltration, ventilation, mixing
1696 14064 : SumMCpT = thisZoneHB.MCPTI + thisZoneHB.MCPTV + thisZoneHB.MCPTM + thisZoneHB.MDotCPOA * state.dataHeatBal->Zone(ZoneNum).OutDryBulbTemp;
1697 :
1698 14064 : MCp_Total = SumMCp + SumSysMCp;
1699 14064 : MCpT_Total = SumMCpT + SumSysMCpT;
1700 :
1701 : // For the York MIT diffusers (variable area) the area varies with the flow rate. Assume 400 ft/min velocity
1702 : // at the diffuser, and a design flow rate of 150 cfm (.0708 m3/s). Then the design area for each diffuser is
1703 : // 150 ft3/min / 400 ft/min = .375 ft2 = .035 m2. This is adjusted each time step by
1704 : // (TotSysFlow/(NumDiffusers*.0708))*.035
1705 14064 : if (state.dataRoomAirMod->ZoneUCSDUE(UINum).DiffuserType == Diffuser::VarArea) {
1706 0 : DiffArea = 0.035 * TotSysFlow / (0.0708 * NumDiffusers);
1707 : }
1708 : // initial estimate of convective transfer from surfaces; assume HeightFrac is 0.5.
1709 14064 : HcUCSDUF(state, ZoneNum, 0.5);
1710 42192 : ConvGainsWindows = state.dataUFADManager->HAT_MXWin + state.dataUFADManager->HAT_OCWin -
1711 14064 : state.dataUFADManager->HA_MXWin * state.dataRoomAirMod->ZTMX(ZoneNum) -
1712 14064 : state.dataUFADManager->HA_OCWin * state.dataRoomAirMod->ZTOC(ZoneNum);
1713 42192 : PowerInPlumes = ConvGains + state.dataUFADManager->HAT_OC - state.dataUFADManager->HA_OC * state.dataRoomAirMod->ZTOC(ZoneNum) +
1714 28128 : state.dataUFADManager->HAT_MX - state.dataUFADManager->HA_MX * state.dataRoomAirMod->ZTMX(ZoneNum);
1715 : // NumberOfPlumes = PowerInPlumes / PowerPerPlume
1716 14064 : if (PowerPerPlume > 0.0 && PowerInPlumes > 0.0) {
1717 7571 : NumberOfPlumes = PowerInPlumes / PowerPerPlume;
1718 7571 : NumDiffusersPerPlume = NumDiffusers / NumberOfPlumes;
1719 : } else {
1720 6493 : NumberOfPlumes = 1.0;
1721 6493 : NumDiffusersPerPlume = 1.0;
1722 : }
1723 14064 : if ((PowerInPlumes <= 0.0) || (TotSysFlow == 0.0) || (TSupK - DataGlobalConstants::KelvinConv) > thisZoneHB.MAT) {
1724 : // The system will mix
1725 7038 : HeightFrac = 0.0;
1726 : } else {
1727 7026 : if (PowerInPlumes > 0.0) {
1728 7026 : if (state.dataRoomAirMod->ZoneUCSDUE(UINum).WinWidth > 0.0) { // exterior zone formula
1729 7026 : PowerInPlumesPerMeter = PowerInPlumes / state.dataRoomAirMod->ZoneUCSDUE(UINum).WinWidth;
1730 7026 : Gamma = (TotSysFlow * std::cos(ThrowAngle)) / (NumDiffusers * DiffArea * std::pow(0.0281 * 0.001 * PowerInPlumesPerMeter, 0.333333));
1731 : } else { // interior zone formula
1732 0 : Gamma = std::pow(TotSysFlow * std::cos(ThrowAngle), 1.5) /
1733 0 : (NumberOfPlumes * std::pow(NumDiffusersPerPlume * DiffArea, 1.25) * std::sqrt(0.0281 * 0.001 * PowerInPlumes));
1734 : }
1735 : } else {
1736 0 : Gamma = 1000.0;
1737 : }
1738 7026 : if (state.dataRoomAirMod->ZoneUCSDUE(UINum).CalcTransHeight) {
1739 0 : if (state.dataRoomAirMod->ZoneUCSDUE(UINum).WinWidth > 0.0) { // use exterior zone formula
1740 0 : HeightFrac = (std::sqrt(DiffArea) * (11.03 * std::log(Gamma) - 10.73) + 0.5 * SourceHeight) / CeilingHeight;
1741 : } else { // use interior zone formula
1742 0 : HeightFrac = (std::sqrt(NumDiffusersPerPlume * DiffArea) * (7.43 * std::log(Gamma) - 1.35) + 0.5 * SourceHeight) / CeilingHeight;
1743 : }
1744 : } else {
1745 7026 : HeightFrac = state.dataRoomAirMod->ZoneUCSDUE(UINum).TransHeight / CeilingHeight;
1746 : }
1747 7026 : HeightFrac = max(0.0, min(1.0, HeightFrac));
1748 21078 : GainsFrac = state.dataRoomAirMod->ZoneUCSDUE(UINum).A_Kc * std::pow(Gamma, state.dataRoomAirMod->ZoneUCSDUE(UINum).B_Kc) +
1749 14052 : state.dataRoomAirMod->ZoneUCSDUE(UINum).C_Kc + state.dataRoomAirMod->ZoneUCSDUE(UINum).D_Kc * Gamma +
1750 7026 : state.dataRoomAirMod->ZoneUCSDUE(UINum).E_Kc * pow_2(Gamma);
1751 7026 : GainsFrac = max(0.7, min(GainsFrac, 1.0));
1752 7026 : if (state.dataRoomAirMod->ZoneUCSDUE(UINum).ShadeDown) {
1753 0 : GainsFrac -= 0.2;
1754 : }
1755 7026 : state.dataRoomAirMod->ZoneUFPowInPlumes(ZoneNum) = PowerInPlumes;
1756 34866 : for (Ctd = 1; Ctd <= 4; ++Ctd) {
1757 27928 : HcUCSDUF(state, ZoneNum, HeightFrac);
1758 83784 : ConvGainsWindows = state.dataUFADManager->HAT_MXWin + state.dataUFADManager->HAT_OCWin -
1759 27928 : state.dataUFADManager->HA_MXWin * state.dataRoomAirMod->ZTMX(ZoneNum) -
1760 27928 : state.dataUFADManager->HA_OCWin * state.dataRoomAirMod->ZTOC(ZoneNum);
1761 27928 : ConvGainsWindows = max(ConvGainsWindows, 0.0);
1762 83784 : PowerInPlumes = ConvGains + state.dataUFADManager->HAT_OC - state.dataUFADManager->HA_OC * state.dataRoomAirMod->ZTOC(ZoneNum) +
1763 55856 : state.dataUFADManager->HAT_MX - state.dataUFADManager->HA_MX * state.dataRoomAirMod->ZTMX(ZoneNum);
1764 : // NumberOfPlumes = PowerInPlumes / PowerPerPlume
1765 27928 : NumberOfPlumes = 1.0;
1766 27928 : if (PowerInPlumes <= 0.0) break;
1767 27840 : if (state.dataRoomAirMod->ZoneUCSDUE(UINum).WinWidth > 0.0) { // use exterior zone formula
1768 27840 : PowerInPlumesPerMeter = PowerInPlumes / state.dataRoomAirMod->ZoneUCSDUE(UINum).WinWidth;
1769 27840 : Gamma = (TotSysFlow * std::cos(ThrowAngle)) / (NumDiffusers * DiffArea * std::pow(0.0281 * 0.001 * PowerInPlumesPerMeter, 0.333333));
1770 : } else { // use interior zone formula
1771 0 : Gamma = std::pow(TotSysFlow * std::cos(ThrowAngle), 1.5) /
1772 0 : (NumberOfPlumes * std::pow(NumDiffusersPerPlume * DiffArea, 1.25) * std::sqrt(0.0281 * 0.001 * PowerInPlumes));
1773 : }
1774 27840 : if (state.dataRoomAirMod->ZoneUCSDUE(UINum).CalcTransHeight) {
1775 0 : if (state.dataRoomAirMod->ZoneUCSDUE(UINum).WinWidth > 0.0) { // exterior zone formula
1776 0 : HeightFrac = (std::sqrt(DiffArea) * (11.03 * std::log(Gamma) - 10.73) + 0.5 * SourceHeight) / CeilingHeight;
1777 : } else { // interior zone formula
1778 0 : HeightFrac = (std::sqrt(NumDiffusersPerPlume * DiffArea) * (7.43 * std::log(Gamma) - 1.35) + 0.5 * SourceHeight) / CeilingHeight;
1779 : }
1780 : } else {
1781 27840 : HeightFrac = state.dataRoomAirMod->ZoneUCSDUE(UINum).TransHeight / CeilingHeight;
1782 : }
1783 27840 : HeightFrac = min(1.0, HeightFrac);
1784 27840 : state.dataRoomAirMod->HeightTransition(ZoneNum) = HeightFrac * CeilingHeight;
1785 83520 : GainsFrac = state.dataRoomAirMod->ZoneUCSDUE(UINum).A_Kc * std::pow(Gamma, state.dataRoomAirMod->ZoneUCSDUE(UINum).B_Kc) +
1786 55680 : state.dataRoomAirMod->ZoneUCSDUE(UINum).C_Kc + state.dataRoomAirMod->ZoneUCSDUE(UINum).D_Kc * Gamma +
1787 27840 : state.dataRoomAirMod->ZoneUCSDUE(UINum).E_Kc * pow_2(Gamma);
1788 27840 : GainsFrac = max(0.7, min(GainsFrac, 1.0));
1789 27840 : if (state.dataRoomAirMod->ZoneUCSDUE(UINum).ShadeDown) {
1790 0 : GainsFrac -= 0.2;
1791 : }
1792 27840 : state.dataRoomAirMod->AIRRATOC(ZoneNum) =
1793 55680 : state.dataHeatBal->Zone(ZoneNum).Volume *
1794 83520 : (state.dataRoomAirMod->HeightTransition(ZoneNum) - min(state.dataRoomAirMod->HeightTransition(ZoneNum), 0.2)) / CeilingHeight *
1795 55680 : state.dataHeatBal->Zone(ZoneNum).ZoneVolCapMultpSens *
1796 83520 : PsyRhoAirFnPbTdbW(state, state.dataEnvrn->OutBaroPress, state.dataRoomAirMod->MATOC(ZoneNum), thisZoneHB.ZoneAirHumRat) *
1797 55680 : PsyCpAirFnW(thisZoneHB.ZoneAirHumRat) / (TimeStepSys * DataGlobalConstants::SecInHour);
1798 27840 : state.dataRoomAirMod->AIRRATMX(ZoneNum) =
1799 55680 : state.dataHeatBal->Zone(ZoneNum).Volume * (CeilingHeight - state.dataRoomAirMod->HeightTransition(ZoneNum)) / CeilingHeight *
1800 55680 : state.dataHeatBal->Zone(ZoneNum).ZoneVolCapMultpSens *
1801 83520 : PsyRhoAirFnPbTdbW(state, state.dataEnvrn->OutBaroPress, state.dataRoomAirMod->MATMX(ZoneNum), thisZoneHB.ZoneAirHumRat) *
1802 55680 : PsyCpAirFnW(thisZoneHB.ZoneAirHumRat) / (TimeStepSys * DataGlobalConstants::SecInHour);
1803 :
1804 27840 : if (state.dataHVACGlobal->UseZoneTimeStepHistory) {
1805 17692 : state.dataRoomAirMod->ZTM3OC(ZoneNum) = state.dataRoomAirMod->XM3TOC(ZoneNum);
1806 17692 : state.dataRoomAirMod->ZTM2OC(ZoneNum) = state.dataRoomAirMod->XM2TOC(ZoneNum);
1807 17692 : state.dataRoomAirMod->ZTM1OC(ZoneNum) = state.dataRoomAirMod->XMATOC(ZoneNum);
1808 :
1809 17692 : state.dataRoomAirMod->ZTM3MX(ZoneNum) = state.dataRoomAirMod->XM3TMX(ZoneNum);
1810 17692 : state.dataRoomAirMod->ZTM2MX(ZoneNum) = state.dataRoomAirMod->XM2TMX(ZoneNum);
1811 17692 : state.dataRoomAirMod->ZTM1MX(ZoneNum) = state.dataRoomAirMod->XMATMX(ZoneNum);
1812 :
1813 : } else {
1814 10148 : state.dataRoomAirMod->ZTM3OC(ZoneNum) = state.dataRoomAirMod->DSXM3TOC(ZoneNum);
1815 10148 : state.dataRoomAirMod->ZTM2OC(ZoneNum) = state.dataRoomAirMod->DSXM2TOC(ZoneNum);
1816 10148 : state.dataRoomAirMod->ZTM1OC(ZoneNum) = state.dataRoomAirMod->DSXMATOC(ZoneNum);
1817 :
1818 10148 : state.dataRoomAirMod->ZTM3MX(ZoneNum) = state.dataRoomAirMod->DSXM3TMX(ZoneNum);
1819 10148 : state.dataRoomAirMod->ZTM2MX(ZoneNum) = state.dataRoomAirMod->DSXM2TMX(ZoneNum);
1820 10148 : state.dataRoomAirMod->ZTM1MX(ZoneNum) = state.dataRoomAirMod->DSXMATMX(ZoneNum);
1821 : }
1822 :
1823 27840 : AirCap = state.dataRoomAirMod->AIRRATOC(ZoneNum);
1824 55680 : TempHistTerm = AirCap * (3.0 * state.dataRoomAirMod->ZTM1OC(ZoneNum) - (3.0 / 2.0) * state.dataRoomAirMod->ZTM2OC(ZoneNum) +
1825 27840 : (1.0 / 3.0) * state.dataRoomAirMod->ZTM3OC(ZoneNum));
1826 27840 : TempDepCoef = GainsFrac * state.dataUFADManager->HA_OC + MCp_Total;
1827 83520 : TempIndCoef = GainsFrac * (ConvGains + state.dataUFADManager->HAT_OC + state.dataUFADManager->HAT_MX -
1828 55680 : state.dataUFADManager->HA_MX * state.dataRoomAirMod->ZTMX(ZoneNum)) +
1829 27840 : MCpT_Total + thisZoneHB.NonAirSystemResponse / ZoneMult;
1830 27840 : switch (state.dataHeatBal->ZoneAirSolutionAlgo) {
1831 27840 : case DataHeatBalance::SolutionAlgo::ThirdOrder: {
1832 55680 : state.dataRoomAirMod->ZTOC(ZoneNum) = (TempHistTerm +
1833 55680 : GainsFrac * (ConvGains + state.dataUFADManager->HAT_OC + state.dataUFADManager->HAT_MX -
1834 55680 : state.dataUFADManager->HA_MX * state.dataRoomAirMod->ZTMX(ZoneNum)) +
1835 55680 : MCpT_Total + thisZoneHB.NonAirSystemResponse / ZoneMult) /
1836 27840 : ((11.0 / 6.0) * AirCap + GainsFrac * state.dataUFADManager->HA_OC + MCp_Total);
1837 27840 : } break;
1838 0 : case DataHeatBalance::SolutionAlgo::AnalyticalSolution: {
1839 0 : if (TempDepCoef == 0.0) { // B=0
1840 0 : state.dataRoomAirMod->ZTOC(ZoneNum) = state.dataRoomAirMod->Zone1OC(ZoneNum) + TempIndCoef / AirCap;
1841 : } else {
1842 0 : state.dataRoomAirMod->ZTOC(ZoneNum) =
1843 0 : (state.dataRoomAirMod->Zone1OC(ZoneNum) - TempIndCoef / TempDepCoef) * std::exp(min(700.0, -TempDepCoef / AirCap)) +
1844 0 : TempIndCoef / TempDepCoef;
1845 : }
1846 0 : } break;
1847 0 : case DataHeatBalance::SolutionAlgo::EulerMethod: {
1848 0 : state.dataRoomAirMod->ZTOC(ZoneNum) = (AirCap * state.dataRoomAirMod->Zone1OC(ZoneNum) + TempIndCoef) / (AirCap + TempDepCoef);
1849 0 : } break;
1850 0 : default:
1851 0 : break;
1852 : }
1853 27840 : AirCap = state.dataRoomAirMod->AIRRATMX(ZoneNum);
1854 55680 : TempHistTerm = AirCap * (3.0 * state.dataRoomAirMod->ZTM1MX(ZoneNum) - (3.0 / 2.0) * state.dataRoomAirMod->ZTM2MX(ZoneNum) +
1855 27840 : (1.0 / 3.0) * state.dataRoomAirMod->ZTM3MX(ZoneNum));
1856 27840 : TempDepCoef = (1.0 - GainsFrac) * state.dataUFADManager->HA_MX + MCp_Total;
1857 83520 : TempIndCoef = (1.0 - GainsFrac) * (ConvGains + state.dataUFADManager->HAT_OC + state.dataUFADManager->HAT_MX -
1858 27840 : state.dataUFADManager->HA_OC * state.dataRoomAirMod->ZTOC(ZoneNum)) +
1859 27840 : state.dataRoomAirMod->ZTOC(ZoneNum) * MCp_Total;
1860 27840 : switch (state.dataHeatBal->ZoneAirSolutionAlgo) {
1861 27840 : case DataHeatBalance::SolutionAlgo::ThirdOrder: {
1862 27840 : state.dataRoomAirMod->ZTMX(ZoneNum) =
1863 27840 : (TempHistTerm +
1864 55680 : (1.0 - GainsFrac) * (ConvGains + state.dataUFADManager->HAT_OC + state.dataUFADManager->HAT_MX -
1865 55680 : state.dataUFADManager->HA_OC * state.dataRoomAirMod->ZTOC(ZoneNum)) +
1866 55680 : state.dataRoomAirMod->ZTOC(ZoneNum) * MCp_Total) /
1867 27840 : ((11.0 / 6.0) * AirCap + (1.0 - GainsFrac) * state.dataUFADManager->HA_MX + MCp_Total);
1868 27840 : } break;
1869 0 : case DataHeatBalance::SolutionAlgo::AnalyticalSolution: {
1870 0 : if (TempDepCoef == 0.0) { // B=0
1871 0 : state.dataRoomAirMod->ZTMX(ZoneNum) = state.dataRoomAirMod->Zone1MX(ZoneNum) + TempIndCoef / AirCap;
1872 : } else {
1873 0 : state.dataRoomAirMod->ZTMX(ZoneNum) =
1874 0 : (state.dataRoomAirMod->Zone1MX(ZoneNum) - TempIndCoef / TempDepCoef) * std::exp(min(700.0, -TempDepCoef / AirCap)) +
1875 0 : TempIndCoef / TempDepCoef;
1876 : }
1877 0 : } break;
1878 0 : case DataHeatBalance::SolutionAlgo::EulerMethod: {
1879 0 : state.dataRoomAirMod->ZTMX(ZoneNum) = (AirCap * state.dataRoomAirMod->Zone1MX(ZoneNum) + TempIndCoef) / (AirCap + TempDepCoef);
1880 0 : } break;
1881 0 : default:
1882 0 : break;
1883 : }
1884 27840 : state.dataRoomAirMod->ZTFloor(ZoneNum) = state.dataRoomAirMod->ZTOC(ZoneNum);
1885 : }
1886 7026 : if (PowerInPlumes <= 0.0) {
1887 88 : HeightFrac = 0.0;
1888 88 : state.dataRoomAirMod->AirModel(ZoneNum).SimAirModel = false;
1889 88 : state.dataRoomAirMod->ZoneUFGamma(ZoneNum) = 0.0;
1890 88 : state.dataRoomAirMod->ZoneUFPowInPlumes(ZoneNum) = 0.0;
1891 88 : state.dataRoomAirMod->ZoneUFPowInPlumesfromWindows(ZoneNum) = 0.0;
1892 : } else {
1893 6938 : state.dataRoomAirMod->AirModel(ZoneNum).SimAirModel = true;
1894 6938 : state.dataRoomAirMod->ZoneUFGamma(ZoneNum) = Gamma;
1895 6938 : state.dataRoomAirMod->ZoneUFPowInPlumes(ZoneNum) = PowerInPlumes;
1896 6938 : state.dataRoomAirMod->ZoneUFPowInPlumesfromWindows(ZoneNum) = ConvGainsWindows;
1897 : }
1898 : }
1899 :
1900 : //=============================== M I X E D Calculation ==============================================
1901 26854 : if (state.dataRoomAirMod->ZTMX(ZoneNum) < state.dataRoomAirMod->ZTOC(ZoneNum) || MCp_Total <= 0.0 ||
1902 12790 : HeightFrac * CeilingHeight < state.dataUFADManager->ThickOccupiedSubzoneMin) {
1903 7245 : MIXFLAG = true;
1904 7245 : HeightFrac = 0.0;
1905 7245 : Real64 const thisZoneT1 = thisZoneHB.ZoneT1;
1906 :
1907 7245 : state.dataRoomAirMod->AvgTempGrad(ZoneNum) = 0.0;
1908 7245 : state.dataRoomAirMod->MaxTempGrad(ZoneNum) = 0.0;
1909 7245 : state.dataRoomAirMod->AirModel(ZoneNum).SimAirModel = false;
1910 7245 : Real64 AirCap = thisZoneHB.AirPowerCap;
1911 7245 : TempHistTerm = AirCap * (3.0 * thisZoneHB.ZTM[0] - (3.0 / 2.0) * thisZoneHB.ZTM[1] + (1.0 / 3.0) * thisZoneHB.ZTM[2]);
1912 :
1913 28980 : for (Ctd = 1; Ctd <= 3; ++Ctd) {
1914 21735 : TempDepCoef = state.dataUFADManager->HA_MX + state.dataUFADManager->HA_OC + MCp_Total;
1915 21735 : TempIndCoef = ConvGains + state.dataUFADManager->HAT_MX + state.dataUFADManager->HAT_OC + MCpT_Total;
1916 21735 : switch (state.dataHeatBal->ZoneAirSolutionAlgo) {
1917 21735 : case DataHeatBalance::SolutionAlgo::ThirdOrder: {
1918 43470 : ZTAveraged = (TempHistTerm + ConvGains + state.dataUFADManager->HAT_MX + state.dataUFADManager->HAT_OC + MCpT_Total) /
1919 21735 : ((11.0 / 6.0) * AirCap + state.dataUFADManager->HA_MX + state.dataUFADManager->HA_OC + MCp_Total);
1920 21735 : } break;
1921 0 : case DataHeatBalance::SolutionAlgo::AnalyticalSolution: {
1922 0 : if (TempDepCoef == 0.0) { // B=0
1923 0 : ZTAveraged = thisZoneT1 + TempIndCoef / AirCap;
1924 : } else {
1925 0 : ZTAveraged = (thisZoneT1 - TempIndCoef / TempDepCoef) * std::exp(min(700.0, -TempDepCoef / AirCap)) + TempIndCoef / TempDepCoef;
1926 : }
1927 0 : } break;
1928 0 : case DataHeatBalance::SolutionAlgo::EulerMethod: {
1929 0 : ZTAveraged = (AirCap * thisZoneT1 + TempIndCoef) / (AirCap + TempDepCoef);
1930 0 : } break;
1931 0 : default:
1932 0 : break;
1933 : }
1934 21735 : state.dataRoomAirMod->ZTOC(ZoneNum) = ZTAveraged;
1935 21735 : state.dataRoomAirMod->ZTMX(ZoneNum) = ZTAveraged;
1936 21735 : state.dataRoomAirMod->ZTFloor(ZoneNum) = ZTAveraged;
1937 21735 : HcUCSDUF(state, ZoneNum, HeightFrac);
1938 21735 : TempDepCoef = state.dataUFADManager->HA_MX + state.dataUFADManager->HA_OC + MCp_Total;
1939 21735 : TempIndCoef = ConvGains + state.dataUFADManager->HAT_MX + state.dataUFADManager->HAT_OC + MCpT_Total;
1940 21735 : switch (state.dataHeatBal->ZoneAirSolutionAlgo) {
1941 21735 : case DataHeatBalance::SolutionAlgo::ThirdOrder: {
1942 43470 : ZTAveraged = (TempHistTerm + ConvGains + state.dataUFADManager->HAT_MX + state.dataUFADManager->HAT_OC + MCpT_Total) /
1943 21735 : ((11.0 / 6.0) * AirCap + state.dataUFADManager->HA_MX + state.dataUFADManager->HA_OC + MCp_Total);
1944 21735 : } break;
1945 0 : case DataHeatBalance::SolutionAlgo::AnalyticalSolution: {
1946 0 : if (TempDepCoef == 0.0) { // B=0
1947 0 : ZTAveraged = thisZoneT1 + TempIndCoef / AirCap;
1948 : } else {
1949 0 : ZTAveraged = (thisZoneT1 - TempIndCoef / TempDepCoef) * std::exp(min(700.0, -TempDepCoef / AirCap)) + TempIndCoef / TempDepCoef;
1950 : }
1951 0 : } break;
1952 0 : case DataHeatBalance::SolutionAlgo::EulerMethod: {
1953 0 : ZTAveraged = (AirCap * thisZoneT1 + TempIndCoef) / (AirCap + TempDepCoef);
1954 0 : } break;
1955 0 : default:
1956 0 : break;
1957 : }
1958 21735 : state.dataRoomAirMod->ZTOC(ZoneNum) = ZTAveraged;
1959 21735 : state.dataRoomAirMod->ZTMX(ZoneNum) = ZTAveraged;
1960 21735 : state.dataRoomAirMod->ZTFloor(ZoneNum) = ZTAveraged;
1961 : }
1962 : }
1963 : //=========================================================================================
1964 :
1965 : // Comfort temperature and temperature at the thermostat/temperature control sensor
1966 :
1967 14064 : HeightUpSubzoneAve = (CeilingHeight + state.dataRoomAirMod->HeightTransition(ZoneNum)) / 2.0;
1968 14064 : HeightOccupiedSubzoneAve = state.dataRoomAirMod->HeightTransition(ZoneNum) / 2.0;
1969 : // Comfort temperature
1970 :
1971 14064 : if (MIXFLAG) {
1972 7245 : state.dataRoomAirMod->TCMF(ZoneNum) = ZTAveraged;
1973 : } else {
1974 6819 : if (HeightComfort < HeightOccupiedSubzoneAve) {
1975 0 : state.dataRoomAirMod->TCMF(ZoneNum) = state.dataRoomAirMod->ZTOC(ZoneNum);
1976 6819 : } else if (HeightComfort >= HeightOccupiedSubzoneAve && HeightComfort < HeightUpSubzoneAve) {
1977 20457 : state.dataRoomAirMod->TCMF(ZoneNum) = (state.dataRoomAirMod->ZTOC(ZoneNum) * (HeightUpSubzoneAve - HeightComfort) +
1978 13638 : state.dataRoomAirMod->ZTMX(ZoneNum) * (HeightComfort - HeightOccupiedSubzoneAve)) /
1979 6819 : (HeightUpSubzoneAve - HeightOccupiedSubzoneAve);
1980 0 : } else if (HeightComfort >= HeightUpSubzoneAve && HeightComfort <= CeilingHeight) {
1981 0 : state.dataRoomAirMod->TCMF(ZoneNum) = state.dataRoomAirMod->ZTMX(ZoneNum);
1982 : } else {
1983 0 : ShowFatalError(state, "UFAD comfort height is above ceiling or below floor in Zone: " + state.dataHeatBal->Zone(ZoneNum).Name);
1984 : }
1985 : }
1986 :
1987 : // Temperature at the thermostat/temperature control sensor
1988 :
1989 14064 : if (MIXFLAG) {
1990 7245 : state.dataHeatBalFanSys->TempTstatAir(ZoneNum) = ZTAveraged;
1991 : } else {
1992 6819 : if (HeightThermostat < HeightOccupiedSubzoneAve) {
1993 0 : state.dataHeatBalFanSys->TempTstatAir(ZoneNum) = state.dataRoomAirMod->ZTOC(ZoneNum);
1994 6819 : } else if (HeightThermostat >= HeightOccupiedSubzoneAve && HeightThermostat < HeightUpSubzoneAve) {
1995 20457 : state.dataHeatBalFanSys->TempTstatAir(ZoneNum) = (state.dataRoomAirMod->ZTOC(ZoneNum) * (HeightUpSubzoneAve - HeightThermostat) +
1996 13638 : state.dataRoomAirMod->ZTMX(ZoneNum) * (HeightThermostat - HeightOccupiedSubzoneAve)) /
1997 6819 : (HeightUpSubzoneAve - HeightOccupiedSubzoneAve);
1998 0 : } else if (HeightThermostat >= HeightUpSubzoneAve && HeightThermostat <= CeilingHeight) {
1999 0 : state.dataHeatBalFanSys->TempTstatAir(ZoneNum) = state.dataRoomAirMod->ZTMX(ZoneNum);
2000 : } else {
2001 0 : ShowFatalError(state,
2002 0 : "Underfloor air distribution thermostat height is above ceiling or below floor in Zone: " +
2003 0 : state.dataHeatBal->Zone(ZoneNum).Name);
2004 : }
2005 : }
2006 :
2007 : // Temperature gradients
2008 14064 : if ((HeightUpSubzoneAve - HeightOccupiedSubzoneAve) > 0.1) {
2009 14064 : state.dataRoomAirMod->AvgTempGrad(ZoneNum) =
2010 14064 : (state.dataRoomAirMod->ZTMX(ZoneNum) - state.dataRoomAirMod->ZTOC(ZoneNum)) / (HeightUpSubzoneAve - HeightOccupiedSubzoneAve);
2011 : } else {
2012 0 : state.dataRoomAirMod->AvgTempGrad(ZoneNum) = 0.0;
2013 : }
2014 :
2015 14064 : if (MIXFLAG) {
2016 7245 : state.dataRoomAirMod->ZoneUFMixedFlag(ZoneNum) = 1;
2017 7245 : state.dataRoomAirMod->AirModel(ZoneNum).SimAirModel = false;
2018 : } else {
2019 6819 : state.dataRoomAirMod->ZoneUFMixedFlag(ZoneNum) = 0;
2020 6819 : state.dataRoomAirMod->AirModel(ZoneNum).SimAirModel = true;
2021 : }
2022 :
2023 14064 : if (ZoneEquipConfigNum > 0) {
2024 14064 : ZoneNodeNum = state.dataHeatBal->Zone(ZoneNum).SystemZoneNodeNumber;
2025 14064 : state.dataLoopNodes->Node(ZoneNodeNum).Temp = state.dataRoomAirMod->ZTMX(ZoneNum);
2026 : }
2027 :
2028 14064 : if (MIXFLAG) {
2029 7245 : state.dataRoomAirMod->Phi(ZoneNum) = 1.0;
2030 : } else {
2031 13638 : state.dataRoomAirMod->Phi(ZoneNum) = (state.dataRoomAirMod->ZTOC(ZoneNum) - (TSupK - DataGlobalConstants::KelvinConv)) /
2032 6819 : (state.dataRoomAirMod->ZTMX(ZoneNum) - (TSupK - DataGlobalConstants::KelvinConv));
2033 : }
2034 :
2035 : // Mixed for reporting purposes
2036 14064 : if ((MIXFLAG) || ((state.dataRoomAirMod->ZTMX(ZoneNum) - state.dataRoomAirMod->ZTOC(ZoneNum)) < TempDiffCritRep)) {
2037 7246 : state.dataRoomAirMod->ZoneUFMixedFlagRep(ZoneNum) = 1.0;
2038 7246 : state.dataRoomAirMod->HeightTransition(ZoneNum) = 0.0;
2039 7246 : state.dataRoomAirMod->AvgTempGrad(ZoneNum) = 0.0;
2040 : } else {
2041 6818 : state.dataRoomAirMod->ZoneUFMixedFlagRep(ZoneNum) = 0.0;
2042 : }
2043 14064 : }
2044 :
2045 2313 : } // namespace EnergyPlus::UFADManager
|
