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 <AirflowNetwork/Solver.hpp>
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/DataSurfaces.hh>
68 : #include <EnergyPlus/DataUCSDSharedData.hh>
69 : #include <EnergyPlus/DataZoneEquipment.hh>
70 : #include <EnergyPlus/DisplacementVentMgr.hh>
71 : #include <EnergyPlus/InternalHeatGains.hh>
72 : #include <EnergyPlus/Psychrometrics.hh>
73 : #include <EnergyPlus/ScheduleManager.hh>
74 : #include <EnergyPlus/UtilityRoutines.hh>
75 : #include <EnergyPlus/ZoneTempPredictorCorrector.hh>
76 :
77 : namespace EnergyPlus::DisplacementVentMgr {
78 :
79 : // MODULE INFORMATION:
80 : // AUTHOR G. Carrilho da Graca
81 : // DATE WRITTEN February 2004
82 : // MODIFIED na
83 : // RE-ENGINEERED na
84 :
85 : // PURPOSE OF THIS MODULE:
86 : // Routines that implement the UCSD Displacement Ventilation
87 :
88 : // Using/Aliasing
89 : using namespace DataLoopNode;
90 : using namespace DataEnvironment;
91 : using namespace DataHeatBalance;
92 : using namespace DataHeatBalSurface;
93 : using namespace DataSurfaces;
94 : using namespace DataRoomAirModel;
95 : using ConvectionCoefficients::CalcDetailedHcInForDVModel;
96 :
97 15024 : void ManageUCSDDVModel(EnergyPlusData &state, int const ZoneNum) // index number for the specified zone
98 : {
99 :
100 : // SUBROUTINE INFORMATION:
101 : // AUTHOR G. Carrilho da Graca
102 : // DATE WRITTEN February 2004
103 : // MODIFIED na
104 : // RE-ENGINEERED na
105 :
106 : // PURPOSE OF THIS SUBROUTINE:
107 : // manage the UCSD Displacement Ventilation model
108 :
109 : // initialize Displacement Ventilation model
110 15024 : InitUCSDDV(state, ZoneNum);
111 :
112 : // perform Displacement Ventilation model calculations
113 15024 : CalcUCSDDV(state, ZoneNum);
114 15024 : }
115 :
116 : //**************************************************************************************************
117 :
118 15024 : void InitUCSDDV(EnergyPlusData &state, int const ZoneNum)
119 : {
120 :
121 : // SUBROUTINE INFORMATION:
122 : // AUTHOR G. Carrilho da Graca
123 : // DATE WRITTEN February 2004
124 : // MODIFIED -
125 : // RE-ENGINEERED -
126 :
127 : // PURPOSE OF THIS SUBROUTINE:
128 : // Low Energy Cooling by Ventilation initialization subroutine.
129 : // All the data preparation needed to run the LECV models.
130 : // The subroutines sets up arrays with the locations in the main EnergyPlus surface array of
131 : // ceiling, windows, doors and walls. The zone maximum and minimum height is calculated.
132 :
133 : // Do the one time initializations
134 15024 : if (state.dataDispVentMgr->InitUCSDDVMyOneTimeFlag) {
135 4 : state.dataDispVentMgr->MyEnvrnFlag.dimension(state.dataGlobal->NumOfZones, true);
136 4 : state.dataDispVentMgr->HeightFloorSubzoneTop = 0.2;
137 4 : state.dataDispVentMgr->ThickOccupiedSubzoneMin = 0.2;
138 4 : state.dataDispVentMgr->HeightIntMassDefault = 2.0;
139 4 : state.dataDispVentMgr->InitUCSDDVMyOneTimeFlag = false;
140 : }
141 :
142 : // Do the begin environment initializations
143 15024 : if (state.dataGlobal->BeginEnvrnFlag && state.dataDispVentMgr->MyEnvrnFlag(ZoneNum)) {
144 28 : state.dataDispVentMgr->HAT_MX = 0.0;
145 28 : state.dataDispVentMgr->HAT_OC = 0.0;
146 28 : state.dataDispVentMgr->HA_MX = 0.0;
147 28 : state.dataDispVentMgr->HA_OC = 0.0;
148 28 : state.dataDispVentMgr->HAT_FLOOR = 0.0;
149 28 : state.dataDispVentMgr->HA_FLOOR = 0.0;
150 28 : state.dataDispVentMgr->MyEnvrnFlag(ZoneNum) = false;
151 : }
152 :
153 15024 : if (!state.dataGlobal->BeginEnvrnFlag) {
154 14936 : state.dataDispVentMgr->MyEnvrnFlag(ZoneNum) = true;
155 : }
156 :
157 : // initialize these module variables every timestep
158 15024 : state.dataDispVentMgr->HeightIntMass = state.dataDispVentMgr->HeightIntMassDefault;
159 15024 : }
160 :
161 : //**************************************************************************************************
162 :
163 64395 : void HcUCSDDV(EnergyPlusData &state, int const ZoneNum, Real64 const FractionHeight)
164 : {
165 :
166 : // SUBROUTINE INFORMATION:
167 : // AUTHOR G. Carrilho da Graca
168 : // DATE WRITTEN February 2004
169 : // MODIFIED -
170 : // RE-ENGINEERED -
171 :
172 : // PURPOSE OF THIS SUBROUTINE:
173 : // Main subroutine for convection calculation in the UCSD Displacement Ventilation model.
174 : // It calls CalcDetailedHcInForDVModel for convection coefficient
175 : // initial calculations and averages the final result comparing the position of the surface with
176 : // the interface subzone height.
177 :
178 : // Using/Aliasing
179 : using namespace DataEnvironment;
180 : using namespace DataHeatBalance;
181 : using ScheduleManager::GetScheduleIndex;
182 :
183 : // SUBROUTINE LOCAL VARIABLE DECLARATIONS:
184 : int Ctd; // DO loop counter for surfaces
185 : Real64 HLD; // Convection coefficient for the lower area of surface
186 : Real64 TmedDV; // Average temperature for DV
187 : Real64 Z1; // auxiliary var for lowest height
188 : Real64 Z2; // auxiliary var for highest height
189 : Real64 ZSupSurf; // highest height for this surface
190 : Real64 ZInfSurf; // lowest height for this surface
191 : Real64 HLU; // Convection coefficient for the upper area of surface
192 : Real64 LayH; // Height of the Occupied/Mixed subzone interface
193 : Real64 LayFrac; // Fraction height of the Occupied/Mixed subzone interface
194 : int SurfNum; // Surface number
195 :
196 64395 : state.dataDispVentMgr->HAT_MX = 0.0;
197 64395 : state.dataDispVentMgr->HAT_OC = 0.0;
198 64395 : state.dataDispVentMgr->HA_MX = 0.0;
199 64395 : state.dataDispVentMgr->HA_OC = 0.0;
200 64395 : state.dataDispVentMgr->HAT_FLOOR = 0.0;
201 64395 : state.dataDispVentMgr->HA_FLOOR = 0.0;
202 64395 : auto &SurfTempIn(state.dataHeatBalSurf->SurfTempIn);
203 :
204 : // Is the air flow model for this zone set to UCSDDV Displacement Ventilation?
205 64395 : if (state.dataRoomAirMod->IsZoneDV(ZoneNum)) {
206 64395 : LayFrac = FractionHeight;
207 64395 : LayH = FractionHeight *
208 64395 : (state.dataRoomAirMod->ZoneCeilingHeight((ZoneNum - 1) * 2 + 2) - state.dataRoomAirMod->ZoneCeilingHeight((ZoneNum - 1) * 2 + 1));
209 : // WALL Hc, HA and HAT calculation
210 321975 : for (Ctd = state.dataUCSDShared->PosZ_Wall((ZoneNum - 1) * 2 + 1); Ctd <= state.dataUCSDShared->PosZ_Wall((ZoneNum - 1) * 2 + 2); ++Ctd) {
211 257580 : SurfNum = state.dataUCSDShared->APos_Wall(Ctd);
212 257580 : state.dataSurface->SurfTAirRef(SurfNum) = DataSurfaces::RefAirTemp::AdjacentAirTemp;
213 257580 : state.dataSurface->SurfTAirRefRpt(SurfNum) = DataSurfaces::SurfTAirRefReportVals[state.dataSurface->SurfTAirRef(SurfNum)];
214 257580 : if (SurfNum == 0) continue;
215 257580 : Z1 = minval(state.dataSurface->Surface(SurfNum).Vertex({1, state.dataSurface->Surface(SurfNum).Sides}), &Vector::z);
216 257580 : Z2 = maxval(state.dataSurface->Surface(SurfNum).Vertex({1, state.dataSurface->Surface(SurfNum).Sides}), &Vector::z);
217 257580 : ZSupSurf = Z2 - state.dataRoomAirMod->ZoneCeilingHeight((ZoneNum - 1) * 2 + 1);
218 257580 : ZInfSurf = Z1 - state.dataRoomAirMod->ZoneCeilingHeight((ZoneNum - 1) * 2 + 1);
219 :
220 : // The Wall surface is in the upper subzone
221 257580 : if (ZInfSurf > LayH) {
222 0 : state.dataHeatBal->SurfTempEffBulkAir(SurfNum) = state.dataRoomAirMod->ZTMX(ZoneNum);
223 0 : CalcDetailedHcInForDVModel(state, SurfNum, SurfTempIn, state.dataRoomAirMod->DVHcIn);
224 0 : state.dataUCSDShared->HWall(Ctd) = state.dataRoomAirMod->DVHcIn(SurfNum);
225 0 : state.dataDispVentMgr->HAT_MX += state.dataSurface->Surface(SurfNum).Area * SurfTempIn(SurfNum) * state.dataUCSDShared->HWall(Ctd);
226 0 : state.dataDispVentMgr->HA_MX += state.dataSurface->Surface(SurfNum).Area * state.dataUCSDShared->HWall(Ctd);
227 : }
228 :
229 : // The Wall surface is in the lower subzone
230 257580 : if (ZSupSurf < LayH) {
231 0 : state.dataHeatBal->SurfTempEffBulkAir(SurfNum) = state.dataRoomAirMod->ZTOC(ZoneNum);
232 0 : CalcDetailedHcInForDVModel(state, SurfNum, SurfTempIn, state.dataRoomAirMod->DVHcIn);
233 0 : state.dataUCSDShared->HWall(Ctd) = state.dataRoomAirMod->DVHcIn(SurfNum);
234 0 : state.dataDispVentMgr->HAT_OC += state.dataSurface->Surface(SurfNum).Area * SurfTempIn(SurfNum) * state.dataUCSDShared->HWall(Ctd);
235 0 : state.dataDispVentMgr->HA_OC += state.dataSurface->Surface(SurfNum).Area * state.dataUCSDShared->HWall(Ctd);
236 : }
237 :
238 : // The Wall surface is partially in upper and partially in lower subzone
239 257580 : if (ZInfSurf <= LayH && ZSupSurf >= LayH) {
240 257580 : state.dataHeatBal->SurfTempEffBulkAir(SurfNum) = state.dataRoomAirMod->ZTMX(ZoneNum);
241 257580 : CalcDetailedHcInForDVModel(state, SurfNum, SurfTempIn, state.dataRoomAirMod->DVHcIn);
242 257580 : HLU = state.dataRoomAirMod->DVHcIn(SurfNum);
243 257580 : state.dataHeatBal->SurfTempEffBulkAir(SurfNum) = state.dataRoomAirMod->ZTOC(ZoneNum);
244 257580 : CalcDetailedHcInForDVModel(state, SurfNum, SurfTempIn, state.dataRoomAirMod->DVHcIn);
245 257580 : HLD = state.dataRoomAirMod->DVHcIn(SurfNum);
246 515160 : TmedDV = ((ZSupSurf - LayH) * state.dataRoomAirMod->ZTMX(ZoneNum) + (LayH - ZInfSurf) * state.dataRoomAirMod->ZTOC(ZoneNum)) /
247 257580 : (ZSupSurf - ZInfSurf);
248 257580 : state.dataUCSDShared->HWall(Ctd) = ((LayH - ZInfSurf) * HLD + (ZSupSurf - LayH) * HLU) / (ZSupSurf - ZInfSurf);
249 257580 : state.dataDispVentMgr->HAT_MX +=
250 257580 : state.dataSurface->Surface(SurfNum).Area * (ZSupSurf - LayH) / (ZSupSurf - ZInfSurf) * SurfTempIn(SurfNum) * HLU;
251 257580 : state.dataDispVentMgr->HA_MX += state.dataSurface->Surface(SurfNum).Area * (ZSupSurf - LayH) / (ZSupSurf - ZInfSurf) * HLU;
252 257580 : state.dataDispVentMgr->HAT_OC +=
253 257580 : state.dataSurface->Surface(SurfNum).Area * (LayH - ZInfSurf) / (ZSupSurf - ZInfSurf) * SurfTempIn(SurfNum) * HLD;
254 257580 : state.dataDispVentMgr->HA_OC += state.dataSurface->Surface(SurfNum).Area * (LayH - ZInfSurf) / (ZSupSurf - ZInfSurf) * HLD;
255 257580 : state.dataHeatBal->SurfTempEffBulkAir(SurfNum) = TmedDV;
256 : }
257 :
258 257580 : state.dataRoomAirMod->DVHcIn(SurfNum) = state.dataUCSDShared->HWall(Ctd);
259 :
260 : } // END WALL
261 :
262 : // WINDOW Hc, HA and HAT CALCULATION
263 302350 : for (Ctd = state.dataUCSDShared->PosZ_Window((ZoneNum - 1) * 2 + 1); Ctd <= state.dataUCSDShared->PosZ_Window((ZoneNum - 1) * 2 + 2); ++Ctd) {
264 237955 : SurfNum = state.dataUCSDShared->APos_Window(Ctd);
265 237955 : state.dataSurface->SurfTAirRef(SurfNum) = DataSurfaces::RefAirTemp::AdjacentAirTemp;
266 237955 : state.dataSurface->SurfTAirRefRpt(SurfNum) = DataSurfaces::SurfTAirRefReportVals[state.dataSurface->SurfTAirRef(SurfNum)];
267 237955 : if (SurfNum == 0) continue;
268 237955 : if (state.dataSurface->Surface(SurfNum).Tilt > 10.0 && state.dataSurface->Surface(SurfNum).Tilt < 170.0) { // Window Wall
269 237955 : Z1 = minval(state.dataSurface->Surface(SurfNum).Vertex({1, state.dataSurface->Surface(SurfNum).Sides}), &Vector::z);
270 237955 : Z2 = maxval(state.dataSurface->Surface(SurfNum).Vertex({1, state.dataSurface->Surface(SurfNum).Sides}), &Vector::z);
271 237955 : ZSupSurf = Z2 - state.dataRoomAirMod->ZoneCeilingHeight((ZoneNum - 1) * 2 + 1);
272 237955 : ZInfSurf = Z1 - state.dataRoomAirMod->ZoneCeilingHeight((ZoneNum - 1) * 2 + 1);
273 :
274 237955 : if (ZInfSurf > LayH) {
275 182486 : state.dataHeatBal->SurfTempEffBulkAir(SurfNum) = state.dataRoomAirMod->ZTMX(ZoneNum);
276 182486 : CalcDetailedHcInForDVModel(state, SurfNum, SurfTempIn, state.dataRoomAirMod->DVHcIn);
277 182486 : state.dataUCSDShared->HWindow(Ctd) = state.dataRoomAirMod->DVHcIn(SurfNum);
278 182486 : state.dataDispVentMgr->HAT_MX +=
279 182486 : state.dataSurface->Surface(SurfNum).Area * SurfTempIn(SurfNum) * state.dataUCSDShared->HWindow(Ctd);
280 182486 : state.dataDispVentMgr->HA_MX += state.dataSurface->Surface(SurfNum).Area * state.dataUCSDShared->HWindow(Ctd);
281 : }
282 :
283 237955 : if (ZSupSurf < LayH) {
284 15124 : state.dataHeatBal->SurfTempEffBulkAir(SurfNum) = state.dataRoomAirMod->ZTOC(ZoneNum);
285 15124 : CalcDetailedHcInForDVModel(state, SurfNum, SurfTempIn, state.dataRoomAirMod->DVHcIn);
286 15124 : state.dataUCSDShared->HWindow(Ctd) = state.dataRoomAirMod->DVHcIn(SurfNum);
287 15124 : state.dataDispVentMgr->HAT_OC +=
288 15124 : state.dataSurface->Surface(SurfNum).Area * SurfTempIn(SurfNum) * state.dataUCSDShared->HWindow(Ctd);
289 15124 : state.dataDispVentMgr->HA_OC += state.dataSurface->Surface(SurfNum).Area * state.dataUCSDShared->HWindow(Ctd);
290 : }
291 :
292 237955 : if (ZInfSurf <= LayH && ZSupSurf >= LayH) {
293 40345 : state.dataHeatBal->SurfTempEffBulkAir(SurfNum) = state.dataRoomAirMod->ZTMX(ZoneNum);
294 40345 : CalcDetailedHcInForDVModel(state, SurfNum, SurfTempIn, state.dataRoomAirMod->DVHcIn);
295 40345 : HLU = state.dataRoomAirMod->DVHcIn(SurfNum);
296 40345 : state.dataHeatBal->SurfTempEffBulkAir(SurfNum) = state.dataRoomAirMod->ZTOC(ZoneNum);
297 40345 : CalcDetailedHcInForDVModel(state, SurfNum, SurfTempIn, state.dataRoomAirMod->DVHcIn);
298 40345 : HLD = state.dataRoomAirMod->DVHcIn(SurfNum);
299 80690 : TmedDV = ((ZSupSurf - LayH) * state.dataRoomAirMod->ZTMX(ZoneNum) + (LayH - ZInfSurf) * state.dataRoomAirMod->ZTOC(ZoneNum)) /
300 40345 : (ZSupSurf - ZInfSurf);
301 40345 : state.dataUCSDShared->HWindow(Ctd) = ((LayH - ZInfSurf) * HLD + (ZSupSurf - LayH) * HLU) / (ZSupSurf - ZInfSurf);
302 40345 : state.dataDispVentMgr->HAT_MX +=
303 40345 : state.dataSurface->Surface(SurfNum).Area * (ZSupSurf - LayH) / (ZSupSurf - ZInfSurf) * SurfTempIn(SurfNum) * HLU;
304 40345 : state.dataDispVentMgr->HA_MX += state.dataSurface->Surface(SurfNum).Area * (ZSupSurf - LayH) / (ZSupSurf - ZInfSurf) * HLU;
305 40345 : state.dataDispVentMgr->HAT_OC +=
306 40345 : state.dataSurface->Surface(SurfNum).Area * (LayH - ZInfSurf) / (ZSupSurf - ZInfSurf) * SurfTempIn(SurfNum) * HLD;
307 40345 : state.dataDispVentMgr->HA_OC += state.dataSurface->Surface(SurfNum).Area * (LayH - ZInfSurf) / (ZSupSurf - ZInfSurf) * HLD;
308 40345 : state.dataHeatBal->SurfTempEffBulkAir(SurfNum) = TmedDV;
309 : }
310 : }
311 :
312 237955 : if (state.dataSurface->Surface(SurfNum).Tilt <= 10.0) { // Window Ceiling
313 0 : state.dataHeatBal->SurfTempEffBulkAir(SurfNum) = state.dataRoomAirMod->ZTMX(ZoneNum);
314 0 : CalcDetailedHcInForDVModel(state, SurfNum, SurfTempIn, state.dataRoomAirMod->DVHcIn);
315 0 : state.dataUCSDShared->HWindow(Ctd) = state.dataRoomAirMod->DVHcIn(SurfNum);
316 0 : state.dataDispVentMgr->HAT_MX += state.dataSurface->Surface(SurfNum).Area * SurfTempIn(SurfNum) * state.dataUCSDShared->HWindow(Ctd);
317 0 : state.dataDispVentMgr->HA_MX += state.dataSurface->Surface(SurfNum).Area * state.dataUCSDShared->HWindow(Ctd);
318 : }
319 :
320 237955 : if (state.dataSurface->Surface(SurfNum).Tilt >= 170.0) { // Window Floor
321 0 : state.dataHeatBal->SurfTempEffBulkAir(SurfNum) = state.dataRoomAirMod->ZTOC(ZoneNum);
322 0 : CalcDetailedHcInForDVModel(state, SurfNum, SurfTempIn, state.dataRoomAirMod->DVHcIn);
323 0 : state.dataUCSDShared->HWindow(Ctd) = state.dataRoomAirMod->DVHcIn(SurfNum);
324 0 : state.dataDispVentMgr->HAT_OC += state.dataSurface->Surface(SurfNum).Area * SurfTempIn(SurfNum) * state.dataUCSDShared->HWindow(Ctd);
325 0 : state.dataDispVentMgr->HA_OC += state.dataSurface->Surface(SurfNum).Area * state.dataUCSDShared->HWindow(Ctd);
326 : }
327 :
328 237955 : state.dataRoomAirMod->DVHcIn(SurfNum) = state.dataUCSDShared->HWindow(Ctd);
329 :
330 : } // END WINDOW
331 :
332 : // DOOR Hc, HA and HAT CALCULATION
333 64395 : for (Ctd = state.dataUCSDShared->PosZ_Door((ZoneNum - 1) * 2 + 1); Ctd <= state.dataUCSDShared->PosZ_Door((ZoneNum - 1) * 2 + 2);
334 : ++Ctd) { // DOOR
335 0 : SurfNum = state.dataUCSDShared->APos_Door(Ctd);
336 0 : state.dataSurface->SurfTAirRef(SurfNum) = DataSurfaces::RefAirTemp::AdjacentAirTemp;
337 0 : state.dataSurface->SurfTAirRefRpt(SurfNum) = DataSurfaces::SurfTAirRefReportVals[state.dataSurface->SurfTAirRef(SurfNum)];
338 0 : if (SurfNum == 0) continue;
339 0 : if (state.dataSurface->Surface(SurfNum).Tilt > 10.0 && state.dataSurface->Surface(SurfNum).Tilt < 170.0) { // Door Wall
340 0 : Z1 = minval(state.dataSurface->Surface(SurfNum).Vertex({1, state.dataSurface->Surface(SurfNum).Sides}), &Vector::z);
341 0 : Z2 = maxval(state.dataSurface->Surface(SurfNum).Vertex({1, state.dataSurface->Surface(SurfNum).Sides}), &Vector::z);
342 0 : ZSupSurf = Z2 - state.dataRoomAirMod->ZoneCeilingHeight((ZoneNum - 1) * 2 + 1);
343 0 : ZInfSurf = Z1 - state.dataRoomAirMod->ZoneCeilingHeight((ZoneNum - 1) * 2 + 1);
344 :
345 0 : if (ZInfSurf > LayH) {
346 0 : state.dataHeatBal->SurfTempEffBulkAir(SurfNum) = state.dataRoomAirMod->ZTMX(ZoneNum);
347 0 : CalcDetailedHcInForDVModel(state, SurfNum, SurfTempIn, state.dataRoomAirMod->DVHcIn);
348 0 : state.dataUCSDShared->HDoor(Ctd) = state.dataRoomAirMod->DVHcIn(SurfNum);
349 0 : state.dataDispVentMgr->HAT_MX +=
350 0 : state.dataSurface->Surface(SurfNum).Area * SurfTempIn(SurfNum) * state.dataUCSDShared->HDoor(Ctd);
351 0 : state.dataDispVentMgr->HA_MX += state.dataSurface->Surface(SurfNum).Area * state.dataUCSDShared->HDoor(Ctd);
352 : }
353 :
354 0 : if (ZSupSurf < LayH) {
355 0 : state.dataHeatBal->SurfTempEffBulkAir(SurfNum) = state.dataRoomAirMod->ZTOC(ZoneNum);
356 0 : CalcDetailedHcInForDVModel(state, SurfNum, SurfTempIn, state.dataRoomAirMod->DVHcIn);
357 0 : state.dataUCSDShared->HDoor(Ctd) = state.dataRoomAirMod->DVHcIn(SurfNum);
358 0 : state.dataDispVentMgr->HAT_OC +=
359 0 : state.dataSurface->Surface(SurfNum).Area * SurfTempIn(SurfNum) * state.dataUCSDShared->HDoor(Ctd);
360 0 : state.dataDispVentMgr->HA_OC += state.dataSurface->Surface(SurfNum).Area * state.dataUCSDShared->HDoor(Ctd);
361 : }
362 :
363 0 : if (ZInfSurf <= LayH && ZSupSurf >= LayH) {
364 0 : state.dataHeatBal->SurfTempEffBulkAir(SurfNum) = state.dataRoomAirMod->ZTMX(ZoneNum);
365 0 : CalcDetailedHcInForDVModel(state, SurfNum, SurfTempIn, state.dataRoomAirMod->DVHcIn);
366 0 : HLU = state.dataRoomAirMod->DVHcIn(SurfNum);
367 0 : state.dataHeatBal->SurfTempEffBulkAir(SurfNum) = state.dataRoomAirMod->ZTOC(ZoneNum);
368 0 : CalcDetailedHcInForDVModel(state, SurfNum, SurfTempIn, state.dataRoomAirMod->DVHcIn);
369 0 : HLD = state.dataRoomAirMod->DVHcIn(SurfNum);
370 0 : TmedDV = ((ZSupSurf - LayH) * state.dataRoomAirMod->ZTMX(ZoneNum) + (LayH - ZInfSurf) * state.dataRoomAirMod->ZTOC(ZoneNum)) /
371 0 : (ZSupSurf - ZInfSurf);
372 0 : state.dataUCSDShared->HDoor(Ctd) = ((LayH - ZInfSurf) * HLD + (ZSupSurf - LayH) * HLU) / (ZSupSurf - ZInfSurf);
373 0 : state.dataDispVentMgr->HAT_MX +=
374 0 : state.dataSurface->Surface(SurfNum).Area * (ZSupSurf - LayH) / (ZSupSurf - ZInfSurf) * SurfTempIn(SurfNum) * HLU;
375 0 : state.dataDispVentMgr->HA_MX += state.dataSurface->Surface(SurfNum).Area * (ZSupSurf - LayH) / (ZSupSurf - ZInfSurf) * HLU;
376 0 : state.dataDispVentMgr->HAT_OC +=
377 0 : state.dataSurface->Surface(SurfNum).Area * (LayH - ZInfSurf) / (ZSupSurf - ZInfSurf) * SurfTempIn(SurfNum) * HLD;
378 0 : state.dataDispVentMgr->HA_OC += state.dataSurface->Surface(SurfNum).Area * (LayH - ZInfSurf) / (ZSupSurf - ZInfSurf) * HLD;
379 0 : state.dataHeatBal->SurfTempEffBulkAir(SurfNum) = TmedDV;
380 : }
381 : }
382 :
383 0 : if (state.dataSurface->Surface(SurfNum).Tilt <= 10.0) { // Door Ceiling
384 0 : state.dataHeatBal->SurfTempEffBulkAir(SurfNum) = state.dataRoomAirMod->ZTMX(ZoneNum);
385 0 : CalcDetailedHcInForDVModel(state, SurfNum, SurfTempIn, state.dataRoomAirMod->DVHcIn);
386 0 : state.dataUCSDShared->HDoor(Ctd) = state.dataRoomAirMod->DVHcIn(SurfNum);
387 0 : state.dataDispVentMgr->HAT_MX += state.dataSurface->Surface(SurfNum).Area * SurfTempIn(SurfNum) * state.dataUCSDShared->HDoor(Ctd);
388 0 : state.dataDispVentMgr->HA_MX += state.dataSurface->Surface(SurfNum).Area * state.dataUCSDShared->HDoor(Ctd);
389 : }
390 :
391 0 : if (state.dataSurface->Surface(SurfNum).Tilt >= 170.0) { // Door Floor
392 0 : state.dataHeatBal->SurfTempEffBulkAir(SurfNum) = state.dataRoomAirMod->ZTOC(ZoneNum);
393 0 : CalcDetailedHcInForDVModel(state, SurfNum, SurfTempIn, state.dataRoomAirMod->DVHcIn);
394 0 : state.dataUCSDShared->HDoor(Ctd) = state.dataRoomAirMod->DVHcIn(SurfNum);
395 0 : state.dataDispVentMgr->HAT_OC += state.dataSurface->Surface(SurfNum).Area * SurfTempIn(SurfNum) * state.dataUCSDShared->HDoor(Ctd);
396 0 : state.dataDispVentMgr->HA_OC += state.dataSurface->Surface(SurfNum).Area * state.dataUCSDShared->HDoor(Ctd);
397 : }
398 :
399 0 : state.dataRoomAirMod->DVHcIn(SurfNum) = state.dataUCSDShared->HDoor(Ctd);
400 :
401 : } // END DOOR
402 :
403 : // INTERNAL Hc, HA and HAT CALCULATION
404 64395 : state.dataDispVentMgr->HeightIntMass =
405 64395 : min(state.dataDispVentMgr->HeightIntMassDefault,
406 64395 : (state.dataRoomAirMod->ZoneCeilingHeight((ZoneNum - 1) * 2 + 2) - state.dataRoomAirMod->ZoneCeilingHeight((ZoneNum - 1) * 2 + 1)));
407 138500 : for (Ctd = state.dataUCSDShared->PosZ_Internal((ZoneNum - 1) * 2 + 1); Ctd <= state.dataUCSDShared->PosZ_Internal((ZoneNum - 1) * 2 + 2);
408 : ++Ctd) {
409 74105 : SurfNum = state.dataUCSDShared->APos_Internal(Ctd);
410 74105 : state.dataSurface->SurfTAirRef(SurfNum) = DataSurfaces::RefAirTemp::AdjacentAirTemp;
411 74105 : state.dataSurface->SurfTAirRefRpt(SurfNum) = DataSurfaces::SurfTAirRefReportVals[state.dataSurface->SurfTAirRef(SurfNum)];
412 74105 : if (SurfNum == 0) continue;
413 74105 : ZSupSurf = state.dataDispVentMgr->HeightIntMass;
414 74105 : ZInfSurf = 0.0;
415 :
416 74105 : if (ZSupSurf < LayH) {
417 4220 : state.dataHeatBal->SurfTempEffBulkAir(SurfNum) = state.dataRoomAirMod->ZTOC(ZoneNum);
418 4220 : CalcDetailedHcInForDVModel(state, SurfNum, SurfTempIn, state.dataRoomAirMod->DVHcIn);
419 4220 : state.dataUCSDShared->HInternal(Ctd) = state.dataRoomAirMod->DVHcIn(SurfNum);
420 4220 : state.dataDispVentMgr->HAT_OC +=
421 4220 : state.dataSurface->Surface(SurfNum).Area * SurfTempIn(SurfNum) * state.dataUCSDShared->HInternal(Ctd);
422 4220 : state.dataDispVentMgr->HA_OC += state.dataSurface->Surface(SurfNum).Area * state.dataUCSDShared->HInternal(Ctd);
423 : }
424 :
425 74105 : if (ZInfSurf <= LayH && ZSupSurf >= LayH) {
426 69885 : state.dataHeatBal->SurfTempEffBulkAir(SurfNum) = state.dataRoomAirMod->ZTMX(ZoneNum);
427 69885 : CalcDetailedHcInForDVModel(state, SurfNum, SurfTempIn, state.dataRoomAirMod->DVHcIn);
428 69885 : HLU = state.dataRoomAirMod->DVHcIn(SurfNum);
429 69885 : state.dataHeatBal->SurfTempEffBulkAir(SurfNum) = state.dataRoomAirMod->ZTOC(ZoneNum);
430 69885 : CalcDetailedHcInForDVModel(state, SurfNum, SurfTempIn, state.dataRoomAirMod->DVHcIn);
431 69885 : HLD = state.dataRoomAirMod->DVHcIn(SurfNum);
432 139770 : TmedDV = ((ZSupSurf - LayH) * state.dataRoomAirMod->ZTMX(ZoneNum) + (LayH - ZInfSurf) * state.dataRoomAirMod->ZTOC(ZoneNum)) /
433 69885 : (ZSupSurf - ZInfSurf);
434 69885 : state.dataUCSDShared->HInternal(Ctd) = ((LayH - ZInfSurf) * HLD + (ZSupSurf - LayH) * HLU) / (ZSupSurf - ZInfSurf);
435 69885 : state.dataDispVentMgr->HAT_MX +=
436 69885 : state.dataSurface->Surface(SurfNum).Area * (ZSupSurf - LayH) / (ZSupSurf - ZInfSurf) * SurfTempIn(SurfNum) * HLU;
437 69885 : state.dataDispVentMgr->HA_MX += state.dataSurface->Surface(SurfNum).Area * (ZSupSurf - LayH) / (ZSupSurf - ZInfSurf) * HLU;
438 69885 : state.dataDispVentMgr->HAT_OC +=
439 69885 : state.dataSurface->Surface(SurfNum).Area * (LayH - ZInfSurf) / (ZSupSurf - ZInfSurf) * SurfTempIn(SurfNum) * HLD;
440 69885 : state.dataDispVentMgr->HA_OC += state.dataSurface->Surface(SurfNum).Area * (LayH - ZInfSurf) / (ZSupSurf - ZInfSurf) * HLD;
441 69885 : state.dataHeatBal->SurfTempEffBulkAir(SurfNum) = TmedDV;
442 : }
443 :
444 74105 : state.dataRoomAirMod->DVHcIn(SurfNum) = state.dataUCSDShared->HInternal(Ctd);
445 : } // END INTERNAL
446 :
447 : // CEILING Hc, HA and HAT CALCULATION
448 128790 : for (Ctd = state.dataUCSDShared->PosZ_Ceiling((ZoneNum - 1) * 2 + 1); Ctd <= state.dataUCSDShared->PosZ_Ceiling((ZoneNum - 1) * 2 + 2);
449 : ++Ctd) {
450 64395 : SurfNum = state.dataUCSDShared->APos_Ceiling(Ctd);
451 64395 : state.dataSurface->SurfTAirRef(SurfNum) = DataSurfaces::RefAirTemp::AdjacentAirTemp;
452 64395 : state.dataSurface->SurfTAirRefRpt(SurfNum) = DataSurfaces::SurfTAirRefReportVals[state.dataSurface->SurfTAirRef(SurfNum)];
453 64395 : if (SurfNum == 0) continue;
454 64395 : state.dataHeatBal->SurfTempEffBulkAir(SurfNum) = state.dataRoomAirMod->ZTMX(ZoneNum);
455 64395 : CalcDetailedHcInForDVModel(state, SurfNum, SurfTempIn, state.dataRoomAirMod->DVHcIn);
456 64395 : state.dataUCSDShared->HCeiling(Ctd) = state.dataRoomAirMod->DVHcIn(SurfNum);
457 64395 : state.dataDispVentMgr->HAT_MX += state.dataSurface->Surface(SurfNum).Area * SurfTempIn(SurfNum) * state.dataUCSDShared->HCeiling(Ctd);
458 64395 : state.dataDispVentMgr->HA_MX += state.dataSurface->Surface(SurfNum).Area * state.dataUCSDShared->HCeiling(Ctd);
459 64395 : state.dataRoomAirMod->DVHcIn(SurfNum) = state.dataUCSDShared->HCeiling(Ctd);
460 : } // END CEILING
461 :
462 : // FLOOR Hc, HA and HAT CALCULATION
463 128790 : for (Ctd = state.dataUCSDShared->PosZ_Floor((ZoneNum - 1) * 2 + 1); Ctd <= state.dataUCSDShared->PosZ_Floor((ZoneNum - 1) * 2 + 2); ++Ctd) {
464 64395 : SurfNum = state.dataUCSDShared->APos_Floor(Ctd);
465 64395 : state.dataSurface->SurfTAirRef(SurfNum) = DataSurfaces::RefAirTemp::AdjacentAirTemp;
466 64395 : state.dataSurface->SurfTAirRefRpt(SurfNum) = DataSurfaces::SurfTAirRefReportVals[state.dataSurface->SurfTAirRef(SurfNum)];
467 64395 : if (SurfNum == 0) continue;
468 64395 : state.dataHeatBal->SurfTempEffBulkAir(SurfNum) = state.dataRoomAirMod->ZTFloor(ZoneNum);
469 64395 : CalcDetailedHcInForDVModel(state, SurfNum, SurfTempIn, state.dataRoomAirMod->DVHcIn);
470 64395 : state.dataUCSDShared->HFloor(Ctd) = state.dataRoomAirMod->DVHcIn(SurfNum);
471 64395 : state.dataDispVentMgr->HAT_FLOOR += state.dataSurface->Surface(SurfNum).Area * SurfTempIn(SurfNum) * state.dataUCSDShared->HFloor(Ctd);
472 64395 : state.dataDispVentMgr->HA_FLOOR += state.dataSurface->Surface(SurfNum).Area * state.dataUCSDShared->HFloor(Ctd);
473 64395 : state.dataHeatBal->SurfTempEffBulkAir(SurfNum) = state.dataRoomAirMod->ZTFloor(ZoneNum);
474 64395 : state.dataRoomAirMod->DVHcIn(SurfNum) = state.dataUCSDShared->HFloor(Ctd);
475 : } // END FLOOR
476 : }
477 64395 : }
478 :
479 : //**************************************************************************************************
480 :
481 23820 : Real64 calculateThirdOrderFloorTemperature(Real64 temperatureHistoryTerm,
482 : Real64 HAT_floor,
483 : Real64 HA_floor,
484 : Real64 MCpT_Total,
485 : Real64 MCp_Total,
486 : Real64 occupiedTemp,
487 : Real64 nonAirSystemResponse,
488 : Real64 zoneMultiplier,
489 : Real64 airCap)
490 : {
491 23820 : const Real64 elevenOverSix = 11.0 / 6.0;
492 23820 : return (temperatureHistoryTerm + HAT_floor + MCpT_Total + 0.6 * occupiedTemp * MCp_Total + nonAirSystemResponse / zoneMultiplier) /
493 23820 : (elevenOverSix * airCap + HA_floor + 1.6 * MCp_Total);
494 : }
495 :
496 15024 : void CalcUCSDDV(EnergyPlusData &state, int const ZoneNum) // Which Zonenum
497 : {
498 :
499 : // SUBROUTINE INFORMATION:
500 : // AUTHOR G. Carrilho da Graca
501 : // DATE WRITTEN February 2004
502 : // MODIFIED Brent Griffith June 2008 for new interpolation and time history
503 : // RE-ENGINEERED -
504 :
505 : // PURPOSE OF THIS SUBROUTINE:
506 : // Subroutine for displacement ventilation modelling.
507 : // This subroutine calculates the mixed subzone height, surface heat transfer coefficients and
508 : // room air equivalent temperatures and three space temperatures (floor subzone, occupied zone and upper,
509 : // mixed subzone temperature)
510 :
511 : // REFERENCES:
512 : // Model developed by Paul Linden (UCSD), G. Carrilho da Graca (UCSD) and P. Haves (LBL).
513 : // Work funded by the California Energy Comission. More information on the model can found in:
514 : // "Simplified Models for Heat Transfer in Rooms" G. Carrilho da Graca, Ph.D. thesis UCSD. December 2003.
515 :
516 : // Using/Aliasing
517 : using namespace DataEnvironment;
518 : using namespace DataHeatBalance;
519 15024 : auto &TimeStepSys = state.dataHVACGlobal->TimeStepSys;
520 15024 : auto &UseZoneTimeStepHistory = state.dataHVACGlobal->UseZoneTimeStepHistory;
521 : using InternalHeatGains::SumInternalConvectionGainsByTypes;
522 : using InternalHeatGains::SumReturnAirConvectionGainsByTypes;
523 : using Psychrometrics::PsyCpAirFnW;
524 : using Psychrometrics::PsyRhoAirFnPbTdbW;
525 : using ScheduleManager::GetCurrentScheduleValue;
526 : using ScheduleManager::GetScheduleIndex;
527 :
528 : // SUBROUTINE PARAMETER DEFINITIONS:
529 15024 : Real64 const OneThird(1.0 / 3.0);
530 15024 : Real64 const MinFlow_pow_fac(std::pow(1.0 / 24.55 * 1.0, 1.0 / 0.6));
531 :
532 : // SUBROUTINE LOCAL VARIABLE DECLARATIONS:
533 : Real64 HeightFrac; // Fractional height of transition between occupied and mixed subzones
534 : Real64 GainsFrac; // Fraction of lower subzone internal gains that mix as opposed to forming plumes
535 : Real64 ConvGains; // Total convective gains in the room
536 : Real64 ConvGainsOccupiedSubzone; // Total convective gains released in occupied subzone
537 : Real64 ConvGainsMixedSubzone; // Total convective gains released in mixed subzone
538 : Real64 MCp_Total; // Total capacity rate into the zone - assumed to enter at low level
539 : Real64 ZTAveraged;
540 : Real64 TempDiffCritRep; // Minimum temperature difference between mixed and occupied subzones for reporting
541 : bool MIXFLAG;
542 : int Ctd;
543 : Real64 MinFlow;
544 : Real64 NumPLPP; // Number of plumes per person
545 : int NumberOfOccupants;
546 : Real64 MTGAUX;
547 : int ZoneEquipConfigNum;
548 : int NodeNum;
549 : Real64 PowerInPlumes;
550 : Real64 SumSysMCp;
551 : Real64 SumSysMCpT;
552 : Real64 NodeTemp;
553 : Real64 MassFlowRate;
554 : Real64 CpAir;
555 : Real64 MCpT_Total;
556 : int ZoneNodeNum; // index number of the zone node
557 : Real64 NumberOfPlumes;
558 : Real64 SumMCp;
559 : Real64 SumMCpT;
560 : Real64 TempHistTerm;
561 : Real64 PowerPerPlume;
562 : Real64 HeightMixedSubzoneAve; // Height of center of mixed air subzone
563 : Real64 HeightOccupiedSubzoneAve; // Height of center of occupied air subzone
564 : Real64 HeightFloorSubzoneAve; // Height of center of floor air subzone
565 : Real64 HeightThermostat; // Height of center of thermostat/temperature control sensor
566 : Real64 HeightComfort; // Height at which air temperature value is used to calculate comfort
567 : Real64 CeilingHeight;
568 : Real64 ZoneMult; // total zone multiplier
569 : int Loop;
570 : int FlagApertures;
571 :
572 15024 : auto &TempDepCoef = state.dataDispVentMgr->TempDepCoef;
573 15024 : auto &TempIndCoef = state.dataDispVentMgr->TempIndCoef;
574 :
575 : Real64 RetAirGain;
576 15024 : assert(state.dataRoomAirMod->AirModel.allocated());
577 :
578 : // Exact solution or Euler method
579 15024 : if (state.dataHeatBal->ZoneAirSolutionAlgo != DataHeatBalance::SolutionAlgo::ThirdOrder) {
580 6608 : if (state.dataHVACGlobal->ShortenTimeStepSysRoomAir && TimeStepSys < state.dataGlobal->TimeStepZone) {
581 295 : if (state.dataHVACGlobal->PreviousTimeStep < state.dataGlobal->TimeStepZone) {
582 93 : state.dataRoomAirMod->Zone1Floor(ZoneNum) = state.dataRoomAirMod->ZoneM2Floor(ZoneNum);
583 93 : state.dataRoomAirMod->Zone1OC(ZoneNum) = state.dataRoomAirMod->ZoneM2OC(ZoneNum);
584 93 : state.dataRoomAirMod->Zone1MX(ZoneNum) = state.dataRoomAirMod->ZoneM2MX(ZoneNum);
585 : } else {
586 202 : state.dataRoomAirMod->Zone1Floor(ZoneNum) = state.dataRoomAirMod->ZoneMXFloor(ZoneNum);
587 202 : state.dataRoomAirMod->Zone1OC(ZoneNum) = state.dataRoomAirMod->ZoneMXOC(ZoneNum);
588 202 : state.dataRoomAirMod->Zone1MX(ZoneNum) = state.dataRoomAirMod->ZoneMXMX(ZoneNum);
589 : }
590 : } else {
591 6313 : state.dataRoomAirMod->Zone1Floor(ZoneNum) = state.dataRoomAirMod->ZTFloor(ZoneNum);
592 6313 : state.dataRoomAirMod->Zone1OC(ZoneNum) = state.dataRoomAirMod->ZTOC(ZoneNum);
593 6313 : state.dataRoomAirMod->Zone1MX(ZoneNum) = state.dataRoomAirMod->ZTMX(ZoneNum);
594 : }
595 : }
596 :
597 15024 : auto &Zone(state.dataHeatBal->Zone);
598 :
599 15024 : MIXFLAG = false;
600 15024 : FlagApertures = 1;
601 15024 : state.dataRoomAirMod->DVHcIn = state.dataHeatBalSurf->SurfHConvInt;
602 15024 : CeilingHeight = state.dataRoomAirMod->ZoneCeilingHeight((ZoneNum - 1) * 2 + 2) - state.dataRoomAirMod->ZoneCeilingHeight((ZoneNum - 1) * 2 + 1);
603 15024 : ZoneMult = Zone(ZoneNum).Multiplier * Zone(ZoneNum).ListMultiplier;
604 15024 : auto &thisZoneHB = state.dataZoneTempPredictorCorrector->zoneHeatBalance(ZoneNum);
605 :
606 30048 : for (Ctd = 1; Ctd <= state.dataRoomAirMod->TotUCSDDV; ++Ctd) {
607 15024 : if (ZoneNum == state.dataRoomAirMod->ZoneUCSDDV(Ctd).ZonePtr) {
608 15024 : GainsFrac = GetCurrentScheduleValue(state, state.dataRoomAirMod->ZoneUCSDDV(Ctd).SchedGainsPtr);
609 15024 : NumPLPP = state.dataRoomAirMod->ZoneUCSDDV(Ctd).NumPlumesPerOcc;
610 15024 : HeightThermostat = state.dataRoomAirMod->ZoneUCSDDV(Ctd).ThermostatHeight;
611 15024 : HeightComfort = state.dataRoomAirMod->ZoneUCSDDV(Ctd).ComfortHeight;
612 15024 : TempDiffCritRep = state.dataRoomAirMod->ZoneUCSDDV(Ctd).TempTrigger;
613 : }
614 : }
615 :
616 15024 : ConvGainsOccupiedSubzone = SumInternalConvectionGainsByTypes(state, ZoneNum, DisplacementVentMgr::IntGainTypesOccupied);
617 :
618 15024 : ConvGainsOccupiedSubzone += 0.5 * thisZoneHB.SysDepZoneLoadsLagged;
619 :
620 : // Add heat to return air if zonal system (no return air) or cycling system (return air frequently very
621 : // low or zero)
622 15024 : if (Zone(ZoneNum).NoHeatToReturnAir) {
623 0 : RetAirGain = SumReturnAirConvectionGainsByTypes(state, ZoneNum, DisplacementVentMgr::IntGainTypesOccupied);
624 0 : ConvGainsOccupiedSubzone += RetAirGain;
625 : }
626 :
627 15024 : ConvGainsMixedSubzone = SumInternalConvectionGainsByTypes(state, ZoneNum, DisplacementVentMgr::IntGainTypesMixedSubzone);
628 15024 : ConvGainsMixedSubzone +=
629 15024 : state.dataHeatBalFanSys->SumConvHTRadSys(ZoneNum) + state.dataHeatBalFanSys->SumConvPool(ZoneNum) + 0.5 * thisZoneHB.SysDepZoneLoadsLagged;
630 15024 : if (Zone(ZoneNum).NoHeatToReturnAir) {
631 0 : RetAirGain = SumReturnAirConvectionGainsByTypes(state, ZoneNum, DisplacementVentMgr::IntGainTypesMixedSubzone);
632 0 : ConvGainsMixedSubzone += RetAirGain;
633 : }
634 :
635 15024 : ConvGains = ConvGainsOccupiedSubzone + ConvGainsMixedSubzone;
636 :
637 : //=================== Entering air system temperature and flow====================
638 15024 : SumSysMCp = 0.0;
639 15024 : SumSysMCpT = 0.0;
640 : // Check to make sure if this is a controlled zone and determine ZoneEquipConfigNum
641 15024 : ZoneEquipConfigNum = ZoneNum;
642 15024 : if (state.dataZoneEquip->ZoneEquipConfig(ZoneEquipConfigNum).IsControlled) {
643 16832 : for (NodeNum = 1; NodeNum <= state.dataZoneEquip->ZoneEquipConfig(ZoneEquipConfigNum).NumInletNodes; ++NodeNum) {
644 8416 : NodeTemp = state.dataLoopNodes->Node(state.dataZoneEquip->ZoneEquipConfig(ZoneEquipConfigNum).InletNode(NodeNum)).Temp;
645 8416 : MassFlowRate = state.dataLoopNodes->Node(state.dataZoneEquip->ZoneEquipConfig(ZoneEquipConfigNum).InletNode(NodeNum)).MassFlowRate;
646 8416 : CpAir = PsyCpAirFnW(thisZoneHB.ZoneAirHumRat);
647 8416 : SumSysMCp += MassFlowRate * CpAir;
648 8416 : SumSysMCpT += MassFlowRate * CpAir * NodeTemp;
649 : }
650 : }
651 :
652 15024 : SumMCp = thisZoneHB.MCPI + thisZoneHB.MCPV + thisZoneHB.MCPM + thisZoneHB.MCPE + thisZoneHB.MCPC + thisZoneHB.MDotCPOA;
653 30048 : SumMCpT = thisZoneHB.MCPTI + thisZoneHB.MCPTV + thisZoneHB.MCPTM + thisZoneHB.MCPTE + thisZoneHB.MCPTC +
654 15024 : thisZoneHB.MDotCPOA * Zone(ZoneNum).OutDryBulbTemp;
655 15024 : if (state.afn->simulation_control.type == AirflowNetwork::ControlType::MultizoneWithoutDistribution) {
656 6608 : SumMCp = state.afn->exchangeData(ZoneNum).SumMCp + state.afn->exchangeData(ZoneNum).SumMVCp + state.afn->exchangeData(ZoneNum).SumMMCp;
657 6608 : SumMCpT = state.afn->exchangeData(ZoneNum).SumMCpT + state.afn->exchangeData(ZoneNum).SumMVCpT + state.afn->exchangeData(ZoneNum).SumMMCpT;
658 : }
659 :
660 15024 : MCp_Total = SumMCp + SumSysMCp;
661 15024 : MCpT_Total = SumMCpT + SumSysMCpT;
662 :
663 15024 : if (state.dataHeatBal->TotPeople > 0) {
664 15024 : NumberOfOccupants = 0;
665 15024 : NumberOfPlumes = 0.0;
666 45140 : for (Ctd = 1; Ctd <= state.dataHeatBal->TotPeople; ++Ctd) {
667 30116 : if (state.dataHeatBal->People(Ctd).ZonePtr == ZoneNum) {
668 30116 : NumberOfOccupants += state.dataHeatBal->People(Ctd).NumberOfPeople; // *GetCurrentScheduleValue(state, People(Ctd)%NumberOfPeoplePtr)
669 30116 : NumberOfPlumes = NumberOfOccupants * NumPLPP;
670 : }
671 : }
672 15024 : if (NumberOfPlumes == 0.0) {
673 0 : NumberOfPlumes = 1.0;
674 : }
675 15024 : PowerInPlumes = (1.0 - GainsFrac) * ConvGainsOccupiedSubzone;
676 15024 : PowerPerPlume = PowerInPlumes / NumberOfPlumes;
677 : } else {
678 0 : NumberOfPlumes = 1.0;
679 0 : PowerInPlumes = (1.0 - GainsFrac) * ConvGainsOccupiedSubzone;
680 0 : PowerPerPlume = PowerInPlumes / NumberOfPlumes;
681 : }
682 :
683 : // When AirflowNetwork is used verify if bottom apertures are inflowing and upper apertures are
684 : // outflowing. The lower apertures have to be located below 0.8m and the upper apertures
685 : // have to be located above 1.8m.
686 :
687 15024 : if (state.afn->NumOfLinksMultiZone > 0) {
688 26432 : for (Loop = 1; Loop <= state.dataRoomAirMod->AirflowNetworkSurfaceUCSDCV(0, ZoneNum); ++Loop) {
689 : // direct AirflowNetwork surface
690 :
691 39648 : if (state.dataSurface->Surface(state.afn->MultizoneSurfaceData(state.dataRoomAirMod->AirflowNetworkSurfaceUCSDCV(Loop, ZoneNum)).SurfNum)
692 19824 : .Zone == ZoneNum) {
693 :
694 26432 : if ((state.dataRoomAirMod->SurfParametersCVDV(state.dataRoomAirMod->AirflowNetworkSurfaceUCSDCV(Loop, ZoneNum)).Zmax < 0.8 &&
695 6608 : state.afn->AirflowNetworkLinkSimu(state.dataRoomAirMod->AirflowNetworkSurfaceUCSDCV(Loop, ZoneNum)).VolFLOW > 0)) {
696 0 : FlagApertures = 0;
697 0 : break;
698 : }
699 26432 : if (state.dataRoomAirMod->SurfParametersCVDV(state.dataRoomAirMod->AirflowNetworkSurfaceUCSDCV(Loop, ZoneNum)).Zmin > 1.8 &&
700 6608 : state.afn->AirflowNetworkLinkSimu(state.dataRoomAirMod->AirflowNetworkSurfaceUCSDCV(Loop, ZoneNum)).VolFLOW2 > 0) {
701 0 : FlagApertures = 0;
702 0 : break;
703 : }
704 :
705 46256 : if ((state.dataRoomAirMod->SurfParametersCVDV(state.dataRoomAirMod->AirflowNetworkSurfaceUCSDCV(Loop, ZoneNum)).Zmin > 0.8 &&
706 39648 : state.dataRoomAirMod->SurfParametersCVDV(state.dataRoomAirMod->AirflowNetworkSurfaceUCSDCV(Loop, ZoneNum)).Zmin < 1.8) ||
707 33040 : (state.dataRoomAirMod->SurfParametersCVDV(state.dataRoomAirMod->AirflowNetworkSurfaceUCSDCV(Loop, ZoneNum)).Zmax > 0.8 &&
708 13216 : state.dataRoomAirMod->SurfParametersCVDV(state.dataRoomAirMod->AirflowNetworkSurfaceUCSDCV(Loop, ZoneNum)).Zmax < 1.8)) {
709 0 : FlagApertures = 0;
710 0 : break;
711 : }
712 : // indirect AirflowNetwork surface; this is an interzone surface
713 : } else {
714 :
715 0 : if (state.dataRoomAirMod->SurfParametersCVDV(state.dataRoomAirMod->AirflowNetworkSurfaceUCSDCV(Loop, ZoneNum)).Zmax +
716 : Zone(state.dataSurface
717 0 : ->Surface(
718 0 : state.afn->MultizoneSurfaceData(state.dataRoomAirMod->AirflowNetworkSurfaceUCSDCV(Loop, ZoneNum)).SurfNum)
719 0 : .Zone)
720 0 : .OriginZ -
721 0 : Zone(ZoneNum).OriginZ <
722 0 : 0.8 &&
723 0 : state.afn->AirflowNetworkLinkSimu(state.dataRoomAirMod->AirflowNetworkSurfaceUCSDCV(Loop, ZoneNum)).VolFLOW2 > 0) {
724 0 : FlagApertures = 0;
725 0 : break;
726 : }
727 0 : if (state.dataRoomAirMod->SurfParametersCVDV(state.dataRoomAirMod->AirflowNetworkSurfaceUCSDCV(Loop, ZoneNum)).Zmin +
728 : Zone(state.dataSurface
729 0 : ->Surface(
730 0 : state.afn->MultizoneSurfaceData(state.dataRoomAirMod->AirflowNetworkSurfaceUCSDCV(Loop, ZoneNum)).SurfNum)
731 0 : .Zone)
732 0 : .OriginZ -
733 0 : Zone(ZoneNum).OriginZ >
734 0 : 1.8 &&
735 0 : state.afn->AirflowNetworkLinkSimu(state.dataRoomAirMod->AirflowNetworkSurfaceUCSDCV(Loop, ZoneNum)).VolFLOW > 0) {
736 0 : FlagApertures = 0;
737 0 : break;
738 : }
739 0 : if ((state.dataRoomAirMod->SurfParametersCVDV(state.dataRoomAirMod->AirflowNetworkSurfaceUCSDCV(Loop, ZoneNum)).Zmin +
740 : Zone(state.dataSurface
741 0 : ->Surface(
742 0 : state.afn->MultizoneSurfaceData(state.dataRoomAirMod->AirflowNetworkSurfaceUCSDCV(Loop, ZoneNum)).SurfNum)
743 0 : .Zone)
744 0 : .OriginZ -
745 0 : Zone(ZoneNum).OriginZ >
746 0 : 0.8 &&
747 0 : state.dataRoomAirMod->SurfParametersCVDV(state.dataRoomAirMod->AirflowNetworkSurfaceUCSDCV(Loop, ZoneNum)).Zmin +
748 : Zone(state.dataSurface
749 0 : ->Surface(
750 0 : state.afn->MultizoneSurfaceData(state.dataRoomAirMod->AirflowNetworkSurfaceUCSDCV(Loop, ZoneNum)).SurfNum)
751 0 : .Zone)
752 0 : .OriginZ -
753 0 : Zone(ZoneNum).OriginZ <
754 0 : 1.8) ||
755 0 : (state.dataRoomAirMod->SurfParametersCVDV(state.dataRoomAirMod->AirflowNetworkSurfaceUCSDCV(Loop, ZoneNum)).Zmax +
756 : Zone(state.dataSurface
757 0 : ->Surface(
758 0 : state.afn->MultizoneSurfaceData(state.dataRoomAirMod->AirflowNetworkSurfaceUCSDCV(Loop, ZoneNum)).SurfNum)
759 0 : .Zone)
760 0 : .OriginZ -
761 0 : Zone(ZoneNum).OriginZ >
762 0 : 0.8 &&
763 0 : state.dataRoomAirMod->SurfParametersCVDV(state.dataRoomAirMod->AirflowNetworkSurfaceUCSDCV(Loop, ZoneNum)).Zmax +
764 : Zone(state.dataSurface
765 0 : ->Surface(
766 0 : state.afn->MultizoneSurfaceData(state.dataRoomAirMod->AirflowNetworkSurfaceUCSDCV(Loop, ZoneNum)).SurfNum)
767 0 : .Zone)
768 0 : .OriginZ -
769 0 : Zone(ZoneNum).OriginZ <
770 : 1.8)) {
771 0 : FlagApertures = 0;
772 0 : break;
773 : }
774 : }
775 : }
776 : }
777 :
778 15024 : if ((PowerInPlumes == 0.0) || (MCpT_Total == 0.0) || FlagApertures == 0) {
779 : // The system will mix
780 5466 : HeightFrac = 0.0;
781 : } else {
782 9558 : Real64 const plume_fac(NumberOfPlumes * std::pow(PowerPerPlume, OneThird));
783 9558 : HeightFrac = min(24.55 * std::pow(MCp_Total * 0.000833 / plume_fac, 0.6) / CeilingHeight, 1.0);
784 47790 : for (Ctd = 1; Ctd <= 4; ++Ctd) {
785 38232 : HcUCSDDV(state, ZoneNum, HeightFrac);
786 : // HeightFrac = min( 24.55 * std::pow( MCp_Total * 0.000833 / ( NumberOfPlumes * std::pow( PowerPerPlume, OneThird ) ), 0.6 ) /
787 : // CeilingHeight, 1.0 ); //Tuned This does not vary in loop EPTeam-replaces above (cause diffs) HeightFrac =
788 : // MIN(24.55d0*(MCp_Total*0.000833d0/(NumberOfPlumes*PowerPerPlume**(1.0d0/3.d0)))**0.6 / CeilingHeight , 1.0d0)
789 38232 : state.dataRoomAirMod->HeightTransition(ZoneNum) = HeightFrac * CeilingHeight;
790 38232 : state.dataRoomAirMod->AIRRATFloor(ZoneNum) =
791 38232 : Zone(ZoneNum).Volume * min(state.dataRoomAirMod->HeightTransition(ZoneNum), state.dataDispVentMgr->HeightFloorSubzoneTop) /
792 76464 : CeilingHeight * Zone(ZoneNum).ZoneVolCapMultpSens *
793 114696 : PsyRhoAirFnPbTdbW(state, state.dataEnvrn->OutBaroPress, state.dataRoomAirMod->MATFloor(ZoneNum), thisZoneHB.ZoneAirHumRat) *
794 76464 : PsyCpAirFnW(thisZoneHB.ZoneAirHumRat) / (TimeStepSys * DataGlobalConstants::SecInHour);
795 38232 : state.dataRoomAirMod->AIRRATOC(ZoneNum) =
796 38232 : Zone(ZoneNum).Volume * (state.dataRoomAirMod->HeightTransition(ZoneNum) - min(state.dataRoomAirMod->HeightTransition(ZoneNum), 0.2)) /
797 76464 : CeilingHeight * Zone(ZoneNum).ZoneVolCapMultpSens *
798 114696 : PsyRhoAirFnPbTdbW(state, state.dataEnvrn->OutBaroPress, state.dataRoomAirMod->MATOC(ZoneNum), thisZoneHB.ZoneAirHumRat) *
799 76464 : PsyCpAirFnW(thisZoneHB.ZoneAirHumRat) / (TimeStepSys * DataGlobalConstants::SecInHour);
800 38232 : state.dataRoomAirMod->AIRRATMX(ZoneNum) =
801 76464 : Zone(ZoneNum).Volume * (CeilingHeight - state.dataRoomAirMod->HeightTransition(ZoneNum)) / CeilingHeight *
802 76464 : Zone(ZoneNum).ZoneVolCapMultpSens *
803 114696 : PsyRhoAirFnPbTdbW(state, state.dataEnvrn->OutBaroPress, state.dataRoomAirMod->MATMX(ZoneNum), thisZoneHB.ZoneAirHumRat) *
804 76464 : PsyCpAirFnW(thisZoneHB.ZoneAirHumRat) / (TimeStepSys * DataGlobalConstants::SecInHour);
805 :
806 38232 : if (UseZoneTimeStepHistory) {
807 32348 : state.dataRoomAirMod->ZTM3Floor(ZoneNum) = state.dataRoomAirMod->XM3TFloor(ZoneNum);
808 32348 : state.dataRoomAirMod->ZTM2Floor(ZoneNum) = state.dataRoomAirMod->XM2TFloor(ZoneNum);
809 32348 : state.dataRoomAirMod->ZTM1Floor(ZoneNum) = state.dataRoomAirMod->XMATFloor(ZoneNum);
810 :
811 32348 : state.dataRoomAirMod->ZTM3OC(ZoneNum) = state.dataRoomAirMod->XM3TOC(ZoneNum);
812 32348 : state.dataRoomAirMod->ZTM2OC(ZoneNum) = state.dataRoomAirMod->XM2TOC(ZoneNum);
813 32348 : state.dataRoomAirMod->ZTM1OC(ZoneNum) = state.dataRoomAirMod->XMATOC(ZoneNum);
814 :
815 32348 : state.dataRoomAirMod->ZTM3MX(ZoneNum) = state.dataRoomAirMod->XM3TMX(ZoneNum);
816 32348 : state.dataRoomAirMod->ZTM2MX(ZoneNum) = state.dataRoomAirMod->XM2TMX(ZoneNum);
817 32348 : state.dataRoomAirMod->ZTM1MX(ZoneNum) = state.dataRoomAirMod->XMATMX(ZoneNum);
818 :
819 : } else {
820 5884 : state.dataRoomAirMod->ZTM3Floor(ZoneNum) = state.dataRoomAirMod->DSXM3TFloor(ZoneNum);
821 5884 : state.dataRoomAirMod->ZTM2Floor(ZoneNum) = state.dataRoomAirMod->DSXM2TFloor(ZoneNum);
822 5884 : state.dataRoomAirMod->ZTM1Floor(ZoneNum) = state.dataRoomAirMod->DSXMATFloor(ZoneNum);
823 :
824 5884 : state.dataRoomAirMod->ZTM3OC(ZoneNum) = state.dataRoomAirMod->DSXM3TOC(ZoneNum);
825 5884 : state.dataRoomAirMod->ZTM2OC(ZoneNum) = state.dataRoomAirMod->DSXM2TOC(ZoneNum);
826 5884 : state.dataRoomAirMod->ZTM1OC(ZoneNum) = state.dataRoomAirMod->DSXMATOC(ZoneNum);
827 :
828 5884 : state.dataRoomAirMod->ZTM3MX(ZoneNum) = state.dataRoomAirMod->DSXM3TMX(ZoneNum);
829 5884 : state.dataRoomAirMod->ZTM2MX(ZoneNum) = state.dataRoomAirMod->DSXM2TMX(ZoneNum);
830 5884 : state.dataRoomAirMod->ZTM1MX(ZoneNum) = state.dataRoomAirMod->DSXMATMX(ZoneNum);
831 : }
832 :
833 38232 : Real64 AirCap = state.dataRoomAirMod->AIRRATFloor(ZoneNum);
834 76464 : TempHistTerm = AirCap * (3.0 * state.dataRoomAirMod->ZTM1Floor(ZoneNum) - (3.0 / 2.0) * state.dataRoomAirMod->ZTM2Floor(ZoneNum) +
835 38232 : OneThird * state.dataRoomAirMod->ZTM3Floor(ZoneNum));
836 38232 : TempDepCoef = state.dataDispVentMgr->HA_FLOOR + MCp_Total;
837 38232 : TempIndCoef = state.dataDispVentMgr->HAT_FLOOR + MCpT_Total + thisZoneHB.NonAirSystemResponse / ZoneMult;
838 38232 : switch (state.dataHeatBal->ZoneAirSolutionAlgo) {
839 23820 : case DataHeatBalance::SolutionAlgo::ThirdOrder: {
840 95280 : state.dataRoomAirMod->ZTFloor(ZoneNum) = calculateThirdOrderFloorTemperature(TempHistTerm,
841 23820 : state.dataDispVentMgr->HAT_FLOOR,
842 23820 : state.dataDispVentMgr->HA_FLOOR,
843 : MCpT_Total,
844 : MCp_Total,
845 23820 : state.dataRoomAirMod->ZTOC(ZoneNum),
846 : thisZoneHB.NonAirSystemResponse,
847 : ZoneMult,
848 : AirCap);
849 23820 : } break;
850 0 : case DataHeatBalance::SolutionAlgo::AnalyticalSolution: {
851 0 : if (TempDepCoef == 0.0) { // B=0
852 0 : state.dataRoomAirMod->ZTFloor(ZoneNum) = state.dataRoomAirMod->Zone1Floor(ZoneNum) + TempIndCoef / AirCap;
853 : } else {
854 0 : state.dataRoomAirMod->ZTFloor(ZoneNum) =
855 0 : (state.dataRoomAirMod->Zone1Floor(ZoneNum) - TempIndCoef / TempDepCoef) * std::exp(min(700.0, -TempDepCoef / AirCap)) +
856 0 : TempIndCoef / TempDepCoef;
857 : }
858 0 : } break;
859 14412 : case DataHeatBalance::SolutionAlgo::EulerMethod: {
860 14412 : state.dataRoomAirMod->ZTFloor(ZoneNum) = (AirCap * state.dataRoomAirMod->Zone1Floor(ZoneNum) + TempIndCoef) / (AirCap + TempDepCoef);
861 14412 : } break;
862 0 : default:
863 0 : break;
864 : }
865 38232 : AirCap = state.dataRoomAirMod->AIRRATOC(ZoneNum);
866 76464 : TempHistTerm = AirCap * (3.0 * state.dataRoomAirMod->ZTM1OC(ZoneNum) - (3.0 / 2.0) * state.dataRoomAirMod->ZTM2OC(ZoneNum) +
867 38232 : OneThird * state.dataRoomAirMod->ZTM3OC(ZoneNum));
868 38232 : TempDepCoef = state.dataDispVentMgr->HA_OC + MCp_Total;
869 38232 : TempIndCoef = ConvGainsOccupiedSubzone * GainsFrac + state.dataDispVentMgr->HAT_OC + state.dataRoomAirMod->ZTFloor(ZoneNum) * MCp_Total;
870 38232 : switch (state.dataHeatBal->ZoneAirSolutionAlgo) {
871 23820 : case DataHeatBalance::SolutionAlgo::ThirdOrder: {
872 71460 : state.dataRoomAirMod->ZTOC(ZoneNum) = (TempHistTerm + ConvGainsOccupiedSubzone * GainsFrac + state.dataDispVentMgr->HAT_OC +
873 47640 : 1.6 * state.dataRoomAirMod->ZTFloor(ZoneNum) * MCp_Total) /
874 23820 : ((11.0 / 6.0) * AirCap + state.dataDispVentMgr->HA_OC + 1.6 * MCp_Total);
875 23820 : } break;
876 0 : case DataHeatBalance::SolutionAlgo::AnalyticalSolution: {
877 0 : if (TempDepCoef == 0.0) { // B=0
878 0 : state.dataRoomAirMod->ZTOC(ZoneNum) = state.dataRoomAirMod->Zone1OC(ZoneNum) + TempIndCoef / AirCap;
879 : } else {
880 0 : if (AirCap == 0.0) {
881 0 : state.dataRoomAirMod->ZTOC(ZoneNum) = TempIndCoef / TempDepCoef;
882 : } else {
883 0 : state.dataRoomAirMod->ZTOC(ZoneNum) =
884 0 : (state.dataRoomAirMod->Zone1OC(ZoneNum) - TempIndCoef / TempDepCoef) * std::exp(min(700.0, -TempDepCoef / AirCap)) +
885 0 : TempIndCoef / TempDepCoef;
886 : }
887 : }
888 0 : } break;
889 14412 : case DataHeatBalance::SolutionAlgo::EulerMethod: {
890 14412 : state.dataRoomAirMod->ZTOC(ZoneNum) = (AirCap * state.dataRoomAirMod->Zone1OC(ZoneNum) + TempIndCoef) / (AirCap + TempDepCoef);
891 14412 : } break;
892 0 : default:
893 0 : break;
894 : }
895 38232 : AirCap = state.dataRoomAirMod->AIRRATMX(ZoneNum);
896 76464 : TempHistTerm = AirCap * (3.0 * state.dataRoomAirMod->ZTM1MX(ZoneNum) - (3.0 / 2.0) * state.dataRoomAirMod->ZTM2MX(ZoneNum) +
897 38232 : OneThird * state.dataRoomAirMod->ZTM3MX(ZoneNum));
898 38232 : TempDepCoef = state.dataDispVentMgr->HA_MX + MCp_Total;
899 76464 : TempIndCoef = ConvGainsOccupiedSubzone * (1.0 - GainsFrac) + ConvGainsMixedSubzone + state.dataDispVentMgr->HAT_MX +
900 38232 : state.dataRoomAirMod->ZTOC(ZoneNum) * MCp_Total;
901 38232 : switch (state.dataHeatBal->ZoneAirSolutionAlgo) {
902 23820 : case DataHeatBalance::SolutionAlgo::ThirdOrder: {
903 71460 : state.dataRoomAirMod->ZTMX(ZoneNum) = (TempHistTerm + ConvGainsOccupiedSubzone * (1.0 - GainsFrac) + ConvGainsMixedSubzone +
904 71460 : state.dataDispVentMgr->HAT_MX + state.dataRoomAirMod->ZTOC(ZoneNum) * MCp_Total) /
905 23820 : ((11.0 / 6.0) * AirCap + state.dataDispVentMgr->HA_MX + MCp_Total);
906 23820 : } break;
907 0 : case DataHeatBalance::SolutionAlgo::AnalyticalSolution: {
908 0 : if (TempDepCoef == 0.0) { // B=0
909 0 : state.dataRoomAirMod->ZTMX(ZoneNum) = state.dataRoomAirMod->Zone1MX(ZoneNum) + TempIndCoef / AirCap;
910 : } else {
911 0 : if (AirCap == 0.0) {
912 0 : state.dataRoomAirMod->ZTMX(ZoneNum) = TempIndCoef / TempDepCoef;
913 : } else {
914 0 : state.dataRoomAirMod->ZTMX(ZoneNum) =
915 0 : (state.dataRoomAirMod->Zone1MX(ZoneNum) - TempIndCoef / TempDepCoef) * std::exp(min(700.0, -TempDepCoef / AirCap)) +
916 0 : TempIndCoef / TempDepCoef;
917 : }
918 : }
919 0 : } break;
920 14412 : case DataHeatBalance::SolutionAlgo::EulerMethod: {
921 14412 : state.dataRoomAirMod->ZTMX(ZoneNum) = (AirCap * state.dataRoomAirMod->Zone1MX(ZoneNum) + TempIndCoef) / (AirCap + TempDepCoef);
922 14412 : } break;
923 0 : default:
924 0 : break;
925 : }
926 : }
927 :
928 : // MinFlow for interface layer at z = 1.0
929 9558 : MinFlow = MinFlow_pow_fac * plume_fac;
930 : // EPTeam above replaces (cause diffs?) MinFlow = (1.0d0/24.55d0*1.0d0)**(1.0d0/0.6d0)*NumberOfPlumes*PowerPerPlume**(1.0/3.0)
931 9558 : if (MinFlow != 0.0) {
932 9558 : state.dataRoomAirMod->FracMinFlow(ZoneNum) = MCp_Total * 0.000833 / MinFlow;
933 : } else {
934 0 : state.dataRoomAirMod->FracMinFlow(ZoneNum) = 9.999;
935 : }
936 9558 : state.dataRoomAirMod->AirModel(ZoneNum).SimAirModel = true;
937 : }
938 :
939 : //=============================== M I X E D Calculation ==============================================
940 26493 : if (state.dataRoomAirMod->ZTMX(ZoneNum) < state.dataRoomAirMod->ZTOC(ZoneNum) || MCp_Total <= 0.0 ||
941 11469 : HeightFrac * CeilingHeight < (state.dataDispVentMgr->HeightFloorSubzoneTop + state.dataDispVentMgr->ThickOccupiedSubzoneMin)) {
942 8721 : MIXFLAG = true;
943 8721 : HeightFrac = 0.0;
944 8721 : state.dataRoomAirMod->AvgTempGrad(ZoneNum) = 0.0;
945 8721 : state.dataRoomAirMod->MaxTempGrad(ZoneNum) = 0.0;
946 8721 : state.dataRoomAirMod->AirModel(ZoneNum).SimAirModel = false;
947 8721 : Real64 const thisZoneT1 = thisZoneHB.ZoneT1;
948 8721 : Real64 AirCap = thisZoneHB.AirPowerCap;
949 8721 : TempHistTerm = AirCap * (3.0 * thisZoneHB.ZTM[0] - (3.0 / 2.0) * thisZoneHB.ZTM[1] + OneThird * thisZoneHB.ZTM[2]);
950 :
951 34884 : for (Ctd = 1; Ctd <= 3; ++Ctd) {
952 26163 : TempDepCoef = state.dataDispVentMgr->HA_MX + state.dataDispVentMgr->HA_OC + state.dataDispVentMgr->HA_FLOOR + MCp_Total;
953 26163 : TempIndCoef = ConvGains + state.dataDispVentMgr->HAT_MX + state.dataDispVentMgr->HAT_OC + state.dataDispVentMgr->HAT_FLOOR + MCpT_Total;
954 26163 : switch (state.dataHeatBal->ZoneAirSolutionAlgo) {
955 10626 : case DataHeatBalance::SolutionAlgo::ThirdOrder: {
956 31878 : ZTAveraged = (TempHistTerm + ConvGains + state.dataDispVentMgr->HAT_MX + state.dataDispVentMgr->HAT_OC +
957 21252 : state.dataDispVentMgr->HAT_FLOOR + MCpT_Total) /
958 10626 : ((11.0 / 6.0) * AirCap + state.dataDispVentMgr->HA_MX + state.dataDispVentMgr->HA_OC + state.dataDispVentMgr->HA_FLOOR +
959 : MCp_Total);
960 10626 : } break;
961 0 : case DataHeatBalance::SolutionAlgo::AnalyticalSolution: {
962 0 : if (TempDepCoef == 0.0) { // B=0
963 0 : ZTAveraged = thisZoneT1 + TempIndCoef / AirCap;
964 : } else {
965 0 : ZTAveraged = (thisZoneT1 - TempIndCoef / TempDepCoef) * std::exp(min(700.0, -TempDepCoef / AirCap)) + TempIndCoef / TempDepCoef;
966 : }
967 0 : } break;
968 15537 : case DataHeatBalance::SolutionAlgo::EulerMethod: {
969 15537 : ZTAveraged = (AirCap * thisZoneT1 + TempIndCoef) / (AirCap + TempDepCoef);
970 15537 : } break;
971 0 : default:
972 0 : break;
973 : }
974 26163 : state.dataRoomAirMod->ZTOC(ZoneNum) = ZTAveraged;
975 26163 : state.dataRoomAirMod->ZTMX(ZoneNum) = ZTAveraged;
976 26163 : state.dataRoomAirMod->ZTFloor(ZoneNum) = ZTAveraged;
977 26163 : HcUCSDDV(state, ZoneNum, HeightFrac);
978 26163 : TempDepCoef = state.dataDispVentMgr->HA_MX + state.dataDispVentMgr->HA_OC + state.dataDispVentMgr->HA_FLOOR + MCp_Total;
979 26163 : TempIndCoef = ConvGains + state.dataDispVentMgr->HAT_MX + state.dataDispVentMgr->HAT_OC + state.dataDispVentMgr->HAT_FLOOR + MCpT_Total;
980 26163 : switch (state.dataHeatBal->ZoneAirSolutionAlgo) {
981 10626 : case DataHeatBalance::SolutionAlgo::ThirdOrder: {
982 31878 : ZTAveraged = (TempHistTerm + ConvGains + state.dataDispVentMgr->HAT_MX + state.dataDispVentMgr->HAT_OC +
983 21252 : state.dataDispVentMgr->HAT_FLOOR + MCpT_Total) /
984 10626 : ((11.0 / 6.0) * AirCap + state.dataDispVentMgr->HA_MX + state.dataDispVentMgr->HA_OC + state.dataDispVentMgr->HA_FLOOR +
985 : MCp_Total);
986 10626 : } break;
987 0 : case DataHeatBalance::SolutionAlgo::AnalyticalSolution: {
988 0 : if (TempDepCoef == 0.0) { // B=0
989 0 : ZTAveraged = thisZoneT1 + TempIndCoef / AirCap;
990 : } else {
991 0 : ZTAveraged = (thisZoneT1 - TempIndCoef / TempDepCoef) * std::exp(min(700.0, -TempDepCoef / AirCap)) + TempIndCoef / TempDepCoef;
992 : }
993 0 : } break;
994 15537 : case DataHeatBalance::SolutionAlgo::EulerMethod: {
995 15537 : ZTAveraged = (AirCap * thisZoneT1 + TempIndCoef) / (AirCap + TempDepCoef);
996 15537 : } break;
997 0 : default:
998 0 : break;
999 : }
1000 26163 : state.dataRoomAirMod->ZTOC(ZoneNum) = ZTAveraged;
1001 26163 : state.dataRoomAirMod->ZTMX(ZoneNum) = ZTAveraged;
1002 26163 : state.dataRoomAirMod->ZTFloor(ZoneNum) = ZTAveraged;
1003 : }
1004 : }
1005 : //=========================================================================================
1006 :
1007 : // Comfort temperature and temperature at the thermostat/temperature control sensor
1008 :
1009 15024 : state.dataRoomAirMod->HeightTransition(ZoneNum) = HeightFrac * CeilingHeight;
1010 15024 : HeightMixedSubzoneAve = (CeilingHeight + state.dataRoomAirMod->HeightTransition(ZoneNum)) / 2.0;
1011 15024 : HeightOccupiedSubzoneAve = (state.dataDispVentMgr->HeightFloorSubzoneTop + state.dataRoomAirMod->HeightTransition(ZoneNum)) / 2.0;
1012 15024 : HeightFloorSubzoneAve = state.dataDispVentMgr->HeightFloorSubzoneTop / 2.0;
1013 :
1014 : // Comfort temperature
1015 :
1016 15024 : if (MIXFLAG) {
1017 8721 : state.dataRoomAirMod->TCMF(ZoneNum) = ZTAveraged;
1018 : } else {
1019 6303 : if (HeightComfort >= 0.0 && HeightComfort < HeightFloorSubzoneAve) {
1020 0 : ShowWarningError(state, "Displacement ventilation comfort height is in floor subzone in Zone: " + Zone(ZoneNum).Name);
1021 0 : state.dataRoomAirMod->TCMF(ZoneNum) = state.dataRoomAirMod->ZTFloor(ZoneNum);
1022 6303 : } else if (HeightComfort >= HeightFloorSubzoneAve && HeightComfort < HeightOccupiedSubzoneAve) {
1023 2112 : state.dataRoomAirMod->TCMF(ZoneNum) = (state.dataRoomAirMod->ZTFloor(ZoneNum) * (HeightOccupiedSubzoneAve - HeightComfort) +
1024 1408 : state.dataRoomAirMod->ZTOC(ZoneNum) * (HeightComfort - HeightFloorSubzoneAve)) /
1025 704 : (HeightOccupiedSubzoneAve - HeightFloorSubzoneAve);
1026 : //! TCMF(ZoneNum) = (ZTFloor(ZoneNum) * (HeightOccupiedSubzoneAve - HeightComfort) &
1027 : //! + ZTMX(ZoneNum) * (HeightComfort - HeightFloorSubzoneAve)) &
1028 : //! / (HeightOccupiedSubzoneAve - HeightFloorSubzoneAve)
1029 5599 : } else if (HeightComfort >= HeightOccupiedSubzoneAve && HeightComfort < HeightMixedSubzoneAve) {
1030 16797 : state.dataRoomAirMod->TCMF(ZoneNum) = (state.dataRoomAirMod->ZTOC(ZoneNum) * (HeightMixedSubzoneAve - HeightComfort) +
1031 11198 : state.dataRoomAirMod->ZTMX(ZoneNum) * (HeightComfort - HeightOccupiedSubzoneAve)) /
1032 5599 : (HeightMixedSubzoneAve - HeightOccupiedSubzoneAve);
1033 0 : } else if (HeightComfort >= HeightMixedSubzoneAve && HeightComfort <= CeilingHeight) {
1034 0 : state.dataRoomAirMod->TCMF(ZoneNum) = state.dataRoomAirMod->ZTMX(ZoneNum);
1035 : } else {
1036 0 : ShowFatalError(state, "Displacement ventilation comfort height is above ceiling or below floor in Zone: " + Zone(ZoneNum).Name);
1037 : }
1038 : }
1039 :
1040 : // Temperature at the thermostat/temperature control sensor
1041 :
1042 15024 : if (MIXFLAG) {
1043 8721 : state.dataHeatBalFanSys->TempTstatAir(ZoneNum) = ZTAveraged;
1044 : } else {
1045 6303 : if (HeightThermostat >= 0.0 && HeightThermostat < HeightFloorSubzoneAve) {
1046 0 : ShowWarningError(state, "Displacement thermostat is in floor subzone in Zone: " + Zone(ZoneNum).Name);
1047 0 : state.dataHeatBalFanSys->TempTstatAir(ZoneNum) = state.dataRoomAirMod->ZTFloor(ZoneNum);
1048 6303 : } else if (HeightThermostat >= HeightFloorSubzoneAve && HeightThermostat < HeightOccupiedSubzoneAve) {
1049 2112 : state.dataHeatBalFanSys->TempTstatAir(ZoneNum) = (state.dataRoomAirMod->ZTFloor(ZoneNum) * (HeightOccupiedSubzoneAve - HeightThermostat) +
1050 1408 : state.dataRoomAirMod->ZTOC(ZoneNum) * (HeightThermostat - HeightFloorSubzoneAve)) /
1051 704 : (HeightOccupiedSubzoneAve - HeightFloorSubzoneAve);
1052 : //! TempTstatAir(ZoneNum) = (ZTFloor(ZoneNum) * (HeightOccupiedSubzoneAve - HeightThermostat) &
1053 : //! + ZTMX(ZoneNum) * (HeightThermostat - HeightFloorSubzoneAve)) &
1054 : //! / (HeightOccupiedSubzoneAve - HeightFloorSubzoneAve)
1055 5599 : } else if (HeightThermostat >= HeightOccupiedSubzoneAve && HeightThermostat < HeightMixedSubzoneAve) {
1056 16797 : state.dataHeatBalFanSys->TempTstatAir(ZoneNum) = (state.dataRoomAirMod->ZTOC(ZoneNum) * (HeightMixedSubzoneAve - HeightThermostat) +
1057 11198 : state.dataRoomAirMod->ZTMX(ZoneNum) * (HeightThermostat - HeightOccupiedSubzoneAve)) /
1058 5599 : (HeightMixedSubzoneAve - HeightOccupiedSubzoneAve);
1059 0 : } else if (HeightThermostat >= HeightMixedSubzoneAve && HeightThermostat <= CeilingHeight) {
1060 0 : state.dataHeatBalFanSys->TempTstatAir(ZoneNum) = state.dataRoomAirMod->ZTMX(ZoneNum);
1061 : } else {
1062 0 : ShowFatalError(state, "Displacement ventilation thermostat height is above ceiling or below floor in Zone: " + Zone(ZoneNum).Name);
1063 : }
1064 : }
1065 :
1066 : // Temperature gradients
1067 :
1068 15024 : if ((HeightMixedSubzoneAve - HeightFloorSubzoneAve) > 0.1) {
1069 15024 : state.dataRoomAirMod->AvgTempGrad(ZoneNum) =
1070 15024 : (state.dataRoomAirMod->ZTMX(ZoneNum) - state.dataRoomAirMod->ZTFloor(ZoneNum)) / (HeightMixedSubzoneAve - HeightFloorSubzoneAve);
1071 : } else {
1072 0 : state.dataRoomAirMod->AvgTempGrad(ZoneNum) = -9.999;
1073 : }
1074 15024 : if ((HeightOccupiedSubzoneAve - HeightFloorSubzoneAve) > 0.1) {
1075 6303 : state.dataRoomAirMod->MaxTempGrad(ZoneNum) =
1076 6303 : (state.dataRoomAirMod->ZTOC(ZoneNum) - state.dataRoomAirMod->ZTFloor(ZoneNum)) / (HeightOccupiedSubzoneAve - HeightFloorSubzoneAve);
1077 : } else {
1078 8721 : state.dataRoomAirMod->MaxTempGrad(ZoneNum) = -9.999;
1079 : }
1080 15024 : if ((HeightMixedSubzoneAve - HeightOccupiedSubzoneAve) > 0.1) {
1081 15024 : MTGAUX = (state.dataRoomAirMod->ZTMX(ZoneNum) - state.dataRoomAirMod->ZTOC(ZoneNum)) / (HeightMixedSubzoneAve - HeightOccupiedSubzoneAve);
1082 : } else {
1083 0 : MTGAUX = -9.999;
1084 : }
1085 :
1086 15024 : if (MTGAUX > state.dataRoomAirMod->MaxTempGrad(ZoneNum)) {
1087 12161 : state.dataRoomAirMod->MaxTempGrad(ZoneNum) = MTGAUX;
1088 : }
1089 :
1090 15024 : if (MIXFLAG) {
1091 8721 : state.dataRoomAirMod->ZoneDVMixedFlag(ZoneNum) = 1;
1092 8721 : state.dataRoomAirMod->AirModel(ZoneNum).SimAirModel = false;
1093 : } else {
1094 6303 : state.dataRoomAirMod->ZoneDVMixedFlag(ZoneNum) = 0;
1095 6303 : state.dataRoomAirMod->AirModel(ZoneNum).SimAirModel = true;
1096 : }
1097 :
1098 15024 : if (state.dataZoneEquip->ZoneEquipConfig(ZoneNum).IsControlled) {
1099 8416 : ZoneNodeNum = Zone(ZoneNum).SystemZoneNodeNumber;
1100 8416 : state.dataLoopNodes->Node(ZoneNodeNum).Temp = state.dataRoomAirMod->ZTMX(ZoneNum);
1101 : }
1102 :
1103 : // Mixed for reporting purposes
1104 15024 : if ((MIXFLAG) || ((state.dataRoomAirMod->ZTMX(ZoneNum) - state.dataRoomAirMod->ZTOC(ZoneNum)) < TempDiffCritRep)) {
1105 8984 : state.dataRoomAirMod->ZoneDVMixedFlagRep(ZoneNum) = 1.0;
1106 8984 : state.dataRoomAirMod->FracMinFlow(ZoneNum) = -1.0;
1107 8984 : state.dataRoomAirMod->HeightTransition(ZoneNum) = -9.999;
1108 8984 : state.dataRoomAirMod->AvgTempGrad(ZoneNum) = -9.999;
1109 8984 : state.dataRoomAirMod->MaxTempGrad(ZoneNum) = -9.999;
1110 : } else {
1111 6040 : state.dataRoomAirMod->ZoneDVMixedFlagRep(ZoneNum) = 0.0;
1112 : }
1113 15024 : }
1114 :
1115 2313 : } // namespace EnergyPlus::DisplacementVentMgr
|
