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 <cassert>
50 : #include <cmath>
51 :
52 : // ObjexxFCL Headers
53 : #include <ObjexxFCL/Fmath.hh>
54 :
55 : // EnergyPlus Headers
56 : #include <AirflowNetwork/Solver.hpp>
57 : #include <EnergyPlus/ConvectionCoefficients.hh>
58 : #include <EnergyPlus/CrossVentMgr.hh>
59 : #include <EnergyPlus/Data/EnergyPlusData.hh>
60 : #include <EnergyPlus/DataEnvironment.hh>
61 : #include <EnergyPlus/DataGlobals.hh>
62 : #include <EnergyPlus/DataHeatBalFanSys.hh>
63 : #include <EnergyPlus/DataHeatBalSurface.hh>
64 : #include <EnergyPlus/DataHeatBalance.hh>
65 : #include <EnergyPlus/DataRoomAirModel.hh>
66 : #include <EnergyPlus/DataSurfaces.hh>
67 : #include <EnergyPlus/DataUCSDSharedData.hh>
68 : #include <EnergyPlus/InternalHeatGains.hh>
69 : #include <EnergyPlus/Psychrometrics.hh>
70 : #include <EnergyPlus/ScheduleManager.hh>
71 : #include <EnergyPlus/UtilityRoutines.hh>
72 : #include <EnergyPlus/ZoneTempPredictorCorrector.hh>
73 :
74 : namespace EnergyPlus {
75 :
76 : namespace CrossVentMgr {
77 :
78 : // MODULE INFORMATION:
79 : // AUTHOR G. Carrilho da Graca
80 : // DATE WRITTEN October 2004
81 : // MODIFIED na
82 : // RE-ENGINEERED na
83 :
84 : // PURPOSE OF THIS MODULE:
85 : // Routines that implement the UCSD Cross Ventilation
86 :
87 : using namespace DataEnvironment;
88 : using namespace DataHeatBalance;
89 : using namespace DataHeatBalSurface;
90 : using namespace DataSurfaces;
91 : using namespace DataRoomAirModel;
92 : using ConvectionCoefficients::CalcDetailedHcInForDVModel;
93 :
94 : Real64 constexpr Cjet1(1.873); // First correlation constant for the jet velocity
95 : Real64 constexpr Cjet2(0.243); // Second correlation constant for the jet velocity
96 : Real64 constexpr Crec1(0.591); // First correlation constant for the recirculation velocity
97 : Real64 constexpr Crec2(0.070); // Second correlation constant for the recirculation velocity
98 : Real64 constexpr CjetTemp(0.849); // Correlation constant for the jet temperature rise
99 : Real64 constexpr CrecTemp(1.385); // Correlation constant for the recirculation temperature rise
100 : Real64 constexpr CrecFlow1(0.415); // First correlation constant for the recirculation flow rate
101 : Real64 constexpr CrecFlow2(0.466); // Second correlation constant for the recirculation flow rate
102 :
103 4035 : void ManageUCSDCVModel(EnergyPlusData &state,
104 : int const ZoneNum) // index number for the specified zone
105 : {
106 :
107 : // SUBROUTINE INFORMATION:
108 : // AUTHOR G. Carrilho da Graca
109 : // DATE WRITTEN October 2004
110 : // MODIFIED na
111 : // RE-ENGINEERED na
112 :
113 : // PURPOSE OF THIS SUBROUTINE:
114 : // manage the UCSD Cross Ventilation model
115 :
116 4035 : InitUCSDCV(state, ZoneNum);
117 :
118 : // perform Cross Ventilation model calculations
119 4035 : CalcUCSDCV(state, ZoneNum);
120 4035 : }
121 :
122 4035 : void InitUCSDCV(EnergyPlusData &state, int const ZoneNum)
123 : {
124 :
125 : // SUBROUTINE INFORMATION:
126 : // AUTHOR G. Carrilho da Graca
127 : // DATE WRITTEN October 2004
128 : // MODIFIED -
129 : // RE-ENGINEERED -
130 :
131 : // PURPOSE OF THIS SUBROUTINE:
132 : // Low Energy Cooling by Ventilation initialization subroutine.
133 : // All the data preparation needed to run the LECV models.
134 : // The subroutines sets up arrays with the locations in the main EnergyPlus surface array of
135 : // ceiling, windows, doors and walls. The zone maximum and minimum height is calculated.
136 :
137 : using namespace DataRoomAirModel;
138 :
139 : // Do the one time initializations
140 4035 : if (state.dataCrossVentMgr->InitUCSDCV_MyOneTimeFlag) {
141 2 : state.dataCrossVentMgr->InitUCSDCV_MyEnvrnFlag.dimension(state.dataGlobal->NumOfZones, true);
142 2 : state.dataCrossVentMgr->InitUCSDCV_MyOneTimeFlag = false;
143 : }
144 :
145 : // Do the begin environment initializations
146 4035 : if (state.dataGlobal->BeginEnvrnFlag && state.dataCrossVentMgr->InitUCSDCV_MyEnvrnFlag(ZoneNum)) {
147 12 : state.dataCrossVentMgr->InitUCSDCV_MyEnvrnFlag(ZoneNum) = false;
148 : }
149 :
150 4035 : if (!state.dataGlobal->BeginEnvrnFlag) {
151 4004 : state.dataCrossVentMgr->InitUCSDCV_MyEnvrnFlag(ZoneNum) = true;
152 : }
153 4035 : }
154 :
155 16558 : void HcUCSDCV(EnergyPlusData &state, int const ZoneNum)
156 : {
157 :
158 : // SUBROUTINE INFORMATION:
159 : // AUTHOR G. Carrilho da Graca
160 : // DATE WRITTEN October 2004
161 : // MODIFIED 8/2013 - Sam Brunswick
162 : // To improve convection coefficient calculation
163 : // RE-ENGINEERED -
164 :
165 : // PURPOSE OF THIS SUBROUTINE:
166 : // Main subroutine for convection calculation in the UCSD Cross Ventilation model.
167 : // It calls CalcDetailedHcInForDVModel for convection coefficient
168 : // initial calculations and averages the final result comparing the position of the surface with
169 : // the interface subzone height.
170 :
171 : using namespace DataEnvironment;
172 : using namespace DataHeatBalance;
173 : using ScheduleManager::GetScheduleIndex; // , GetDayScheduleValues
174 :
175 : // SUBROUTINE LOCAL VARIABLE DECLARATIONS:
176 : int Ctd; // DO loop counter for surfaces
177 : int SurfNum; // Surface number
178 : Real64 Hjet;
179 : Real64 Hrec;
180 :
181 : // Initialize HAT and HA
182 16558 : state.dataCrossVentMgr->HAT_J = 0.0;
183 16558 : state.dataCrossVentMgr->HAT_R = 0.0;
184 16558 : state.dataCrossVentMgr->HA_J = 0.0;
185 16558 : state.dataCrossVentMgr->HA_R = 0.0;
186 :
187 : // Is the air flow model for this zone set to UCSDCV Cross Ventilation?
188 16558 : if (state.dataRoomAirMod->IsZoneCV(ZoneNum)) {
189 : // WALL Hc, HA and HAT calculation
190 82790 : for (Ctd = state.dataUCSDShared->PosZ_Wall((ZoneNum - 1) * 2 + 1); Ctd <= state.dataUCSDShared->PosZ_Wall((ZoneNum - 1) * 2 + 2); ++Ctd) {
191 66232 : SurfNum = state.dataUCSDShared->APos_Wall(Ctd);
192 66232 : state.dataSurface->SurfTAirRef(SurfNum) = DataSurfaces::RefAirTemp::AdjacentAirTemp;
193 66232 : state.dataSurface->SurfTAirRefRpt(SurfNum) = DataSurfaces::SurfTAirRefReportVals[state.dataSurface->SurfTAirRef(SurfNum)];
194 66232 : if (SurfNum == 0) continue;
195 66232 : state.dataHeatBal->SurfTempEffBulkAir(SurfNum) = state.dataRoomAirMod->ZTREC(ZoneNum);
196 198696 : CalcDetailedHcInForDVModel(
197 198696 : state, SurfNum, state.dataHeatBalSurf->SurfTempIn, state.dataRoomAirMod->CVHcIn, state.dataRoomAirMod->Urec);
198 66232 : state.dataUCSDShared->HWall(Ctd) = state.dataRoomAirMod->CVHcIn(SurfNum);
199 66232 : state.dataCrossVentMgr->HAT_R +=
200 66232 : state.dataSurface->Surface(SurfNum).Area * state.dataHeatBalSurf->SurfTempIn(SurfNum) * state.dataUCSDShared->HWall(Ctd);
201 66232 : state.dataCrossVentMgr->HA_R += state.dataSurface->Surface(SurfNum).Area * state.dataUCSDShared->HWall(Ctd);
202 : } // END WALL
203 : // WINDOW Hc, HA and HAT CALCULATION
204 64936 : for (Ctd = state.dataUCSDShared->PosZ_Window((ZoneNum - 1) * 2 + 1); Ctd <= state.dataUCSDShared->PosZ_Window((ZoneNum - 1) * 2 + 2);
205 : ++Ctd) {
206 48378 : SurfNum = state.dataUCSDShared->APos_Window(Ctd);
207 48378 : state.dataSurface->SurfTAirRef(SurfNum) = DataSurfaces::RefAirTemp::AdjacentAirTemp;
208 48378 : state.dataSurface->SurfTAirRefRpt(SurfNum) = DataSurfaces::SurfTAirRefReportVals[state.dataSurface->SurfTAirRef(SurfNum)];
209 48378 : if (SurfNum == 0) continue;
210 48378 : if (state.dataSurface->Surface(SurfNum).Tilt > 10.0 && state.dataSurface->Surface(SurfNum).Tilt < 170.0) { // Window Wall
211 48378 : state.dataHeatBal->SurfTempEffBulkAir(SurfNum) = state.dataRoomAirMod->ZTREC(ZoneNum);
212 145134 : CalcDetailedHcInForDVModel(
213 145134 : state, SurfNum, state.dataHeatBalSurf->SurfTempIn, state.dataRoomAirMod->CVHcIn, state.dataRoomAirMod->Urec);
214 48378 : state.dataUCSDShared->HWindow(Ctd) = state.dataRoomAirMod->CVHcIn(SurfNum);
215 48378 : state.dataCrossVentMgr->HAT_R +=
216 48378 : state.dataSurface->Surface(SurfNum).Area * state.dataHeatBalSurf->SurfTempIn(SurfNum) * state.dataUCSDShared->HWindow(Ctd);
217 48378 : state.dataCrossVentMgr->HA_R += state.dataSurface->Surface(SurfNum).Area * state.dataUCSDShared->HWindow(Ctd);
218 : }
219 48378 : if (state.dataSurface->Surface(SurfNum).Tilt <= 10.0) { // Window Ceiling
220 0 : state.dataHeatBal->SurfTempEffBulkAir(SurfNum) = state.dataRoomAirMod->ZTJET(ZoneNum);
221 0 : CalcDetailedHcInForDVModel(
222 0 : state, SurfNum, state.dataHeatBalSurf->SurfTempIn, state.dataRoomAirMod->CVHcIn, state.dataRoomAirMod->Ujet);
223 0 : Hjet = state.dataRoomAirMod->CVHcIn(SurfNum);
224 0 : state.dataHeatBal->SurfTempEffBulkAir(SurfNum) = state.dataRoomAirMod->ZTREC(ZoneNum);
225 0 : CalcDetailedHcInForDVModel(
226 0 : state, SurfNum, state.dataHeatBalSurf->SurfTempIn, state.dataRoomAirMod->CVHcIn, state.dataRoomAirMod->Urec);
227 0 : Hrec = state.dataRoomAirMod->CVHcIn(SurfNum);
228 0 : state.dataUCSDShared->HWindow(Ctd) =
229 0 : state.dataRoomAirMod->JetRecAreaRatio(ZoneNum) * Hjet + (1 - state.dataRoomAirMod->JetRecAreaRatio(ZoneNum)) * Hrec;
230 0 : state.dataCrossVentMgr->HAT_R += state.dataSurface->Surface(SurfNum).Area *
231 0 : (1.0 - state.dataRoomAirMod->JetRecAreaRatio(ZoneNum)) *
232 0 : state.dataHeatBalSurf->SurfTempIn(SurfNum) * Hrec;
233 0 : state.dataCrossVentMgr->HA_R +=
234 0 : state.dataSurface->Surface(SurfNum).Area * (1.0 - state.dataRoomAirMod->JetRecAreaRatio(ZoneNum)) * Hrec;
235 0 : state.dataCrossVentMgr->HAT_J += state.dataSurface->Surface(SurfNum).Area * state.dataRoomAirMod->JetRecAreaRatio(ZoneNum) *
236 0 : state.dataHeatBalSurf->SurfTempIn(SurfNum) * Hjet;
237 0 : state.dataCrossVentMgr->HA_J += state.dataSurface->Surface(SurfNum).Area * state.dataRoomAirMod->JetRecAreaRatio(ZoneNum) * Hjet;
238 0 : state.dataHeatBal->SurfTempEffBulkAir(SurfNum) =
239 0 : state.dataRoomAirMod->JetRecAreaRatio(ZoneNum) * state.dataRoomAirMod->ZTJET(ZoneNum) +
240 0 : (1 - state.dataRoomAirMod->JetRecAreaRatio(ZoneNum)) * state.dataRoomAirMod->ZTREC(ZoneNum);
241 : }
242 48378 : if (state.dataSurface->Surface(SurfNum).Tilt >= 170.0) { // Window Floor
243 0 : state.dataHeatBal->SurfTempEffBulkAir(SurfNum) = state.dataRoomAirMod->ZTJET(ZoneNum);
244 0 : CalcDetailedHcInForDVModel(
245 0 : state, SurfNum, state.dataHeatBalSurf->SurfTempIn, state.dataRoomAirMod->CVHcIn, state.dataRoomAirMod->Ujet);
246 0 : Hjet = state.dataRoomAirMod->CVHcIn(SurfNum);
247 0 : state.dataHeatBal->SurfTempEffBulkAir(SurfNum) = state.dataRoomAirMod->ZTREC(ZoneNum);
248 0 : CalcDetailedHcInForDVModel(
249 0 : state, SurfNum, state.dataHeatBalSurf->SurfTempIn, state.dataRoomAirMod->CVHcIn, state.dataRoomAirMod->Urec);
250 0 : Hrec = state.dataRoomAirMod->CVHcIn(SurfNum);
251 0 : state.dataUCSDShared->HWindow(Ctd) =
252 0 : state.dataRoomAirMod->JetRecAreaRatio(ZoneNum) * Hjet + (1 - state.dataRoomAirMod->JetRecAreaRatio(ZoneNum)) * Hrec;
253 0 : state.dataCrossVentMgr->HAT_R += state.dataSurface->Surface(SurfNum).Area *
254 0 : (1.0 - state.dataRoomAirMod->JetRecAreaRatio(ZoneNum)) *
255 0 : state.dataHeatBalSurf->SurfTempIn(SurfNum) * Hrec;
256 0 : state.dataCrossVentMgr->HA_R +=
257 0 : state.dataSurface->Surface(SurfNum).Area * (1.0 - state.dataRoomAirMod->JetRecAreaRatio(ZoneNum)) * Hrec;
258 0 : state.dataCrossVentMgr->HAT_J += state.dataSurface->Surface(SurfNum).Area * state.dataRoomAirMod->JetRecAreaRatio(ZoneNum) *
259 0 : state.dataHeatBalSurf->SurfTempIn(SurfNum) * Hjet;
260 0 : state.dataCrossVentMgr->HA_J += state.dataSurface->Surface(SurfNum).Area * state.dataRoomAirMod->JetRecAreaRatio(ZoneNum) * Hjet;
261 0 : state.dataHeatBal->SurfTempEffBulkAir(SurfNum) =
262 0 : state.dataRoomAirMod->JetRecAreaRatio(ZoneNum) * state.dataRoomAirMod->ZTJET(ZoneNum) +
263 0 : (1 - state.dataRoomAirMod->JetRecAreaRatio(ZoneNum)) * state.dataRoomAirMod->ZTREC(ZoneNum);
264 : }
265 48378 : state.dataRoomAirMod->CVHcIn(SurfNum) = state.dataUCSDShared->HWindow(Ctd);
266 : } // END WINDOW
267 : // DOOR Hc, HA and HAT CALCULATION
268 16558 : for (Ctd = state.dataUCSDShared->PosZ_Door((ZoneNum - 1) * 2 + 1); Ctd <= state.dataUCSDShared->PosZ_Door((ZoneNum - 1) * 2 + 2);
269 : ++Ctd) { // DOOR
270 0 : SurfNum = state.dataUCSDShared->APos_Door(Ctd);
271 0 : state.dataSurface->SurfTAirRef(SurfNum) = DataSurfaces::RefAirTemp::AdjacentAirTemp;
272 0 : state.dataSurface->SurfTAirRefRpt(SurfNum) = DataSurfaces::SurfTAirRefReportVals[state.dataSurface->SurfTAirRef(SurfNum)];
273 0 : if (SurfNum == 0) continue;
274 0 : state.dataHeatBal->SurfTempEffBulkAir(SurfNum) = state.dataRoomAirMod->ZTREC(ZoneNum);
275 0 : CalcDetailedHcInForDVModel(
276 0 : state, SurfNum, state.dataHeatBalSurf->SurfTempIn, state.dataRoomAirMod->CVHcIn, state.dataRoomAirMod->Urec);
277 0 : state.dataUCSDShared->HDoor(Ctd) = state.dataRoomAirMod->CVHcIn(SurfNum);
278 0 : state.dataCrossVentMgr->HAT_R +=
279 0 : state.dataSurface->Surface(SurfNum).Area * state.dataHeatBalSurf->SurfTempIn(SurfNum) * state.dataUCSDShared->HDoor(Ctd);
280 0 : state.dataCrossVentMgr->HA_R += state.dataSurface->Surface(SurfNum).Area * state.dataUCSDShared->HDoor(Ctd);
281 : } // END DOOR
282 : // INTERNAL Hc, HA and HAT CALCULATION
283 16558 : for (Ctd = state.dataUCSDShared->PosZ_Internal((ZoneNum - 1) * 2 + 1); Ctd <= state.dataUCSDShared->PosZ_Internal((ZoneNum - 1) * 2 + 2);
284 : ++Ctd) {
285 0 : SurfNum = state.dataUCSDShared->APos_Internal(Ctd);
286 0 : state.dataSurface->SurfTAirRef(SurfNum) = DataSurfaces::RefAirTemp::AdjacentAirTemp;
287 0 : state.dataSurface->SurfTAirRefRpt(SurfNum) = DataSurfaces::SurfTAirRefReportVals[state.dataSurface->SurfTAirRef(SurfNum)];
288 0 : if (SurfNum == 0) continue;
289 0 : state.dataHeatBal->SurfTempEffBulkAir(SurfNum) = state.dataRoomAirMod->ZTREC(ZoneNum);
290 0 : CalcDetailedHcInForDVModel(
291 0 : state, SurfNum, state.dataHeatBalSurf->SurfTempIn, state.dataRoomAirMod->CVHcIn, state.dataRoomAirMod->Urec);
292 0 : state.dataUCSDShared->HInternal(Ctd) = state.dataRoomAirMod->CVHcIn(SurfNum);
293 0 : state.dataCrossVentMgr->HAT_R +=
294 0 : state.dataSurface->Surface(SurfNum).Area * state.dataHeatBalSurf->SurfTempIn(SurfNum) * state.dataUCSDShared->HInternal(Ctd);
295 0 : state.dataCrossVentMgr->HA_R += state.dataSurface->Surface(SurfNum).Area * state.dataUCSDShared->HInternal(Ctd);
296 : } // END INTERNAL
297 :
298 : // CEILING Hc, HA and HAT CALCULATION
299 33116 : for (Ctd = state.dataUCSDShared->PosZ_Ceiling((ZoneNum - 1) * 2 + 1); Ctd <= state.dataUCSDShared->PosZ_Ceiling((ZoneNum - 1) * 2 + 2);
300 : ++Ctd) {
301 16558 : SurfNum = state.dataUCSDShared->APos_Ceiling(Ctd);
302 16558 : state.dataSurface->SurfTAirRef(SurfNum) = DataSurfaces::RefAirTemp::AdjacentAirTemp;
303 16558 : state.dataSurface->SurfTAirRefRpt(SurfNum) = DataSurfaces::SurfTAirRefReportVals[state.dataSurface->SurfTAirRef(SurfNum)];
304 16558 : if (SurfNum == 0) continue;
305 16558 : state.dataHeatBal->SurfTempEffBulkAir(SurfNum) = state.dataRoomAirMod->ZTJET(ZoneNum);
306 49674 : CalcDetailedHcInForDVModel(
307 49674 : state, SurfNum, state.dataHeatBalSurf->SurfTempIn, state.dataRoomAirMod->CVHcIn, state.dataRoomAirMod->Ujet);
308 16558 : Hjet = state.dataRoomAirMod->CVHcIn(SurfNum);
309 16558 : state.dataHeatBal->SurfTempEffBulkAir(SurfNum) = state.dataRoomAirMod->ZTREC(ZoneNum);
310 49674 : CalcDetailedHcInForDVModel(
311 49674 : state, SurfNum, state.dataHeatBalSurf->SurfTempIn, state.dataRoomAirMod->CVHcIn, state.dataRoomAirMod->Urec);
312 16558 : Hrec = state.dataRoomAirMod->CVHcIn(SurfNum);
313 16558 : state.dataUCSDShared->HCeiling(Ctd) =
314 16558 : state.dataRoomAirMod->JetRecAreaRatio(ZoneNum) * Hjet + (1 - state.dataRoomAirMod->JetRecAreaRatio(ZoneNum)) * Hrec;
315 49674 : state.dataCrossVentMgr->HAT_R += state.dataSurface->Surface(SurfNum).Area * (1 - state.dataRoomAirMod->JetRecAreaRatio(ZoneNum)) *
316 33116 : state.dataHeatBalSurf->SurfTempIn(SurfNum) * Hrec;
317 16558 : state.dataCrossVentMgr->HA_R +=
318 16558 : state.dataSurface->Surface(SurfNum).Area * (1 - state.dataRoomAirMod->JetRecAreaRatio(ZoneNum)) * Hrec;
319 49674 : state.dataCrossVentMgr->HAT_J += state.dataSurface->Surface(SurfNum).Area * state.dataRoomAirMod->JetRecAreaRatio(ZoneNum) *
320 33116 : state.dataHeatBalSurf->SurfTempIn(SurfNum) * Hjet;
321 16558 : state.dataCrossVentMgr->HA_J += state.dataSurface->Surface(SurfNum).Area * state.dataRoomAirMod->JetRecAreaRatio(ZoneNum) * Hjet;
322 16558 : state.dataHeatBal->SurfTempEffBulkAir(SurfNum) =
323 33116 : state.dataRoomAirMod->JetRecAreaRatio(ZoneNum) * state.dataRoomAirMod->ZTJET(ZoneNum) +
324 16558 : (1 - state.dataRoomAirMod->JetRecAreaRatio(ZoneNum)) * state.dataRoomAirMod->ZTREC(ZoneNum);
325 16558 : state.dataRoomAirMod->CVHcIn(SurfNum) = state.dataUCSDShared->HCeiling(Ctd);
326 : } // END CEILING
327 : // FLOOR Hc, HA and HAT CALCULATION
328 33116 : for (Ctd = state.dataUCSDShared->PosZ_Floor((ZoneNum - 1) * 2 + 1); Ctd <= state.dataUCSDShared->PosZ_Floor((ZoneNum - 1) * 2 + 2);
329 : ++Ctd) {
330 16558 : SurfNum = state.dataUCSDShared->APos_Floor(Ctd);
331 16558 : state.dataSurface->SurfTAirRef(SurfNum) = DataSurfaces::RefAirTemp::AdjacentAirTemp;
332 16558 : state.dataSurface->SurfTAirRefRpt(SurfNum) = DataSurfaces::SurfTAirRefReportVals[state.dataSurface->SurfTAirRef(SurfNum)];
333 16558 : if (SurfNum == 0) continue;
334 16558 : state.dataHeatBal->SurfTempEffBulkAir(SurfNum) = state.dataRoomAirMod->ZTJET(ZoneNum);
335 49674 : CalcDetailedHcInForDVModel(
336 49674 : state, SurfNum, state.dataHeatBalSurf->SurfTempIn, state.dataRoomAirMod->CVHcIn, state.dataRoomAirMod->Ujet);
337 16558 : Hjet = state.dataRoomAirMod->CVHcIn(SurfNum);
338 16558 : state.dataHeatBal->SurfTempEffBulkAir(SurfNum) = state.dataRoomAirMod->ZTREC(ZoneNum);
339 49674 : CalcDetailedHcInForDVModel(
340 49674 : state, SurfNum, state.dataHeatBalSurf->SurfTempIn, state.dataRoomAirMod->CVHcIn, state.dataRoomAirMod->Urec);
341 16558 : Hrec = state.dataRoomAirMod->CVHcIn(SurfNum);
342 16558 : state.dataUCSDShared->HFloor(Ctd) =
343 16558 : state.dataRoomAirMod->JetRecAreaRatio(ZoneNum) * Hjet + (1 - state.dataRoomAirMod->JetRecAreaRatio(ZoneNum)) * Hrec;
344 49674 : state.dataCrossVentMgr->HAT_R += state.dataSurface->Surface(SurfNum).Area * (1 - state.dataRoomAirMod->JetRecAreaRatio(ZoneNum)) *
345 33116 : state.dataHeatBalSurf->SurfTempIn(SurfNum) * Hrec;
346 16558 : state.dataCrossVentMgr->HA_R +=
347 16558 : state.dataSurface->Surface(SurfNum).Area * (1 - state.dataRoomAirMod->JetRecAreaRatio(ZoneNum)) * Hrec;
348 49674 : state.dataCrossVentMgr->HAT_J += state.dataSurface->Surface(SurfNum).Area * state.dataRoomAirMod->JetRecAreaRatio(ZoneNum) *
349 33116 : state.dataHeatBalSurf->SurfTempIn(SurfNum) * Hjet;
350 16558 : state.dataCrossVentMgr->HA_J += state.dataSurface->Surface(SurfNum).Area * state.dataRoomAirMod->JetRecAreaRatio(ZoneNum) * Hjet;
351 16558 : state.dataHeatBal->SurfTempEffBulkAir(SurfNum) =
352 33116 : state.dataRoomAirMod->JetRecAreaRatio(ZoneNum) * state.dataRoomAirMod->ZTJET(ZoneNum) +
353 16558 : (1 - state.dataRoomAirMod->JetRecAreaRatio(ZoneNum)) * state.dataRoomAirMod->ZTREC(ZoneNum);
354 16558 : state.dataRoomAirMod->CVHcIn(SurfNum) = state.dataUCSDShared->HFloor(Ctd);
355 : } // END FLOOR
356 : }
357 16558 : }
358 :
359 4035 : void EvolveParaUCSDCV(EnergyPlusData &state, int const ZoneNum)
360 : {
361 :
362 : // SUBROUTINE INFORMATION:
363 : // AUTHOR G. Carrilho da Graca
364 : // DATE WRITTEN October 2004
365 : // MODIFIED 8/2013 - Sam Brunswick
366 : // To incorporate an improved model
367 : // and add modeling of multiple jets
368 :
369 : // PURPOSE OF THIS SUBROUTINE:
370 : // Subroutine for parameter actualization in the UCSD Cross Ventilation model.
371 :
372 : using namespace Psychrometrics;
373 :
374 4035 : Real64 constexpr MinUin(0.2);
375 :
376 : Real64 Uin; // Inflow air velocity [m/s]
377 : Real64 CosPhi; // Angle (in degrees) between the wind and the outward normal of the dominant surface
378 : Real64 SurfNorm; // Outward normal of surface
379 4035 : Real64 SumToZone(0.0); // Sum of velocities through
380 4035 : Real64 MaxFlux(0.0);
381 4035 : int MaxSurf(0);
382 : Real64 XX;
383 : Real64 YY;
384 : Real64 ZZ;
385 : Real64 XX_Wall;
386 : Real64 YY_Wall;
387 : Real64 ZZ_Wall;
388 : Real64 ActiveSurfNum;
389 : int NSides; // Number of sides in surface
390 : Real64 Wroom; // Room width
391 : Real64 Aroom; // Room area cross section
392 4035 : int NodeNum1(0); // The first node number in an AirflowNetwork linkage data
393 4035 : int NodeNum2(0); // The Second node number in an AirflowNetwork linkage data
394 :
395 4035 : assert(state.dataRoomAirMod->AirModel.allocated());
396 4035 : state.dataRoomAirMod->RecInflowRatio(ZoneNum) = 0.0;
397 4035 : auto const &thisZoneHB = state.dataZoneTempPredictorCorrector->zoneHeatBalance(ZoneNum);
398 :
399 : // Identify the dominant aperture:
400 4035 : MaxSurf = state.dataRoomAirMod->AirflowNetworkSurfaceUCSDCV(1, ZoneNum);
401 4035 : int const surfNum = state.afn->MultizoneSurfaceData(MaxSurf).SurfNum;
402 4035 : auto const &thisSurface = state.dataSurface->Surface(surfNum);
403 4035 : if (thisSurface.Zone == ZoneNum) {
404 : // this is a direct airflow network aperture
405 4035 : SumToZone = state.afn->AirflowNetworkLinkSimu(state.dataRoomAirMod->AirflowNetworkSurfaceUCSDCV(1, ZoneNum)).VolFLOW2;
406 4035 : MaxFlux = state.afn->AirflowNetworkLinkSimu(state.dataRoomAirMod->AirflowNetworkSurfaceUCSDCV(1, ZoneNum)).VolFLOW2;
407 : } else {
408 : // this is an indirect airflow network aperture
409 0 : SumToZone = state.afn->AirflowNetworkLinkSimu(state.dataRoomAirMod->AirflowNetworkSurfaceUCSDCV(1, ZoneNum)).VolFLOW;
410 0 : MaxFlux = state.afn->AirflowNetworkLinkSimu(state.dataRoomAirMod->AirflowNetworkSurfaceUCSDCV(1, ZoneNum)).VolFLOW;
411 : }
412 :
413 12786 : for (int Ctd2 = 2; Ctd2 <= state.dataRoomAirMod->AirflowNetworkSurfaceUCSDCV(0, ZoneNum); ++Ctd2) {
414 17502 : if (state.dataSurface->Surface(state.afn->MultizoneSurfaceData(state.dataRoomAirMod->AirflowNetworkSurfaceUCSDCV(Ctd2, ZoneNum)).SurfNum)
415 8751 : .Zone == ZoneNum) {
416 8751 : if (state.afn->AirflowNetworkLinkSimu(state.dataRoomAirMod->AirflowNetworkSurfaceUCSDCV(Ctd2, ZoneNum)).VolFLOW2 > MaxFlux) {
417 442 : MaxFlux = state.afn->AirflowNetworkLinkSimu(state.dataRoomAirMod->AirflowNetworkSurfaceUCSDCV(Ctd2, ZoneNum)).VolFLOW2;
418 442 : MaxSurf = state.dataRoomAirMod->AirflowNetworkSurfaceUCSDCV(Ctd2, ZoneNum);
419 : }
420 8751 : SumToZone += state.afn->AirflowNetworkLinkSimu(state.dataRoomAirMod->AirflowNetworkSurfaceUCSDCV(Ctd2, ZoneNum)).VolFLOW2;
421 : } else {
422 0 : if (state.afn->AirflowNetworkLinkSimu(state.dataRoomAirMod->AirflowNetworkSurfaceUCSDCV(Ctd2, ZoneNum)).VolFLOW > MaxFlux) {
423 0 : MaxFlux = state.afn->AirflowNetworkLinkSimu(state.dataRoomAirMod->AirflowNetworkSurfaceUCSDCV(Ctd2, ZoneNum)).VolFLOW;
424 0 : MaxSurf = state.dataRoomAirMod->AirflowNetworkSurfaceUCSDCV(Ctd2, ZoneNum);
425 : }
426 0 : SumToZone += state.afn->AirflowNetworkLinkSimu(state.dataRoomAirMod->AirflowNetworkSurfaceUCSDCV(Ctd2, ZoneNum)).VolFLOW;
427 : }
428 : }
429 :
430 : // Check if wind direction is within +/- 90 degrees of the outward normal of the dominant surface
431 4035 : SurfNorm = thisSurface.Azimuth;
432 4035 : CosPhi = std::cos((state.dataEnvrn->WindDir - SurfNorm) * DataGlobalConstants::DegToRadians);
433 4035 : if (CosPhi <= 0) {
434 1949 : state.dataRoomAirMod->AirModel(ZoneNum).SimAirModel = false;
435 3898 : auto flows(state.dataRoomAirMod->CVJetRecFlows(_, ZoneNum));
436 10288 : for (int i = 1, u = flows.u(); i <= u; ++i) {
437 8339 : auto &e(flows(i));
438 8339 : e.Ujet = e.Urec = 0.0;
439 : }
440 1949 : state.dataRoomAirMod->Urec(ZoneNum) = 0.0;
441 1949 : state.dataRoomAirMod->Ujet(ZoneNum) = 0.0;
442 1949 : state.dataRoomAirMod->Qrec(ZoneNum) = 0.0;
443 1949 : if (thisSurface.ExtBoundCond > 0) {
444 0 : state.dataRoomAirMod->Tin(ZoneNum) =
445 0 : state.dataZoneTempPredictorCorrector->zoneHeatBalance(state.dataSurface->Surface(thisSurface.ExtBoundCond).Zone).MAT;
446 1949 : } else if (thisSurface.ExtBoundCond == ExternalEnvironment) {
447 1949 : state.dataRoomAirMod->Tin(ZoneNum) = state.dataSurface->SurfOutDryBulbTemp(surfNum);
448 0 : } else if (thisSurface.ExtBoundCond == Ground) {
449 0 : state.dataRoomAirMod->Tin(ZoneNum) = state.dataSurface->SurfOutDryBulbTemp(surfNum);
450 0 : } else if (thisSurface.ExtBoundCond == OtherSideCoefNoCalcExt || thisSurface.ExtBoundCond == OtherSideCoefCalcExt) {
451 0 : auto &thisOSC = state.dataSurface->OSC(thisSurface.OSCPtr);
452 0 : thisOSC.OSCTempCalc =
453 0 : (thisOSC.ZoneAirTempCoef * thisZoneHB.MAT + thisOSC.ExtDryBulbCoef * state.dataSurface->SurfOutDryBulbTemp(surfNum) +
454 0 : thisOSC.ConstTempCoef * thisOSC.ConstTemp + thisOSC.GroundTempCoef * state.dataEnvrn->GroundTemp +
455 0 : thisOSC.WindSpeedCoef * state.dataSurface->SurfOutWindSpeed(surfNum) * state.dataSurface->SurfOutDryBulbTemp(surfNum));
456 0 : state.dataRoomAirMod->Tin(ZoneNum) = thisOSC.OSCTempCalc;
457 : } else {
458 0 : state.dataRoomAirMod->Tin(ZoneNum) = state.dataSurface->SurfOutDryBulbTemp(surfNum);
459 : }
460 1949 : return;
461 : }
462 :
463 : // Calculate the opening area for all apertures
464 8482 : for (int Ctd = 1; Ctd <= state.dataRoomAirMod->AirflowNetworkSurfaceUCSDCV(0, ZoneNum); ++Ctd) {
465 6396 : int cCompNum = state.afn->AirflowNetworkLinkageData(Ctd).CompNum;
466 6396 : if (state.afn->AirflowNetworkCompData(cCompNum).CompTypeNum == AirflowNetwork::iComponentTypeNum::DOP) {
467 19188 : state.dataRoomAirMod->CVJetRecFlows(Ctd, ZoneNum).Area = state.dataRoomAirMod->SurfParametersCVDV(Ctd).Width *
468 12792 : state.dataRoomAirMod->SurfParametersCVDV(Ctd).Height *
469 6396 : state.afn->MultizoneSurfaceData(Ctd).OpenFactor;
470 0 : } else if (state.afn->AirflowNetworkCompData(cCompNum).CompTypeNum == AirflowNetwork::iComponentTypeNum::SCR) {
471 0 : state.dataRoomAirMod->CVJetRecFlows(Ctd, ZoneNum).Area =
472 0 : state.dataRoomAirMod->SurfParametersCVDV(Ctd).Width * state.dataRoomAirMod->SurfParametersCVDV(Ctd).Height;
473 : } else {
474 0 : ShowSevereError(
475 : state, "RoomAirModelCrossVent:EvolveParaUCSDCV: Illegal leakage component referenced in the cross ventilation room air model");
476 0 : ShowContinueError(state,
477 0 : "Surface " + state.afn->AirflowNetworkLinkageData(Ctd).Name + " in zone " + state.dataHeatBal->Zone(ZoneNum).Name +
478 0 : " uses leakage component " + state.afn->AirflowNetworkLinkageData(Ctd).CompName);
479 0 : ShowContinueError(state, "Only leakage component types AirflowNetwork:MultiZone:Component:DetailedOpening and ");
480 0 : ShowContinueError(state, "AirflowNetwork:MultiZone:Surface:Crack can be used with the cross ventilation room air model");
481 0 : ShowFatalError(state, "Previous severe error causes program termination");
482 : }
483 : }
484 :
485 : // Calculate Droom, Wroom, Dstar
486 : // Droom the distance between the average point of the base surface of the airflow network Surface (if the base surface
487 : // is a Window or Door it looks for the second base surface).
488 : // Dstar is Droom corrected for wind angle
489 2086 : Wroom = state.dataHeatBal->Zone(ZoneNum).Volume / state.dataHeatBal->Zone(ZoneNum).FloorArea;
490 2086 : auto const &baseSurface(state.dataSurface->Surface(thisSurface.BaseSurf));
491 2086 : if ((baseSurface.Sides == 3) || (baseSurface.Sides == 4)) {
492 2086 : XX = baseSurface.Centroid.x;
493 2086 : YY = baseSurface.Centroid.y;
494 2086 : ZZ = baseSurface.Centroid.z;
495 : } else {
496 : // If the surface has more than 4 vertex then average the vertex coordinates in X, Y and Z.
497 0 : NSides = baseSurface.Sides;
498 0 : assert(NSides > 0);
499 0 : XX = YY = ZZ = 0.0;
500 0 : for (int i = 1; i <= NSides; ++i) {
501 0 : auto const &v(baseSurface.Vertex(i));
502 0 : XX += v.x;
503 0 : YY += v.y;
504 0 : ZZ += v.z;
505 : }
506 0 : XX /= double(NSides);
507 0 : YY /= double(NSides);
508 0 : ZZ /= double(NSides);
509 : }
510 :
511 2086 : Real64 const Wroom_2(pow_2(Wroom));
512 10430 : for (int Ctd = state.dataUCSDShared->PosZ_Wall(2 * ZoneNum - 1); Ctd <= state.dataUCSDShared->PosZ_Wall(2 * ZoneNum); ++Ctd) {
513 16688 : if ((state.dataSurface->Surface(state.dataUCSDShared->APos_Wall(Ctd)).Sides == 3) ||
514 8344 : (state.dataSurface->Surface(state.dataUCSDShared->APos_Wall(Ctd)).Sides == 4)) {
515 8344 : XX_Wall = state.dataSurface->Surface(state.dataUCSDShared->APos_Wall(Ctd)).Centroid.x;
516 8344 : YY_Wall = state.dataSurface->Surface(state.dataUCSDShared->APos_Wall(Ctd)).Centroid.y;
517 8344 : ZZ_Wall = state.dataSurface->Surface(state.dataUCSDShared->APos_Wall(Ctd)).Centroid.z;
518 : } else {
519 0 : NSides = state.dataSurface->Surface(state.dataUCSDShared->APos_Wall(Ctd)).Sides;
520 0 : assert(NSides > 0);
521 0 : XX_Wall = YY_Wall = ZZ_Wall = 0.0;
522 0 : for (int i = 1; i <= NSides; ++i) {
523 0 : auto const &v(state.dataSurface->Surface(state.dataUCSDShared->APos_Wall(Ctd)).Vertex(i));
524 0 : XX_Wall += v.x;
525 0 : YY_Wall += v.y;
526 0 : ZZ_Wall += v.z;
527 : }
528 0 : XX_Wall /= double(NSides);
529 0 : YY_Wall /= double(NSides);
530 0 : ZZ_Wall /= double(NSides);
531 : }
532 8344 : auto DroomTemp = std::sqrt(pow_2(XX - XX_Wall) + pow_2(YY - YY_Wall) + pow_2(ZZ - ZZ_Wall));
533 8344 : if (DroomTemp > state.dataRoomAirMod->Droom(ZoneNum)) {
534 8 : state.dataRoomAirMod->Droom(ZoneNum) = DroomTemp;
535 : }
536 8344 : state.dataRoomAirMod->Dstar(ZoneNum) =
537 8344 : min(state.dataRoomAirMod->Droom(ZoneNum) / CosPhi, std::sqrt(Wroom_2 + pow_2(state.dataRoomAirMod->Droom(ZoneNum))));
538 : }
539 :
540 : // Room area
541 2086 : Aroom = state.dataHeatBal->Zone(ZoneNum).Volume / state.dataRoomAirMod->Droom(ZoneNum);
542 :
543 : // Populate an array of inflow volume fluxes (Fin) for all apertures in the zone
544 : // Calculate inflow velocity (%Uin) for each aperture in the zone
545 8482 : for (int Ctd = 1; Ctd <= state.dataRoomAirMod->AirflowNetworkSurfaceUCSDCV(0, ZoneNum); ++Ctd) {
546 6396 : if (state.dataSurface->Surface(state.afn->MultizoneSurfaceData(Ctd).SurfNum).Zone == ZoneNum) {
547 : // this is a direct airflow network aperture
548 6396 : state.dataRoomAirMod->CVJetRecFlows(Ctd, ZoneNum).Fin =
549 6396 : state.afn->AirflowNetworkLinkSimu(state.dataRoomAirMod->AirflowNetworkSurfaceUCSDCV(Ctd, ZoneNum)).VolFLOW2;
550 : } else {
551 : // this is an indirect airflow network aperture
552 0 : state.dataRoomAirMod->CVJetRecFlows(Ctd, ZoneNum).Fin =
553 0 : state.afn->AirflowNetworkLinkSimu(state.dataRoomAirMod->AirflowNetworkSurfaceUCSDCV(Ctd, ZoneNum)).VolFLOW;
554 : }
555 6396 : if (state.dataRoomAirMod->CVJetRecFlows(Ctd, ZoneNum).Area != 0) {
556 4152 : state.dataRoomAirMod->CVJetRecFlows(Ctd, ZoneNum).Uin =
557 4152 : state.dataRoomAirMod->CVJetRecFlows(Ctd, ZoneNum).Fin / state.dataRoomAirMod->CVJetRecFlows(Ctd, ZoneNum).Area;
558 : } else {
559 2244 : state.dataRoomAirMod->CVJetRecFlows(Ctd, ZoneNum).Uin = 0.0;
560 : }
561 : }
562 :
563 : // Verify if Uin is higher than minimum for each aperture
564 : // Create a flow flag for each aperture
565 : // Calculate the total area of all active apertures
566 2086 : ActiveSurfNum = 0.0;
567 2086 : state.dataRoomAirMod->Ain(ZoneNum) = 0.0;
568 8482 : for (int Ctd = 1; Ctd <= state.dataRoomAirMod->AirflowNetworkSurfaceUCSDCV(0, ZoneNum); ++Ctd) {
569 6396 : if (state.dataRoomAirMod->CVJetRecFlows(Ctd, ZoneNum).Uin <= MinUin) {
570 4320 : state.dataRoomAirMod->CVJetRecFlows(Ctd, ZoneNum).FlowFlag = 0;
571 : } else {
572 2076 : state.dataRoomAirMod->CVJetRecFlows(Ctd, ZoneNum).FlowFlag = 1;
573 : }
574 6396 : ActiveSurfNum += state.dataRoomAirMod->CVJetRecFlows(Ctd, ZoneNum).FlowFlag;
575 6396 : state.dataRoomAirMod->Ain(ZoneNum) +=
576 6396 : state.dataRoomAirMod->CVJetRecFlows(Ctd, ZoneNum).Area * state.dataRoomAirMod->CVJetRecFlows(Ctd, ZoneNum).FlowFlag;
577 : }
578 :
579 : // Verify if any of the apertures have minimum flow
580 2086 : if (ActiveSurfNum == 0) {
581 561 : state.dataRoomAirMod->AirModel(ZoneNum).SimAirModel = false;
582 561 : if (thisSurface.ExtBoundCond > 0) {
583 0 : state.dataRoomAirMod->Tin(ZoneNum) =
584 0 : state.dataZoneTempPredictorCorrector->zoneHeatBalance(state.dataSurface->Surface(thisSurface.ExtBoundCond).Zone).MAT;
585 561 : } else if (thisSurface.ExtBoundCond == ExternalEnvironment) {
586 561 : state.dataRoomAirMod->Tin(ZoneNum) = state.dataSurface->SurfOutDryBulbTemp(surfNum);
587 0 : } else if (thisSurface.ExtBoundCond == Ground) {
588 0 : state.dataRoomAirMod->Tin(ZoneNum) = state.dataSurface->SurfOutDryBulbTemp(surfNum);
589 0 : } else if (thisSurface.ExtBoundCond == OtherSideCoefNoCalcExt || thisSurface.ExtBoundCond == OtherSideCoefCalcExt) {
590 0 : auto &thisOSC = state.dataSurface->OSC(thisSurface.OSCPtr);
591 0 : thisOSC.OSCTempCalc =
592 0 : (thisOSC.ZoneAirTempCoef * thisZoneHB.MAT + thisOSC.ExtDryBulbCoef * state.dataSurface->SurfOutDryBulbTemp(surfNum) +
593 0 : thisOSC.ConstTempCoef * thisOSC.ConstTemp + thisOSC.GroundTempCoef * state.dataEnvrn->GroundTemp +
594 0 : thisOSC.WindSpeedCoef * state.dataSurface->SurfOutWindSpeed(surfNum) * state.dataSurface->SurfOutDryBulbTemp(surfNum));
595 0 : state.dataRoomAirMod->Tin(ZoneNum) = thisOSC.OSCTempCalc;
596 : } else {
597 0 : state.dataRoomAirMod->Tin(ZoneNum) = state.dataSurface->SurfOutDryBulbTemp(surfNum);
598 : }
599 561 : state.dataRoomAirMod->Urec(ZoneNum) = 0.0;
600 561 : state.dataRoomAirMod->Ujet(ZoneNum) = 0.0;
601 561 : state.dataRoomAirMod->Qrec(ZoneNum) = 0.0;
602 1122 : auto flows(state.dataRoomAirMod->CVJetRecFlows(_, ZoneNum));
603 3366 : for (int i = 1, u = flows.u(); i <= u; ++i) {
604 2805 : auto &e(flows(i));
605 2805 : e.Ujet = e.Urec = 0.0;
606 : }
607 561 : return;
608 : }
609 :
610 : // Calculate Uin, the area weighted average velocity of all the active apertures in the zone
611 : // Calculate Qtot, the total volumetric flow rate through all active openings in the zone
612 1525 : Uin = 0.0;
613 :
614 5677 : for (int Ctd = 1; Ctd <= state.dataRoomAirMod->AirflowNetworkSurfaceUCSDCV(0, ZoneNum); ++Ctd) {
615 12456 : Uin += state.dataRoomAirMod->CVJetRecFlows(Ctd, ZoneNum).Area * state.dataRoomAirMod->CVJetRecFlows(Ctd, ZoneNum).Uin *
616 8304 : state.dataRoomAirMod->CVJetRecFlows(Ctd, ZoneNum).FlowFlag / state.dataRoomAirMod->Ain(ZoneNum);
617 : }
618 :
619 : // Verify if Uin is higher than minimum:
620 1525 : if (Uin < MinUin) {
621 0 : state.dataRoomAirMod->AirModel(ZoneNum).SimAirModel = false;
622 0 : state.dataRoomAirMod->Urec(ZoneNum) = 0.0;
623 0 : state.dataRoomAirMod->Ujet(ZoneNum) = 0.0;
624 0 : state.dataRoomAirMod->Qrec(ZoneNum) = 0.0;
625 0 : state.dataRoomAirMod->RecInflowRatio(ZoneNum) = 0.0;
626 0 : auto flows(state.dataRoomAirMod->CVJetRecFlows(_, ZoneNum));
627 0 : for (int i = 1, u = flows.u(); i <= u; ++i) {
628 0 : auto &e(flows(i));
629 0 : e.Ujet = e.Urec = 0.0;
630 : }
631 0 : if (thisSurface.ExtBoundCond > 0) {
632 0 : state.dataRoomAirMod->Tin(ZoneNum) =
633 0 : state.dataZoneTempPredictorCorrector->zoneHeatBalance(state.dataSurface->Surface(thisSurface.ExtBoundCond).Zone).MAT;
634 0 : } else if (thisSurface.ExtBoundCond == ExternalEnvironment) {
635 0 : state.dataRoomAirMod->Tin(ZoneNum) = state.dataSurface->SurfOutDryBulbTemp(surfNum);
636 0 : } else if (thisSurface.ExtBoundCond == Ground) {
637 0 : state.dataRoomAirMod->Tin(ZoneNum) = state.dataSurface->SurfOutDryBulbTemp(surfNum);
638 0 : } else if (thisSurface.ExtBoundCond == OtherSideCoefNoCalcExt || thisSurface.ExtBoundCond == OtherSideCoefCalcExt) {
639 0 : auto &thisOSC = state.dataSurface->OSC(thisSurface.OSCPtr);
640 0 : thisOSC.OSCTempCalc =
641 0 : (thisOSC.ZoneAirTempCoef * thisZoneHB.MAT + thisOSC.ExtDryBulbCoef * state.dataSurface->SurfOutDryBulbTemp(surfNum) +
642 0 : thisOSC.ConstTempCoef * thisOSC.ConstTemp + thisOSC.GroundTempCoef * state.dataEnvrn->GroundTemp +
643 0 : thisOSC.WindSpeedCoef * state.dataSurface->SurfOutWindSpeed(surfNum) * state.dataSurface->SurfOutDryBulbTemp(surfNum));
644 0 : state.dataRoomAirMod->Tin(ZoneNum) = thisOSC.OSCTempCalc;
645 :
646 : } else {
647 0 : state.dataRoomAirMod->Tin(ZoneNum) = state.dataSurface->SurfOutDryBulbTemp(surfNum);
648 : }
649 0 : return;
650 : }
651 :
652 : // Evaluate parameter that determines whether recirculations are present
653 3050 : for (int Ctd = 1; Ctd <= state.dataRoomAirMod->TotUCSDCV; ++Ctd) {
654 1525 : if (ZoneNum == state.dataRoomAirMod->ZoneUCSDCV(Ctd).ZonePtr) {
655 1525 : if (state.dataRoomAirMod->Ain(ZoneNum) / Aroom > 1.0 / 2.0) {
656 0 : state.dataRoomAirMod->JetRecAreaRatio(ZoneNum) = 1.0;
657 : } else {
658 1525 : state.dataRoomAirMod->JetRecAreaRatio(ZoneNum) = std::sqrt(state.dataRoomAirMod->Ain(ZoneNum) / Aroom);
659 : }
660 : }
661 : }
662 :
663 1525 : state.dataRoomAirMod->AirModel(ZoneNum).SimAirModel = true;
664 : // Calculate jet and recirculation velocities for all active apertures
665 1525 : state.dataRoomAirMod->Ujet(ZoneNum) = 0.0;
666 1525 : state.dataRoomAirMod->Urec(ZoneNum) = 0.0;
667 1525 : state.dataRoomAirMod->Qrec(ZoneNum) = 0.0;
668 1525 : state.dataRoomAirMod->Qtot(ZoneNum) = 0.0;
669 3050 : auto flows(state.dataRoomAirMod->CVJetRecFlows(_, ZoneNum));
670 7202 : for (int i = 1, u = flows.u(); i <= u; ++i) {
671 5677 : auto &e(flows(i));
672 5677 : e.Ujet = e.Urec = e.Qrec = 0.0;
673 : }
674 5677 : for (int Ctd = 1; Ctd <= state.dataRoomAirMod->AirflowNetworkSurfaceUCSDCV(0, ZoneNum); ++Ctd) {
675 4152 : if (state.dataRoomAirMod->CVJetRecFlows(Ctd, ZoneNum).Uin != 0) {
676 : Real64 dstarexp =
677 2076 : max(state.dataRoomAirMod->Dstar(ZoneNum) / (6.0 * std::sqrt(state.dataRoomAirMod->CVJetRecFlows(Ctd, ZoneNum).Area)), 1.0);
678 6228 : state.dataRoomAirMod->CVJetRecFlows(Ctd, ZoneNum).Vjet = state.dataRoomAirMod->CVJetRecFlows(Ctd, ZoneNum).Uin *
679 6228 : std::sqrt(state.dataRoomAirMod->CVJetRecFlows(Ctd, ZoneNum).Area) * 6.3 *
680 4152 : std::log(dstarexp) / state.dataRoomAirMod->Dstar(ZoneNum);
681 2076 : state.dataRoomAirMod->CVJetRecFlows(Ctd, ZoneNum).Yjet =
682 4152 : Cjet1 * std::sqrt(state.dataRoomAirMod->CVJetRecFlows(Ctd, ZoneNum).Area / Aroom) *
683 4152 : state.dataRoomAirMod->CVJetRecFlows(Ctd, ZoneNum).Vjet / state.dataRoomAirMod->CVJetRecFlows(Ctd, ZoneNum).Uin +
684 : Cjet2;
685 2076 : state.dataRoomAirMod->CVJetRecFlows(Ctd, ZoneNum).Yrec =
686 4152 : Crec1 * std::sqrt(state.dataRoomAirMod->CVJetRecFlows(Ctd, ZoneNum).Area / Aroom) *
687 4152 : state.dataRoomAirMod->CVJetRecFlows(Ctd, ZoneNum).Vjet / state.dataRoomAirMod->CVJetRecFlows(Ctd, ZoneNum).Uin +
688 : Crec2;
689 2076 : state.dataRoomAirMod->CVJetRecFlows(Ctd, ZoneNum).YQrec =
690 4152 : CrecFlow1 * std::sqrt(state.dataRoomAirMod->CVJetRecFlows(Ctd, ZoneNum).Area * Aroom) *
691 4152 : state.dataRoomAirMod->CVJetRecFlows(Ctd, ZoneNum).Vjet / state.dataRoomAirMod->CVJetRecFlows(Ctd, ZoneNum).Uin +
692 : CrecFlow2;
693 6228 : state.dataRoomAirMod->CVJetRecFlows(Ctd, ZoneNum).Ujet = state.dataRoomAirMod->CVJetRecFlows(Ctd, ZoneNum).FlowFlag *
694 4152 : state.dataRoomAirMod->CVJetRecFlows(Ctd, ZoneNum).Yjet /
695 2076 : state.dataRoomAirMod->CVJetRecFlows(Ctd, ZoneNum).Uin;
696 6228 : state.dataRoomAirMod->CVJetRecFlows(Ctd, ZoneNum).Urec = state.dataRoomAirMod->CVJetRecFlows(Ctd, ZoneNum).FlowFlag *
697 4152 : state.dataRoomAirMod->CVJetRecFlows(Ctd, ZoneNum).Yrec /
698 2076 : state.dataRoomAirMod->CVJetRecFlows(Ctd, ZoneNum).Uin;
699 6228 : state.dataRoomAirMod->CVJetRecFlows(Ctd, ZoneNum).Qrec = state.dataRoomAirMod->CVJetRecFlows(Ctd, ZoneNum).FlowFlag *
700 4152 : state.dataRoomAirMod->CVJetRecFlows(Ctd, ZoneNum).YQrec /
701 2076 : state.dataRoomAirMod->CVJetRecFlows(Ctd, ZoneNum).Uin;
702 6228 : state.dataRoomAirMod->Ujet(ZoneNum) += state.dataRoomAirMod->CVJetRecFlows(Ctd, ZoneNum).Area *
703 4152 : state.dataRoomAirMod->CVJetRecFlows(Ctd, ZoneNum).Ujet / state.dataRoomAirMod->Ain(ZoneNum);
704 6228 : state.dataRoomAirMod->Urec(ZoneNum) += state.dataRoomAirMod->CVJetRecFlows(Ctd, ZoneNum).Area *
705 4152 : state.dataRoomAirMod->CVJetRecFlows(Ctd, ZoneNum).Urec / state.dataRoomAirMod->Ain(ZoneNum);
706 2076 : state.dataRoomAirMod->Qrec(ZoneNum) += state.dataRoomAirMod->CVJetRecFlows(Ctd, ZoneNum).Qrec;
707 2076 : state.dataRoomAirMod->Qtot(ZoneNum) +=
708 2076 : state.dataRoomAirMod->CVJetRecFlows(Ctd, ZoneNum).Fin * state.dataRoomAirMod->CVJetRecFlows(Ctd, ZoneNum).FlowFlag;
709 6228 : state.dataRoomAirMod->Urec(ZoneNum) += state.dataRoomAirMod->CVJetRecFlows(Ctd, ZoneNum).Area *
710 4152 : state.dataRoomAirMod->CVJetRecFlows(Ctd, ZoneNum).Urec / state.dataRoomAirMod->Ain(ZoneNum);
711 : }
712 : }
713 :
714 : // Ratio between recirculation flow rate and total inflow rate
715 1525 : if (state.dataRoomAirMod->Qtot(ZoneNum) != 0) {
716 1525 : state.dataRoomAirMod->RecInflowRatio(ZoneNum) = state.dataRoomAirMod->Qrec(ZoneNum) / state.dataRoomAirMod->Qtot(ZoneNum);
717 : } else {
718 0 : state.dataRoomAirMod->RecInflowRatio(ZoneNum) = 0.0;
719 : }
720 :
721 : // Set Tin based on external conditions of the dominant aperture
722 1525 : if (thisSurface.ExtBoundCond <= 0) {
723 1525 : if (thisSurface.ExtBoundCond == ExternalEnvironment) {
724 1525 : state.dataRoomAirMod->Tin(ZoneNum) = state.dataSurface->SurfOutDryBulbTemp(surfNum);
725 0 : } else if (thisSurface.ExtBoundCond == Ground) {
726 0 : state.dataRoomAirMod->Tin(ZoneNum) = state.dataSurface->SurfOutDryBulbTemp(surfNum);
727 0 : } else if (thisSurface.ExtBoundCond == OtherSideCoefNoCalcExt || thisSurface.ExtBoundCond == OtherSideCoefCalcExt) {
728 0 : auto &thisOSC = state.dataSurface->OSC(thisSurface.OSCPtr);
729 0 : thisOSC.OSCTempCalc =
730 0 : (thisOSC.ZoneAirTempCoef * thisZoneHB.MAT + thisOSC.ExtDryBulbCoef * state.dataSurface->SurfOutDryBulbTemp(surfNum) +
731 0 : thisOSC.ConstTempCoef * thisOSC.ConstTemp + thisOSC.GroundTempCoef * state.dataEnvrn->GroundTemp +
732 0 : thisOSC.WindSpeedCoef * state.dataSurface->SurfOutWindSpeed(surfNum) * state.dataSurface->SurfOutDryBulbTemp(surfNum));
733 0 : state.dataRoomAirMod->Tin(ZoneNum) = thisOSC.OSCTempCalc;
734 : } else {
735 0 : state.dataRoomAirMod->Tin(ZoneNum) = state.dataSurface->SurfOutDryBulbTemp(surfNum);
736 : }
737 : } else {
738 : // adiabatic surface
739 0 : if (surfNum == thisSurface.ExtBoundCond) {
740 0 : NodeNum1 = state.afn->AirflowNetworkLinkageData(MaxSurf).NodeNums[0];
741 0 : NodeNum2 = state.afn->AirflowNetworkLinkageData(MaxSurf).NodeNums[1];
742 0 : if (thisSurface.Zone == ZoneNum) {
743 0 : if (state.afn->AirflowNetworkNodeData(NodeNum1).EPlusZoneNum <= 0) {
744 0 : state.dataRoomAirMod->Tin(ZoneNum) = state.dataSurface->SurfOutDryBulbTemp(surfNum);
745 0 : } else if (state.dataRoomAirMod->AirModel(state.afn->AirflowNetworkNodeData(NodeNum1).EPlusZoneNum).AirModelType ==
746 : DataRoomAirModel::RoomAirModel::UCSDCV) {
747 0 : state.dataRoomAirMod->Tin(ZoneNum) =
748 0 : state.dataRoomAirMod->RoomOutflowTemp(state.afn->AirflowNetworkNodeData(NodeNum1).EPlusZoneNum);
749 : } else {
750 0 : state.dataRoomAirMod->Tin(ZoneNum) =
751 0 : state.dataZoneTempPredictorCorrector->zoneHeatBalance(state.afn->AirflowNetworkNodeData(NodeNum1).EPlusZoneNum).MAT;
752 : }
753 :
754 : } else {
755 :
756 0 : if (state.afn->AirflowNetworkNodeData(NodeNum2).EPlusZoneNum <= 0) {
757 0 : state.dataRoomAirMod->Tin(ZoneNum) = state.dataSurface->SurfOutDryBulbTemp(surfNum);
758 0 : } else if (state.dataRoomAirMod->AirModel(state.afn->AirflowNetworkNodeData(NodeNum2).EPlusZoneNum).AirModelType ==
759 : DataRoomAirModel::RoomAirModel::UCSDCV) {
760 0 : state.dataRoomAirMod->Tin(ZoneNum) =
761 0 : state.dataRoomAirMod->RoomOutflowTemp(state.afn->AirflowNetworkNodeData(NodeNum2).EPlusZoneNum);
762 : } else {
763 0 : state.dataRoomAirMod->Tin(ZoneNum) =
764 0 : state.dataZoneTempPredictorCorrector->zoneHeatBalance(state.afn->AirflowNetworkNodeData(NodeNum2).EPlusZoneNum).MAT;
765 : }
766 : }
767 0 : } else if ((thisSurface.Zone == ZoneNum) &&
768 0 : (state.dataRoomAirMod->AirModel(state.dataSurface->Surface(thisSurface.ExtBoundCond).Zone).AirModelType ==
769 : DataRoomAirModel::RoomAirModel::UCSDCV)) {
770 0 : state.dataRoomAirMod->Tin(ZoneNum) = state.dataRoomAirMod->RoomOutflowTemp(state.dataSurface->Surface(thisSurface.ExtBoundCond).Zone);
771 0 : } else if ((thisSurface.Zone != ZoneNum) &&
772 0 : (state.dataRoomAirMod->AirModel(thisSurface.Zone).AirModelType == DataRoomAirModel::RoomAirModel::UCSDCV)) {
773 0 : state.dataRoomAirMod->Tin(ZoneNum) = state.dataRoomAirMod->RoomOutflowTemp(surfNum);
774 : } else {
775 0 : if (thisSurface.Zone == ZoneNum) {
776 0 : state.dataRoomAirMod->Tin(ZoneNum) =
777 0 : state.dataZoneTempPredictorCorrector->zoneHeatBalance(state.dataSurface->Surface(thisSurface.ExtBoundCond).Zone).MAT;
778 : } else {
779 0 : state.dataRoomAirMod->Tin(ZoneNum) = state.dataZoneTempPredictorCorrector->zoneHeatBalance(thisSurface.Zone).MAT;
780 : }
781 : }
782 : }
783 : }
784 :
785 4035 : void CalcUCSDCV(EnergyPlusData &state,
786 : int const ZoneNum) // Which Zonenum
787 : {
788 :
789 : // SUBROUTINE INFORMATION:
790 : // AUTHOR G. Carrilho da Graca
791 : // DATE WRITTEN October 2004
792 : // MODIFIED 8/2013 - Sam Brunswick
793 : // To incorporate improved temperature calculations
794 : // RE-ENGINEERED -
795 :
796 : // PURPOSE OF THIS SUBROUTINE:
797 : // Subroutine for cross ventilation modelling.
798 :
799 : // REFERENCES:
800 : // Model developed by Paul Linden (UCSD), G. Carrilho da Graca (UCSD) and P. Haves (LBL).
801 : // Work funded by the California Energy Comission. More information on the model can found in:
802 : // "Simplified Models for Heat Transfer in Rooms" G. Carrilho da Graca, Ph.D. thesis UCSD. December 2003.
803 :
804 : using namespace DataEnvironment;
805 : using namespace DataHeatBalance;
806 : using Psychrometrics::PsyCpAirFnW;
807 : using Psychrometrics::PsyRhoAirFnPbTdbW;
808 : using ScheduleManager::GetCurrentScheduleValue;
809 : using ScheduleManager::GetScheduleIndex;
810 :
811 : // SUBROUTINE LOCAL VARIABLE DECLARATIONS:
812 : Real64 GainsFrac; // Fraction of lower subzone internal gains that mix as opposed to forming plumes
813 : Real64 ConvGains; // Total convective gains in the room
814 : Real64 ConvGainsJet; // Total convective gains released in jet subzone
815 : Real64 ConvGainsRec; // Total convective gains released in recirculation subzone
816 : Real64 MCp_Total; // Total capacity rate into the zone - assumed to enter at low level
817 : Real64 ZTAveraged;
818 :
819 4035 : auto &Zone(state.dataHeatBal->Zone);
820 :
821 : Real64 MCpT_Total;
822 : Real64 L;
823 : Real64 ZoneMult; // total zone multiplier
824 : Real64 RetAirConvGain;
825 :
826 4035 : GainsFrac = 0.0;
827 4035 : ZoneMult = Zone(ZoneNum).Multiplier * Zone(ZoneNum).ListMultiplier;
828 4035 : auto &thisZoneHB = state.dataZoneTempPredictorCorrector->zoneHeatBalance(ZoneNum);
829 :
830 8070 : for (int Ctd = 1; Ctd <= state.dataRoomAirMod->TotUCSDCV; ++Ctd) {
831 4035 : if (ZoneNum == state.dataRoomAirMod->ZoneUCSDCV(Ctd).ZonePtr) {
832 4035 : GainsFrac = GetCurrentScheduleValue(state, state.dataRoomAirMod->ZoneUCSDCV(Ctd).SchedGainsPtr);
833 : }
834 : }
835 :
836 4035 : ConvGains = InternalHeatGains::zoneSumAllInternalConvectionGains(state, ZoneNum);
837 12105 : ConvGains += state.dataHeatBalFanSys->SumConvHTRadSys(ZoneNum) + state.dataHeatBalFanSys->SumConvPool(ZoneNum) +
838 8070 : thisZoneHB.SysDepZoneLoadsLagged + thisZoneHB.NonAirSystemResponse / ZoneMult;
839 :
840 : // Add heat to return air if zonal system (no return air) or cycling system (return air frequently very low or zero)
841 4035 : if (Zone(ZoneNum).NoHeatToReturnAir) {
842 0 : RetAirConvGain = InternalHeatGains::zoneSumAllReturnAirConvectionGains(state, ZoneNum, 0);
843 0 : ConvGains += RetAirConvGain;
844 : }
845 :
846 4035 : ConvGainsJet = ConvGains * GainsFrac;
847 4035 : ConvGainsRec = ConvGains * (1.0 - GainsFrac);
848 4035 : MCp_Total = thisZoneHB.MCPI + thisZoneHB.MCPV + thisZoneHB.MCPM + thisZoneHB.MCPE + thisZoneHB.MCPC + thisZoneHB.MDotCPOA;
849 8070 : MCpT_Total = thisZoneHB.MCPTI + thisZoneHB.MCPTV + thisZoneHB.MCPTM + thisZoneHB.MCPTE + thisZoneHB.MCPTC +
850 4035 : thisZoneHB.MDotCPOA * Zone(ZoneNum).OutDryBulbTemp;
851 :
852 4035 : if (state.afn->simulation_control.type == AirflowNetwork::ControlType::MultizoneWithoutDistribution) {
853 4035 : MCp_Total = state.afn->exchangeData(ZoneNum).SumMCp + state.afn->exchangeData(ZoneNum).SumMVCp + state.afn->exchangeData(ZoneNum).SumMMCp;
854 4035 : MCpT_Total =
855 4035 : state.afn->exchangeData(ZoneNum).SumMCpT + state.afn->exchangeData(ZoneNum).SumMVCpT + state.afn->exchangeData(ZoneNum).SumMMCpT;
856 : }
857 :
858 4035 : EvolveParaUCSDCV(state, ZoneNum);
859 4035 : L = state.dataRoomAirMod->Droom(ZoneNum);
860 :
861 4035 : if (state.dataRoomAirMod->AirModel(ZoneNum).SimAirModel) {
862 : //=============================== CROSS VENTILATION Calculation ==============================================
863 1525 : state.dataRoomAirMod->ZoneCVisMixing(ZoneNum) = 0.0;
864 1525 : state.dataRoomAirMod->ZoneCVhasREC(ZoneNum) = 1.0;
865 7625 : for (int Ctd = 1; Ctd <= 4; ++Ctd) {
866 6100 : HcUCSDCV(state, ZoneNum);
867 6100 : if (state.dataRoomAirMod->JetRecAreaRatio(ZoneNum) != 1.0) {
868 6100 : state.dataRoomAirMod->ZTREC(ZoneNum) =
869 12200 : (ConvGainsRec * CrecTemp + CrecTemp * state.dataCrossVentMgr->HAT_R + state.dataRoomAirMod->Tin(ZoneNum) * MCp_Total) /
870 6100 : (CrecTemp * state.dataCrossVentMgr->HA_R + MCp_Total);
871 : }
872 18300 : state.dataRoomAirMod->ZTJET(ZoneNum) = (ConvGainsJet * CjetTemp + ConvGainsRec * CjetTemp + CjetTemp * state.dataCrossVentMgr->HAT_J +
873 18300 : CjetTemp * state.dataCrossVentMgr->HAT_R + state.dataRoomAirMod->Tin(ZoneNum) * MCp_Total -
874 12200 : CjetTemp * state.dataCrossVentMgr->HA_R * state.dataRoomAirMod->ZTREC(ZoneNum)) /
875 6100 : (CjetTemp * state.dataCrossVentMgr->HA_J + MCp_Total);
876 6100 : state.dataRoomAirMod->RoomOutflowTemp(ZoneNum) =
877 12200 : (ConvGainsJet + ConvGainsRec + state.dataCrossVentMgr->HAT_J + state.dataCrossVentMgr->HAT_R +
878 18300 : state.dataRoomAirMod->Tin(ZoneNum) * MCp_Total - state.dataCrossVentMgr->HA_J * state.dataRoomAirMod->ZTJET(ZoneNum) -
879 12200 : state.dataCrossVentMgr->HA_R * state.dataRoomAirMod->ZTREC(ZoneNum)) /
880 : MCp_Total;
881 : }
882 1525 : if (state.dataRoomAirMod->JetRecAreaRatio(ZoneNum) == 1.0) {
883 0 : state.dataRoomAirMod->ZoneCVhasREC(ZoneNum) = 0.0;
884 0 : state.dataRoomAirMod->ZTREC(ZoneNum) = state.dataRoomAirMod->RoomOutflowTemp(ZoneNum);
885 0 : state.dataRoomAirMod->ZTREC(ZoneNum) = state.dataRoomAirMod->ZTJET(ZoneNum);
886 0 : state.dataRoomAirMod->ZTREC(ZoneNum) = state.dataRoomAirMod->ZTJET(ZoneNum);
887 : }
888 : // If temperature increase is above 1.5C then go to mixing
889 1525 : if (state.dataRoomAirMod->RoomOutflowTemp(ZoneNum) - state.dataRoomAirMod->Tin(ZoneNum) > 1.5) {
890 976 : state.dataRoomAirMod->ZoneCVisMixing(ZoneNum) = 1.0;
891 976 : state.dataRoomAirMod->ZoneCVhasREC(ZoneNum) = 0.0;
892 976 : state.dataRoomAirMod->AirModel(ZoneNum).SimAirModel = false;
893 976 : state.dataRoomAirMod->Ujet(ZoneNum) = 0.0;
894 976 : state.dataRoomAirMod->Urec(ZoneNum) = 0.0;
895 976 : state.dataRoomAirMod->Qrec(ZoneNum) = 0.0;
896 976 : state.dataRoomAirMod->RecInflowRatio(ZoneNum) = 0.0;
897 3908 : for (auto &e : state.dataRoomAirMod->CVJetRecFlows) {
898 2932 : e.Ujet = 0.0;
899 2932 : e.Urec = 0.0;
900 : }
901 3904 : for (int Ctd = 1; Ctd <= 3; ++Ctd) {
902 2928 : ZTAveraged = state.dataZoneTempPredictorCorrector->zoneHeatBalance(ZoneNum).MAT;
903 2928 : state.dataRoomAirMod->RoomOutflowTemp(ZoneNum) = ZTAveraged;
904 2928 : state.dataRoomAirMod->ZTJET(ZoneNum) = ZTAveraged;
905 2928 : state.dataRoomAirMod->ZTREC(ZoneNum) = ZTAveraged;
906 2928 : state.dataRoomAirMod->RoomOutflowTemp(ZoneNum) = ZTAveraged;
907 2928 : state.dataRoomAirMod->ZTREC(ZoneNum) = ZTAveraged;
908 2928 : state.dataRoomAirMod->ZTJET(ZoneNum) = ZTAveraged;
909 2928 : state.dataRoomAirMod->ZTREC(ZoneNum) = ZTAveraged;
910 2928 : HcUCSDCV(state, ZoneNum);
911 2928 : ZTAveraged = state.dataZoneTempPredictorCorrector->zoneHeatBalance(ZoneNum).MAT;
912 2928 : state.dataRoomAirMod->RoomOutflowTemp(ZoneNum) = ZTAveraged;
913 2928 : state.dataRoomAirMod->ZTJET(ZoneNum) = ZTAveraged;
914 2928 : state.dataRoomAirMod->ZTREC(ZoneNum) = ZTAveraged;
915 2928 : state.dataRoomAirMod->RoomOutflowTemp(ZoneNum) = ZTAveraged;
916 2928 : state.dataRoomAirMod->ZTREC(ZoneNum) = ZTAveraged;
917 2928 : state.dataRoomAirMod->ZTJET(ZoneNum) = ZTAveraged;
918 2928 : state.dataRoomAirMod->ZTREC(ZoneNum) = ZTAveraged;
919 : }
920 : }
921 : } else {
922 : //=============================== M I X E D Calculation ======================================================
923 2510 : state.dataRoomAirMod->ZoneCVisMixing(ZoneNum) = 1.0;
924 2510 : state.dataRoomAirMod->ZoneCVhasREC(ZoneNum) = 0.0;
925 2510 : state.dataRoomAirMod->Ujet(ZoneNum) = 0.0;
926 2510 : state.dataRoomAirMod->Urec(ZoneNum) = 0.0;
927 2510 : state.dataRoomAirMod->Qrec(ZoneNum) = 0.0;
928 2510 : state.dataRoomAirMod->RecInflowRatio(ZoneNum) = 0.0;
929 13654 : for (auto &e : state.dataRoomAirMod->CVJetRecFlows) {
930 11144 : e.Ujet = 0.0;
931 11144 : e.Urec = 0.0;
932 : }
933 10040 : for (int Ctd = 1; Ctd <= 3; ++Ctd) {
934 7530 : ZTAveraged = state.dataZoneTempPredictorCorrector->zoneHeatBalance(ZoneNum).MAT;
935 7530 : state.dataRoomAirMod->RoomOutflowTemp(ZoneNum) = ZTAveraged;
936 7530 : state.dataRoomAirMod->ZTJET(ZoneNum) = ZTAveraged;
937 7530 : state.dataRoomAirMod->ZTREC(ZoneNum) = ZTAveraged;
938 7530 : state.dataRoomAirMod->RoomOutflowTemp(ZoneNum) = ZTAveraged;
939 7530 : state.dataRoomAirMod->ZTREC(ZoneNum) = ZTAveraged;
940 7530 : state.dataRoomAirMod->ZTJET(ZoneNum) = ZTAveraged;
941 7530 : state.dataRoomAirMod->ZTREC(ZoneNum) = ZTAveraged;
942 7530 : HcUCSDCV(state, ZoneNum);
943 7530 : ZTAveraged = state.dataZoneTempPredictorCorrector->zoneHeatBalance(ZoneNum).MAT;
944 7530 : state.dataRoomAirMod->RoomOutflowTemp(ZoneNum) = ZTAveraged;
945 7530 : state.dataRoomAirMod->ZTJET(ZoneNum) = ZTAveraged;
946 7530 : state.dataRoomAirMod->ZTREC(ZoneNum) = ZTAveraged;
947 7530 : state.dataRoomAirMod->RoomOutflowTemp(ZoneNum) = ZTAveraged;
948 7530 : state.dataRoomAirMod->ZTREC(ZoneNum) = ZTAveraged;
949 7530 : state.dataRoomAirMod->ZTJET(ZoneNum) = ZTAveraged;
950 7530 : state.dataRoomAirMod->ZTREC(ZoneNum) = ZTAveraged;
951 : }
952 : }
953 4035 : }
954 :
955 : } // namespace CrossVentMgr
956 :
957 2313 : } // namespace EnergyPlus
|
