Line data Source code
1 : // EnergyPlus, Copyright (c) 1996-2023, The Board of Trustees of the University of Illinois,
2 : // The Regents of the University of California, through Lawrence Berkeley National Laboratory
3 : // (subject to receipt of any required approvals from the U.S. Dept. of Energy), Oak Ridge
4 : // National Laboratory, managed by UT-Battelle, Alliance for Sustainable Energy, LLC, and other
5 : // contributors. All rights reserved.
6 : //
7 : // NOTICE: This Software was developed under funding from the U.S. Department of Energy and the
8 : // U.S. Government consequently retains certain rights. As such, the U.S. Government has been
9 : // granted for itself and others acting on its behalf a paid-up, nonexclusive, irrevocable,
10 : // worldwide license in the Software to reproduce, distribute copies to the public, prepare
11 : // derivative works, and perform publicly and display publicly, and to permit others to do so.
12 : //
13 : // Redistribution and use in source and binary forms, with or without modification, are permitted
14 : // provided that the following conditions are met:
15 : //
16 : // (1) Redistributions of source code must retain the above copyright notice, this list of
17 : // conditions and the following disclaimer.
18 : //
19 : // (2) Redistributions in binary form must reproduce the above copyright notice, this list of
20 : // conditions and the following disclaimer in the documentation and/or other materials
21 : // provided with the distribution.
22 : //
23 : // (3) Neither the name of the University of California, Lawrence Berkeley National Laboratory,
24 : // the University of Illinois, U.S. Dept. of Energy nor the names of its contributors may be
25 : // used to endorse or promote products derived from this software without specific prior
26 : // written permission.
27 : //
28 : // (4) Use of EnergyPlus(TM) Name. If Licensee (i) distributes the software in stand-alone form
29 : // without changes from the version obtained under this License, or (ii) Licensee makes a
30 : // reference solely to the software portion of its product, Licensee must refer to the
31 : // software as "EnergyPlus version X" software, where "X" is the version number Licensee
32 : // obtained under this License and may not use a different name for the software. Except as
33 : // specifically required in this Section (4), Licensee shall not use in a company name, a
34 : // product name, in advertising, publicity, or other promotional activities any name, trade
35 : // name, trademark, logo, or other designation of "EnergyPlus", "E+", "e+" or confusingly
36 : // similar designation, without the U.S. Department of Energy's prior written consent.
37 : //
38 : // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR
39 : // IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY
40 : // AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
41 : // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
42 : // CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
43 : // SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
44 : // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
45 : // OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
46 : // POSSIBILITY OF SUCH DAMAGE.
47 :
48 : // C++ Headers
49 : #include <algorithm>
50 : #include <cassert>
51 : #include <cmath>
52 : // ObjexxFCL Headers
53 : #include <ObjexxFCL/Array.functions.hh>
54 : #include <ObjexxFCL/Array1D.hh>
55 : #include <ObjexxFCL/Array2D.hh>
56 : #include <ObjexxFCL/Fmath.hh>
57 : #include <ObjexxFCL/string.functions.hh>
58 :
59 : // EnergyPlus Headers
60 : #include <AirflowNetwork/Solver.hpp>
61 : #include <EnergyPlus/ChilledCeilingPanelSimple.hh>
62 : #include <EnergyPlus/Construction.hh>
63 : #include <EnergyPlus/ConvectionCoefficients.hh>
64 : #include <EnergyPlus/Data/EnergyPlusData.hh>
65 : #include <EnergyPlus/DataContaminantBalance.hh>
66 : #include <EnergyPlus/DataDaylighting.hh>
67 : #include <EnergyPlus/DataDaylightingDevices.hh>
68 : #include <EnergyPlus/DataEnvironment.hh>
69 : #include <EnergyPlus/DataHeatBalFanSys.hh>
70 : #include <EnergyPlus/DataHeatBalSurface.hh>
71 : #include <EnergyPlus/DataHeatBalance.hh>
72 : #include <EnergyPlus/DataLoopNode.hh>
73 : #include <EnergyPlus/DataMoistureBalance.hh>
74 : #include <EnergyPlus/DataMoistureBalanceEMPD.hh>
75 : #include <EnergyPlus/DataRoomAirModel.hh>
76 : #include <EnergyPlus/DataRuntimeLanguage.hh>
77 : #include <EnergyPlus/DataSizing.hh>
78 : #include <EnergyPlus/DataSurfaces.hh>
79 : #include <EnergyPlus/DataSystemVariables.hh>
80 : #include <EnergyPlus/DataViewFactorInformation.hh>
81 : #include <EnergyPlus/DataWindowEquivalentLayer.hh>
82 : #include <EnergyPlus/DataZoneEquipment.hh>
83 : #include <EnergyPlus/DaylightingDevices.hh>
84 : #include <EnergyPlus/DaylightingManager.hh>
85 : #include <EnergyPlus/DisplayRoutines.hh>
86 : #include <EnergyPlus/EcoRoofManager.hh>
87 : #include <EnergyPlus/ElectricBaseboardRadiator.hh>
88 : #include <EnergyPlus/FileSystem.hh>
89 : #include <EnergyPlus/General.hh>
90 : #include <EnergyPlus/GeneralRoutines.hh>
91 : #include <EnergyPlus/HWBaseboardRadiator.hh>
92 : #include <EnergyPlus/HeatBalFiniteDiffManager.hh>
93 : #include <EnergyPlus/HeatBalanceAirManager.hh>
94 : #include <EnergyPlus/HeatBalanceHAMTManager.hh>
95 : #include <EnergyPlus/HeatBalanceIntRadExchange.hh>
96 : #include <EnergyPlus/HeatBalanceKivaManager.hh>
97 : #include <EnergyPlus/HeatBalanceSurfaceManager.hh>
98 : #include <EnergyPlus/HighTempRadiantSystem.hh>
99 : #include <EnergyPlus/InputProcessing/InputProcessor.hh>
100 : #include <EnergyPlus/InternalHeatGains.hh>
101 : #include <EnergyPlus/LowTempRadiantSystem.hh>
102 : #include <EnergyPlus/MoistureBalanceEMPDManager.hh>
103 : #include <EnergyPlus/OutputProcessor.hh>
104 : #include <EnergyPlus/OutputReportPredefined.hh>
105 : #include <EnergyPlus/OutputReportTabular.hh>
106 : #include <EnergyPlus/Psychrometrics.hh>
107 : #include <EnergyPlus/ScheduleManager.hh>
108 : #include <EnergyPlus/SolarShading.hh>
109 : #include <EnergyPlus/SteamBaseboardRadiator.hh>
110 : #include <EnergyPlus/SurfaceGeometry.hh>
111 : #include <EnergyPlus/SwimmingPool.hh>
112 : #include <EnergyPlus/ThermalComfort.hh>
113 : #include <EnergyPlus/UtilityRoutines.hh>
114 : #include <EnergyPlus/WindowComplexManager.hh>
115 : #include <EnergyPlus/WindowEquivalentLayer.hh>
116 : #include <EnergyPlus/WindowManager.hh>
117 : #include <EnergyPlus/WindowManagerExteriorData.hh>
118 : #include <EnergyPlus/WindowManagerExteriorThermal.hh>
119 : #include <EnergyPlus/ZoneTempPredictorCorrector.hh>
120 : #include <WCECommon.hpp>
121 : #include <WCEMultiLayerOptics.hpp>
122 : #include <WCESingleLayerOptics.hpp>
123 : #include <WCETarcog.hpp>
124 :
125 : namespace EnergyPlus::HeatBalanceSurfaceManager {
126 :
127 : // Module containing the routines dealing with the Heat Balance of the surfaces
128 :
129 : // MODULE INFORMATION:
130 : // AUTHOR
131 : // DATE WRITTEN
132 : // MODIFIED DJS (PSU Dec 2006) to add ecoroof
133 : // RE-ENGINEERED na
134 :
135 : // PURPOSE OF THIS MODULE:
136 : // To encapsulate the data and algorithms required to
137 : // manage the simluation of the surface heat balance for the building.
138 :
139 : // METHODOLOGY EMPLOYED:
140 : // na
141 :
142 : // REFERENCES:
143 : // The heat balance method is outlined in the "TARP Reference Manual", NIST, NBSIR 83-2655, Feb 1983.
144 : // The methods are also summarized in many BSO Theses and papers.
145 :
146 : // OTHER NOTES:
147 : // This module was created from IBLAST subroutines
148 :
149 : // USE STATEMENTS:
150 : // Use statements for data only modules
151 : // Using/Aliasing
152 : using namespace DataEnvironment;
153 : using namespace DataHeatBalance;
154 : using namespace DataHeatBalSurface;
155 : using namespace DataSurfaces;
156 :
157 : // Use statements for access to subroutines in other modules
158 : using namespace ScheduleManager;
159 : using namespace SolarShading;
160 : using namespace WindowManager;
161 : using namespace FenestrationCommon;
162 : using namespace SingleLayerOptics;
163 : using namespace MultiLayerOptics;
164 :
165 : // These are now external subroutines
166 : // PUBLIC CalcHeatBalanceOutsideSurf ! The heat balance routines are now public because the
167 : // PUBLIC CalcHeatBalanceInsideSurf ! radiant systems need access to them in order to simulate
168 :
169 2568313 : void ManageSurfaceHeatBalance(EnergyPlusData &state)
170 : {
171 :
172 : // SUBROUTINE INFORMATION:
173 : // AUTHOR Richard Liesen
174 : // DATE WRITTEN January 1998
175 : // MODIFIED na
176 : // RE-ENGINEERED na
177 :
178 : // PURPOSE OF THIS SUBROUTINE:
179 : // This subroutine manages the heat surface balance method of calculating
180 : // building thermal loads. It is called from the HeatBalanceManager
181 : // at the time step level. This driver manages the calls to all of
182 : // the other drivers and simulation algorithms.
183 :
184 : using HeatBalanceAirManager::ManageAirHeatBalance;
185 : using OutputReportTabular::GatherComponentLoadsSurface; // for writing tabular component loads output reports
186 : using ThermalComfort::ManageThermalComfort;
187 :
188 2568313 : auto &Surface(state.dataSurface->Surface);
189 :
190 2568313 : if (state.dataHeatBalSurfMgr->ManageSurfaceHeatBalancefirstTime) DisplayString(state, "Initializing Surfaces");
191 2568313 : InitSurfaceHeatBalance(state); // Initialize all heat balance related parameters
192 :
193 : // Solve the zone heat balance 'Detailed' solution
194 : // Call the outside and inside surface heat balances
195 2568313 : if (state.dataHeatBalSurfMgr->ManageSurfaceHeatBalancefirstTime) DisplayString(state, "Calculate Outside Surface Heat Balance");
196 2568313 : CalcHeatBalanceOutsideSurf(state);
197 2568313 : if (state.dataHeatBalSurfMgr->ManageSurfaceHeatBalancefirstTime) DisplayString(state, "Calculate Inside Surface Heat Balance");
198 2568313 : CalcHeatBalanceInsideSurf(state);
199 :
200 : // The air heat balance must be called before the temperature history
201 : // updates because there may be a radiant system in the building
202 2568313 : if (state.dataHeatBalSurfMgr->ManageSurfaceHeatBalancefirstTime) DisplayString(state, "Calculate Air Heat Balance");
203 2568313 : ManageAirHeatBalance(state);
204 :
205 : // IF NECESSARY, do one final "average" heat balance pass. This is only
206 : // necessary if a radiant system is present and it was actually on for
207 : // part or all of the time step.
208 2568313 : UpdateFinalSurfaceHeatBalance(state);
209 :
210 : // Before we leave the Surface Manager the thermal histories need to be updated
211 2568313 : if (state.dataHeatBal->AnyCTF || state.dataHeatBal->AnyEMPD) {
212 2417443 : UpdateThermalHistories(state); // Update the thermal histories
213 : }
214 :
215 2568313 : if (state.dataHeatBal->AnyCondFD) {
216 1759149 : for (int SurfNum = 1; SurfNum <= state.dataSurface->TotSurfaces; ++SurfNum) {
217 1625106 : int const ConstrNum = Surface(SurfNum).Construction;
218 1625106 : if (ConstrNum <= 0) continue; // Shading surface, not really a heat transfer surface
219 1625106 : if (state.dataConstruction->Construct(ConstrNum).TypeIsWindow) continue; // Windows simulated in Window module
220 1557822 : if (Surface(SurfNum).HeatTransferAlgorithm != DataSurfaces::HeatTransferModel::CondFD) continue;
221 1507392 : state.dataHeatBalFiniteDiffMgr->SurfaceFD(SurfNum).UpdateMoistureBalance();
222 : }
223 : }
224 :
225 2568313 : ManageThermalComfort(state, false); // "Record keeping" for the zone
226 :
227 2568313 : ReportSurfaceHeatBalance(state);
228 2568313 : if (state.dataGlobal->ZoneSizingCalc) GatherComponentLoadsSurface(state);
229 :
230 2568313 : CalcThermalResilience(state);
231 :
232 2568313 : if (state.dataOutRptTab->displayThermalResilienceSummary) {
233 942558 : ReportThermalResilience(state);
234 : }
235 :
236 2568313 : if (state.dataOutRptTab->displayCO2ResilienceSummary) {
237 17922 : ReportCO2Resilience(state);
238 : }
239 :
240 2568313 : if (state.dataOutRptTab->displayVisualResilienceSummary) {
241 90411 : ReportVisualResilience(state);
242 : }
243 :
244 2568313 : state.dataHeatBalSurfMgr->ManageSurfaceHeatBalancefirstTime = false;
245 2568313 : }
246 :
247 : // Beginning Initialization Section of the Module
248 : //******************************************************************************
249 :
250 2568509 : void InitSurfaceHeatBalance(EnergyPlusData &state)
251 : {
252 :
253 : // SUBROUTINE INFORMATION:
254 : // AUTHOR Richard J. Liesen
255 : // DATE WRITTEN January 1998
256 : // MODIFIED Nov. 1999, FCW,
257 : // Move ComputeIntThermalAbsorpFactors
258 : // so called every timestep
259 : // MODIFIED Aug. 2017
260 : // Add initializations of surface data to linked air node value if defined
261 :
262 : // PURPOSE OF THIS SUBROUTINE:
263 : // This subroutine is for surface initializations within the
264 : // heat balance.
265 :
266 : // METHODOLOGY EMPLOYED:
267 : // Uses the status flags to trigger record keeping events.
268 :
269 : // Using/Aliasing
270 : using namespace SolarShading;
271 : using ConvectionCoefficients::InitInteriorConvectionCoeffs;
272 : using HeatBalanceIntRadExchange::CalcInteriorRadExchange;
273 : using HeatBalFiniteDiffManager::InitHeatBalFiniteDiff;
274 : using InternalHeatGains::ManageInternalHeatGains;
275 :
276 2568509 : auto &Surface(state.dataSurface->Surface);
277 :
278 2568509 : if (state.dataHeatBalSurfMgr->InitSurfaceHeatBalancefirstTime) DisplayString(state, "Initializing Outdoor environment for Surfaces");
279 :
280 : // set zone level wind dir to global value
281 : // Initialize zone outdoor environmental variables
282 : // Bulk Initialization for Temperatures & WindSpeed
283 : // using the zone, modify the zone Dry/Wet BulbTemps
284 :
285 : // DO ZoneNum = 1, NumOfZones
286 : // Zone(ZoneNum)%WindSpeed = WindSpeedAt(Zone(ZoneNum)%Centroid%z)
287 : // END DO
288 :
289 : // Initialize surface outdoor environmental variables
290 : // Bulk Initialization for Temperatures & WindSpeed
291 : // using the surface centroids, modify the surface Dry/Wet BulbTemps
292 2568509 : SetSurfaceOutBulbTempAt(state);
293 2568509 : CheckSurfaceOutBulbTempAt(state);
294 :
295 2568509 : SetSurfaceWindSpeedAt(state);
296 2568509 : SetSurfaceWindDirAt(state);
297 : // DO SurfNum = 1, TotSurfaces
298 : // IF (Surface(SurfNum)%ExtWind) Surface(SurfNum)%WindSpeed = WindSpeedAt(Surface(SurfNum)%Centroid%z)
299 : // END DO
300 2568509 : if (state.dataGlobal->AnyLocalEnvironmentsInModel) {
301 620862 : for (int SurfNum = 1; SurfNum <= state.dataSurface->TotSurfaces; ++SurfNum) {
302 613426 : if (state.dataSurface->Surface(SurfNum).SurfLinkedOutAirNode > 0) {
303 2706 : auto &linkedNode = state.dataLoopNodes->Node(state.dataSurface->Surface(SurfNum).SurfLinkedOutAirNode);
304 2706 : state.dataSurface->SurfOutDryBulbTemp(SurfNum) = linkedNode.OutAirDryBulb;
305 2706 : state.dataSurface->SurfOutWetBulbTemp(SurfNum) = linkedNode.OutAirWetBulb;
306 2706 : state.dataSurface->SurfOutWindSpeed(SurfNum) = linkedNode.OutAirWindSpeed;
307 2706 : state.dataSurface->SurfOutWindDir(SurfNum) = linkedNode.OutAirWindDir;
308 : }
309 : }
310 : }
311 : // Overwriting surface and zone level environmental data with EMS override value
312 2568509 : if (state.dataGlobal->AnyEnergyManagementSystemInModel) {
313 38237398 : for (int SurfNum = 1; SurfNum <= state.dataSurface->TotSurfaces; ++SurfNum) {
314 37956507 : if (state.dataSurface->SurfOutDryBulbTempEMSOverrideOn(SurfNum)) {
315 0 : state.dataSurface->SurfOutDryBulbTemp(SurfNum) = state.dataSurface->SurfOutDryBulbTempEMSOverrideValue(SurfNum);
316 : }
317 37956507 : if (state.dataSurface->SurfOutWetBulbTempEMSOverrideOn(SurfNum)) {
318 0 : state.dataSurface->SurfOutWetBulbTemp(SurfNum) = state.dataSurface->SurfOutWetBulbTempEMSOverrideValue(SurfNum);
319 : }
320 37956507 : if (state.dataSurface->SurfWindSpeedEMSOverrideOn(SurfNum)) {
321 0 : state.dataSurface->SurfOutWindSpeed(SurfNum) = state.dataSurface->SurfWindSpeedEMSOverrideValue(SurfNum);
322 : }
323 37956507 : if (state.dataSurface->SurfWindDirEMSOverrideOn(SurfNum)) {
324 0 : state.dataSurface->SurfOutWindDir(SurfNum) = state.dataSurface->SurfWindDirEMSOverrideValue(SurfNum);
325 : }
326 37956507 : if (state.dataSurface->SurfViewFactorGroundEMSOverrideOn(SurfNum)) {
327 0 : Surface(SurfNum).ViewFactorGround = state.dataSurface->SurfViewFactorGroundEMSOverrideValue(SurfNum);
328 : }
329 : }
330 : }
331 :
332 : // Do the Begin Simulation initializations
333 2568509 : if (state.dataGlobal->BeginSimFlag) {
334 771 : AllocateSurfaceHeatBalArrays(state); // Allocate the Module Arrays before any inits take place
335 771 : state.dataHeatBalSurf->InterZoneWindow =
336 1542 : std::any_of(state.dataViewFactor->EnclSolInfo.begin(),
337 1542 : state.dataViewFactor->EnclSolInfo.end(),
338 4810 : [](DataViewFactorInformation::EnclosureViewFactorInformation const &e) { return e.HasInterZoneWindow; });
339 : }
340 2568509 : if (state.dataGlobal->BeginSimFlag || state.dataGlobal->AnySurfPropOverridesInModel) {
341 5585 : for (int zoneNum = 1; zoneNum <= state.dataGlobal->NumOfZones; ++zoneNum) {
342 9632 : for (int spaceNum : state.dataHeatBal->Zone(zoneNum).spaceIndexes) {
343 4818 : auto &thisSpace = state.dataHeatBal->space(spaceNum);
344 4818 : int const firstSurf = thisSpace.HTSurfaceFirst;
345 4818 : int const lastSurf = thisSpace.HTSurfaceLast;
346 47024 : for (int SurfNum = firstSurf; SurfNum <= lastSurf; ++SurfNum) {
347 42206 : int ConstrNum = state.dataSurface->SurfActiveConstruction(SurfNum); // SurfActiveConstruction set above
348 42206 : state.dataHeatBalSurf->SurfAbsSolarInt(SurfNum) = state.dataConstruction->Construct(ConstrNum).InsideAbsorpSolar;
349 42206 : state.dataHeatBalSurf->SurfAbsThermalInt(SurfNum) = state.dataConstruction->Construct(ConstrNum).InsideAbsorpThermal;
350 42206 : state.dataHeatBalSurf->SurfRoughnessExt(SurfNum) = state.dataConstruction->Construct(ConstrNum).OutsideRoughness;
351 42206 : state.dataHeatBalSurf->SurfAbsSolarExt(SurfNum) = state.dataConstruction->Construct(ConstrNum).OutsideAbsorpSolar;
352 42206 : state.dataHeatBalSurf->SurfAbsThermalExt(SurfNum) = state.dataConstruction->Construct(ConstrNum).OutsideAbsorpThermal;
353 : }
354 : }
355 : }
356 : }
357 :
358 : // Do the Begin Environment initializations
359 2568509 : if (state.dataGlobal->BeginEnvrnFlag) {
360 6218 : if (state.dataHeatBalSurfMgr->InitSurfaceHeatBalancefirstTime) DisplayString(state, "Initializing Temperature and Flux Histories");
361 6218 : InitThermalAndFluxHistories(state); // Set initial temperature and flux histories
362 : }
363 :
364 : // Calc movable insulation properties
365 2568509 : if (state.dataSurface->AnyMovableInsulation) {
366 10122 : EvalOutsideMovableInsulation(state);
367 10122 : EvalInsideMovableInsulation(state);
368 : }
369 :
370 : // There are no daily initializations done in this portion of the surface heat balance
371 :
372 : // There are no hourly initializations done in this portion of the surface heat balance
373 :
374 2568509 : GetGroundSurfacesReflectanceAverage(state);
375 :
376 : // Need to be called each timestep in order to check if surface points to new construction (EMS) and if does then
377 : // complex fenestration needs to be initialized for additional states
378 2568509 : TimestepInitComplexFenestration(state);
379 :
380 : // Calculate exterior-surface multipliers that account for anisotropy of
381 : // sky radiance
382 2568509 : if (state.dataEnvrn->SunIsUp && state.dataEnvrn->DifSolarRad > 0.0) {
383 821926 : AnisoSkyViewFactors(state);
384 : } else {
385 1746583 : state.dataSolarShading->SurfAnisoSkyMult = 0.0;
386 : }
387 :
388 : // Set shading flag for exterior windows (except flags related to daylighting) and
389 : // window construction (unshaded or shaded) to be used in heat balance calculation
390 2568509 : if (state.dataHeatBalSurfMgr->InitSurfaceHeatBalancefirstTime) DisplayString(state, "Initializing Window Shading");
391 :
392 2568509 : WindowShadingManager(state);
393 :
394 2568509 : CheckGlazingShadingStatusChange(state);
395 :
396 : // Calculate factors that are used to determine how much long-wave radiation from internal
397 : // gains is absorbed by interior surfaces
398 2568509 : if (state.dataHeatBalSurfMgr->InitSurfaceHeatBalancefirstTime) DisplayString(state, "Computing Interior Absorption Factors");
399 2568509 : if (state.dataHeatBalSurfMgr->InitSurfaceHeatBalancefirstTime) HeatBalanceIntRadExchange::InitInteriorRadExchange(state);
400 2568509 : ComputeIntThermalAbsorpFactors(state);
401 :
402 : // Calculate factors for diffuse solar absorbed by room surfaces and interior shades
403 2568509 : if (state.dataHeatBalSurfMgr->InitSurfaceHeatBalancefirstTime) DisplayString(state, "Computing Interior Diffuse Solar Absorption Factors");
404 2568509 : ComputeIntSWAbsorpFactors(state);
405 :
406 2568509 : if (state.dataHeatBalSurf->InterZoneWindow) {
407 12147 : if (state.dataHeatBalSurfMgr->InitSurfaceHeatBalancefirstTime) {
408 6 : DisplayString(state, "Computing Interior Diffuse Solar Exchange through Interzone Windows");
409 : }
410 12147 : ComputeDifSolExcZonesWIZWindows(state, state.dataGlobal->NumOfZones);
411 : }
412 :
413 2568509 : DaylightingManager::initDaylighting(state, state.dataHeatBalSurfMgr->InitSurfaceHeatBalancefirstTime);
414 :
415 2568509 : CalcInteriorRadExchange(state, state.dataHeatBalSurf->SurfInsideTempHist(1), 0, state.dataHeatBalSurf->SurfQdotRadNetLWInPerArea, _, "Main");
416 :
417 2568509 : if (state.dataSurface->AirflowWindows) WindowGapAirflowControl(state);
418 :
419 : // The order of these initializations is important currently. Over time we hope to
420 : // take the appropriate parts of these inits to the other heat balance managers
421 2568509 : if (state.dataHeatBalSurfMgr->InitSurfaceHeatBalancefirstTime) DisplayString(state, "Initializing Solar Heat Gains");
422 :
423 2568509 : InitSolarHeatGains(state);
424 :
425 2568509 : DaylightingManager::manageDaylighting(state);
426 :
427 2568509 : if (state.dataHeatBalSurfMgr->InitSurfaceHeatBalancefirstTime) DisplayString(state, "Initializing Internal Heat Gains");
428 2568509 : ManageInternalHeatGains(state, false);
429 2568509 : if (state.dataHeatBalSurfMgr->InitSurfaceHeatBalancefirstTime) DisplayString(state, "Initializing Interior Solar Distribution");
430 2568509 : InitIntSolarDistribution(state);
431 :
432 2568509 : if (state.dataHeatBalSurfMgr->InitSurfaceHeatBalancefirstTime) DisplayString(state, "Initializing Interior Convection Coefficients");
433 2568509 : InitInteriorConvectionCoeffs(state, state.dataHeatBalSurf->SurfTempInTmp);
434 :
435 2568509 : if (state.dataGlobal->BeginSimFlag) { // Now's the time to report surfaces, if desired
436 : // if (firstTime) CALL DisplayString('Reporting Surfaces')
437 : // CALL ReportSurfaces
438 771 : if (state.dataHeatBalSurfMgr->InitSurfaceHeatBalancefirstTime) DisplayString(state, "Gathering Information for Predefined Reporting");
439 771 : GatherForPredefinedReport(state);
440 : }
441 :
442 : // Initialize the temperature history terms for conduction through the surfaces
443 2568509 : if (state.dataHeatBal->AnyCondFD) {
444 134043 : InitHeatBalFiniteDiff(state);
445 : }
446 :
447 21015074 : for (int zoneNum = 1; zoneNum <= state.dataGlobal->NumOfZones; ++zoneNum) { // Loop through all surfaces...
448 36909306 : for (int spaceNum : state.dataHeatBal->Zone(zoneNum).spaceIndexes) {
449 18462741 : auto &thisSpace = state.dataHeatBal->space(spaceNum);
450 18462741 : int const firstSurfOpaque = thisSpace.OpaqOrIntMassSurfaceFirst;
451 18462741 : int const lastSurfOpaque = thisSpace.OpaqOrIntMassSurfaceLast;
452 156163195 : for (int SurfNum = firstSurfOpaque; SurfNum <= lastSurfOpaque; ++SurfNum) {
453 137700454 : auto const &surface(Surface(SurfNum));
454 139630006 : if (surface.HeatTransferAlgorithm != DataSurfaces::HeatTransferModel::CTF &&
455 1929552 : surface.HeatTransferAlgorithm != DataSurfaces::HeatTransferModel::EMPD)
456 1779534 : continue;
457 : // Outside surface temp of "normal" windows not needed in Window5 calculation approach
458 : // Window layer temperatures are calculated in CalcHeatBalanceInsideSurf
459 :
460 135920920 : int const ConstrNum = surface.Construction;
461 135920920 : auto const &construct(state.dataConstruction->Construct(ConstrNum));
462 135920920 : state.dataHeatBalSurf->SurfCTFConstOutPart(SurfNum) = 0.0;
463 135920920 : state.dataHeatBalSurf->SurfCTFConstInPart(SurfNum) = 0.0;
464 135920920 : if (construct.NumCTFTerms <= 1) continue;
465 :
466 975615007 : for (int Term = 1; Term <= construct.NumCTFTerms; ++Term) {
467 : // [ l11 ] == ( 1, Term + 1, SurfNum ), [ l12 ] == ( 1, Term + 1, SurfNum )
468 :
469 : // Sign convention for the various terms in the following two equations
470 : // is based on the form of the Conduction Transfer Function equation
471 : // given by:
472 : // Qin,now = (Sum of)(Y Tout) - (Sum of)(Z Tin) + (Sum of)(F Qin,old)
473 : // Qout,now = (Sum of)(X Tout) - (Sum of)(Y Tin) + (Sum of)(F Qout,old)
474 : // In both equations, flux is positive from outside to inside.
475 :
476 : // Tuned Aliases and linear indexing
477 848451607 : Real64 const ctf_cross(construct.CTFCross(Term));
478 :
479 848451607 : Real64 const TH11(state.dataHeatBalSurf->SurfOutsideTempHist(Term + 1)(SurfNum));
480 848451607 : Real64 const TH12(state.dataHeatBalSurf->SurfInsideTempHist(Term + 1)(SurfNum));
481 848451607 : Real64 const QH11(state.dataHeatBalSurf->SurfOutsideFluxHist(Term + 1)(SurfNum));
482 848451607 : Real64 const QH12(state.dataHeatBalSurf->SurfInsideFluxHist(Term + 1)(SurfNum));
483 848451607 : state.dataHeatBalSurf->SurfCTFConstInPart(SurfNum) +=
484 848451607 : ctf_cross * TH11 - construct.CTFInside(Term) * TH12 + construct.CTFFlux(Term) * QH12;
485 :
486 848451607 : state.dataHeatBalSurf->SurfCTFConstOutPart(SurfNum) +=
487 848451607 : construct.CTFOutside(Term) * TH11 - ctf_cross * TH12 + construct.CTFFlux(Term) * QH11;
488 : }
489 : }
490 : }
491 : }
492 2568509 : if (state.dataHeatBal->AnyInternalHeatSourceInInput) {
493 648666 : for (int zoneNum = 1; zoneNum <= state.dataGlobal->NumOfZones; ++zoneNum) { // Loop through all surfaces...
494 979074 : for (int spaceNum : state.dataHeatBal->Zone(zoneNum).spaceIndexes) {
495 489537 : auto &thisSpace = state.dataHeatBal->space(spaceNum);
496 489537 : int const firstSurfOpaque = thisSpace.OpaqOrIntMassSurfaceFirst;
497 489537 : int const lastSurfOpaque = thisSpace.OpaqOrIntMassSurfaceLast;
498 3788271 : for (int SurfNum = firstSurfOpaque; SurfNum <= lastSurfOpaque; ++SurfNum) {
499 3298734 : auto const &surface(Surface(SurfNum));
500 3298734 : int const ConstrNum = surface.Construction;
501 3298734 : auto const &construct(state.dataConstruction->Construct(ConstrNum));
502 3298734 : if (!construct.SourceSinkPresent) continue;
503 721944 : if (surface.HeatTransferAlgorithm != DataSurfaces::HeatTransferModel::CTF &&
504 161478 : surface.HeatTransferAlgorithm != DataSurfaces::HeatTransferModel::EMPD)
505 161478 : continue;
506 398988 : state.dataHeatBalFanSys->CTFTsrcConstPart(SurfNum) = 0.0;
507 398988 : state.dataHeatBalFanSys->CTFTuserConstPart(SurfNum) = 0.0;
508 398988 : if (construct.NumCTFTerms <= 1) continue;
509 4391586 : for (int Term = 1; Term <= construct.NumCTFTerms; ++Term) {
510 3992598 : Real64 const TH11(state.dataHeatBalSurf->SurfOutsideTempHist(Term + 1)(SurfNum));
511 3992598 : Real64 const TH12(state.dataHeatBalSurf->SurfInsideTempHist(Term + 1)(SurfNum));
512 3992598 : Real64 const QsrcHist1(state.dataHeatBalSurf->SurfQsrcHist(SurfNum, Term + 1));
513 :
514 3992598 : state.dataHeatBalSurf->SurfCTFConstInPart(SurfNum) += construct.CTFSourceIn(Term) * QsrcHist1;
515 :
516 3992598 : state.dataHeatBalSurf->SurfCTFConstOutPart(SurfNum) += construct.CTFSourceOut(Term) * QsrcHist1;
517 :
518 3992598 : state.dataHeatBalFanSys->CTFTsrcConstPart(SurfNum) +=
519 7985196 : construct.CTFTSourceOut(Term) * TH11 + construct.CTFTSourceIn(Term) * TH12 + construct.CTFTSourceQ(Term) * QsrcHist1 +
520 3992598 : construct.CTFFlux(Term) * state.dataHeatBalSurf->SurfTsrcHist(SurfNum, Term + 1);
521 :
522 3992598 : state.dataHeatBalFanSys->CTFTuserConstPart(SurfNum) +=
523 7985196 : construct.CTFTUserOut(Term) * TH11 + construct.CTFTUserIn(Term) * TH12 + construct.CTFTUserSource(Term) * QsrcHist1 +
524 3992598 : construct.CTFFlux(Term) * state.dataHeatBalSurf->SurfTuserHist(SurfNum, Term + 1);
525 : }
526 : }
527 : } // ...end of surfaces DO loop for initializing temperature history terms for the surface heat balances
528 : }
529 : }
530 :
531 : // Zero out all of the radiant system heat balance coefficient arrays
532 21015074 : for (int zoneNum = 1; zoneNum <= state.dataGlobal->NumOfZones; ++zoneNum) { // Loop through all surfaces...
533 36909306 : for (int spaceNum : state.dataHeatBal->Zone(zoneNum).spaceIndexes) {
534 18462741 : auto &thisSpace = state.dataHeatBal->space(spaceNum);
535 18462741 : int const firstSurf = thisSpace.HTSurfaceFirst;
536 18462741 : int const lastSurf = thisSpace.HTSurfaceLast;
537 178178515 : for (int SurfNum = firstSurf; SurfNum <= lastSurf; ++SurfNum) {
538 159715774 : state.dataHeatBalFanSys->RadSysTiHBConstCoef(SurfNum) = 0.0;
539 159715774 : state.dataHeatBalFanSys->RadSysTiHBToutCoef(SurfNum) = 0.0;
540 159715774 : state.dataHeatBalFanSys->RadSysTiHBQsrcCoef(SurfNum) = 0.0;
541 159715774 : state.dataHeatBalFanSys->RadSysToHBConstCoef(SurfNum) = 0.0;
542 159715774 : state.dataHeatBalFanSys->RadSysToHBTinCoef(SurfNum) = 0.0;
543 159715774 : state.dataHeatBalFanSys->RadSysToHBQsrcCoef(SurfNum) = 0.0;
544 :
545 159715774 : state.dataHeatBalFanSys->QRadSysSource(SurfNum) = 0.0;
546 159715774 : state.dataHeatBalFanSys->QPVSysSource(SurfNum) = 0.0;
547 159715774 : state.dataHeatBalFanSys->SurfQHTRadSys(SurfNum) = 0.0;
548 159715774 : state.dataHeatBalFanSys->SurfQHWBaseboard(SurfNum) = 0.0;
549 159715774 : state.dataHeatBalFanSys->SurfQSteamBaseboard(SurfNum) = 0.0;
550 159715774 : state.dataHeatBalFanSys->SurfQElecBaseboard(SurfNum) = 0.0;
551 159715774 : state.dataHeatBalFanSys->SurfQCoolingPanel(SurfNum) = 0.0;
552 159715774 : state.dataHeatBalFanSys->QPoolSurfNumerator(SurfNum) = 0.0;
553 159715774 : state.dataHeatBalFanSys->PoolHeatTransCoefs(SurfNum) = 0.0;
554 : } // ...end of Zone Surf loop
555 : }
556 : } // ...end of Zone loop
557 :
558 2568509 : if (state.dataGlobal->ZoneSizingCalc) GatherComponentLoadsSurfAbsFact(state);
559 :
560 2568509 : if (state.dataHeatBalSurfMgr->InitSurfaceHeatBalancefirstTime) {
561 771 : DisplayString(state, "Completed Initializing Surface Heat Balance");
562 : }
563 2568509 : state.dataHeatBalSurfMgr->InitSurfaceHeatBalancefirstTime = false;
564 2568509 : }
565 :
566 771 : void GatherForPredefinedReport(EnergyPlusData &state)
567 : {
568 :
569 : // SUBROUTINE INFORMATION:
570 : // AUTHOR Jason Glazer
571 : // DATE WRITTEN August 2006
572 : // MODIFIED na
573 : // RE-ENGINEERED na
574 :
575 : // PURPOSE OF THIS SUBROUTINE:
576 : // This subroutine reports the information for the predefined reports
577 : // related to envelope components.
578 :
579 : // METHODOLOGY EMPLOYED:
580 : // na
581 :
582 : // REFERENCES:
583 : // na
584 :
585 : // Using/Aliasing
586 : using namespace OutputReportPredefined;
587 : using WindowManager::CalcNominalWindowCond;
588 :
589 : // Locals
590 : // SUBROUTINE ARGUMENT DEFINITIONS:
591 : // na
592 :
593 : // SUBROUTINE PARAMETER DEFINITIONS:
594 : // na
595 :
596 : // INTERFACE BLOCK SPECIFICATIONS:
597 : // na
598 :
599 : // DERIVED TYPE DEFINITIONS:
600 : // na
601 :
602 : // SUBROUTINE LOCAL VARIABLE DECLARATIONS:
603 1542 : std::string surfName;
604 : int curCons;
605 : int zonePt;
606 : Real64 mult;
607 : Real64 curAzimuth;
608 : Real64 curTilt;
609 : Real64 windowArea;
610 : Real64 frameWidth;
611 : Real64 frameArea;
612 : Real64 dividerArea;
613 : // counts for object count report
614 771 : int SurfaceClassCount = int(SurfaceClass::Num);
615 1542 : Array1D_int numSurfaces(SurfaceClassCount);
616 1542 : Array1D_int numExtSurfaces(SurfaceClassCount);
617 : int frameDivNum;
618 : bool isExterior;
619 1542 : Array1D<Real64> computedNetArea; // holds the gross wall area minus the window and door areas
620 :
621 : // the following variables are for the CalcNominalWindowCond call but only SHGCSummer is needed
622 : Real64 nomCond;
623 : Real64 SHGCSummer;
624 : Real64 TransSolNorm;
625 : Real64 TransVisNorm;
626 : Real64 nomUfact;
627 : int errFlag;
628 : int curWSC;
629 : // following variables are totals for fenestration table
630 771 : Real64 windowAreaWMult(0.0);
631 771 : Real64 fenTotArea(0.0);
632 771 : Real64 fenTotAreaNorth(0.0);
633 771 : Real64 fenTotAreaNonNorth(0.0);
634 771 : Real64 ufactArea(0.0);
635 771 : Real64 ufactAreaNorth(0.0);
636 771 : Real64 ufactAreaNonNorth(0.0);
637 771 : Real64 shgcArea(0.0);
638 771 : Real64 shgcAreaNorth(0.0);
639 771 : Real64 shgcAreaNonNorth(0.0);
640 771 : Real64 vistranArea(0.0);
641 771 : Real64 vistranAreaNorth(0.0);
642 771 : Real64 vistranAreaNonNorth(0.0);
643 771 : Real64 intFenTotArea(0.0);
644 771 : Real64 intUfactArea(0.0);
645 771 : Real64 intShgcArea(0.0);
646 771 : Real64 intVistranArea(0.0);
647 : bool isNorth;
648 :
649 771 : constexpr std::array<std::string_view, static_cast<int>(WinShadingType::Num)> WindowShadingTypeNames = {
650 : "No Shade", // 0
651 : "Shade Off", // 1
652 : "Interior Shade",
653 : "Switchable Glazing",
654 : "Exterior Shade",
655 : "Exterior Screen",
656 : "Interior Blind",
657 : "Exterior Blind",
658 : "Between Glass Shade",
659 : "Between Glass Blind",
660 : };
661 :
662 771 : constexpr std::array<std::string_view, static_cast<int>(WindowShadingControlType::Num)> WindowShadingControlTypeNames = {
663 : "Uncontrolled",
664 : "AlwaysOn",
665 : "AlwaysOff",
666 : "OnIfScheduleAllows",
667 : "OnIfHighSolarOnWindow",
668 : "OnIfHighHorizontalSolar",
669 : "OnIfHighOutdoorAirTemperature",
670 : "OnIfHighZoneAirTemperature",
671 : "OnIfHighZoneCooling",
672 : "OnIfHighGlare",
673 : "MeetDaylightIlluminanceSetpoint",
674 : "OnNightIfLowOutdoorTempAndOffDay",
675 : "OnNightIfLowInsideTempAndOffDay",
676 : "OnNightIfHeatingAndOffDay",
677 : "OnNightIfLowOutdoorTempAndOnDayIfCooling",
678 : "OnNightIfHeatingAndOnDayIfCooling",
679 : "OffNightAndOnDayIfCoolingAndHighSolarOnWindow",
680 : "OnNightAndOnDayIfCoolingAndHighSolarOnWindow",
681 : "OnIfHighOutdoorAirTempAndHighSolarOnWindow",
682 : "OnIfHighOutdoorAirTempAndHighHorizontalSolar",
683 : "OnIfHighZoneAirTempAndHighSolarOnWindow",
684 : "OnIfHighZoneAirTempAndHighHorizontalSolar"};
685 :
686 771 : constexpr std::array<std::string_view, static_cast<int>(NfrcProductOptions::Num)> NfrcProductNames = {
687 : "CasementDouble", "CasementSingle", "DualAction",
688 : "Fixed", "Garage", "Greenhouse",
689 : "HingedEscape", "HorizontalSlider", "Jal",
690 : "Pivoted", "ProjectingSingle", "ProjectingDual",
691 : "DoorSidelite", "Skylight", "SlidingPatioDoor",
692 : "CurtainWall", "SpandrelPanel", "SideHingedDoor",
693 : "DoorTransom", "TropicalAwning", "TubularDaylightingDevice",
694 : "VerticalSlider"};
695 :
696 771 : constexpr std::array<Real64, static_cast<int>(NfrcProductOptions::Num)> NfrcWidth = {
697 : // width in meters from Table 4-3 of NFRC 100-2020
698 : 1.200, 0.600, 1.200, // CasementDouble, CasementSingle, DualAction,
699 : 1.200, 2.134, 1.500, // Fixed, Garage, Greenhouse,
700 : 1.500, 1.500, 1.200, // HingedEscape, HorizontalSlider, Jal,
701 : 1.200, 1.500, 1.500, // Pivoted, ProjectingSingle, ProjectingDual,
702 : 0.600, 1.200, 2.000, // DoorSidelite, Skylight, SlidingPatioDoor,
703 : 2.000, 2.000, 1.920, // CurtainWall, SpandrelPanel, SideHingedDoor,
704 : 2.000, 1.500, 0.350, // DoorTransom, TropicalAwning, TubularDaylightingDevice,
705 : 1.200 // VerticalSlider,
706 : };
707 :
708 771 : constexpr std::array<Real64, static_cast<int>(NfrcProductOptions::Num)> NfrcHeight = {
709 : // height in meters from Table 4-3 of NFRC 100-2020
710 : 1.500, 1.500, 1.500, // CasementDouble, CasementSingle, DualAction,
711 : 1.500, 2.134, 1.200, // Fixed, Garage, Greenhouse,
712 : 1.200, 1.200, 1.500, // HingedEscape, HorizontalSlider, Jal,
713 : 1.500, 1.200, 0.600, // Pivoted, ProjectingSingle, ProjectingDual,
714 : 2.090, 1.200, 2.000, // DoorSidelite, Skylight, SlidingPatioDoor,
715 : 2.000, 1.200, 2.090, // CurtainWall, SpandrelPanel, SideHingedDoor,
716 : 0.600, 1.200, 0.350, // DoorTransom, TropicalAwning, TubularDaylightingDevice,
717 : 1.500 // VerticalSlider,
718 : };
719 :
720 771 : constexpr std::array<NfrcVisionType, static_cast<int>(NfrcProductOptions::Num)> NfrcVision = {
721 : NfrcVisionType::DualHorizontal, NfrcVisionType::Single,
722 : NfrcVisionType::DualVertical, // CasementDouble, CasementSingle, DualAction,
723 : NfrcVisionType::Single, NfrcVisionType::Single,
724 : NfrcVisionType::Single, // Fixed, Garage, Greenhouse,
725 : NfrcVisionType::Single, NfrcVisionType::DualHorizontal,
726 : NfrcVisionType::Single, // HingedEscape, HorizontalSlider, Jal,
727 : NfrcVisionType::Single, NfrcVisionType::Single,
728 : NfrcVisionType::DualHorizontal, // Pivoted, ProjectingSingle, ProjectingDual,
729 : NfrcVisionType::Single, NfrcVisionType::Single,
730 : NfrcVisionType::DualHorizontal, // DoorSidelite, Skylight, SlidingPatioDoor,
731 : NfrcVisionType::Single, NfrcVisionType::Single,
732 : NfrcVisionType::Single, // CurtainWall, SpandrelPanel, SideHingedDoor,
733 : NfrcVisionType::Single, NfrcVisionType::Single,
734 : NfrcVisionType::Single, // DoorTransom, TropicalAwning, TubularDaylightingDevice,
735 : NfrcVisionType::DualVertical // VerticalSlider
736 : };
737 :
738 771 : auto &Surface(state.dataSurface->Surface);
739 :
740 771 : numSurfaces = 0;
741 771 : numExtSurfaces = 0;
742 :
743 771 : computedNetArea.allocate(state.dataSurface->TotSurfaces);
744 771 : computedNetArea = 0.0; // start at zero, add wall area and subtract window and door area
745 :
746 : // set up for EIO <FenestrationAssembly> output
747 771 : if (state.dataHeatBal->TotFrameDivider > 0 && state.dataGeneral->Constructions) {
748 18 : print(state.files.eio,
749 : "{}\n",
750 : "! <FenestrationAssembly>,Construction Name,Frame and Divider Name,NFRC Product Type,"
751 18 : "Assembly U-Factor {W/m2-K},Assembly SHGC,Assembly Visible Transmittance");
752 : }
753 : static constexpr std::string_view FenestrationAssemblyFormat("FenestrationAssembly,{},{},{},{:.3R},{:.3R},{:.3R}\n");
754 1542 : std::vector<std::pair<int, int>> uniqConsFrame;
755 771 : std::pair<int, int> consAndFrame;
756 :
757 : // set up for EIO <FenestrationShadedState> output
758 771 : bool fenestrationShadedStateHeaderShown(false);
759 : static constexpr std::string_view FenestrationShadedStateFormat("FenestrationShadedState,{},{:.3R},{:.3R},{:.3R},{},{},{:.3R},{:.3R},{:.3R}\n");
760 1542 : std::vector<std::pair<int, int>> uniqShdConsFrame;
761 771 : std::pair<int, int> shdConsAndFrame;
762 :
763 44533 : for (int iSurf : state.dataSurface->AllSurfaceListReportOrder) {
764 43762 : zonePt = Surface(iSurf).Zone;
765 : // only exterior surfaces including underground
766 135689 : if ((Surface(iSurf).ExtBoundCond == ExternalEnvironment) || (Surface(iSurf).ExtBoundCond == Ground) ||
767 89631 : (Surface(iSurf).ExtBoundCond == GroundFCfactorMethod) || (Surface(iSurf).ExtBoundCond == KivaFoundation)) {
768 20955 : isExterior = true;
769 20955 : switch (Surface(iSurf).Class) {
770 13065 : case SurfaceClass::Wall:
771 : case SurfaceClass::Floor:
772 : case SurfaceClass::Roof: {
773 13065 : surfName = Surface(iSurf).Name;
774 13065 : curCons = Surface(iSurf).Construction;
775 13065 : PreDefTableEntry(state, state.dataOutRptPredefined->pdchOpCons, surfName, state.dataConstruction->Construct(curCons).Name);
776 39195 : PreDefTableEntry(
777 26130 : state, state.dataOutRptPredefined->pdchOpRefl, surfName, 1 - state.dataConstruction->Construct(curCons).OutsideAbsorpSolar);
778 39195 : PreDefTableEntry(
779 26130 : state, state.dataOutRptPredefined->pdchOpUfactNoFilm, surfName, state.dataHeatBal->NominalU(Surface(iSurf).Construction), 3);
780 13065 : mult = state.dataHeatBal->Zone(zonePt).Multiplier * state.dataHeatBal->Zone(zonePt).ListMultiplier;
781 13065 : PreDefTableEntry(state, state.dataOutRptPredefined->pdchOpGrArea, surfName, Surface(iSurf).GrossArea * mult);
782 13065 : computedNetArea(iSurf) += Surface(iSurf).GrossArea * mult;
783 13065 : curAzimuth = Surface(iSurf).Azimuth;
784 : // Round to two decimals, like the display in tables
785 : // (PreDefTableEntry uses a fortran style write, that rounds rather than trim)
786 13065 : curAzimuth = round(curAzimuth * 100.0) / 100.0;
787 13065 : PreDefTableEntry(state, state.dataOutRptPredefined->pdchOpAzimuth, surfName, curAzimuth);
788 13065 : curTilt = Surface(iSurf).Tilt;
789 13065 : PreDefTableEntry(state, state.dataOutRptPredefined->pdchOpTilt, surfName, curTilt);
790 13065 : if ((curTilt >= 60.0) && (curTilt < 180.0)) {
791 8664 : if ((curAzimuth >= 315.0) || (curAzimuth < 45.0)) {
792 2240 : PreDefTableEntry(state, state.dataOutRptPredefined->pdchOpDir, surfName, "N");
793 6424 : } else if ((curAzimuth >= 45.0) && (curAzimuth < 135.0)) {
794 2053 : PreDefTableEntry(state, state.dataOutRptPredefined->pdchOpDir, surfName, "E");
795 4371 : } else if ((curAzimuth >= 135.0) && (curAzimuth < 225.0)) {
796 2250 : PreDefTableEntry(state, state.dataOutRptPredefined->pdchOpDir, surfName, "S");
797 2121 : } else if ((curAzimuth >= 225.0) && (curAzimuth < 315.0)) {
798 2121 : PreDefTableEntry(state, state.dataOutRptPredefined->pdchOpDir, surfName, "W");
799 : }
800 : }
801 13065 : } break;
802 5962 : case SurfaceClass::Window:
803 : case SurfaceClass::TDD_Dome: {
804 5962 : surfName = Surface(iSurf).Name;
805 5962 : curCons = Surface(iSurf).Construction;
806 5962 : PreDefTableEntry(state, state.dataOutRptPredefined->pdchFenCons, surfName, state.dataConstruction->Construct(curCons).Name);
807 5962 : zonePt = Surface(iSurf).Zone;
808 : // if the construction report is requested the SummerSHGC is already calculated
809 5962 : if (state.dataConstruction->Construct(curCons).SummerSHGC != 0) {
810 5328 : SHGCSummer = state.dataConstruction->Construct(curCons).SummerSHGC;
811 5328 : TransVisNorm = state.dataConstruction->Construct(curCons).VisTransNorm;
812 : } else {
813 : // must calculate Summer SHGC
814 634 : if (!state.dataConstruction->Construct(curCons).WindowTypeEQL) {
815 634 : CalcNominalWindowCond(state, curCons, 2, nomCond, SHGCSummer, TransSolNorm, TransVisNorm, errFlag);
816 634 : state.dataConstruction->Construct(curCons).SummerSHGC = SHGCSummer;
817 634 : state.dataConstruction->Construct(curCons).VisTransNorm = TransVisNorm;
818 634 : state.dataConstruction->Construct(curCons).SolTransNorm = TransSolNorm;
819 : }
820 : }
821 5962 : mult = state.dataHeatBal->Zone(zonePt).Multiplier * state.dataHeatBal->Zone(zonePt).ListMultiplier * Surface(iSurf).Multiplier;
822 : // include the frame area if present
823 5962 : windowArea = Surface(iSurf).GrossArea;
824 5962 : frameArea = 0.0;
825 5962 : dividerArea = 0.0;
826 5962 : frameDivNum = Surface(iSurf).FrameDivider;
827 5962 : if (frameDivNum != 0) {
828 381 : frameWidth = state.dataSurface->FrameDivider(frameDivNum).FrameWidth;
829 762 : frameArea = (Surface(iSurf).Height + 2.0 * frameWidth) * (Surface(iSurf).Width + 2.0 * frameWidth) -
830 381 : (Surface(iSurf).Height * Surface(iSurf).Width);
831 381 : windowArea += frameArea;
832 381 : dividerArea =
833 381 : state.dataSurface->FrameDivider(frameDivNum).DividerWidth *
834 762 : (state.dataSurface->FrameDivider(frameDivNum).HorDividers * Surface(iSurf).Width +
835 762 : state.dataSurface->FrameDivider(frameDivNum).VertDividers * Surface(iSurf).Height -
836 762 : state.dataSurface->FrameDivider(frameDivNum).HorDividers * state.dataSurface->FrameDivider(frameDivNum).VertDividers *
837 381 : state.dataSurface->FrameDivider(frameDivNum).DividerWidth);
838 762 : PreDefTableEntry(
839 762 : state, state.dataOutRptPredefined->pdchFenFrameDivName, surfName, state.dataSurface->FrameDivider(frameDivNum).Name);
840 1143 : PreDefTableEntry(state,
841 381 : state.dataOutRptPredefined->pdchFenFrameConductance,
842 : surfName,
843 381 : state.dataSurface->FrameDivider(frameDivNum).FrameConductance,
844 : 3);
845 1143 : PreDefTableEntry(state,
846 381 : state.dataOutRptPredefined->pdchFenDividerConductance,
847 : surfName,
848 381 : state.dataSurface->FrameDivider(frameDivNum).DividerConductance,
849 : 3);
850 :
851 : // report the selected NRFC product type (specific sizes) and the NFRC rating for the assembly (glass + frame + divider)
852 381 : std::string_view NFRCname = NfrcProductNames[static_cast<int>(state.dataSurface->FrameDivider(frameDivNum).NfrcProductType)];
853 381 : const auto windowWidth = NfrcWidth[static_cast<int>(state.dataSurface->FrameDivider(frameDivNum).NfrcProductType)];
854 381 : const auto windowHeight = NfrcHeight[static_cast<int>(state.dataSurface->FrameDivider(frameDivNum).NfrcProductType)];
855 381 : const auto vision = NfrcVision[static_cast<int>(state.dataSurface->FrameDivider(frameDivNum).NfrcProductType)];
856 :
857 381 : PreDefTableEntry(state, state.dataOutRptPredefined->pdchFenAssemNfrcType, surfName, NFRCname);
858 :
859 381 : Real64 uValueAssembly{0.0};
860 381 : Real64 shgcAssembly{0.0};
861 381 : Real64 vtAssembly{0.0};
862 :
863 381 : GetWindowAssemblyNfrcForReport(
864 381 : state, iSurf, Surface(iSurf).Construction, windowWidth, windowHeight, vision, uValueAssembly, shgcAssembly, vtAssembly);
865 381 : if (state.dataWindowManager->inExtWindowModel->isExternalLibraryModel()) {
866 0 : state.dataHeatBal->NominalU(Surface(iSurf).Construction) =
867 0 : GetIGUUValueForNFRCReport(state, iSurf, Surface(iSurf).Construction, windowWidth, windowHeight);
868 0 : SHGCSummer = GetSHGCValueForNFRCReporting(state, iSurf, Surface(iSurf).Construction, windowWidth, windowHeight);
869 : }
870 381 : PreDefTableEntry(state, state.dataOutRptPredefined->pdchFenAssemUfact, surfName, uValueAssembly, 3);
871 381 : PreDefTableEntry(state, state.dataOutRptPredefined->pdchFenAssemSHGC, surfName, shgcAssembly, 3);
872 381 : PreDefTableEntry(state, state.dataOutRptPredefined->pdchFenAssemVisTr, surfName, vtAssembly, 3);
873 :
874 : // output EIO <FenestrationAssembly> for each unique combination of construction and frame/divider
875 381 : if (state.dataGeneral->Constructions) {
876 340 : consAndFrame = std::make_pair(curCons, frameDivNum);
877 340 : if (std::find(uniqConsFrame.begin(), uniqConsFrame.end(), consAndFrame) == uniqConsFrame.end()) {
878 30 : uniqConsFrame.push_back(consAndFrame);
879 60 : print(state.files.eio,
880 : FenestrationAssemblyFormat,
881 30 : state.dataConstruction->Construct(curCons).Name,
882 30 : state.dataSurface->FrameDivider(frameDivNum).Name,
883 : NFRCname,
884 : uValueAssembly,
885 : shgcAssembly,
886 : vtAssembly);
887 : }
888 : }
889 : }
890 5962 : windowAreaWMult = windowArea * mult;
891 5962 : PreDefTableEntry(state, state.dataOutRptPredefined->pdchFenAreaOf1, surfName, windowArea);
892 5962 : PreDefTableEntry(state, state.dataOutRptPredefined->pdchFenFrameAreaOf1, surfName, frameArea);
893 5962 : PreDefTableEntry(state, state.dataOutRptPredefined->pdchFenDividerAreaOf1, surfName, dividerArea);
894 5962 : PreDefTableEntry(state, state.dataOutRptPredefined->pdchFenGlassAreaOf1, surfName, windowArea - (frameArea + dividerArea));
895 5962 : PreDefTableEntry(state, state.dataOutRptPredefined->pdchFenArea, surfName, windowAreaWMult);
896 5962 : computedNetArea(Surface(iSurf).BaseSurf) -= windowAreaWMult;
897 5962 : nomUfact = state.dataHeatBal->NominalU(Surface(iSurf).Construction);
898 5962 : PreDefTableEntry(state, state.dataOutRptPredefined->pdchFenUfact, surfName, nomUfact, 3);
899 :
900 5962 : PreDefTableEntry(state, state.dataOutRptPredefined->pdchFenSHGC, surfName, SHGCSummer, 3);
901 5962 : PreDefTableEntry(state, state.dataOutRptPredefined->pdchFenVisTr, surfName, TransVisNorm, 3);
902 5962 : PreDefTableEntry(state, state.dataOutRptPredefined->pdchFenParent, surfName, Surface(iSurf).BaseSurfName);
903 5962 : curAzimuth = Surface(iSurf).Azimuth;
904 : // Round to two decimals, like the display in tables
905 5962 : curAzimuth = round(curAzimuth * 100.0) / 100.0;
906 5962 : PreDefTableEntry(state, state.dataOutRptPredefined->pdchFenAzimuth, surfName, curAzimuth);
907 5962 : isNorth = false;
908 5962 : curTilt = Surface(iSurf).Tilt;
909 5962 : PreDefTableEntry(state, state.dataOutRptPredefined->pdchFenTilt, surfName, curTilt);
910 5962 : if ((curTilt >= 60.0) && (curTilt < 180.0)) {
911 5565 : if ((curAzimuth >= 315.0) || (curAzimuth < 45.0)) {
912 1397 : PreDefTableEntry(state, state.dataOutRptPredefined->pdchFenDir, surfName, "N");
913 1397 : isNorth = true;
914 4168 : } else if ((curAzimuth >= 45.0) && (curAzimuth < 135.0)) {
915 1011 : PreDefTableEntry(state, state.dataOutRptPredefined->pdchFenDir, surfName, "E");
916 3157 : } else if ((curAzimuth >= 135.0) && (curAzimuth < 225.0)) {
917 2155 : PreDefTableEntry(state, state.dataOutRptPredefined->pdchFenDir, surfName, "S");
918 1002 : } else if ((curAzimuth >= 225.0) && (curAzimuth < 315.0)) {
919 1002 : PreDefTableEntry(state, state.dataOutRptPredefined->pdchFenDir, surfName, "W");
920 : }
921 : }
922 :
923 : // Report table for every shading control state
924 5962 : const auto totalStates{Surface(iSurf).windowShadingControlList.size()};
925 5962 : if (frameDivNum != 0) {
926 422 : for (unsigned int i = 0; i < totalStates; ++i) {
927 41 : const auto windowWidth = NfrcWidth[static_cast<int>(state.dataSurface->FrameDivider(frameDivNum).NfrcProductType)];
928 41 : const auto windowHeight = NfrcHeight[static_cast<int>(state.dataSurface->FrameDivider(frameDivNum).NfrcProductType)];
929 41 : const auto vision = NfrcVision[static_cast<int>(state.dataSurface->FrameDivider(frameDivNum).NfrcProductType)];
930 :
931 41 : const int stateConstrNum = Surface(iSurf).shadedConstructionList[i];
932 41 : const auto stateUValue{GetIGUUValueForNFRCReport(state, iSurf, stateConstrNum, windowWidth, windowHeight)};
933 41 : const auto stateSHGC{GetSHGCValueForNFRCReporting(state, iSurf, stateConstrNum, windowWidth, windowHeight)};
934 41 : std::string const &constructionName{state.dataConstruction->Construct(stateConstrNum).Name};
935 :
936 82 : PreDefTableEntry(state,
937 41 : state.dataOutRptPredefined->pdchFenShdFrameDiv,
938 : constructionName,
939 41 : state.dataSurface->FrameDivider(frameDivNum).Name);
940 41 : PreDefTableEntry(state, state.dataOutRptPredefined->pdchFenShdUfact, constructionName, stateUValue, 3);
941 41 : PreDefTableEntry(state, state.dataOutRptPredefined->pdchFenShdSHGC, constructionName, stateSHGC, 3);
942 123 : PreDefTableEntry(state,
943 41 : state.dataOutRptPredefined->pdchFenShdVisTr,
944 : constructionName,
945 41 : state.dataConstruction->Construct(stateConstrNum).VisTransNorm,
946 : 3);
947 :
948 41 : Real64 stateAssemblyUValue{0.0};
949 41 : Real64 stateAssemblySHGC{0.0};
950 41 : Real64 stateAssemblyVT{0.0};
951 :
952 41 : GetWindowAssemblyNfrcForReport(
953 : state, iSurf, stateConstrNum, windowWidth, windowHeight, vision, stateAssemblyUValue, stateAssemblySHGC, stateAssemblyVT);
954 :
955 41 : std::string_view NFRCname = NfrcProductNames[static_cast<int>(state.dataSurface->FrameDivider(frameDivNum).NfrcProductType)];
956 41 : PreDefTableEntry(state, state.dataOutRptPredefined->pdchFenShdAssemNfrcType, constructionName, NFRCname);
957 :
958 41 : PreDefTableEntry(state, state.dataOutRptPredefined->pdchFenShdAssemUfact, constructionName, stateAssemblyUValue, 3);
959 41 : PreDefTableEntry(state, state.dataOutRptPredefined->pdchFenShdAssemSHGC, constructionName, stateAssemblySHGC, 3);
960 41 : PreDefTableEntry(state, state.dataOutRptPredefined->pdchFenShdAssemVisTr, constructionName, stateAssemblyVT, 3);
961 :
962 41 : if (state.dataGeneral->Constructions) {
963 23 : if (!fenestrationShadedStateHeaderShown) {
964 4 : print(state.files.eio,
965 : "{}\n",
966 : "! <FenestrationShadedState>,Construction Name,Glass U-Factor {W/m2-K},"
967 : "Glass SHGC, Glass Visible Transmittance, Frame and Divider Name,NFRC Product Type,"
968 4 : "Assembly U-Factor {W/m2-K},Assembly SHGC,Assembly Visible Transmittance");
969 4 : fenestrationShadedStateHeaderShown = true;
970 : }
971 :
972 46 : shdConsAndFrame = std::make_pair(stateConstrNum, frameDivNum);
973 23 : if (std::find(uniqShdConsFrame.begin(), uniqShdConsFrame.end(), shdConsAndFrame) == uniqShdConsFrame.end()) {
974 14 : uniqShdConsFrame.push_back(shdConsAndFrame);
975 28 : print(state.files.eio,
976 : FenestrationShadedStateFormat,
977 : constructionName,
978 : stateUValue,
979 : stateSHGC,
980 14 : state.dataConstruction->Construct(stateConstrNum).VisTransNorm,
981 14 : state.dataSurface->FrameDivider(frameDivNum).Name,
982 : NFRCname,
983 : stateAssemblyUValue,
984 : stateAssemblySHGC,
985 : stateAssemblyVT);
986 : }
987 : }
988 : }
989 : }
990 :
991 5962 : curWSC = Surface(iSurf).activeWindowShadingControl;
992 : // compute totals for area weighted averages
993 5962 : fenTotArea += windowAreaWMult;
994 5962 : ufactArea += nomUfact * windowAreaWMult;
995 5962 : shgcArea += SHGCSummer * windowAreaWMult;
996 5962 : vistranArea += TransVisNorm * windowAreaWMult;
997 5962 : if (isNorth) {
998 1397 : fenTotAreaNorth += windowAreaWMult;
999 1397 : ufactAreaNorth += nomUfact * windowAreaWMult;
1000 1397 : shgcAreaNorth += SHGCSummer * windowAreaWMult;
1001 1397 : vistranAreaNorth += TransVisNorm * windowAreaWMult;
1002 : } else {
1003 4565 : fenTotAreaNonNorth += windowAreaWMult;
1004 4565 : ufactAreaNonNorth += nomUfact * windowAreaWMult;
1005 4565 : shgcAreaNonNorth += SHGCSummer * windowAreaWMult;
1006 4565 : vistranAreaNonNorth += TransVisNorm * windowAreaWMult;
1007 : }
1008 : // shading
1009 5962 : if (Surface(iSurf).HasShadeControl) {
1010 143 : PreDefTableEntry(state, state.dataOutRptPredefined->pdchFenSwitchable, surfName, "Yes");
1011 143 : PreDefTableEntry(state, state.dataOutRptPredefined->pdchWscName, surfName, state.dataSurface->WindowShadingControl(curWSC).Name);
1012 : // shading report
1013 286 : PreDefTableEntry(state,
1014 143 : state.dataOutRptPredefined->pdchWscShading,
1015 : surfName,
1016 143 : WindowShadingTypeNames[int(state.dataSurface->WindowShadingControl(curWSC).ShadingType)]);
1017 286 : PreDefTableEntry(state,
1018 143 : state.dataOutRptPredefined->pdchWscControl,
1019 : surfName,
1020 143 : WindowShadingControlTypeNames[int(state.dataSurface->WindowShadingControl(curWSC).shadingControlType)]);
1021 :
1022 : // output list of all possible shading contructions for shaded windows including those with storms
1023 286 : std::string names = "";
1024 290 : for (auto construction : Surface(iSurf).shadedConstructionList) {
1025 147 : if (!names.empty()) names.append("; ");
1026 147 : names.append(state.dataConstruction->Construct(construction).Name);
1027 : }
1028 143 : for (auto construction : Surface(iSurf).shadedStormWinConstructionList) {
1029 0 : if (!names.empty()) names.append("; ");
1030 0 : names.append(state.dataConstruction->Construct(construction).Name);
1031 : }
1032 143 : PreDefTableEntry(state, state.dataOutRptPredefined->pdchWscShadCons, surfName, names);
1033 :
1034 143 : if (state.dataSurface->WindowShadingControl(curWSC).GlareControlIsActive) {
1035 30 : PreDefTableEntry(state, state.dataOutRptPredefined->pdchWscGlare, surfName, "Yes");
1036 : } else {
1037 113 : PreDefTableEntry(state, state.dataOutRptPredefined->pdchWscGlare, surfName, "No");
1038 : }
1039 : } else {
1040 5819 : PreDefTableEntry(state, state.dataOutRptPredefined->pdchFenSwitchable, surfName, "No");
1041 : }
1042 5962 : } break;
1043 386 : case SurfaceClass::Door: {
1044 386 : surfName = Surface(iSurf).Name;
1045 386 : curCons = Surface(iSurf).Construction;
1046 386 : PreDefTableEntry(state, state.dataOutRptPredefined->pdchDrCons, surfName, state.dataConstruction->Construct(curCons).Name);
1047 1158 : PreDefTableEntry(
1048 772 : state, state.dataOutRptPredefined->pdchDrUfactNoFilm, surfName, state.dataHeatBal->NominalU(Surface(iSurf).Construction), 3);
1049 386 : mult = state.dataHeatBal->Zone(zonePt).Multiplier * state.dataHeatBal->Zone(zonePt).ListMultiplier;
1050 386 : PreDefTableEntry(state, state.dataOutRptPredefined->pdchDrGrArea, surfName, Surface(iSurf).GrossArea * mult);
1051 386 : PreDefTableEntry(state, state.dataOutRptPredefined->pdchDrParent, surfName, Surface(iSurf).BaseSurfName);
1052 386 : computedNetArea(Surface(iSurf).BaseSurf) -= Surface(iSurf).GrossArea * mult;
1053 386 : } break;
1054 1542 : default:
1055 1542 : break;
1056 : }
1057 : } else {
1058 : // interior surfaces
1059 22807 : isExterior = false;
1060 61315 : if ((Surface(iSurf).Class == SurfaceClass::Wall) || (Surface(iSurf).Class == SurfaceClass::Floor) ||
1061 30896 : (Surface(iSurf).Class == SurfaceClass::Roof) || (Surface(iSurf).Class == SurfaceClass::IntMass)) {
1062 22713 : surfName = Surface(iSurf).Name;
1063 22713 : curCons = Surface(iSurf).Construction;
1064 22713 : PreDefTableEntry(state, state.dataOutRptPredefined->pdchIntOpCons, surfName, state.dataConstruction->Construct(curCons).Name);
1065 68139 : PreDefTableEntry(
1066 45426 : state, state.dataOutRptPredefined->pdchIntOpRefl, surfName, 1 - state.dataConstruction->Construct(curCons).OutsideAbsorpSolar);
1067 68139 : PreDefTableEntry(
1068 45426 : state, state.dataOutRptPredefined->pdchIntOpUfactNoFilm, surfName, state.dataHeatBal->NominalU(Surface(iSurf).Construction), 3);
1069 22713 : mult = state.dataHeatBal->Zone(zonePt).Multiplier * state.dataHeatBal->Zone(zonePt).ListMultiplier;
1070 22713 : PreDefTableEntry(state, state.dataOutRptPredefined->pdchIntOpGrArea, surfName, Surface(iSurf).GrossArea * mult);
1071 22713 : computedNetArea(iSurf) += Surface(iSurf).GrossArea * mult;
1072 22713 : curAzimuth = Surface(iSurf).Azimuth;
1073 : // Round to two decimals, like the display in tables
1074 : // (PreDefTableEntry uses a fortran style write, that rounds rather than trim)
1075 22713 : curAzimuth = round(curAzimuth * 100.0) / 100.0;
1076 22713 : PreDefTableEntry(state, state.dataOutRptPredefined->pdchIntOpAzimuth, surfName, curAzimuth);
1077 22713 : curTilt = Surface(iSurf).Tilt;
1078 22713 : PreDefTableEntry(state, state.dataOutRptPredefined->pdchIntOpTilt, surfName, curTilt);
1079 22713 : if ((curTilt >= 60.0) && (curTilt < 180.0)) {
1080 15102 : if ((curAzimuth >= 315.0) || (curAzimuth < 45.0)) {
1081 5556 : PreDefTableEntry(state, state.dataOutRptPredefined->pdchIntOpDir, surfName, "N");
1082 9546 : } else if ((curAzimuth >= 45.0) && (curAzimuth < 135.0)) {
1083 3138 : PreDefTableEntry(state, state.dataOutRptPredefined->pdchIntOpDir, surfName, "E");
1084 6408 : } else if ((curAzimuth >= 135.0) && (curAzimuth < 225.0)) {
1085 3275 : PreDefTableEntry(state, state.dataOutRptPredefined->pdchIntOpDir, surfName, "S");
1086 3133 : } else if ((curAzimuth >= 225.0) && (curAzimuth < 315.0)) {
1087 3133 : PreDefTableEntry(state, state.dataOutRptPredefined->pdchIntOpDir, surfName, "W");
1088 : }
1089 : }
1090 : // interior window report
1091 94 : } else if ((Surface(iSurf).Class == SurfaceClass::Window) || (Surface(iSurf).Class == SurfaceClass::TDD_Dome)) {
1092 14 : if (!has_prefix(Surface(iSurf).Name,
1093 14 : "iz-")) { // don't count created interzone surfaces that are mirrors of other surfaces
1094 12 : surfName = Surface(iSurf).Name;
1095 12 : curCons = Surface(iSurf).Construction;
1096 12 : PreDefTableEntry(state, state.dataOutRptPredefined->pdchIntFenCons, surfName, state.dataConstruction->Construct(curCons).Name);
1097 12 : zonePt = Surface(iSurf).Zone;
1098 12 : mult = state.dataHeatBal->Zone(zonePt).Multiplier * state.dataHeatBal->Zone(zonePt).ListMultiplier * Surface(iSurf).Multiplier;
1099 : // include the frame area if present
1100 12 : windowArea = Surface(iSurf).GrossArea;
1101 12 : if (Surface(iSurf).FrameDivider != 0) {
1102 0 : frameWidth = state.dataSurface->FrameDivider(Surface(iSurf).FrameDivider).FrameWidth;
1103 0 : frameArea = (Surface(iSurf).Height + 2 * frameWidth) * (Surface(iSurf).Width + 2 * frameWidth) -
1104 0 : (Surface(iSurf).Height * Surface(iSurf).Width);
1105 0 : windowArea += frameArea;
1106 : }
1107 12 : windowAreaWMult = windowArea * mult;
1108 12 : PreDefTableEntry(state, state.dataOutRptPredefined->pdchIntFenAreaOf1, surfName, windowArea);
1109 12 : PreDefTableEntry(state, state.dataOutRptPredefined->pdchIntFenArea, surfName, windowAreaWMult);
1110 12 : computedNetArea(Surface(iSurf).BaseSurf) -= windowAreaWMult;
1111 12 : nomUfact = state.dataHeatBal->NominalU(Surface(iSurf).Construction);
1112 12 : PreDefTableEntry(state, state.dataOutRptPredefined->pdchIntFenUfact, surfName, nomUfact, 3);
1113 12 : if (!state.dataConstruction->Construct(curCons).TypeIsAirBoundary) {
1114 : // Solar properties not applicable for air boundary surfaces
1115 : // if the construction report is requested the SummerSHGC is already calculated
1116 12 : if (state.dataConstruction->Construct(curCons).SummerSHGC != 0) {
1117 12 : SHGCSummer = state.dataConstruction->Construct(curCons).SummerSHGC;
1118 12 : TransVisNorm = state.dataConstruction->Construct(curCons).VisTransNorm;
1119 : } else {
1120 : // must calculate Summer SHGC
1121 0 : if (!state.dataConstruction->Construct(curCons).WindowTypeEQL) {
1122 0 : CalcNominalWindowCond(state, curCons, 2, nomCond, SHGCSummer, TransSolNorm, TransVisNorm, errFlag);
1123 : }
1124 : }
1125 12 : PreDefTableEntry(state, state.dataOutRptPredefined->pdchIntFenSHGC, surfName, SHGCSummer, 3);
1126 12 : PreDefTableEntry(state, state.dataOutRptPredefined->pdchIntFenVisTr, surfName, TransVisNorm, 3);
1127 : // compute totals for area weighted averages
1128 12 : intShgcArea += SHGCSummer * windowAreaWMult;
1129 12 : intVistranArea += TransVisNorm * windowAreaWMult;
1130 : }
1131 12 : PreDefTableEntry(state, state.dataOutRptPredefined->pdchIntFenParent, surfName, Surface(iSurf).BaseSurfName);
1132 : // compute totals for area weighted averages
1133 12 : intFenTotArea += windowAreaWMult;
1134 12 : intUfactArea += nomUfact * windowAreaWMult;
1135 : }
1136 80 : } else if (Surface(iSurf).Class == SurfaceClass::Door) {
1137 80 : surfName = Surface(iSurf).Name;
1138 80 : curCons = Surface(iSurf).Construction;
1139 80 : PreDefTableEntry(state, state.dataOutRptPredefined->pdchIntDrCons, surfName, state.dataConstruction->Construct(curCons).Name);
1140 240 : PreDefTableEntry(
1141 160 : state, state.dataOutRptPredefined->pdchIntDrUfactNoFilm, surfName, state.dataHeatBal->NominalU(Surface(iSurf).Construction), 3);
1142 80 : mult = state.dataHeatBal->Zone(zonePt).Multiplier * state.dataHeatBal->Zone(zonePt).ListMultiplier;
1143 80 : PreDefTableEntry(state, state.dataOutRptPredefined->pdchIntDrGrArea, surfName, Surface(iSurf).GrossArea * mult);
1144 80 : PreDefTableEntry(state, state.dataOutRptPredefined->pdchIntDrParent, surfName, Surface(iSurf).BaseSurfName);
1145 80 : computedNetArea(Surface(iSurf).BaseSurf) -= Surface(iSurf).GrossArea * mult;
1146 : }
1147 : }
1148 43762 : int currSurfaceClass = int(Surface(iSurf).Class);
1149 43762 : assert(currSurfaceClass < int(SurfaceClass::Num));
1150 43762 : assert(currSurfaceClass > int(SurfaceClass::None));
1151 43762 : ++numSurfaces(currSurfaceClass);
1152 43762 : if (isExterior) {
1153 20955 : ++numExtSurfaces(currSurfaceClass);
1154 : }
1155 43762 : if (Surface(iSurf).Class == SurfaceClass::Window) {
1156 11441 : if (state.dataSurface->SurfWinOriginalClass(iSurf) == SurfaceClass::GlassDoor ||
1157 5467 : state.dataSurface->SurfWinOriginalClass(iSurf) == SurfaceClass::TDD_Diffuser) {
1158 509 : int currOriginalSurfaceClass = int(state.dataSurface->SurfWinOriginalClass(iSurf));
1159 509 : ++numSurfaces(currOriginalSurfaceClass);
1160 509 : if (isExterior) {
1161 507 : ++numExtSurfaces(currOriginalSurfaceClass);
1162 : }
1163 : }
1164 : }
1165 : }
1166 : // for fins and overhangs just add them explicitly since not otherwise classified
1167 1542 : int totOverhangs = state.dataInputProcessing->inputProcessor->getNumObjectsFound(state, "Shading:Overhang") +
1168 771 : state.dataInputProcessing->inputProcessor->getNumObjectsFound(state, "Shading:Overhang:Projection");
1169 771 : numSurfaces(int(SurfaceClass::Overhang)) = totOverhangs;
1170 771 : numExtSurfaces(int(SurfaceClass::Overhang)) = totOverhangs;
1171 1542 : int totFins = state.dataInputProcessing->inputProcessor->getNumObjectsFound(state, "Shading:Fin") +
1172 771 : state.dataInputProcessing->inputProcessor->getNumObjectsFound(state, "Shading:Fin:Projection");
1173 771 : numSurfaces(int(SurfaceClass::Fin)) = totFins;
1174 771 : numExtSurfaces(int(SurfaceClass::Fin)) = totFins;
1175 : // go through all the surfaces again and this time insert the net area results
1176 44533 : for (int iSurf : state.dataSurface->AllSurfaceListReportOrder) {
1177 43762 : zonePt = Surface(iSurf).Zone;
1178 43762 : auto const SurfaceClass(Surface(iSurf).Class);
1179 : // exterior surfaces including underground
1180 135689 : if ((Surface(iSurf).ExtBoundCond == ExternalEnvironment) || (Surface(iSurf).ExtBoundCond == Ground) ||
1181 89631 : (Surface(iSurf).ExtBoundCond == GroundFCfactorMethod) || (Surface(iSurf).ExtBoundCond == KivaFoundation)) {
1182 20955 : if ((SurfaceClass == SurfaceClass::Wall) || (SurfaceClass == SurfaceClass::Floor) || (SurfaceClass == SurfaceClass::Roof)) {
1183 13065 : surfName = Surface(iSurf).Name;
1184 13065 : PreDefTableEntry(state, state.dataOutRptPredefined->pdchOpNetArea, surfName, computedNetArea(iSurf));
1185 : }
1186 : } else {
1187 22807 : if ((SurfaceClass == SurfaceClass::Wall) || (SurfaceClass == SurfaceClass::Floor) || (SurfaceClass == SurfaceClass::Roof)) {
1188 20429 : surfName = Surface(iSurf).Name;
1189 20429 : PreDefTableEntry(state, state.dataOutRptPredefined->pdchIntOpNetArea, surfName, computedNetArea(iSurf));
1190 : }
1191 : } // interior surfaces
1192 : }
1193 : // total
1194 771 : PreDefTableEntry(state, state.dataOutRptPredefined->pdchFenArea, "Total or Average", fenTotArea);
1195 771 : if (fenTotArea > 0.0) {
1196 678 : PreDefTableEntry(state, state.dataOutRptPredefined->pdchFenUfact, "Total or Average", ufactArea / fenTotArea, 3);
1197 678 : PreDefTableEntry(state, state.dataOutRptPredefined->pdchFenSHGC, "Total or Average", shgcArea / fenTotArea, 3);
1198 678 : PreDefTableEntry(state, state.dataOutRptPredefined->pdchFenVisTr, "Total or Average", vistranArea / fenTotArea, 3);
1199 : } else {
1200 93 : PreDefTableEntry(state, state.dataOutRptPredefined->pdchFenUfact, "Total or Average", "-");
1201 93 : PreDefTableEntry(state, state.dataOutRptPredefined->pdchFenSHGC, "Total or Average", "-");
1202 93 : PreDefTableEntry(state, state.dataOutRptPredefined->pdchFenVisTr, "Total or Average", "-");
1203 : }
1204 : // north
1205 771 : PreDefTableEntry(state, state.dataOutRptPredefined->pdchFenArea, "North Total or Average", fenTotAreaNorth);
1206 771 : if (fenTotAreaNorth > 0.0) {
1207 388 : PreDefTableEntry(state, state.dataOutRptPredefined->pdchFenUfact, "North Total or Average", ufactAreaNorth / fenTotAreaNorth, 3);
1208 388 : PreDefTableEntry(state, state.dataOutRptPredefined->pdchFenSHGC, "North Total or Average", shgcAreaNorth / fenTotAreaNorth, 3);
1209 388 : PreDefTableEntry(state, state.dataOutRptPredefined->pdchFenVisTr, "North Total or Average", vistranAreaNorth / fenTotAreaNorth, 3);
1210 : } else {
1211 383 : PreDefTableEntry(state, state.dataOutRptPredefined->pdchFenUfact, "North Total or Average", "-");
1212 383 : PreDefTableEntry(state, state.dataOutRptPredefined->pdchFenSHGC, "North Total or Average", "-");
1213 383 : PreDefTableEntry(state, state.dataOutRptPredefined->pdchFenVisTr, "North Total or Average", "-");
1214 : }
1215 : // non-north
1216 771 : PreDefTableEntry(state, state.dataOutRptPredefined->pdchFenArea, "Non-North Total or Average", fenTotAreaNonNorth);
1217 771 : if (fenTotAreaNonNorth > 0.0) {
1218 677 : PreDefTableEntry(state, state.dataOutRptPredefined->pdchFenUfact, "Non-North Total or Average", ufactAreaNonNorth / fenTotAreaNonNorth, 3);
1219 677 : PreDefTableEntry(state, state.dataOutRptPredefined->pdchFenSHGC, "Non-North Total or Average", shgcAreaNonNorth / fenTotAreaNonNorth, 3);
1220 677 : PreDefTableEntry(state, state.dataOutRptPredefined->pdchFenVisTr, "Non-North Total or Average", vistranAreaNonNorth / fenTotAreaNonNorth, 3);
1221 : } else {
1222 94 : PreDefTableEntry(state, state.dataOutRptPredefined->pdchFenUfact, "Non-North Total or Average", "-");
1223 94 : PreDefTableEntry(state, state.dataOutRptPredefined->pdchFenSHGC, "Non-North Total or Average", "-");
1224 94 : PreDefTableEntry(state, state.dataOutRptPredefined->pdchFenVisTr, "Non-North Total or Average", "-");
1225 : }
1226 : // interior fenestration totals
1227 771 : PreDefTableEntry(state, state.dataOutRptPredefined->pdchIntFenArea, "Total or Average", intFenTotArea);
1228 771 : if (intFenTotArea > 0.0) {
1229 6 : PreDefTableEntry(state, state.dataOutRptPredefined->pdchIntFenUfact, "Total or Average", intUfactArea / intFenTotArea, 3);
1230 6 : PreDefTableEntry(state, state.dataOutRptPredefined->pdchIntFenSHGC, "Total or Average", intShgcArea / intFenTotArea, 3);
1231 6 : PreDefTableEntry(state, state.dataOutRptPredefined->pdchIntFenVisTr, "Total or Average", intVistranArea / intFenTotArea, 3);
1232 : } else {
1233 765 : PreDefTableEntry(state, state.dataOutRptPredefined->pdchIntFenUfact, "Total or Average", "-");
1234 765 : PreDefTableEntry(state, state.dataOutRptPredefined->pdchIntFenSHGC, "Total or Average", "-");
1235 765 : PreDefTableEntry(state, state.dataOutRptPredefined->pdchIntFenVisTr, "Total or Average", "-");
1236 : }
1237 : // counts
1238 771 : PreDefTableEntry(state, state.dataOutRptPredefined->pdchSurfCntTot, "Wall", numSurfaces(int(SurfaceClass::Wall)));
1239 771 : PreDefTableEntry(state, state.dataOutRptPredefined->pdchSurfCntExt, "Wall", numExtSurfaces(int(SurfaceClass::Wall)));
1240 771 : PreDefTableEntry(state, state.dataOutRptPredefined->pdchSurfCntTot, "Floor", numSurfaces(int(SurfaceClass::Floor)));
1241 771 : PreDefTableEntry(state, state.dataOutRptPredefined->pdchSurfCntExt, "Floor", numExtSurfaces(int(SurfaceClass::Floor)));
1242 771 : PreDefTableEntry(state, state.dataOutRptPredefined->pdchSurfCntTot, "Roof", numSurfaces(int(SurfaceClass::Roof)));
1243 771 : PreDefTableEntry(state, state.dataOutRptPredefined->pdchSurfCntExt, "Roof", numExtSurfaces(int(SurfaceClass::Roof)));
1244 771 : PreDefTableEntry(state, state.dataOutRptPredefined->pdchSurfCntTot, "Internal Mass", numSurfaces(int(SurfaceClass::IntMass)));
1245 771 : PreDefTableEntry(state, state.dataOutRptPredefined->pdchSurfCntExt, "Internal Mass", numExtSurfaces(int(SurfaceClass::IntMass)));
1246 771 : PreDefTableEntry(state, state.dataOutRptPredefined->pdchSurfCntTot, "Building Detached Shading", numSurfaces(int(SurfaceClass::Detached_B)));
1247 771 : PreDefTableEntry(state, state.dataOutRptPredefined->pdchSurfCntExt, "Building Detached Shading", numExtSurfaces(int(SurfaceClass::Detached_B)));
1248 771 : PreDefTableEntry(state, state.dataOutRptPredefined->pdchSurfCntTot, "Fixed Detached Shading", numSurfaces(int(SurfaceClass::Detached_F)));
1249 771 : PreDefTableEntry(state, state.dataOutRptPredefined->pdchSurfCntExt, "Fixed Detached Shading", numExtSurfaces(int(SurfaceClass::Detached_F)));
1250 771 : PreDefTableEntry(state, state.dataOutRptPredefined->pdchSurfCntTot, "Window", numSurfaces(int(SurfaceClass::Window)));
1251 771 : PreDefTableEntry(state, state.dataOutRptPredefined->pdchSurfCntExt, "Window", numExtSurfaces(int(SurfaceClass::Window)));
1252 771 : PreDefTableEntry(state, state.dataOutRptPredefined->pdchSurfCntTot, "Door", numSurfaces(int(SurfaceClass::Door)));
1253 771 : PreDefTableEntry(state, state.dataOutRptPredefined->pdchSurfCntExt, "Door", numExtSurfaces(int(SurfaceClass::Door)));
1254 771 : PreDefTableEntry(state, state.dataOutRptPredefined->pdchSurfCntTot, "Glass Door", numSurfaces(int(SurfaceClass::GlassDoor)));
1255 771 : PreDefTableEntry(state, state.dataOutRptPredefined->pdchSurfCntExt, "Glass Door", numExtSurfaces(int(SurfaceClass::GlassDoor)));
1256 771 : PreDefTableEntry(state, state.dataOutRptPredefined->pdchSurfCntTot, "Shading", numSurfaces(int(SurfaceClass::Shading)));
1257 771 : PreDefTableEntry(state, state.dataOutRptPredefined->pdchSurfCntExt, "Shading", numExtSurfaces(int(SurfaceClass::Shading)));
1258 771 : PreDefTableEntry(state, state.dataOutRptPredefined->pdchSurfCntTot, "Overhang", numSurfaces(int(SurfaceClass::Overhang)));
1259 771 : PreDefTableEntry(state, state.dataOutRptPredefined->pdchSurfCntExt, "Overhang", numExtSurfaces(int(SurfaceClass::Overhang)));
1260 771 : PreDefTableEntry(state, state.dataOutRptPredefined->pdchSurfCntTot, "Fin", numSurfaces(int(SurfaceClass::Fin)));
1261 771 : PreDefTableEntry(state, state.dataOutRptPredefined->pdchSurfCntExt, "Fin", numExtSurfaces(int(SurfaceClass::Fin)));
1262 771 : PreDefTableEntry(state, state.dataOutRptPredefined->pdchSurfCntTot, "Tubular Daylighting Device Dome", numSurfaces(int(SurfaceClass::TDD_Dome)));
1263 1542 : PreDefTableEntry(
1264 1542 : state, state.dataOutRptPredefined->pdchSurfCntExt, "Tubular Daylighting Device Dome", numExtSurfaces(int(SurfaceClass::TDD_Dome)));
1265 1542 : PreDefTableEntry(
1266 1542 : state, state.dataOutRptPredefined->pdchSurfCntTot, "Tubular Daylighting Device Diffuser", numSurfaces(int(SurfaceClass::TDD_Diffuser)));
1267 1542 : PreDefTableEntry(
1268 1542 : state, state.dataOutRptPredefined->pdchSurfCntExt, "Tubular Daylighting Device Diffuser", numExtSurfaces(int(SurfaceClass::TDD_Diffuser)));
1269 771 : }
1270 :
1271 771 : void AllocateSurfaceHeatBalArrays(EnergyPlusData &state)
1272 : {
1273 :
1274 : // SUBROUTINE INFORMATION:
1275 : // AUTHOR Richard Liesen
1276 : // DATE WRITTEN February 1998
1277 :
1278 : // METHODOLOGY EMPLOYED:
1279 : // Uses the status flags to trigger variable allocation.
1280 :
1281 771 : auto &Surface(state.dataSurface->Surface);
1282 :
1283 : // Use the total number of surfaces to allocate variables to avoid a surface number limit
1284 771 : state.dataHeatBalSurf->SurfCTFConstInPart.dimension(state.dataSurface->TotSurfaces, 0.0);
1285 771 : state.dataHeatBalSurf->SurfCTFConstOutPart.dimension(state.dataSurface->TotSurfaces, 0.0);
1286 771 : state.dataHeatBalSurf->SurfCTFCross0.dimension(state.dataSurface->TotSurfaces, 0.0);
1287 771 : state.dataHeatBalSurf->SurfCTFInside0.dimension(state.dataSurface->TotSurfaces, 0.0);
1288 771 : state.dataHeatBalSurf->SurfTempOutHist.dimension(state.dataSurface->TotSurfaces, 0.0);
1289 771 : state.dataHeatBalSurf->SurfCTFSourceIn0.dimension(state.dataSurface->TotSurfaces, 0.0);
1290 771 : state.dataHeatBalSurf->SurfQSourceSinkHist.dimension(state.dataSurface->TotSurfaces, 0.0);
1291 771 : state.dataHeatBalSurf->SurfIsAdiabatic.dimension(state.dataSurface->TotSurfaces, 0);
1292 771 : state.dataHeatBalSurf->SurfIsSourceOrSink.dimension(state.dataSurface->TotSurfaces, 0);
1293 771 : state.dataHeatBalSurf->SurfIsOperatingPool.dimension(state.dataSurface->TotSurfaces, 0);
1294 771 : state.dataHeatBalSurf->SurfTempTerm.dimension(state.dataSurface->TotSurfaces, 0);
1295 771 : state.dataHeatBalSurf->SurfTempDiv.dimension(state.dataSurface->TotSurfaces, 0);
1296 771 : if (state.dataHeatBal->AnyInternalHeatSourceInInput) {
1297 36 : state.dataHeatBalFanSys->CTFTsrcConstPart.dimension(state.dataSurface->TotSurfaces, 0.0);
1298 36 : state.dataHeatBalFanSys->CTFTuserConstPart.dimension(state.dataSurface->TotSurfaces, 0.0);
1299 : }
1300 :
1301 771 : state.dataHeatBal->SurfTempEffBulkAir.dimension(state.dataSurface->TotSurfaces, DataHeatBalance::ZoneInitialTemp);
1302 771 : state.dataHeatBalSurf->SurfHConvInt.dimension(state.dataSurface->TotSurfaces, 0.0);
1303 771 : state.dataHeatBalSurf->SurfHcExt.dimension(state.dataSurface->TotSurfaces, 0.0);
1304 771 : state.dataHeatBalSurf->SurfHAirExt.dimension(state.dataSurface->TotSurfaces, 0.0);
1305 771 : state.dataHeatBalSurf->SurfHSkyExt.dimension(state.dataSurface->TotSurfaces, 0.0);
1306 771 : state.dataHeatBalSurf->SurfHGrdExt.dimension(state.dataSurface->TotSurfaces, 0.0);
1307 :
1308 771 : state.dataHeatBalSurf->SurfTempIn.dimension(state.dataSurface->TotSurfaces, 0.0);
1309 771 : state.dataHeatBalSurf->SurfTempInsOld.dimension(state.dataSurface->TotSurfaces, 0.0);
1310 771 : state.dataHeatBalSurf->SurfTempInTmp.dimension(state.dataSurface->TotSurfaces, 0.0);
1311 771 : state.dataHeatBalSurfMgr->RefAirTemp.dimension(state.dataSurface->TotSurfaces, 0.0);
1312 771 : state.dataHeatBalSurf->SurfQRadLWOutSrdSurfs.dimension(state.dataSurface->TotSurfaces, 0.0);
1313 :
1314 771 : state.dataHeatBal->SurfWinQRadSWwinAbs.dimension(state.dataSurface->TotSurfaces, DataWindowEquivalentLayer::CFSMAXNL + 1, 0.0);
1315 771 : state.dataHeatBal->SurfWinInitialDifSolwinAbs.dimension(state.dataSurface->TotSurfaces, DataWindowEquivalentLayer::CFSMAXNL, 0.0);
1316 771 : state.dataHeatBalSurf->SurfQRadSWOutMvIns.dimension(state.dataSurface->TotSurfaces, 0.0);
1317 771 : state.dataHeatBal->SurfQdotRadIntGainsInPerArea.dimension(state.dataSurface->TotSurfaces, 0.0);
1318 771 : state.dataHeatBalSurf->SurfQAdditionalHeatSourceOutside.dimension(state.dataSurface->TotSurfaces, 0.0);
1319 771 : state.dataHeatBalSurf->SurfQAdditionalHeatSourceInside.dimension(state.dataSurface->TotSurfaces, 0.0);
1320 :
1321 771 : state.dataHeatBalSurf->SurfInsideTempHist.allocate(Construction::MaxCTFTerms);
1322 771 : state.dataHeatBalSurf->SurfOutsideTempHist.allocate(Construction::MaxCTFTerms);
1323 771 : state.dataHeatBalSurf->SurfInsideFluxHist.allocate(Construction::MaxCTFTerms);
1324 771 : state.dataHeatBalSurf->SurfOutsideFluxHist.allocate(Construction::MaxCTFTerms);
1325 15420 : for (int loop = 1; loop <= Construction::MaxCTFTerms; ++loop) {
1326 14649 : state.dataHeatBalSurf->SurfInsideTempHist(loop).dimension(state.dataSurface->TotSurfaces, 0);
1327 14649 : state.dataHeatBalSurf->SurfOutsideTempHist(loop).dimension(state.dataSurface->TotSurfaces, 0);
1328 14649 : state.dataHeatBalSurf->SurfInsideFluxHist(loop).dimension(state.dataSurface->TotSurfaces, 0);
1329 14649 : state.dataHeatBalSurf->SurfOutsideFluxHist(loop).dimension(state.dataSurface->TotSurfaces, 0);
1330 : }
1331 :
1332 771 : if (!state.dataHeatBal->SimpleCTFOnly || state.dataGlobal->AnyEnergyManagementSystemInModel) {
1333 131 : state.dataHeatBalSurf->SurfCurrNumHist.dimension(state.dataSurface->TotSurfaces, 0);
1334 :
1335 131 : state.dataHeatBalSurf->SurfInsideTempHistMaster.allocate(Construction::MaxCTFTerms);
1336 131 : state.dataHeatBalSurf->SurfOutsideTempHistMaster.allocate(Construction::MaxCTFTerms);
1337 131 : state.dataHeatBalSurf->SurfInsideFluxHistMaster.allocate(Construction::MaxCTFTerms);
1338 131 : state.dataHeatBalSurf->SurfOutsideFluxHistMaster.allocate(Construction::MaxCTFTerms);
1339 :
1340 2620 : for (int loop = 1; loop <= Construction::MaxCTFTerms; ++loop) {
1341 2489 : state.dataHeatBalSurf->SurfInsideTempHistMaster(loop).dimension(state.dataSurface->TotSurfaces, 0);
1342 2489 : state.dataHeatBalSurf->SurfOutsideTempHistMaster(loop).dimension(state.dataSurface->TotSurfaces, 0);
1343 2489 : state.dataHeatBalSurf->SurfInsideFluxHistMaster(loop).dimension(state.dataSurface->TotSurfaces, 0);
1344 2489 : state.dataHeatBalSurf->SurfOutsideFluxHistMaster(loop).dimension(state.dataSurface->TotSurfaces, 0);
1345 : }
1346 : }
1347 :
1348 771 : state.dataHeatBalSurf->SurfTempOut.dimension(state.dataSurface->TotSurfaces, 0.0);
1349 771 : state.dataHeatBalSurf->SurfTempInMovInsRep.dimension(state.dataSurface->TotSurfaces, 0.0);
1350 771 : state.dataHeatBalSurf->SurfQConvInReport.dimension(state.dataSurface->TotSurfaces, 0.0);
1351 771 : state.dataHeatBalSurf->SurfQdotConvInPerArea.dimension(state.dataSurface->TotSurfaces, 0.0);
1352 771 : state.dataHeatBalSurf->SurfQdotConvInRep.dimension(state.dataSurface->TotSurfaces, 0.0);
1353 :
1354 771 : state.dataHeatBalSurf->SurfQRadNetSurfInReport.dimension(state.dataSurface->TotSurfaces, 0.0);
1355 771 : state.dataHeatBalSurf->SurfQdotRadNetSurfInRep.dimension(state.dataSurface->TotSurfaces, 0.0);
1356 :
1357 771 : state.dataHeatBalSurf->SurfQRadSolarInReport.dimension(state.dataSurface->TotSurfaces, 0.0);
1358 771 : state.dataHeatBalSurf->SurfQdotRadSolarInRep.dimension(state.dataSurface->TotSurfaces, 0.0);
1359 771 : state.dataHeatBalSurf->SurfQdotRadSolarInRepPerArea.dimension(state.dataSurface->TotSurfaces, 0.0);
1360 :
1361 771 : state.dataHeatBalSurf->SurfQRadLightsInReport.dimension(state.dataSurface->TotSurfaces, 0.0);
1362 771 : state.dataHeatBalSurf->SurfQdotRadLightsInRep.dimension(state.dataSurface->TotSurfaces, 0.0);
1363 :
1364 771 : state.dataHeatBalSurf->SurfQRadIntGainsInReport.dimension(state.dataSurface->TotSurfaces, 0.0);
1365 771 : state.dataHeatBalSurf->SurfQdotRadIntGainsInRep.dimension(state.dataSurface->TotSurfaces, 0.0);
1366 :
1367 771 : state.dataHeatBalSurf->AnyRadiantSystems.dimension(state.dataSurface->TotSurfaces, false);
1368 771 : state.dataHeatBalSurf->SurfQRadHVACInReport.dimension(state.dataSurface->TotSurfaces, 0.0);
1369 771 : state.dataHeatBalSurf->SurfQdotRadHVACInRep.dimension(state.dataSurface->TotSurfaces, 0.0);
1370 771 : state.dataHeatBalSurf->SurfQdotRadHVACInPerArea.dimension(state.dataSurface->TotSurfaces, 0.0);
1371 :
1372 771 : state.dataHeatBalSurf->SurfQConvOutReport.dimension(state.dataSurface->TotSurfaces, 0.0);
1373 771 : state.dataHeatBalSurf->SurfQdotConvOutPerArea.dimension(state.dataSurface->TotSurfaces, 0.0);
1374 771 : state.dataHeatBalSurf->SurfQdotConvOutRep.dimension(state.dataSurface->TotSurfaces, 0.0);
1375 :
1376 771 : state.dataHeatBalSurf->SurfQdotRadOutRep.dimension(state.dataSurface->TotSurfaces, 0.0);
1377 771 : state.dataHeatBalSurf->SurfQdotRadOutRepPerArea.dimension(state.dataSurface->TotSurfaces, 0.0);
1378 771 : state.dataHeatBalSurf->SurfQRadOutReport.dimension(state.dataSurface->TotSurfaces, 0.0);
1379 :
1380 771 : state.dataHeatBalSurf->SurfQAirExtReport.dimension(state.dataSurface->TotSurfaces, 0.0);
1381 771 : state.dataHeatBalSurf->SurfQHeatEmiReport.dimension(state.dataSurface->TotSurfaces, 0.0);
1382 :
1383 771 : state.dataHeatBal->SurfOpaqSWOutAbsTotalReport.dimension(state.dataSurface->TotSurfaces, 0.0);
1384 771 : state.dataHeatBal->SurfOpaqSWOutAbsEnergyReport.dimension(state.dataSurface->TotSurfaces, 0.0);
1385 :
1386 771 : state.dataHeatBalSurf->SurfOpaqInsFaceCond.dimension(state.dataSurface->TotSurfaces, 0.0);
1387 771 : state.dataHeatBalSurf->SurfOpaqInsFaceCondFlux.dimension(state.dataSurface->TotSurfaces, 0.0);
1388 771 : state.dataHeatBalSurf->SurfOpaqInsFaceCondGainRep.dimension(state.dataSurface->TotSurfaces, 0.0);
1389 771 : state.dataHeatBalSurf->SurfOpaqInsFaceCondLossRep.dimension(state.dataSurface->TotSurfaces, 0.0);
1390 771 : state.dataHeatBalSurf->SurfOpaqInsFaceCondEnergy.dimension(state.dataSurface->TotSurfaces, 0.0);
1391 :
1392 771 : state.dataHeatBalSurf->SurfOpaqOutFaceCond.dimension(state.dataSurface->TotSurfaces, 0.0);
1393 771 : state.dataHeatBalSurf->SurfOpaqOutFaceCondFlux.dimension(state.dataSurface->TotSurfaces, 0.0);
1394 771 : state.dataHeatBalSurf->SurfOpaqExtFaceCondGainRep.dimension(state.dataSurface->TotSurfaces, 0.0);
1395 771 : state.dataHeatBalSurf->SurfOpaqExtFaceCondLossRep.dimension(state.dataSurface->TotSurfaces, 0.0);
1396 771 : state.dataHeatBalSurf->SurfOpaqOutFaceCondEnergy.dimension(state.dataSurface->TotSurfaces, 0.0);
1397 :
1398 771 : state.dataHeatBalSurf->SurfOpaqAvgFaceCondGainRep.dimension(state.dataSurface->TotSurfaces, 0.0);
1399 771 : state.dataHeatBalSurf->SurfOpaqAvgFaceCondLossRep.dimension(state.dataSurface->TotSurfaces, 0.0);
1400 771 : state.dataHeatBalSurf->SurfOpaqAvgFaceCond.dimension(state.dataSurface->TotSurfaces, 0.0);
1401 771 : state.dataHeatBalSurf->SurfOpaqAvgFaceCondFlux.dimension(state.dataSurface->TotSurfaces, 0.0);
1402 771 : state.dataHeatBalSurf->SurfOpaqAvgFaceCondEnergy.dimension(state.dataSurface->TotSurfaces, 0.0);
1403 :
1404 771 : state.dataHeatBalSurf->SurfOpaqStorageCondGainRep.dimension(state.dataSurface->TotSurfaces, 0.0);
1405 771 : state.dataHeatBalSurf->SurfOpaqStorageCondLossRep.dimension(state.dataSurface->TotSurfaces, 0.0);
1406 771 : state.dataHeatBalSurf->SurfOpaqStorageCond.dimension(state.dataSurface->TotSurfaces, 0.0);
1407 771 : state.dataHeatBalSurf->SurfOpaqStorageCondFlux.dimension(state.dataSurface->TotSurfaces, 0.0);
1408 771 : state.dataHeatBalSurf->SurfOpaqStorageCondEnergy.dimension(state.dataSurface->TotSurfaces, 0.0);
1409 :
1410 771 : state.dataHeatBalSurf->SurfOpaqInsFaceBeamSolAbsorbed.dimension(state.dataSurface->TotSurfaces, 0.0);
1411 :
1412 771 : state.dataHeatBalSurf->SurfOpaqQRadSWOutAbs.dimension(state.dataSurface->TotSurfaces, 0.0);
1413 771 : state.dataHeatBalSurf->SurfOpaqQRadSWInAbs.dimension(state.dataSurface->TotSurfaces, 0.0);
1414 :
1415 771 : state.dataHeatBalSurf->SurfOpaqInitialDifSolInAbs.dimension(state.dataSurface->TotSurfaces, 0.0);
1416 771 : state.dataHeatBalSurf->SurfWinInitialDifSolInTrans.dimension(state.dataSurface->TotSurfaces, 0.0);
1417 :
1418 771 : state.dataHeatBalSurf->SurfQdotRadNetLWInPerArea.dimension(state.dataSurface->TotSurfaces, 0.0);
1419 771 : state.dataHeatBalSurf->SurfQdotRadLightsInPerArea.dimension(state.dataSurface->TotSurfaces, 0.0);
1420 :
1421 771 : if (state.dataHeatBal->AnyInternalHeatSourceInInput) {
1422 36 : state.dataHeatBalSurf->SurfTempSource.dimension(state.dataSurface->TotSurfaces, 0.0);
1423 36 : state.dataHeatBalSurf->SurfTempUserLoc.dimension(state.dataSurface->TotSurfaces, 0.0);
1424 36 : state.dataHeatBalSurf->SurfTsrcHist.dimension(state.dataSurface->TotSurfaces, Construction::MaxCTFTerms, 0.0);
1425 36 : state.dataHeatBalSurf->SurfTuserHist.dimension(state.dataSurface->TotSurfaces, Construction::MaxCTFTerms, 0.0);
1426 36 : state.dataHeatBalSurf->SurfQsrcHist.dimension(state.dataSurface->TotSurfaces, Construction::MaxCTFTerms, 0.0);
1427 36 : state.dataHeatBalSurf->SurfTsrcHistM.dimension(state.dataSurface->TotSurfaces, Construction::MaxCTFTerms, 0.0);
1428 36 : state.dataHeatBalSurf->SurfTuserHistM.dimension(state.dataSurface->TotSurfaces, Construction::MaxCTFTerms, 0.0);
1429 36 : state.dataHeatBalSurf->SurfQsrcHistM.dimension(state.dataSurface->TotSurfaces, Construction::MaxCTFTerms, 0.0);
1430 : }
1431 :
1432 771 : state.dataHeatBalFanSys->RadSysTiHBConstCoef.dimension(state.dataSurface->TotSurfaces, 0.0);
1433 771 : state.dataHeatBalFanSys->RadSysTiHBToutCoef.dimension(state.dataSurface->TotSurfaces, 0.0);
1434 771 : state.dataHeatBalFanSys->RadSysTiHBQsrcCoef.dimension(state.dataSurface->TotSurfaces, 0.0);
1435 771 : state.dataHeatBalFanSys->RadSysToHBConstCoef.dimension(state.dataSurface->TotSurfaces, 0.0);
1436 771 : state.dataHeatBalFanSys->RadSysToHBTinCoef.dimension(state.dataSurface->TotSurfaces, 0.0);
1437 771 : state.dataHeatBalFanSys->RadSysToHBQsrcCoef.dimension(state.dataSurface->TotSurfaces, 0.0);
1438 771 : state.dataHeatBalFanSys->QRadSysSource.dimension(state.dataSurface->TotSurfaces, 0.0);
1439 771 : state.dataHeatBalFanSys->TCondFDSourceNode.dimension(state.dataSurface->TotSurfaces, 15.0);
1440 771 : state.dataHeatBalFanSys->SurfQHTRadSys.dimension(state.dataSurface->TotSurfaces, 0.0);
1441 771 : state.dataHeatBalFanSys->SurfQHWBaseboard.dimension(state.dataSurface->TotSurfaces, 0.0);
1442 771 : state.dataHeatBalFanSys->SurfQSteamBaseboard.dimension(state.dataSurface->TotSurfaces, 0.0);
1443 771 : state.dataHeatBalFanSys->SurfQElecBaseboard.dimension(state.dataSurface->TotSurfaces, 0.0);
1444 771 : state.dataHeatBalFanSys->SurfQCoolingPanel.dimension(state.dataSurface->TotSurfaces, 0.0);
1445 771 : state.dataHeatBalFanSys->QRadSurfAFNDuct.dimension(state.dataSurface->TotSurfaces, 0.0);
1446 :
1447 : // allocate terms used for pool surface heat balance
1448 771 : state.dataHeatBalFanSys->QPoolSurfNumerator.dimension(state.dataSurface->TotSurfaces, 0.0);
1449 771 : state.dataHeatBalFanSys->PoolHeatTransCoefs.dimension(state.dataSurface->TotSurfaces, 0.0);
1450 :
1451 : // allocate term used as sink for PV electricity
1452 771 : state.dataHeatBalFanSys->QPVSysSource.dimension(state.dataSurface->TotSurfaces, 0.0);
1453 :
1454 : // Allocate the moisture balance arrays
1455 771 : state.dataMstBal->TempOutsideAirFD.dimension(state.dataSurface->TotSurfaces, 0.0);
1456 771 : state.dataMstBal->RhoVaporAirOut.dimension(state.dataSurface->TotSurfaces, 0.0);
1457 771 : state.dataMstBal->RhoVaporSurfIn.dimension(state.dataSurface->TotSurfaces, 0.0);
1458 771 : state.dataMstBal->RhoVaporAirIn.dimension(state.dataSurface->TotSurfaces, 0.0);
1459 771 : state.dataMstBal->HConvExtFD.dimension(state.dataSurface->TotSurfaces, 0.0);
1460 771 : state.dataMstBal->HMassConvExtFD.dimension(state.dataSurface->TotSurfaces, 0.0);
1461 771 : state.dataMstBal->HConvInFD.dimension(state.dataSurface->TotSurfaces, 0.0);
1462 771 : state.dataMstBal->HMassConvInFD.dimension(state.dataSurface->TotSurfaces, 0.0);
1463 771 : state.dataMstBal->HSkyFD.dimension(state.dataSurface->TotSurfaces, 0.0);
1464 771 : state.dataMstBal->HGrndFD.dimension(state.dataSurface->TotSurfaces, 0.0);
1465 771 : state.dataMstBal->HAirFD.dimension(state.dataSurface->TotSurfaces, 0.0);
1466 :
1467 771 : state.dataHeatBalSurf->SurfQdotRadNetLWInPerArea.dimension(state.dataSurface->TotSurfaces, 0.0);
1468 771 : state.dataHeatBalSurf->SurfQdotRadLightsInPerArea.dimension(state.dataSurface->TotSurfaces, 0.0);
1469 771 : state.dataSurface->SurfSkySolarInc.dimension(state.dataSurface->TotSurfaces, 0);
1470 771 : state.dataSurface->SurfGndSolarInc.dimension(state.dataSurface->TotSurfaces, 0);
1471 : // allocate movable insulation arrays
1472 771 : if (state.dataSurface->AnyMovableInsulation) {
1473 5 : state.dataHeatBalSurf->SurfMovInsulExtPresent.dimension(state.dataSurface->TotSurfaces, false);
1474 5 : state.dataHeatBalSurf->SurfMovInsulIntPresent.dimension(state.dataSurface->TotSurfaces, false);
1475 5 : state.dataHeatBalSurf->SurfMovInsulIntPresentPrevTS.dimension(state.dataSurface->TotSurfaces, false);
1476 5 : state.dataHeatBalSurf->SurfMovInsulHExt.dimension(state.dataSurface->TotSurfaces, 0.0);
1477 5 : state.dataHeatBalSurf->SurfMovInsulHInt.dimension(state.dataSurface->TotSurfaces, 0.0);
1478 : }
1479 771 : state.dataHeatBalSurf->SurfAbsSolarExt.dimension(state.dataSurface->TotSurfaces, 0.0);
1480 771 : state.dataHeatBalSurf->SurfAbsThermalExt.dimension(state.dataSurface->TotSurfaces, 0.0);
1481 771 : state.dataHeatBalSurf->SurfRoughnessExt.dimension(state.dataSurface->TotSurfaces, DataSurfaces::SurfaceRoughness::Invalid);
1482 771 : state.dataHeatBalSurf->SurfAbsSolarInt.dimension(state.dataSurface->TotSurfaces, 0.0);
1483 771 : state.dataHeatBalSurf->SurfAbsThermalInt.dimension(state.dataSurface->TotSurfaces, 0.0);
1484 :
1485 771 : DisplayString(state, "Setting up Surface Reporting Variables");
1486 : // Setup surface report variables CurrentModuleObject='Opaque Surfaces'
1487 44533 : for (int loop = 1; loop <= state.dataSurface->TotSurfaces; ++loop) {
1488 43762 : if (!Surface(loop).HeatTransSurf) continue;
1489 126621 : SetupOutputVariable(state,
1490 : "Surface Inside Face Temperature",
1491 : OutputProcessor::Unit::C,
1492 42207 : state.dataHeatBalSurf->SurfTempIn(loop),
1493 : OutputProcessor::SOVTimeStepType::Zone,
1494 : OutputProcessor::SOVStoreType::State,
1495 84414 : Surface(loop).Name);
1496 126621 : SetupOutputVariable(state,
1497 : "Surface Inside Face Interior Movable Insulation Temperature",
1498 : OutputProcessor::Unit::C,
1499 42207 : state.dataHeatBalSurf->SurfTempInMovInsRep(loop),
1500 : OutputProcessor::SOVTimeStepType::Zone,
1501 : OutputProcessor::SOVStoreType::State,
1502 84414 : Surface(loop).Name);
1503 :
1504 42207 : if (Surface(loop).ExtBoundCond != KivaFoundation) {
1505 126507 : SetupOutputVariable(state,
1506 : "Surface Outside Face Temperature",
1507 : OutputProcessor::Unit::C,
1508 42169 : state.dataHeatBalSurf->SurfTempOut(loop),
1509 : OutputProcessor::SOVTimeStepType::Zone,
1510 : OutputProcessor::SOVStoreType::State,
1511 84338 : Surface(loop).Name);
1512 : }
1513 :
1514 126621 : SetupOutputVariable(state,
1515 : "Surface Inside Face Adjacent Air Temperature",
1516 : OutputProcessor::Unit::C,
1517 42207 : state.dataHeatBal->SurfTempEffBulkAir(loop),
1518 : OutputProcessor::SOVTimeStepType::Zone,
1519 : OutputProcessor::SOVStoreType::State,
1520 84414 : Surface(loop).Name);
1521 126621 : SetupOutputVariable(state,
1522 : "Surface Inside Face Convection Heat Transfer Coefficient",
1523 : OutputProcessor::Unit::W_m2K,
1524 42207 : state.dataHeatBalSurf->SurfHConvInt(loop),
1525 : OutputProcessor::SOVTimeStepType::Zone,
1526 : OutputProcessor::SOVStoreType::State,
1527 84414 : Surface(loop).Name);
1528 126621 : SetupOutputVariable(state,
1529 : "Surface Inside Face Convection Heat Gain Rate",
1530 : OutputProcessor::Unit::W,
1531 42207 : state.dataHeatBalSurf->SurfQdotConvInRep(loop),
1532 : OutputProcessor::SOVTimeStepType::Zone,
1533 : OutputProcessor::SOVStoreType::State,
1534 84414 : Surface(loop).Name);
1535 126621 : SetupOutputVariable(state,
1536 : "Surface Inside Face Convection Heat Gain Rate per Area",
1537 : OutputProcessor::Unit::W_m2,
1538 42207 : state.dataHeatBalSurf->SurfQdotConvInPerArea(loop),
1539 : OutputProcessor::SOVTimeStepType::Zone,
1540 : OutputProcessor::SOVStoreType::State,
1541 84414 : Surface(loop).Name);
1542 126621 : SetupOutputVariable(state,
1543 : "Surface Inside Face Convection Heat Gain Energy",
1544 : OutputProcessor::Unit::J,
1545 42207 : state.dataHeatBalSurf->SurfQConvInReport(loop),
1546 : OutputProcessor::SOVTimeStepType::Zone,
1547 : OutputProcessor::SOVStoreType::Summed,
1548 84414 : Surface(loop).Name);
1549 :
1550 126621 : SetupOutputVariable(state,
1551 : "Surface Inside Face Net Surface Thermal Radiation Heat Gain Rate",
1552 : OutputProcessor::Unit::W,
1553 42207 : state.dataHeatBalSurf->SurfQdotRadNetSurfInRep(loop),
1554 : OutputProcessor::SOVTimeStepType::Zone,
1555 : OutputProcessor::SOVStoreType::State,
1556 84414 : Surface(loop).Name);
1557 126621 : SetupOutputVariable(state,
1558 : "Surface Inside Face Net Surface Thermal Radiation Heat Gain Rate per Area",
1559 : OutputProcessor::Unit::W_m2,
1560 42207 : state.dataHeatBalSurf->SurfQdotRadNetLWInPerArea(loop),
1561 : OutputProcessor::SOVTimeStepType::Zone,
1562 : OutputProcessor::SOVStoreType::State,
1563 84414 : Surface(loop).Name);
1564 126621 : SetupOutputVariable(state,
1565 : "Surface Inside Face Net Surface Thermal Radiation Heat Gain Energy",
1566 : OutputProcessor::Unit::J,
1567 42207 : state.dataHeatBalSurf->SurfQRadNetSurfInReport(loop),
1568 : OutputProcessor::SOVTimeStepType::Zone,
1569 : OutputProcessor::SOVStoreType::Summed,
1570 84414 : Surface(loop).Name);
1571 :
1572 42207 : if (Surface(loop).Class != SurfaceClass::Window) {
1573 108699 : SetupOutputVariable(state,
1574 : "Surface Inside Face Solar Radiation Heat Gain Rate",
1575 : OutputProcessor::Unit::W,
1576 36233 : state.dataHeatBalSurf->SurfQdotRadSolarInRep(loop),
1577 : OutputProcessor::SOVTimeStepType::Zone,
1578 : OutputProcessor::SOVStoreType::State,
1579 72466 : Surface(loop).Name);
1580 108699 : SetupOutputVariable(state,
1581 : "Surface Inside Face Solar Radiation Heat Gain Rate per Area",
1582 : OutputProcessor::Unit::W_m2,
1583 36233 : state.dataHeatBalSurf->SurfQdotRadSolarInRepPerArea(loop),
1584 : OutputProcessor::SOVTimeStepType::Zone,
1585 : OutputProcessor::SOVStoreType::State,
1586 72466 : Surface(loop).Name);
1587 108699 : SetupOutputVariable(state,
1588 : "Surface Inside Face Solar Radiation Heat Gain Energy",
1589 : OutputProcessor::Unit::J,
1590 36233 : state.dataHeatBalSurf->SurfQRadSolarInReport(loop),
1591 : OutputProcessor::SOVTimeStepType::Zone,
1592 : OutputProcessor::SOVStoreType::Summed,
1593 72466 : Surface(loop).Name);
1594 :
1595 108699 : SetupOutputVariable(state,
1596 : "Surface Inside Face Lights Radiation Heat Gain Rate",
1597 : OutputProcessor::Unit::W,
1598 36233 : state.dataHeatBalSurf->SurfQdotRadLightsInRep(loop),
1599 : OutputProcessor::SOVTimeStepType::Zone,
1600 : OutputProcessor::SOVStoreType::State,
1601 72466 : Surface(loop).Name);
1602 108699 : SetupOutputVariable(state,
1603 : "Surface Inside Face Lights Radiation Heat Gain Rate per Area",
1604 : OutputProcessor::Unit::W_m2,
1605 36233 : state.dataHeatBalSurf->SurfQdotRadLightsInPerArea(loop),
1606 : OutputProcessor::SOVTimeStepType::Zone,
1607 : OutputProcessor::SOVStoreType::State,
1608 72466 : Surface(loop).Name);
1609 108699 : SetupOutputVariable(state,
1610 : "Surface Inside Face Lights Radiation Heat Gain Energy",
1611 : OutputProcessor::Unit::J,
1612 36233 : state.dataHeatBalSurf->SurfQRadLightsInReport(loop),
1613 : OutputProcessor::SOVTimeStepType::Zone,
1614 : OutputProcessor::SOVStoreType::Summed,
1615 72466 : Surface(loop).Name);
1616 : }
1617 :
1618 126621 : SetupOutputVariable(state,
1619 : "Surface Inside Face Internal Gains Radiation Heat Gain Rate",
1620 : OutputProcessor::Unit::W,
1621 42207 : state.dataHeatBalSurf->SurfQdotRadIntGainsInRep(loop),
1622 : OutputProcessor::SOVTimeStepType::Zone,
1623 : OutputProcessor::SOVStoreType::State,
1624 84414 : Surface(loop).Name);
1625 126621 : SetupOutputVariable(state,
1626 : "Surface Inside Face Internal Gains Radiation Heat Gain Rate per Area",
1627 : OutputProcessor::Unit::W_m2,
1628 42207 : state.dataHeatBal->SurfQdotRadIntGainsInPerArea(loop),
1629 : OutputProcessor::SOVTimeStepType::Zone,
1630 : OutputProcessor::SOVStoreType::State,
1631 84414 : Surface(loop).Name);
1632 126621 : SetupOutputVariable(state,
1633 : "Surface Inside Face Internal Gains Radiation Heat Gain Energy",
1634 : OutputProcessor::Unit::J,
1635 42207 : state.dataHeatBalSurf->SurfQRadIntGainsInReport(loop),
1636 : OutputProcessor::SOVTimeStepType::Zone,
1637 : OutputProcessor::SOVStoreType::Summed,
1638 84414 : Surface(loop).Name);
1639 :
1640 126621 : SetupOutputVariable(state,
1641 : "Surface Inside Face System Radiation Heat Gain Rate",
1642 : OutputProcessor::Unit::W,
1643 42207 : state.dataHeatBalSurf->SurfQdotRadHVACInRep(loop),
1644 : OutputProcessor::SOVTimeStepType::Zone,
1645 : OutputProcessor::SOVStoreType::State,
1646 84414 : Surface(loop).Name);
1647 126621 : SetupOutputVariable(state,
1648 : "Surface Inside Face System Radiation Heat Gain Rate per Area",
1649 : OutputProcessor::Unit::W_m2,
1650 42207 : state.dataHeatBalSurf->SurfQdotRadHVACInPerArea(loop),
1651 : OutputProcessor::SOVTimeStepType::Zone,
1652 : OutputProcessor::SOVStoreType::State,
1653 84414 : Surface(loop).Name);
1654 126621 : SetupOutputVariable(state,
1655 : "Surface Inside Face System Radiation Heat Gain Energy",
1656 : OutputProcessor::Unit::J,
1657 42207 : state.dataHeatBalSurf->SurfQRadHVACInReport(loop),
1658 : OutputProcessor::SOVTimeStepType::Zone,
1659 : OutputProcessor::SOVStoreType::Summed,
1660 84414 : Surface(loop).Name);
1661 :
1662 42207 : if (Surface(loop).ExtBoundCond == ExternalEnvironment || state.dataGlobal->DisplayAdvancedReportVariables) {
1663 51987 : SetupOutputVariable(state,
1664 : "Surface Outside Face Outdoor Air Drybulb Temperature",
1665 : OutputProcessor::Unit::C,
1666 17329 : state.dataSurface->SurfOutDryBulbTemp(loop),
1667 : OutputProcessor::SOVTimeStepType::Zone,
1668 : OutputProcessor::SOVStoreType::State,
1669 34658 : Surface(loop).Name);
1670 51987 : SetupOutputVariable(state,
1671 : "Surface Outside Face Outdoor Air Wetbulb Temperature",
1672 : OutputProcessor::Unit::C,
1673 17329 : state.dataSurface->SurfOutWetBulbTemp(loop),
1674 : OutputProcessor::SOVTimeStepType::Zone,
1675 : OutputProcessor::SOVStoreType::State,
1676 34658 : Surface(loop).Name);
1677 51987 : SetupOutputVariable(state,
1678 : "Surface Outside Face Outdoor Air Wind Speed",
1679 : OutputProcessor::Unit::m_s,
1680 17329 : state.dataSurface->SurfOutWindSpeed(loop),
1681 : OutputProcessor::SOVTimeStepType::Zone,
1682 : OutputProcessor::SOVStoreType::State,
1683 34658 : Surface(loop).Name);
1684 51987 : SetupOutputVariable(state,
1685 : "Surface Outside Face Outdoor Air Wind Direction",
1686 : OutputProcessor::Unit::deg,
1687 17329 : state.dataSurface->SurfOutWindDir(loop),
1688 : OutputProcessor::SOVTimeStepType::Zone,
1689 : OutputProcessor::SOVStoreType::State,
1690 34658 : Surface(loop).Name);
1691 51987 : SetupOutputVariable(state,
1692 : "Surface Outside Face Convection Heat Gain Rate",
1693 : OutputProcessor::Unit::W,
1694 17329 : state.dataHeatBalSurf->SurfQdotConvOutRep(loop),
1695 : OutputProcessor::SOVTimeStepType::Zone,
1696 : OutputProcessor::SOVStoreType::State,
1697 34658 : Surface(loop).Name);
1698 51987 : SetupOutputVariable(state,
1699 : "Surface Outside Face Convection Heat Gain Rate per Area",
1700 : OutputProcessor::Unit::W_m2,
1701 17329 : state.dataHeatBalSurf->SurfQdotConvOutPerArea(loop),
1702 : OutputProcessor::SOVTimeStepType::Zone,
1703 : OutputProcessor::SOVStoreType::State,
1704 34658 : Surface(loop).Name);
1705 51987 : SetupOutputVariable(state,
1706 : "Surface Outside Face Convection Heat Gain Energy",
1707 : OutputProcessor::Unit::J,
1708 17329 : state.dataHeatBalSurf->SurfQConvOutReport(loop),
1709 : OutputProcessor::SOVTimeStepType::Zone,
1710 : OutputProcessor::SOVStoreType::Summed,
1711 34658 : Surface(loop).Name);
1712 51987 : SetupOutputVariable(state,
1713 : "Surface Outside Face Convection Heat Transfer Coefficient",
1714 : OutputProcessor::Unit::W_m2K,
1715 17329 : state.dataHeatBalSurf->SurfHcExt(loop),
1716 : OutputProcessor::SOVTimeStepType::Zone,
1717 : OutputProcessor::SOVStoreType::State,
1718 34658 : Surface(loop).Name);
1719 51987 : SetupOutputVariable(state,
1720 : "Surface Outside Face Net Thermal Radiation Heat Gain Rate",
1721 : OutputProcessor::Unit::W,
1722 17329 : state.dataHeatBalSurf->SurfQdotRadOutRep(loop),
1723 : OutputProcessor::SOVTimeStepType::Zone,
1724 : OutputProcessor::SOVStoreType::State,
1725 34658 : Surface(loop).Name);
1726 51987 : SetupOutputVariable(state,
1727 : "Surface Outside Face Net Thermal Radiation Heat Gain Rate per Area",
1728 : OutputProcessor::Unit::W_m2,
1729 17329 : state.dataHeatBalSurf->SurfQdotRadOutRepPerArea(loop),
1730 : OutputProcessor::SOVTimeStepType::Zone,
1731 : OutputProcessor::SOVStoreType::State,
1732 34658 : Surface(loop).Name);
1733 51987 : SetupOutputVariable(state,
1734 : "Surface Outside Face Net Thermal Radiation Heat Gain Energy",
1735 : OutputProcessor::Unit::J,
1736 17329 : state.dataHeatBalSurf->SurfQRadOutReport(loop),
1737 : OutputProcessor::SOVTimeStepType::Zone,
1738 : OutputProcessor::SOVStoreType::Summed,
1739 34658 : Surface(loop).Name);
1740 51987 : SetupOutputVariable(state,
1741 : "Surface Outside Face Thermal Radiation to Air Heat Transfer Coefficient",
1742 : OutputProcessor::Unit::W_m2K,
1743 17329 : state.dataHeatBalSurf->SurfHAirExt(loop),
1744 : OutputProcessor::SOVTimeStepType::Zone,
1745 : OutputProcessor::SOVStoreType::State,
1746 34658 : Surface(loop).Name);
1747 51987 : SetupOutputVariable(state,
1748 : "Surface Outside Face Thermal Radiation to Sky Heat Transfer Coefficient",
1749 : OutputProcessor::Unit::W_m2K,
1750 17329 : state.dataHeatBalSurf->SurfHSkyExt(loop),
1751 : OutputProcessor::SOVTimeStepType::Zone,
1752 : OutputProcessor::SOVStoreType::State,
1753 34658 : Surface(loop).Name);
1754 51987 : SetupOutputVariable(state,
1755 : "Surface Outside Face Thermal Radiation to Ground Heat Transfer Coefficient",
1756 : OutputProcessor::Unit::W_m2K,
1757 17329 : state.dataHeatBalSurf->SurfHGrdExt(loop),
1758 : OutputProcessor::SOVTimeStepType::Zone,
1759 : OutputProcessor::SOVStoreType::State,
1760 34658 : Surface(loop).Name);
1761 51987 : SetupOutputVariable(state,
1762 : "Surface Outside Face Thermal Radiation to Air Heat Transfer Rate",
1763 : OutputProcessor::Unit::W,
1764 17329 : state.dataHeatBalSurf->SurfQAirExtReport(loop),
1765 : OutputProcessor::SOVTimeStepType::Zone,
1766 : OutputProcessor::SOVStoreType::State,
1767 34658 : Surface(loop).Name);
1768 51987 : SetupOutputVariable(state,
1769 : "Surface Outside Face Heat Emission to Air Rate",
1770 : OutputProcessor::Unit::W,
1771 17329 : state.dataHeatBalSurf->SurfQHeatEmiReport(loop),
1772 : OutputProcessor::SOVTimeStepType::Zone,
1773 : OutputProcessor::SOVStoreType::State,
1774 34658 : Surface(loop).Name);
1775 :
1776 17329 : if (Surface(loop).Class != SurfaceClass::Window) {
1777 34107 : SetupOutputVariable(state,
1778 : "Surface Outside Face Solar Radiation Heat Gain Rate",
1779 : OutputProcessor::Unit::W,
1780 11369 : state.dataHeatBal->SurfOpaqSWOutAbsTotalReport(loop),
1781 : OutputProcessor::SOVTimeStepType::Zone,
1782 : OutputProcessor::SOVStoreType::Average,
1783 22738 : Surface(loop).Name);
1784 34107 : SetupOutputVariable(state,
1785 : "Surface Outside Face Solar Radiation Heat Gain Rate per Area",
1786 : OutputProcessor::Unit::W_m2,
1787 11369 : state.dataHeatBalSurf->SurfOpaqQRadSWOutAbs(loop),
1788 : OutputProcessor::SOVTimeStepType::Zone,
1789 : OutputProcessor::SOVStoreType::Average,
1790 22738 : Surface(loop).Name);
1791 34107 : SetupOutputVariable(state,
1792 : "Surface Outside Face Solar Radiation Heat Gain Energy",
1793 : OutputProcessor::Unit::J,
1794 11369 : state.dataHeatBal->SurfOpaqSWOutAbsEnergyReport(loop),
1795 : OutputProcessor::SOVTimeStepType::Zone,
1796 : OutputProcessor::SOVStoreType::Summed,
1797 22738 : Surface(loop).Name);
1798 : }
1799 : }
1800 132032 : if (Surface(loop).Class == SurfaceClass::Floor || Surface(loop).Class == SurfaceClass::Wall || Surface(loop).Class == SurfaceClass::IntMass ||
1801 60583 : Surface(loop).Class == SurfaceClass::Roof || Surface(loop).Class == SurfaceClass::Door) {
1802 : // IF (DisplayAdvancedReportVariables) THEN !CurrentModuleObject='Opaque Surfaces(Advanced)'
1803 108690 : SetupOutputVariable(state,
1804 : "Surface Inside Face Conduction Heat Transfer Rate",
1805 : OutputProcessor::Unit::W,
1806 36230 : state.dataHeatBalSurf->SurfOpaqInsFaceCond(loop),
1807 : OutputProcessor::SOVTimeStepType::Zone,
1808 : OutputProcessor::SOVStoreType::State,
1809 72460 : Surface(loop).Name);
1810 108690 : SetupOutputVariable(state,
1811 : "Surface Inside Face Conduction Heat Gain Rate",
1812 : OutputProcessor::Unit::W,
1813 36230 : state.dataHeatBalSurf->SurfOpaqInsFaceCondGainRep(loop),
1814 : OutputProcessor::SOVTimeStepType::Zone,
1815 : OutputProcessor::SOVStoreType::State,
1816 72460 : Surface(loop).Name);
1817 108690 : SetupOutputVariable(state,
1818 : "Surface Inside Face Conduction Heat Loss Rate",
1819 : OutputProcessor::Unit::W,
1820 36230 : state.dataHeatBalSurf->SurfOpaqInsFaceCondLossRep(loop),
1821 : OutputProcessor::SOVTimeStepType::Zone,
1822 : OutputProcessor::SOVStoreType::State,
1823 72460 : Surface(loop).Name);
1824 108690 : SetupOutputVariable(state,
1825 : "Surface Inside Face Conduction Heat Transfer Rate per Area",
1826 : OutputProcessor::Unit::W_m2,
1827 36230 : state.dataHeatBalSurf->SurfOpaqInsFaceCondFlux(loop),
1828 : OutputProcessor::SOVTimeStepType::Zone,
1829 : OutputProcessor::SOVStoreType::State,
1830 72460 : Surface(loop).Name);
1831 108690 : SetupOutputVariable(state,
1832 : "Surface Inside Face Conduction Heat Transfer Energy",
1833 : OutputProcessor::Unit::J,
1834 36230 : state.dataHeatBalSurf->SurfOpaqInsFaceCondEnergy(loop),
1835 : OutputProcessor::SOVTimeStepType::Zone,
1836 : OutputProcessor::SOVStoreType::Summed,
1837 72460 : Surface(loop).Name);
1838 :
1839 36230 : if (Surface(loop).ExtBoundCond != KivaFoundation) {
1840 108576 : SetupOutputVariable(state,
1841 : "Surface Outside Face Conduction Heat Transfer Rate",
1842 : OutputProcessor::Unit::W,
1843 36192 : state.dataHeatBalSurf->SurfOpaqOutFaceCond(loop),
1844 : OutputProcessor::SOVTimeStepType::Zone,
1845 : OutputProcessor::SOVStoreType::State,
1846 72384 : Surface(loop).Name);
1847 108576 : SetupOutputVariable(state,
1848 : "Surface Outside Face Conduction Heat Gain Rate",
1849 : OutputProcessor::Unit::W,
1850 36192 : state.dataHeatBalSurf->SurfOpaqExtFaceCondGainRep(loop),
1851 : OutputProcessor::SOVTimeStepType::Zone,
1852 : OutputProcessor::SOVStoreType::State,
1853 72384 : Surface(loop).Name);
1854 108576 : SetupOutputVariable(state,
1855 : "Surface Outside Face Conduction Heat Loss Rate",
1856 : OutputProcessor::Unit::W,
1857 36192 : state.dataHeatBalSurf->SurfOpaqExtFaceCondLossRep(loop),
1858 : OutputProcessor::SOVTimeStepType::Zone,
1859 : OutputProcessor::SOVStoreType::State,
1860 72384 : Surface(loop).Name);
1861 108576 : SetupOutputVariable(state,
1862 : "Surface Outside Face Conduction Heat Transfer Rate per Area",
1863 : OutputProcessor::Unit::W_m2,
1864 36192 : state.dataHeatBalSurf->SurfOpaqOutFaceCondFlux(loop),
1865 : OutputProcessor::SOVTimeStepType::Zone,
1866 : OutputProcessor::SOVStoreType::State,
1867 72384 : Surface(loop).Name);
1868 108576 : SetupOutputVariable(state,
1869 : "Surface Outside Face Conduction Heat Transfer Energy",
1870 : OutputProcessor::Unit::J,
1871 36192 : state.dataHeatBalSurf->SurfOpaqOutFaceCondEnergy(loop),
1872 : OutputProcessor::SOVTimeStepType::Zone,
1873 : OutputProcessor::SOVStoreType::Summed,
1874 72384 : Surface(loop).Name);
1875 :
1876 108576 : SetupOutputVariable(state,
1877 : "Surface Average Face Conduction Heat Transfer Rate",
1878 : OutputProcessor::Unit::W,
1879 36192 : state.dataHeatBalSurf->SurfOpaqAvgFaceCond(loop),
1880 : OutputProcessor::SOVTimeStepType::Zone,
1881 : OutputProcessor::SOVStoreType::State,
1882 72384 : Surface(loop).Name);
1883 108576 : SetupOutputVariable(state,
1884 : "Surface Average Face Conduction Heat Gain Rate",
1885 : OutputProcessor::Unit::W,
1886 36192 : state.dataHeatBalSurf->SurfOpaqAvgFaceCondGainRep(loop),
1887 : OutputProcessor::SOVTimeStepType::Zone,
1888 : OutputProcessor::SOVStoreType::State,
1889 72384 : Surface(loop).Name);
1890 108576 : SetupOutputVariable(state,
1891 : "Surface Average Face Conduction Heat Loss Rate",
1892 : OutputProcessor::Unit::W,
1893 36192 : state.dataHeatBalSurf->SurfOpaqAvgFaceCondLossRep(loop),
1894 : OutputProcessor::SOVTimeStepType::Zone,
1895 : OutputProcessor::SOVStoreType::State,
1896 72384 : Surface(loop).Name);
1897 108576 : SetupOutputVariable(state,
1898 : "Surface Average Face Conduction Heat Transfer Rate per Area",
1899 : OutputProcessor::Unit::W_m2,
1900 36192 : state.dataHeatBalSurf->SurfOpaqAvgFaceCondFlux(loop),
1901 : OutputProcessor::SOVTimeStepType::Zone,
1902 : OutputProcessor::SOVStoreType::State,
1903 72384 : Surface(loop).Name);
1904 108576 : SetupOutputVariable(state,
1905 : "Surface Average Face Conduction Heat Transfer Energy",
1906 : OutputProcessor::Unit::J,
1907 36192 : state.dataHeatBalSurf->SurfOpaqAvgFaceCondEnergy(loop),
1908 : OutputProcessor::SOVTimeStepType::Zone,
1909 : OutputProcessor::SOVStoreType::Summed,
1910 72384 : Surface(loop).Name);
1911 :
1912 108576 : SetupOutputVariable(state,
1913 : "Surface Heat Storage Rate",
1914 : OutputProcessor::Unit::W,
1915 36192 : state.dataHeatBalSurf->SurfOpaqStorageCond(loop),
1916 : OutputProcessor::SOVTimeStepType::Zone,
1917 : OutputProcessor::SOVStoreType::State,
1918 72384 : Surface(loop).Name);
1919 108576 : SetupOutputVariable(state,
1920 : "Surface Heat Storage Gain Rate",
1921 : OutputProcessor::Unit::W,
1922 36192 : state.dataHeatBalSurf->SurfOpaqStorageCondGainRep(loop),
1923 : OutputProcessor::SOVTimeStepType::Zone,
1924 : OutputProcessor::SOVStoreType::State,
1925 72384 : Surface(loop).Name);
1926 108576 : SetupOutputVariable(state,
1927 : "Surface Heat Storage Loss Rate",
1928 : OutputProcessor::Unit::W,
1929 36192 : state.dataHeatBalSurf->SurfOpaqStorageCondLossRep(loop),
1930 : OutputProcessor::SOVTimeStepType::Zone,
1931 : OutputProcessor::SOVStoreType::State,
1932 72384 : Surface(loop).Name);
1933 108576 : SetupOutputVariable(state,
1934 : "Surface Heat Storage Rate per Area",
1935 : OutputProcessor::Unit::W_m2,
1936 36192 : state.dataHeatBalSurf->SurfOpaqStorageCondFlux(loop),
1937 : OutputProcessor::SOVTimeStepType::Zone,
1938 : OutputProcessor::SOVStoreType::State,
1939 72384 : Surface(loop).Name);
1940 108576 : SetupOutputVariable(state,
1941 : "Surface Heat Storage Energy",
1942 : OutputProcessor::Unit::J,
1943 36192 : state.dataHeatBalSurf->SurfOpaqStorageCondEnergy(loop),
1944 : OutputProcessor::SOVTimeStepType::Zone,
1945 : OutputProcessor::SOVStoreType::Summed,
1946 72384 : Surface(loop).Name);
1947 : }
1948 :
1949 : // ENDIF
1950 : // CurrentModuleObject='Opaque Surfaces'
1951 :
1952 108690 : SetupOutputVariable(state,
1953 : "Surface Inside Face Beam Solar Radiation Heat Gain Rate",
1954 : OutputProcessor::Unit::W,
1955 36230 : state.dataHeatBalSurf->SurfOpaqInsFaceBeamSolAbsorbed(loop),
1956 : OutputProcessor::SOVTimeStepType::Zone,
1957 : OutputProcessor::SOVStoreType::State,
1958 72460 : Surface(loop).Name);
1959 : }
1960 42207 : if (state.dataConstruction->Construct(Surface(loop).Construction).SourceSinkPresent) {
1961 426 : SetupOutputVariable(state,
1962 : "Surface Internal Source Location Temperature",
1963 : OutputProcessor::Unit::C,
1964 142 : state.dataHeatBalSurf->SurfTempSource(loop),
1965 : OutputProcessor::SOVTimeStepType::Zone,
1966 : OutputProcessor::SOVStoreType::State,
1967 284 : Surface(loop).Name);
1968 426 : SetupOutputVariable(state,
1969 : "Surface Internal User Specified Location Temperature",
1970 : OutputProcessor::Unit::C,
1971 142 : state.dataHeatBalSurf->SurfTempUserLoc(loop),
1972 : OutputProcessor::SOVTimeStepType::Zone,
1973 : OutputProcessor::SOVStoreType::State,
1974 284 : Surface(loop).Name);
1975 : }
1976 :
1977 42207 : if (Surface(loop).Class == SurfaceClass::Window) { // CurrentModuleObject='Windows'
1978 17922 : SetupOutputVariable(state,
1979 : "Surface Shading Device Is On Time Fraction",
1980 : OutputProcessor::Unit::None,
1981 5974 : state.dataSurface->SurfWinFracTimeShadingDeviceOn(loop),
1982 : OutputProcessor::SOVTimeStepType::Zone,
1983 : OutputProcessor::SOVStoreType::Average,
1984 11948 : Surface(loop).Name);
1985 23896 : SetupOutputVariable(state,
1986 : "Surface Storm Window On Off Status",
1987 : OutputProcessor::Unit::None,
1988 5974 : state.dataSurface->SurfWinStormWinFlag(loop),
1989 : OutputProcessor::SOVTimeStepType::Zone,
1990 : OutputProcessor::SOVStoreType::State,
1991 11948 : Surface(loop).Name);
1992 17922 : SetupOutputVariable(state,
1993 : "Surface Window Blind Slat Angle",
1994 : OutputProcessor::Unit::deg,
1995 5974 : state.dataSurface->SurfWinSlatAngThisTSDeg(loop),
1996 : OutputProcessor::SOVTimeStepType::Zone,
1997 : OutputProcessor::SOVStoreType::State,
1998 11948 : Surface(loop).Name);
1999 : }
2000 : // IF (DisplayAdvancedReportVariables) THEN !CurrentModuleObject='Opaque Surfaces(Advanced)'
2001 168828 : SetupOutputVariable(state,
2002 : "Surface Inside Face Convection Classification Index",
2003 : OutputProcessor::Unit::None,
2004 42207 : state.dataSurface->SurfIntConvClassificationRpt(loop),
2005 : OutputProcessor::SOVTimeStepType::Zone,
2006 : OutputProcessor::SOVStoreType::Average,
2007 84414 : Surface(loop).Name);
2008 168828 : SetupOutputVariable(state,
2009 : "Surface Inside Face Convection Model Equation Index",
2010 : OutputProcessor::Unit::None,
2011 42207 : state.dataSurface->SurfIntConvHcModelEq(loop),
2012 : OutputProcessor::SOVTimeStepType::Zone,
2013 : OutputProcessor::SOVStoreType::Average,
2014 84414 : Surface(loop).Name);
2015 168828 : SetupOutputVariable(state,
2016 : "Surface Inside Face Convection Reference Air Index",
2017 : OutputProcessor::Unit::None,
2018 42207 : state.dataSurface->SurfTAirRefRpt(loop),
2019 : OutputProcessor::SOVTimeStepType::Zone,
2020 : OutputProcessor::SOVStoreType::Average,
2021 84414 : Surface(loop).Name);
2022 42207 : if (Surface(loop).ExtBoundCond == ExternalEnvironment) {
2023 68320 : SetupOutputVariable(state,
2024 : "Surface Outside Face Convection Classification Index",
2025 : OutputProcessor::Unit::None,
2026 17080 : state.dataSurface->SurfOutConvClassificationRpt(loop),
2027 : OutputProcessor::SOVTimeStepType::Zone,
2028 : OutputProcessor::SOVStoreType::Average,
2029 34160 : Surface(loop).Name);
2030 68320 : SetupOutputVariable(state,
2031 : "Surface Outside Face Forced Convection Model Equation Index",
2032 : OutputProcessor::Unit::None,
2033 17080 : state.dataSurface->SurfOutConvHfModelEq(loop),
2034 : OutputProcessor::SOVTimeStepType::Zone,
2035 : OutputProcessor::SOVStoreType::Average,
2036 34160 : Surface(loop).Name);
2037 68320 : SetupOutputVariable(state,
2038 : "Surface Outside Face Natural Convection Model Equation Index",
2039 : OutputProcessor::Unit::None,
2040 17080 : state.dataSurface->SurfOutConvHnModelEq(loop),
2041 : OutputProcessor::SOVTimeStepType::Zone,
2042 : OutputProcessor::SOVStoreType::Average,
2043 34160 : Surface(loop).Name);
2044 : }
2045 :
2046 126621 : SetupOutputVariable(state,
2047 : "Surface Inside Face Heat Source Gain Rate per Area",
2048 : OutputProcessor::Unit::W_m2,
2049 42207 : state.dataHeatBalSurf->SurfQAdditionalHeatSourceInside(loop),
2050 : OutputProcessor::SOVTimeStepType::Zone,
2051 : OutputProcessor::SOVStoreType::Average,
2052 84414 : Surface(loop).Name);
2053 126621 : SetupOutputVariable(state,
2054 : "Surface Outside Face Heat Source Gain Rate per Area",
2055 : OutputProcessor::Unit::W_m2,
2056 42207 : state.dataHeatBalSurf->SurfQAdditionalHeatSourceOutside(loop),
2057 : OutputProcessor::SOVTimeStepType::Zone,
2058 : OutputProcessor::SOVStoreType::Average,
2059 84414 : Surface(loop).Name);
2060 :
2061 : // ENDIF
2062 42207 : if (state.dataGlobal->DisplayAdvancedReportVariables) {
2063 2240 : SetupOutputVariable(state,
2064 : "Surface Construction Index",
2065 : OutputProcessor::Unit::None,
2066 560 : Surface(loop).Construction,
2067 : OutputProcessor::SOVTimeStepType::Zone,
2068 : OutputProcessor::SOVStoreType::Average,
2069 1120 : Surface(loop).Name);
2070 : }
2071 : }
2072 :
2073 2313 : SetupOutputVariable(state,
2074 : "Site Total Surface Heat Emission to Air",
2075 : OutputProcessor::Unit::J,
2076 771 : state.dataHeatBalSurf->SumSurfaceHeatEmission,
2077 : OutputProcessor::SOVTimeStepType::Zone,
2078 : OutputProcessor::SOVStoreType::Summed,
2079 1542 : "Environment");
2080 771 : }
2081 :
2082 6218 : void InitThermalAndFluxHistories(EnergyPlusData &state)
2083 : {
2084 :
2085 : // SUBROUTINE INFORMATION:
2086 : // AUTHOR George Walton
2087 : // DATE WRITTEN March 1978
2088 : // MODIFIED na
2089 : // RE-ENGINEERED Feb98 (RKS)
2090 :
2091 : // PURPOSE OF THIS SUBROUTINE:
2092 : // This subroutine sets the initial temperature and flux histories
2093 : // needed for a stable and reasonable heat balance solution starting
2094 : // point.
2095 :
2096 : // METHODOLOGY EMPLOYED:
2097 : // This subroutine assumes that the simulation is at steady state at
2098 : // the beginning and then begins to vary. Thus, the temperatures, the
2099 : // fluxes. and their histories can all be set to the same value. Some
2100 : // of the initializations depend on the surface characteristics. This
2101 : // requires a DO loop to perform the proper calculation.
2102 :
2103 : // REFERENCES:
2104 : // (I)BLAST legacy routine INITTH
2105 :
2106 : // SUBROUTINE LOCAL VARIABLE DECLARATIONS:
2107 : int SurfNum; // DO loop counter for surfaces
2108 : int OSCMnum; // DO loop counter for Other side conditions modeled (OSCM)
2109 :
2110 6218 : auto &Surface(state.dataSurface->Surface);
2111 :
2112 : // First do the "bulk" initializations of arrays sized to NumOfZones
2113 52491 : for (int zoneNum = 1; zoneNum <= state.dataGlobal->NumOfZones; ++zoneNum) {
2114 46273 : state.dataHeatBal->ZoneMRT(zoneNum) = DataHeatBalance::ZoneInitialTemp; // module level array
2115 : // TODO: Reinitializing this entire struct may cause diffs
2116 46273 : new (&state.dataZoneTempPredictorCorrector->zoneHeatBalance(zoneNum)) ZoneTempPredictorCorrector::ZoneHeatBalanceData();
2117 : // Initialize the Zone Humidity Ratio here so that it is available for EMPD implementations
2118 46273 : auto &thisZoneHB = state.dataZoneTempPredictorCorrector->zoneHeatBalance(zoneNum);
2119 46273 : thisZoneHB.ZoneAirHumRatAvg = state.dataEnvrn->OutHumRat;
2120 46273 : thisZoneHB.ZoneAirHumRat = state.dataEnvrn->OutHumRat;
2121 46273 : state.dataHeatBalFanSys->TempTstatAir(zoneNum) = DataHeatBalance::ZoneInitialTemp;
2122 : }
2123 : // Reset spaceHeatBalance even if doSpaceHeatBalance is false, beause spaceHB is used to gether zoneHB in some cases
2124 52531 : for (auto &thisSpaceHB : state.dataZoneTempPredictorCorrector->spaceHeatBalance) {
2125 46313 : new (&thisSpaceHB) ZoneTempPredictorCorrector::SpaceHeatBalanceData();
2126 : // Initialize the Zone Humidity Ratio here so that it is available for EMPD implementations
2127 46313 : thisSpaceHB.ZoneAirHumRatAvg = state.dataEnvrn->OutHumRat;
2128 46313 : thisSpaceHB.ZoneAirHumRat = state.dataEnvrn->OutHumRat;
2129 : }
2130 :
2131 : // "Bulk" initializations of arrays sized to TotSurfaces
2132 52491 : for (int zoneNum = 1; zoneNum <= state.dataGlobal->NumOfZones; ++zoneNum) {
2133 92586 : for (int spaceNum : state.dataHeatBal->Zone(zoneNum).spaceIndexes) {
2134 46313 : auto &thisSpace = state.dataHeatBal->space(spaceNum);
2135 46313 : int const firstSurf = thisSpace.HTSurfaceFirst;
2136 46313 : int const lastSurf = thisSpace.HTSurfaceLast;
2137 453582 : for (int SurfNum = firstSurf; SurfNum <= lastSurf; ++SurfNum) {
2138 407269 : state.dataHeatBal->SurfTempEffBulkAir(SurfNum) = SurfInitialTemp;
2139 407269 : state.dataHeatBalSurf->SurfTempIn(SurfNum) = SurfInitialTemp; // module level array
2140 407269 : state.dataHeatBalSurf->SurfTempInTmp(SurfNum) = SurfInitialTemp; // module level array
2141 407269 : state.dataHeatBalSurf->SurfHConvInt(SurfNum) = SurfInitialConvCoeff; // module level array
2142 407269 : state.dataHeatBalSurf->SurfHcExt(SurfNum) = 0.0;
2143 407269 : state.dataHeatBalSurf->SurfHAirExt(SurfNum) = 0.0;
2144 407269 : state.dataHeatBalSurf->SurfHSkyExt(SurfNum) = 0.0;
2145 407269 : state.dataHeatBalSurf->SurfHGrdExt(SurfNum) = 0.0;
2146 407269 : state.dataHeatBalSurf->SurfTempOut(SurfNum) = 0.0;
2147 407269 : state.dataHeatBalSurf->SurfTempInMovInsRep(SurfNum) = 0.0;
2148 407269 : state.dataHeatBalSurf->SurfQConvInReport(SurfNum) = 0.0;
2149 407269 : state.dataHeatBalSurf->SurfQdotConvInRep(SurfNum) = 0.0;
2150 407269 : state.dataHeatBalSurf->SurfQdotConvInPerArea(SurfNum) = 0.0;
2151 407269 : state.dataHeatBalSurf->SurfQRadNetSurfInReport(SurfNum) = 0.0;
2152 407269 : state.dataHeatBalSurf->SurfQdotRadNetSurfInRep(SurfNum) = 0.0;
2153 407269 : state.dataHeatBalSurf->SurfQRadSolarInReport(SurfNum) = 0.0;
2154 407269 : state.dataHeatBalSurf->SurfQdotRadSolarInRep(SurfNum) = 0.0;
2155 407269 : state.dataHeatBalSurf->SurfQdotRadSolarInRepPerArea(SurfNum) = 0.0;
2156 407269 : state.dataHeatBalSurf->SurfQRadLightsInReport(SurfNum) = 0.0;
2157 407269 : state.dataHeatBalSurf->SurfQdotRadLightsInRep(SurfNum) = 0.0;
2158 407269 : state.dataHeatBalSurf->SurfQRadIntGainsInReport(SurfNum) = 0.0;
2159 407269 : state.dataHeatBalSurf->SurfQdotRadIntGainsInRep(SurfNum) = 0.0;
2160 407269 : state.dataHeatBalSurf->AnyRadiantSystems(SurfNum) = false;
2161 407269 : state.dataHeatBalSurf->SurfQRadHVACInReport(SurfNum) = 0.0;
2162 407269 : state.dataHeatBalSurf->SurfQdotRadHVACInRep(SurfNum) = 0.0;
2163 407269 : state.dataHeatBalSurf->SurfQdotRadHVACInPerArea(SurfNum) = 0.0;
2164 407269 : state.dataHeatBalSurf->SurfQConvOutReport(SurfNum) = 0.0;
2165 407269 : state.dataHeatBalSurf->SurfQdotConvOutRep(SurfNum) = 0.0;
2166 407269 : state.dataHeatBalSurf->SurfQdotConvOutPerArea(SurfNum) = 0.0;
2167 407269 : state.dataHeatBalSurf->SurfQRadOutReport(SurfNum) = 0.0;
2168 407269 : state.dataHeatBalSurf->SurfQdotRadOutRep(SurfNum) = 0.0;
2169 407269 : state.dataHeatBalSurf->SurfQdotRadOutRepPerArea(SurfNum) = 0.0;
2170 407269 : state.dataHeatBalSurf->SurfQAirExtReport(SurfNum) = 0.0;
2171 407269 : state.dataHeatBalSurf->SurfQHeatEmiReport(SurfNum) = 0.0;
2172 : } // end of Surf array
2173 46313 : int const firstSurfOpaq = thisSpace.OpaqOrIntMassSurfaceFirst;
2174 46313 : int const lastSurfOpaq = thisSpace.OpaqOrIntMassSurfaceLast;
2175 46313 : if (firstSurfOpaq >= 0) {
2176 395619 : for (int SurfNum = firstSurfOpaq; SurfNum <= lastSurfOpaq; ++SurfNum) {
2177 349306 : state.dataHeatBalSurf->SurfOpaqInsFaceCond(SurfNum) = 0.0;
2178 349306 : state.dataHeatBalSurf->SurfOpaqInsFaceCondFlux(SurfNum) = 0.0;
2179 349306 : state.dataHeatBalSurf->SurfOpaqInsFaceCondEnergy(SurfNum) = 0.0;
2180 349306 : state.dataHeatBalSurf->SurfOpaqInsFaceBeamSolAbsorbed(SurfNum) = 0.0;
2181 : } // end of Zone Surf
2182 : }
2183 46313 : int const firstSurfWin = thisSpace.WindowSurfaceFirst;
2184 46313 : int const lastSurfWin = thisSpace.WindowSurfaceLast;
2185 46313 : if (firstSurfWin >= 0) {
2186 104266 : for (int SurfNum = firstSurfWin; SurfNum <= lastSurfWin; ++SurfNum) {
2187 : // Initialize window frame and divider temperatures
2188 57953 : state.dataSurface->SurfWinFrameTempIn(SurfNum) = SurfInitialTemp;
2189 57953 : state.dataSurface->SurfWinFrameTempInOld(SurfNum) = SurfInitialTemp;
2190 57953 : state.dataSurface->SurfWinFrameTempSurfOut(SurfNum) = SurfInitialTemp;
2191 57953 : state.dataSurface->SurfWinDividerTempIn(SurfNum) = SurfInitialTemp;
2192 57953 : state.dataSurface->SurfWinDividerTempInOld(SurfNum) = SurfInitialTemp;
2193 57953 : state.dataSurface->SurfWinDividerTempSurfOut(SurfNum) = SurfInitialTemp;
2194 :
2195 : // Initialize previous-timestep shading indicators
2196 57953 : state.dataSurface->SurfWinExtIntShadePrevTS(SurfNum) = WinShadingType::NoShade;
2197 57953 : state.dataSurface->SurfWinShadingFlag(SurfNum) = WinShadingType::NoShade;
2198 : } // end of Zone Surf
2199 : }
2200 : }
2201 : } // end of Zone
2202 :
2203 : // "Bulk" initializations of temperature arrays with dimensions (TotSurface,MaxCTFTerms,2)
2204 52491 : for (int zoneNum = 1; zoneNum <= state.dataGlobal->NumOfZones; ++zoneNum) {
2205 92586 : for (int spaceNum : state.dataHeatBal->Zone(zoneNum).spaceIndexes) {
2206 46313 : auto &thisSpace = state.dataHeatBal->space(spaceNum);
2207 46313 : int const firstSurf = thisSpace.HTSurfaceFirst;
2208 46313 : int const lastSurf = thisSpace.HTSurfaceLast;
2209 926260 : for (int CTFTermNum = 1; CTFTermNum <= Construction::MaxCTFTerms; ++CTFTermNum) {
2210 8618058 : for (int SurfNum = firstSurf; SurfNum <= lastSurf; ++SurfNum) {
2211 7738111 : state.dataHeatBalSurf->SurfInsideTempHist(CTFTermNum)(SurfNum) = SurfInitialTemp;
2212 7738111 : state.dataHeatBalSurf->SurfOutsideTempHist(CTFTermNum)(SurfNum) = SurfInitialTemp;
2213 7738111 : state.dataHeatBalSurf->SurfInsideFluxHist(CTFTermNum)(SurfNum) = 0.0;
2214 7738111 : state.dataHeatBalSurf->SurfOutsideFluxHist(CTFTermNum)(SurfNum) = 0.0;
2215 : }
2216 : }
2217 : }
2218 : }
2219 6218 : if (!state.dataHeatBal->SimpleCTFOnly || state.dataGlobal->AnyEnergyManagementSystemInModel) {
2220 14894 : for (int zoneNum = 1; zoneNum <= state.dataGlobal->NumOfZones; ++zoneNum) {
2221 27502 : for (int spaceNum : state.dataHeatBal->Zone(zoneNum).spaceIndexes) {
2222 13751 : auto &thisSpace = state.dataHeatBal->space(spaceNum);
2223 13751 : int const firstSurf = thisSpace.HTSurfaceFirst;
2224 13751 : int const lastSurf = thisSpace.HTSurfaceLast;
2225 144880 : for (int SurfNum = firstSurf; SurfNum <= lastSurf; ++SurfNum) {
2226 131129 : state.dataHeatBalSurf->SurfCurrNumHist(SurfNum) = 0;
2227 : }
2228 275020 : for (int CTFTermNum = 1; CTFTermNum <= Construction::MaxCTFTerms; ++CTFTermNum) {
2229 2752720 : for (int SurfNum = firstSurf; SurfNum <= lastSurf; ++SurfNum) {
2230 2491451 : state.dataHeatBalSurf->SurfInsideTempHistMaster(CTFTermNum)(SurfNum) = SurfInitialTemp;
2231 2491451 : state.dataHeatBalSurf->SurfOutsideTempHistMaster(CTFTermNum)(SurfNum) = SurfInitialTemp;
2232 2491451 : state.dataHeatBalSurf->SurfInsideFluxHistMaster(CTFTermNum)(SurfNum) = 0.0;
2233 2491451 : state.dataHeatBalSurf->SurfOutsideFluxHistMaster(CTFTermNum)(SurfNum) = 0.0;
2234 : }
2235 : }
2236 : }
2237 : }
2238 : }
2239 6218 : if (state.dataHeatBal->AnyInternalHeatSourceInInput) {
2240 1170 : for (int zoneNum = 1; zoneNum <= state.dataGlobal->NumOfZones; ++zoneNum) {
2241 1770 : for (int spaceNum : state.dataHeatBal->Zone(zoneNum).spaceIndexes) {
2242 885 : auto &thisSpace = state.dataHeatBal->space(spaceNum);
2243 885 : int const firstSurf = thisSpace.HTSurfaceFirst;
2244 885 : int const lastSurf = thisSpace.HTSurfaceLast;
2245 7313 : for (int SurfNum = firstSurf; SurfNum <= lastSurf; ++SurfNum) {
2246 128560 : for (int CTFTermNum = 1; CTFTermNum <= Construction::MaxCTFTerms; ++CTFTermNum) {
2247 122132 : state.dataHeatBalSurf->SurfTsrcHist(SurfNum, CTFTermNum) = SurfInitialTemp;
2248 122132 : state.dataHeatBalSurf->SurfTsrcHistM(SurfNum, CTFTermNum) = SurfInitialTemp;
2249 122132 : state.dataHeatBalSurf->SurfTuserHist(SurfNum, CTFTermNum) = SurfInitialTemp;
2250 122132 : state.dataHeatBalSurf->SurfTuserHistM(SurfNum, CTFTermNum) = SurfInitialTemp;
2251 122132 : state.dataHeatBalSurf->SurfQsrcHist(SurfNum, CTFTermNum) = 0.0;
2252 122132 : state.dataHeatBalSurf->SurfQsrcHistM(SurfNum, CTFTermNum) = 0.0;
2253 : }
2254 : }
2255 : }
2256 : }
2257 : }
2258 6218 : state.dataHeatBal->CondFDRelaxFactor = state.dataHeatBal->CondFDRelaxFactorInput;
2259 :
2260 : // Perform other initializations that depend on the surface characteristics
2261 69187 : for (int CTFTermNum = 1; CTFTermNum <= state.dataHeatBal->MaxCTFTerms + 1; ++CTFTermNum) {
2262 4525220 : for (SurfNum = 1; SurfNum <= state.dataSurface->TotSurfaces; ++SurfNum) {
2263 4462251 : if (!Surface(SurfNum).HeatTransSurf) continue; // Skip non-heat transfer surfaces
2264 : // Reset outside boundary conditions if necessary
2265 4335125 : if ((Surface(SurfNum).ExtBoundCond == ExternalEnvironment) || (Surface(SurfNum).ExtBoundCond == OtherSideCondModeledExt)) {
2266 1672422 : state.dataHeatBalSurf->SurfOutsideTempHist(CTFTermNum)(SurfNum) = state.dataSurface->SurfOutDryBulbTemp(SurfNum);
2267 2662703 : } else if (Surface(SurfNum).ExtBoundCond == Ground) {
2268 207088 : state.dataHeatBalSurf->SurfOutsideTempHist(CTFTermNum)(SurfNum) = state.dataEnvrn->GroundTemp;
2269 2455615 : } else if (Surface(SurfNum).ExtBoundCond == GroundFCfactorMethod) {
2270 17289 : state.dataHeatBalSurf->SurfOutsideTempHist(CTFTermNum)(SurfNum) = state.dataEnvrn->GroundTempFC;
2271 : }
2272 : // Initialize the flux histories
2273 4335125 : state.dataHeatBalSurf->SurfOutsideFluxHist(CTFTermNum)(SurfNum) =
2274 8670250 : state.dataConstruction->Construct(Surface(SurfNum).Construction).UValue *
2275 4335125 : (state.dataHeatBalSurf->SurfOutsideTempHist(1)(SurfNum) - state.dataHeatBalSurf->SurfInsideTempHist(1)(SurfNum));
2276 4335125 : state.dataHeatBalSurf->SurfInsideFluxHist(CTFTermNum)(SurfNum) = state.dataHeatBalSurf->SurfOutsideFluxHist(2)(SurfNum);
2277 : }
2278 : }
2279 426543 : for (SurfNum = 1; SurfNum <= state.dataSurface->TotSurfaces; ++SurfNum) {
2280 :
2281 420325 : if (!Surface(SurfNum).HeatTransSurf) continue; // Skip non-heat transfer surfaces
2282 :
2283 407274 : if (state.dataSurface->SurfExtCavityPresent(SurfNum)) {
2284 30 : state.dataSurface->ExtVentedCavity(state.dataSurface->SurfExtCavNum(SurfNum)).TbaffleLast = 20.0;
2285 30 : state.dataSurface->ExtVentedCavity(state.dataSurface->SurfExtCavNum(SurfNum)).TairLast = 20.0;
2286 : }
2287 : }
2288 : // Initialize Kiva convection algorithms
2289 6474 : for (auto SurfNum : state.dataSurface->AllHTKivaSurfaceList) {
2290 256 : state.dataSurfaceGeometry->kivaManager.surfaceConvMap[SurfNum].in = KIVA_CONST_CONV(3.076);
2291 256 : state.dataSurfaceGeometry->kivaManager.surfaceConvMap[SurfNum].f = KIVA_HF_DEF;
2292 256 : state.dataSurfaceGeometry->kivaManager.surfaceConvMap[SurfNum].out = KIVA_CONST_CONV(0.0);
2293 : }
2294 6218 : if (!state.dataHeatBal->SimpleCTFOnly || state.dataGlobal->AnyEnergyManagementSystemInModel) {
2295 133726 : for (SurfNum = 1; SurfNum <= state.dataSurface->TotSurfaces; ++SurfNum) {
2296 132583 : if (!Surface(SurfNum).HeatTransSurf) continue;
2297 131129 : if ((Surface(SurfNum).ExtBoundCond == ExternalEnvironment) || (Surface(SurfNum).ExtBoundCond == OtherSideCondModeledExt)) {
2298 992380 : for (int CTFTermNum = 1; CTFTermNum <= Construction::MaxCTFTerms; ++CTFTermNum) {
2299 942761 : state.dataHeatBalSurf->SurfOutsideTempHistMaster(CTFTermNum)(SurfNum) = state.dataSurface->SurfOutDryBulbTemp(SurfNum);
2300 : }
2301 81510 : } else if (Surface(SurfNum).ExtBoundCond == Ground) {
2302 73360 : for (int CTFTermNum = 1; CTFTermNum <= Construction::MaxCTFTerms; ++CTFTermNum) {
2303 69692 : state.dataHeatBalSurf->SurfOutsideTempHistMaster(CTFTermNum)(SurfNum) = state.dataEnvrn->GroundTemp;
2304 : }
2305 77842 : } else if (Surface(SurfNum).ExtBoundCond == GroundFCfactorMethod) {
2306 38720 : for (int CTFTermNum = 1; CTFTermNum <= Construction::MaxCTFTerms; ++CTFTermNum) {
2307 36784 : state.dataHeatBalSurf->SurfOutsideTempHistMaster(CTFTermNum)(SurfNum) = state.dataEnvrn->GroundTempFC;
2308 : }
2309 : }
2310 789002 : for (int CTFTermNum = 2; CTFTermNum <= state.dataConstruction->Construct(Surface(SurfNum).Construction).NumCTFTerms + 1; ++CTFTermNum) {
2311 657873 : state.dataHeatBalSurf->SurfOutsideFluxHistMaster(CTFTermNum)(SurfNum) = state.dataHeatBalSurf->SurfOutsideFluxHist(2)(SurfNum);
2312 657873 : state.dataHeatBalSurf->SurfInsideFluxHistMaster(CTFTermNum)(SurfNum) = state.dataHeatBalSurf->SurfOutsideFluxHist(2)(SurfNum);
2313 : }
2314 : }
2315 : }
2316 :
2317 6218 : if (state.dataSurface->TotOSCM >= 1) {
2318 232 : for (OSCMnum = 1; OSCMnum <= state.dataSurface->TotOSCM; ++OSCMnum) {
2319 152 : state.dataSurface->OSCM(OSCMnum).TConv = 20.0;
2320 152 : state.dataSurface->OSCM(OSCMnum).HConv = 4.0;
2321 152 : state.dataSurface->OSCM(OSCMnum).TRad = 20.0;
2322 152 : state.dataSurface->OSCM(OSCMnum).HRad = 4.0;
2323 : }
2324 : }
2325 6218 : }
2326 :
2327 10122 : void EvalOutsideMovableInsulation(EnergyPlusData &state)
2328 : {
2329 : // This subroutine determines whether or not outside movable insulation on opaque surfaces is present at the current time.
2330 20244 : for (int SurfNum : state.dataHeatBalSurf->SurfMovInsulIndexList) {
2331 10122 : Real64 MovInsulSchedVal = GetCurrentScheduleValue(state, state.dataSurface->SurfSchedMovInsulExt(SurfNum));
2332 10122 : if (MovInsulSchedVal <= 0) { // Movable insulation not present at current time
2333 6075 : state.dataHeatBalSurf->SurfMovInsulExtPresent(SurfNum) = false;
2334 6075 : int ConstrNum = state.dataSurface->SurfActiveConstruction(SurfNum);
2335 6075 : state.dataHeatBalSurf->SurfAbsSolarExt(SurfNum) =
2336 6075 : state.dataMaterial->Material(state.dataConstruction->Construct(ConstrNum).LayerPoint(1)).AbsorpSolar;
2337 6075 : state.dataHeatBalSurf->SurfAbsThermalExt(SurfNum) =
2338 6075 : state.dataMaterial->Material(state.dataConstruction->Construct(ConstrNum).LayerPoint(1)).AbsorpThermal;
2339 6075 : state.dataHeatBalSurf->SurfRoughnessExt(SurfNum) =
2340 6075 : state.dataMaterial->Material(state.dataConstruction->Construct(ConstrNum).LayerPoint(1)).Roughness;
2341 6075 : continue;
2342 : }
2343 4047 : int const MaterialIndex(state.dataSurface->SurfMaterialMovInsulExt(SurfNum));
2344 4047 : DataHeatBalance::MaterialGroup const MaterialGroupNum(state.dataMaterial->Material(MaterialIndex).Group);
2345 4047 : state.dataHeatBalSurf->SurfMovInsulExtPresent(SurfNum) = true;
2346 4047 : state.dataHeatBalSurf->SurfMovInsulHExt(SurfNum) = 1.0 / (MovInsulSchedVal * state.dataMaterial->Material(MaterialIndex).Resistance);
2347 4047 : if (MaterialGroupNum == DataHeatBalance::MaterialGroup::WindowGlass ||
2348 : MaterialGroupNum == DataHeatBalance::MaterialGroup::GlassEquivalentLayer) {
2349 2022 : state.dataHeatBalSurf->SurfAbsSolarExt(SurfNum) =
2350 2022 : max(0.0, 1.0 - state.dataMaterial->Material(MaterialIndex).Trans - state.dataMaterial->Material(MaterialIndex).ReflectSolBeamFront);
2351 : } else {
2352 2025 : state.dataHeatBalSurf->SurfAbsSolarExt(SurfNum) = state.dataMaterial->Material(MaterialIndex).AbsorpSolar;
2353 : }
2354 4047 : state.dataHeatBalSurf->SurfAbsThermalExt(SurfNum) = state.dataMaterial->Material(MaterialIndex).AbsorpThermal;
2355 4047 : state.dataHeatBalSurf->SurfRoughnessExt(SurfNum) = state.dataMaterial->Material(MaterialIndex).Roughness;
2356 : }
2357 10122 : }
2358 :
2359 10122 : void EvalInsideMovableInsulation(EnergyPlusData &state)
2360 : {
2361 : // This subroutine determines whether or not inside movable insulation is present at the current time.
2362 20244 : for (int SurfNum : state.dataHeatBalSurf->SurfMovInsulIndexList) {
2363 10122 : Real64 MovInsulSchedVal = GetCurrentScheduleValue(state, state.dataSurface->SurfSchedMovInsulInt(SurfNum));
2364 10122 : if (MovInsulSchedVal <= 0.0) { // Movable insulation not present at current time
2365 4047 : state.dataHeatBalSurf->SurfMovInsulIntPresent(SurfNum) = false;
2366 4047 : int ConstrNum = state.dataSurface->SurfActiveConstruction(SurfNum);
2367 4047 : state.dataHeatBalSurf->SurfAbsSolarInt(SurfNum) = state.dataConstruction->Construct(ConstrNum).InsideAbsorpSolar;
2368 4047 : state.dataHeatBalSurf->SurfAbsThermalInt(SurfNum) = state.dataConstruction->Construct(ConstrNum).InsideAbsorpThermal;
2369 4047 : continue;
2370 : }
2371 6075 : int const MaterialIndex(state.dataSurface->SurfMaterialMovInsulInt(SurfNum));
2372 6075 : DataHeatBalance::MaterialGroup const MaterialGroupNum(state.dataMaterial->Material(MaterialIndex).Group);
2373 6075 : state.dataHeatBalSurf->SurfMovInsulIntPresent(SurfNum) = true;
2374 6075 : state.dataHeatBalSurf->SurfMovInsulHInt(SurfNum) = 1.0 / (MovInsulSchedVal * state.dataMaterial->Material(MaterialIndex).Resistance);
2375 6075 : if (MaterialGroupNum == DataHeatBalance::MaterialGroup::WindowGlass ||
2376 : MaterialGroupNum == DataHeatBalance::MaterialGroup::GlassEquivalentLayer) {
2377 0 : state.dataHeatBalSurf->SurfAbsSolarInt(SurfNum) =
2378 0 : max(0.0, 1.0 - state.dataMaterial->Material(MaterialIndex).Trans - state.dataMaterial->Material(MaterialIndex).ReflectSolBeamFront);
2379 : } else {
2380 6075 : state.dataHeatBalSurf->SurfAbsSolarInt(SurfNum) = state.dataMaterial->Material(MaterialIndex).AbsorpSolar;
2381 : }
2382 6075 : state.dataHeatBalSurf->SurfAbsThermalInt(SurfNum) = state.dataMaterial->Material(MaterialIndex).AbsorpThermal;
2383 : }
2384 10122 : }
2385 :
2386 2568509 : void InitSolarHeatGains(EnergyPlusData &state)
2387 : {
2388 :
2389 : // SUBROUTINE INFORMATION:
2390 : // AUTHOR Anonymous
2391 : // DATE WRITTEN July 1977
2392 : // MODIFIED Mar99 (FW): handle movable interior shades and
2393 : // switchable glazing
2394 : // Oct99 (FW): account for Window5 glass calculation approach
2395 : // May01 (FW): handle interior and exterior blinds
2396 : // Sep03 (FW): initialize SurfaceWindow%FrameQRadOutAbs
2397 : // May06 (RR): handle exterior window screens
2398 : // RE-ENGINEERED Feb98 (RKS)
2399 :
2400 : // PURPOSE OF THIS SUBROUTINE:
2401 : // This subroutine initializes the arrays associated with solar heat
2402 : // gains for both individual surfaces and for zones. As a result,
2403 : // this routine sets the following variable arrays:
2404 : // QBV(unused), QDV, QC, QD; SurfOpaqQRadSWOutAbs and SurfOpaqQRadSWInAbs (for opaque surfaces);
2405 : // SurfWinQRadSWwinAbs (for windows)
2406 :
2407 : // METHODOLOGY EMPLOYED:
2408 : // If the sun is down, all of the pertinent arrays are zeroed. If the
2409 : // sun is up, various calculations are made.
2410 :
2411 : // REFERENCES:
2412 : // (I)BLAST legacy routine QSUN
2413 :
2414 2568509 : auto &Surface(state.dataSurface->Surface);
2415 :
2416 : // Using/Aliasing
2417 : using DaylightingDevices::TransTDD;
2418 : using General::InterpSw;
2419 : using General::POLYF;
2420 : using SolarShading::CalcInteriorSolarDistribution;
2421 : using namespace DataWindowEquivalentLayer;
2422 : using SolarShading::SurfaceScheduledSolarInc;
2423 : using SolarShading::WindowScheduledSolarAbs;
2424 :
2425 2568509 : auto &AbsDiffWin = state.dataHeatBalSurfMgr->AbsDiffWin;
2426 2568509 : auto &AbsDiffWinGnd = state.dataHeatBalSurfMgr->AbsDiffWinGnd;
2427 2568509 : auto &AbsDiffWinSky = state.dataHeatBalSurfMgr->AbsDiffWinSky;
2428 :
2429 21015074 : for (int zoneNum = 1; zoneNum <= state.dataGlobal->NumOfZones; ++zoneNum) {
2430 18446565 : state.dataHeatBal->ZoneWinHeatGainRepEnergy(zoneNum) = 0.0;
2431 18446565 : state.dataHeatBal->ZoneWinHeatLossRepEnergy(zoneNum) = 0.0;
2432 18446565 : state.dataHeatBal->ZnOpqSurfInsFaceCondGnRepEnrg(zoneNum) = 0.0;
2433 18446565 : state.dataHeatBal->ZnOpqSurfInsFaceCondLsRepEnrg(zoneNum) = 0.0;
2434 18446565 : state.dataHeatBal->ZnOpqSurfExtFaceCondGnRepEnrg(zoneNum) = 0.0;
2435 18446565 : state.dataHeatBal->ZnOpqSurfExtFaceCondLsRepEnrg(zoneNum) = 0.0;
2436 :
2437 18446565 : state.dataHeatBal->ZoneWinHeatGain(zoneNum) = 0.0;
2438 18446565 : state.dataHeatBal->ZoneWinHeatGainRep(zoneNum) = 0.0;
2439 18446565 : state.dataHeatBal->ZoneWinHeatLossRep(zoneNum) = 0.0;
2440 18446565 : state.dataHeatBal->ZoneOpaqSurfInsFaceCond(zoneNum) = 0.0;
2441 18446565 : state.dataHeatBal->ZoneOpaqSurfInsFaceCondGainRep(zoneNum) = 0.0;
2442 18446565 : state.dataHeatBal->ZoneOpaqSurfInsFaceCondLossRep(zoneNum) = 0.0;
2443 18446565 : state.dataHeatBal->ZoneOpaqSurfExtFaceCond(zoneNum) = 0.0;
2444 18446565 : state.dataHeatBal->ZoneOpaqSurfExtFaceCondGainRep(zoneNum) = 0.0;
2445 18446565 : state.dataHeatBal->ZoneOpaqSurfExtFaceCondLossRep(zoneNum) = 0.0;
2446 : }
2447 21002924 : for (int enclNum = 1; enclNum <= state.dataViewFactor->NumOfSolarEnclosures; ++enclNum) {
2448 18434415 : state.dataHeatBal->EnclSolInitialDifSolReflW(enclNum) = 0.0;
2449 : }
2450 21015074 : for (int zoneNum = 1; zoneNum <= state.dataGlobal->NumOfZones; ++zoneNum) {
2451 36909306 : for (int spaceNum : state.dataHeatBal->Zone(zoneNum).spaceIndexes) {
2452 18462741 : auto &thisSpace = state.dataHeatBal->space(spaceNum);
2453 18462741 : int const firstSurfOpaq = thisSpace.OpaqOrIntMassSurfaceFirst;
2454 18462741 : int const lastSurfOpaq = thisSpace.OpaqOrIntMassSurfaceLast;
2455 156163195 : for (int SurfNum = firstSurfOpaq; SurfNum <= lastSurfOpaq; ++SurfNum) {
2456 137700454 : state.dataHeatBalSurf->SurfOpaqInsFaceCondGainRep(SurfNum) = 0.0;
2457 137700454 : state.dataHeatBalSurf->SurfOpaqInsFaceCondLossRep(SurfNum) = 0.0;
2458 137700454 : state.dataHeatBalSurf->SurfOpaqQRadSWInAbs(SurfNum) = 0.0;
2459 137700454 : state.dataHeatBalSurf->SurfQdotRadLightsInPerArea(SurfNum) = 0.0;
2460 137700454 : state.dataHeatBalSurf->SurfOpaqQRadSWOutAbs(SurfNum) = 0.0;
2461 137700454 : state.dataHeatBalSurf->SurfOpaqInitialDifSolInAbs(SurfNum) = 0.0;
2462 137700454 : state.dataHeatBalSurf->SurfOpaqInsFaceBeamSolAbsorbed(SurfNum) = 0.0;
2463 137700454 : state.dataHeatBal->SurfOpaqSWOutAbsTotalReport(SurfNum) = 0.0;
2464 137700454 : state.dataHeatBal->SurfOpaqSWOutAbsEnergyReport(SurfNum) = 0.0;
2465 : }
2466 :
2467 18462741 : int const firstSurfWin = thisSpace.WindowSurfaceFirst;
2468 18462741 : int const lastSurfWin = thisSpace.WindowSurfaceLast;
2469 40474011 : for (int SurfNum = firstSurfWin; SurfNum <= lastSurfWin; ++SurfNum) {
2470 : // Faster "inline" than calling SurfaceWindow( SurfNum ).InitSolarHeatGains()
2471 22011270 : state.dataSurface->SurfWinFrameQRadOutAbs(SurfNum) = 0.0;
2472 22011270 : state.dataSurface->SurfWinFrameQRadInAbs(SurfNum) = 0.0;
2473 22011270 : state.dataSurface->SurfWinDividerQRadOutAbs(SurfNum) = 0.0;
2474 22011270 : state.dataSurface->SurfWinDividerQRadInAbs(SurfNum) = 0.0;
2475 22011270 : state.dataSurface->SurfWinIntSWAbsByShade(SurfNum) = 0.0;
2476 22011270 : state.dataSurface->SurfWinIntLWAbsByShade(SurfNum) = 0.0;
2477 22011270 : state.dataSurface->SurfWinConvHeatFlowNatural(SurfNum) = 0.0;
2478 22011270 : state.dataSurface->SurfWinConvHeatGainToZoneAir(SurfNum) = 0.0;
2479 22011270 : state.dataSurface->SurfWinRetHeatGainToZoneAir(SurfNum) = 0.0;
2480 22011270 : state.dataSurface->SurfWinDividerHeatGain(SurfNum) = 0.0;
2481 : }
2482 :
2483 40474011 : for (int SurfNum = firstSurfWin; SurfNum <= lastSurfWin; ++SurfNum) {
2484 22011270 : state.dataSurface->SurfWinGainConvGlazToZoneRep(SurfNum) = 0.0;
2485 22011270 : state.dataSurface->SurfWinGainIRGlazToZoneRep(SurfNum) = 0.0;
2486 22011270 : state.dataSurface->SurfWinLossSWZoneToOutWinRep(SurfNum) = 0.0;
2487 22011270 : state.dataSurface->SurfWinGainFrameDividerToZoneRep(SurfNum) = 0.0;
2488 22011270 : state.dataSurface->SurfWinGainConvShadeToZoneRep(SurfNum) = 0.0;
2489 22011270 : state.dataSurface->SurfWinGainIRShadeToZoneRep(SurfNum) = 0.0;
2490 22011270 : state.dataSurface->SurfWinGapConvHtFlowRep(SurfNum) = 0.0;
2491 22011270 : state.dataSurface->SurfWinShadingAbsorbedSolar(SurfNum) = 0.0;
2492 22011270 : state.dataSurface->SurfWinSysSolTransmittance(SurfNum) = 0.0;
2493 : }
2494 40474011 : for (int SurfNum = firstSurfWin; SurfNum <= lastSurfWin; ++SurfNum) {
2495 22011270 : state.dataSurface->SurfWinHeatGain(SurfNum) = 0.0;
2496 22011270 : state.dataSurface->SurfWinHeatGainRep(SurfNum) = 0.0;
2497 22011270 : state.dataSurface->SurfWinHeatLossRep(SurfNum) = 0.0;
2498 22011270 : state.dataSurface->SurfWinHeatGainRepEnergy(SurfNum) = 0.0;
2499 22011270 : state.dataSurface->SurfWinHeatLossRepEnergy(SurfNum) = 0.0;
2500 22011270 : state.dataSurface->SurfWinGapConvHtFlowRepEnergy(SurfNum) = 0.0;
2501 22011270 : state.dataSurface->SurfWinShadingAbsorbedSolarEnergy(SurfNum) = 0.0;
2502 : }
2503 147701928 : for (int Lay = 1; Lay <= DataWindowEquivalentLayer::CFSMAXNL + 1; Lay++) {
2504 283318077 : for (int SurfNum = firstSurfWin; SurfNum <= lastSurfWin; ++SurfNum) {
2505 154078890 : state.dataHeatBal->SurfWinQRadSWwinAbs(SurfNum, Lay) = 0.0;
2506 : }
2507 : }
2508 : }
2509 : }
2510 2568509 : if (state.dataHeatBalSurfMgr->InitSurfaceHeatBalancefirstTime) {
2511 44533 : for (int SurfNum = 1; SurfNum <= state.dataSurface->TotSurfaces; ++SurfNum) {
2512 43762 : state.dataSurface->SurfBmToDiffReflFacGnd(SurfNum) = Surface(SurfNum).ViewFactorGround;
2513 43762 : state.dataSurface->SurfSkyDiffReflFacGnd(SurfNum) = Surface(SurfNum).ViewFactorGround;
2514 : }
2515 : }
2516 : bool currSolRadPositive =
2517 2568509 : state.dataEnvrn->SunIsUp && (state.dataEnvrn->BeamSolarRad + state.dataEnvrn->GndSolarRad + state.dataEnvrn->DifSolarRad > 0.0);
2518 2568509 : bool sunset = (!currSolRadPositive) && state.dataEnvrn->PreviousSolRadPositive;
2519 2568509 : bool sunIsUpNoRad = state.dataEnvrn->SunIsUp && (!currSolRadPositive);
2520 2568509 : bool resetSolar = state.dataGlobal->BeginEnvrnFlag || sunIsUpNoRad ||
2521 2568509 : sunset; // Reset at (1) Beginning of simulation (2) sunset time, and SunIsUp but not solar time.
2522 2568509 : state.dataEnvrn->PreviousSolRadPositive = currSolRadPositive;
2523 :
2524 2568509 : if (currSolRadPositive || resetSolar) {
2525 84865845 : for (int SurfNum = 1; SurfNum <= state.dataSurface->TotSurfaces; ++SurfNum) {
2526 83560683 : state.dataHeatBal->SurfBmIncInsSurfIntensRep(SurfNum) = 0.0;
2527 83560683 : state.dataHeatBal->SurfBmIncInsSurfAmountRep(SurfNum) = 0.0;
2528 83560683 : state.dataHeatBal->SurfIntBmIncInsSurfIntensRep(SurfNum) = 0.0;
2529 83560683 : state.dataHeatBal->SurfIntBmIncInsSurfAmountRep(SurfNum) = 0.0;
2530 83560683 : state.dataHeatBal->SurfIntBmIncInsSurfAmountRepEnergy(SurfNum) = 0.0;
2531 :
2532 83560683 : state.dataHeatBal->SurfQRadSWOutIncident(SurfNum) = 0.0;
2533 83560683 : state.dataHeatBal->SurfQRadSWOutIncidentBeam(SurfNum) = 0.0;
2534 83560683 : state.dataHeatBal->SurfQRadSWOutIncidentSkyDiffuse(SurfNum) = 0.0;
2535 83560683 : state.dataHeatBal->SurfQRadSWOutIncidentGndDiffuse(SurfNum) = 0.0;
2536 :
2537 83560683 : state.dataHeatBal->SurfQRadSWOutIncBmToDiffReflGnd(SurfNum) = 0.0;
2538 83560683 : state.dataHeatBal->SurfQRadSWOutIncSkyDiffReflGnd(SurfNum) = 0.0;
2539 83560683 : state.dataHeatBal->SurfQRadSWOutIncBmToBmReflObs(SurfNum) = 0.0;
2540 83560683 : state.dataHeatBal->SurfQRadSWOutIncBmToDiffReflObs(SurfNum) = 0.0;
2541 83560683 : state.dataHeatBal->SurfQRadSWOutIncSkyDiffReflObs(SurfNum) = 0.0;
2542 :
2543 83560683 : state.dataSurface->SurfSkySolarInc(SurfNum) = 0.0;
2544 83560683 : state.dataSurface->SurfGndSolarInc(SurfNum) = 0.0;
2545 : }
2546 10690575 : for (int enclNum = 1; enclNum <= state.dataViewFactor->NumOfSolarEnclosures; ++enclNum) {
2547 9385413 : state.dataHeatBal->ZoneTransSolar(enclNum) = 0.0;
2548 9385413 : state.dataHeatBal->ZoneBmSolFrExtWinsRep(enclNum) = 0.0;
2549 9385413 : state.dataHeatBal->ZoneBmSolFrIntWinsRep(enclNum) = 0.0;
2550 9385413 : state.dataHeatBal->ZoneDifSolFrExtWinsRep(enclNum) = 0.0;
2551 9385413 : state.dataHeatBal->ZoneDifSolFrIntWinsRep(enclNum) = 0.0;
2552 9385413 : state.dataHeatBal->ZoneTransSolarEnergy(enclNum) = 0.0;
2553 9385413 : state.dataHeatBal->ZoneBmSolFrExtWinsRepEnergy(enclNum) = 0.0;
2554 9385413 : state.dataHeatBal->ZoneBmSolFrIntWinsRepEnergy(enclNum) = 0.0;
2555 9385413 : state.dataHeatBal->ZoneDifSolFrExtWinsRepEnergy(enclNum) = 0.0;
2556 9385413 : state.dataHeatBal->ZoneDifSolFrIntWinsRepEnergy(enclNum) = 0.0;
2557 : }
2558 10696785 : for (int zoneNum = 1; zoneNum <= state.dataGlobal->NumOfZones; ++zoneNum) {
2559 18791518 : for (int spaceNum : state.dataHeatBal->Zone(zoneNum).spaceIndexes) {
2560 9399895 : auto &thisSpace = state.dataHeatBal->space(spaceNum);
2561 9399895 : int const firstSurfWin = thisSpace.WindowSurfaceFirst;
2562 9399895 : int const lastSurfWin = thisSpace.WindowSurfaceLast;
2563 20654938 : for (int SurfNum = firstSurfWin; SurfNum <= lastSurfWin; ++SurfNum) {
2564 11255043 : state.dataSurface->SurfWinExtBeamAbsByShade(SurfNum) = 0.0;
2565 11255043 : state.dataSurface->SurfWinExtDiffAbsByShade(SurfNum) = 0.0;
2566 11255043 : state.dataSurface->SurfWinIntBeamAbsByShade(SurfNum) = 0.0;
2567 11255043 : state.dataSurface->SurfWinInitialDifSolAbsByShade(SurfNum) = 0.0;
2568 11255043 : state.dataHeatBal->SurfWinQRadSWwinAbsTot(SurfNum) = 0.0;
2569 11255043 : state.dataHeatBal->SurfWinQRadSWwinAbsTotEnergy(SurfNum) = 0.0;
2570 11255043 : state.dataHeatBal->SurfWinSWwinAbsTotalReport(SurfNum) = 0.0;
2571 11255043 : state.dataHeatBalSurf->SurfWinInitialDifSolInTrans(SurfNum) = 0.0;
2572 11255043 : state.dataHeatBal->SurfWinInitialDifSolInTransReport(SurfNum) = 0.0;
2573 : }
2574 20654938 : for (int SurfNum = firstSurfWin; SurfNum <= lastSurfWin; ++SurfNum) {
2575 11255043 : state.dataSurface->SurfWinBlTsolBmBm(SurfNum) = 0.0;
2576 11255043 : state.dataSurface->SurfWinBlTsolBmDif(SurfNum) = 0.0;
2577 11255043 : state.dataSurface->SurfWinBlTsolDifDif(SurfNum) = 0.0;
2578 11255043 : state.dataSurface->SurfWinBlGlSysTsolBmBm(SurfNum) = 0.0;
2579 11255043 : state.dataSurface->SurfWinBlGlSysTsolDifDif(SurfNum) = 0.0;
2580 11255043 : state.dataSurface->SurfWinScTsolBmBm(SurfNum) = 0.0;
2581 11255043 : state.dataSurface->SurfWinScTsolBmDif(SurfNum) = 0.0;
2582 11255043 : state.dataSurface->SurfWinScTsolDifDif(SurfNum) = 0.0;
2583 11255043 : state.dataSurface->SurfWinScGlSysTsolBmBm(SurfNum) = 0.0;
2584 11255043 : state.dataSurface->SurfWinScGlSysTsolDifDif(SurfNum) = 0.0;
2585 11255043 : state.dataSurface->SurfWinGlTsolBmBm(SurfNum) = 0.0;
2586 11255043 : state.dataSurface->SurfWinGlTsolBmDif(SurfNum) = 0.0;
2587 11255043 : state.dataSurface->SurfWinGlTsolDifDif(SurfNum) = 0.0;
2588 : }
2589 20654938 : for (int SurfNum = firstSurfWin; SurfNum <= lastSurfWin; ++SurfNum) {
2590 11255043 : state.dataSurface->SurfWinBmSolTransThruIntWinRep(SurfNum) = 0.0;
2591 11255043 : state.dataSurface->SurfWinBmSolAbsdOutsReveal(SurfNum) = 0.0;
2592 11255043 : state.dataSurface->SurfWinBmSolAbsdInsReveal(SurfNum) = 0.0;
2593 11255043 : state.dataSurface->SurfWinBmSolRefldInsReveal(SurfNum) = 0.0;
2594 11255043 : state.dataSurface->SurfWinOutsRevealDiffOntoGlazing(SurfNum) = 0.0;
2595 11255043 : state.dataSurface->SurfWinInsRevealDiffOntoGlazing(SurfNum) = 0.0;
2596 11255043 : state.dataSurface->SurfWinInsRevealDiffIntoZone(SurfNum) = 0.0;
2597 11255043 : state.dataSurface->SurfWinOutsRevealDiffOntoFrame(SurfNum) = 0.0;
2598 11255043 : state.dataSurface->SurfWinInsRevealDiffOntoFrame(SurfNum) = 0.0;
2599 : }
2600 20654938 : for (int SurfNum = firstSurfWin; SurfNum <= lastSurfWin; ++SurfNum) {
2601 11255043 : state.dataSurface->SurfWinBmSolRefldOutsRevealReport(SurfNum) = 0.0;
2602 11255043 : state.dataSurface->SurfWinBmSolRefldInsRevealReport(SurfNum) = 0.0;
2603 11255043 : state.dataSurface->SurfWinBmSolAbsdInsRevealReport(SurfNum) = 0.0;
2604 11255043 : state.dataSurface->SurfWinInsRevealDiffOntoGlazingReport(SurfNum) = 0.0;
2605 11255043 : state.dataSurface->SurfWinInsRevealDiffIntoZoneReport(SurfNum) = 0.0;
2606 11255043 : state.dataSurface->SurfWinInsRevealDiffOntoFrameReport(SurfNum) = 0.0;
2607 11255043 : state.dataSurface->SurfWinBmSolTransThruIntWinRepEnergy(SurfNum) = 0.0;
2608 11255043 : state.dataSurface->SurfWinBmSolRefldOutsRevealRepEnergy(SurfNum) = 0.0;
2609 11255043 : state.dataSurface->SurfWinBmSolRefldInsRevealRepEnergy(SurfNum) = 0.0;
2610 : }
2611 :
2612 20654938 : for (int SurfNum = firstSurfWin; SurfNum <= lastSurfWin; ++SurfNum) {
2613 11255043 : state.dataSurface->SurfWinTransSolar(SurfNum) = 0.0;
2614 11255043 : state.dataSurface->SurfWinBmSolar(SurfNum) = 0.0;
2615 11255043 : state.dataSurface->SurfWinBmBmSolar(SurfNum) = 0.0;
2616 11255043 : state.dataSurface->SurfWinBmDifSolar(SurfNum) = 0.0;
2617 11255043 : state.dataSurface->SurfWinDifSolar(SurfNum) = 0.0;
2618 11255043 : state.dataSurface->SurfWinTransSolarEnergy(SurfNum) = 0.0;
2619 11255043 : state.dataSurface->SurfWinBmSolarEnergy(SurfNum) = 0.0;
2620 11255043 : state.dataSurface->SurfWinBmBmSolarEnergy(SurfNum) = 0.0;
2621 11255043 : state.dataSurface->SurfWinBmDifSolarEnergy(SurfNum) = 0.0;
2622 11255043 : state.dataSurface->SurfWinDifSolarEnergy(SurfNum) = 0.0;
2623 11255043 : state.dataHeatBal->SurfWinBSDFBeamDirectionRep(SurfNum) = 0;
2624 11255043 : state.dataHeatBal->SurfWinBSDFBeamThetaRep(SurfNum) = 0.0;
2625 11255043 : state.dataHeatBal->SurfWinBSDFBeamPhiRep(SurfNum) = 0.0;
2626 : }
2627 75241353 : for (int Lay = 1; Lay <= state.dataHeatBal->MaxSolidWinLayers; Lay++) {
2628 144703754 : for (int SurfNum = firstSurfWin; SurfNum <= lastSurfWin; ++SurfNum) {
2629 78862296 : state.dataHeatBal->SurfWinQRadSWwinAbsLayer(SurfNum, Lay) = 0.0;
2630 : }
2631 : }
2632 65799265 : for (int Lay = 1; Lay <= DataWindowEquivalentLayer::CFSMAXNL; Lay++) {
2633 123929628 : for (int SurfNum = firstSurfWin; SurfNum <= lastSurfWin; ++SurfNum) {
2634 67530258 : state.dataHeatBal->SurfWinInitialDifSolwinAbs(SurfNum, Lay) = 0.0;
2635 : }
2636 : }
2637 : }
2638 : }
2639 : }
2640 2568509 : if (resetSolar) {
2641 4023965 : for (int enclosureNum = 1; enclosureNum <= state.dataViewFactor->NumOfSolarEnclosures; ++enclosureNum) {
2642 3540906 : state.dataHeatBal->EnclSolQD(enclosureNum) = 0.0;
2643 3540906 : state.dataHeatBal->EnclSolQDforDaylight(enclosureNum) = 0.0;
2644 : }
2645 :
2646 : // TTD domes are currently not considered in the window list of a zone
2647 483059 : if ((int)state.dataDaylightingDevicesData->TDDPipe.size() > 0) {
2648 1233 : for (auto &e : state.dataDaylightingDevicesData->TDDPipe) {
2649 822 : e.TransSolBeam = 0.0;
2650 822 : e.TransSolDiff = 0.0;
2651 822 : e.TransVisBeam = 0.0;
2652 822 : e.TransVisDiff = 0.0;
2653 822 : e.TransmittedSolar = 0.0;
2654 822 : int SurfDome = e.Dome;
2655 822 : state.dataSurface->SurfWinTransSolar(SurfDome) = 0.0;
2656 822 : state.dataHeatBal->SurfQRadSWOutIncident(SurfDome) = 0.0;
2657 822 : state.dataHeatBal->SurfWinQRadSWwinAbsTot(SurfDome) = 0.0;
2658 6576 : for (int Lay = 1; Lay <= DataWindowEquivalentLayer::CFSMAXNL + 1; Lay++) {
2659 5754 : state.dataHeatBal->SurfWinQRadSWwinAbs(SurfDome, Lay) = 0.0;
2660 : }
2661 : }
2662 : }
2663 :
2664 483059 : if (state.dataSurface->CalcSolRefl) {
2665 37007 : for (int SurfNum = 1; SurfNum <= state.dataSurface->TotSurfaces; ++SurfNum) {
2666 33428 : state.dataSurface->SurfBmToBmReflFacObs(SurfNum) = 0.0;
2667 33428 : state.dataSurface->SurfBmToDiffReflFacObs(SurfNum) = 0.0;
2668 33428 : state.dataSurface->SurfBmToDiffReflFacGnd(SurfNum) = 0.0;
2669 : }
2670 : }
2671 32004107 : for (int SurfNum = 1; SurfNum <= state.dataSurface->TotSurfaces; ++SurfNum) {
2672 31521048 : state.dataHeatBal->SurfInitialDifSolInAbsReport(SurfNum) = 0.0;
2673 31521048 : state.dataHeatBal->SurfCosIncidenceAngle(SurfNum) = 0.0;
2674 31521048 : state.dataHeatBal->SurfSWInAbsTotalReport(SurfNum) = 0.0;
2675 31521048 : state.dataSurface->SurfWinProfileAngHor(SurfNum) = 0.0;
2676 31521048 : state.dataSurface->SurfWinProfileAngVert(SurfNum) = 0.0;
2677 31521048 : state.dataSurface->SurfWinSysSolReflectance(SurfNum) = 0.0;
2678 31521048 : state.dataSurface->SurfWinSysSolAbsorptance(SurfNum) = 0.0;
2679 : }
2680 : }
2681 2568509 : if (currSolRadPositive) { // Sun is up, calculate solar quantities
2682 822103 : assert(equal_dimensions(state.dataSurface->SurfReflFacBmToBmSolObs,
2683 : state.dataSurface->SurfReflFacBmToDiffSolObs)); // For linear indexing
2684 822103 : assert(equal_dimensions(state.dataSurface->SurfReflFacBmToBmSolObs,
2685 : state.dataSurface->SurfReflFacBmToDiffSolGnd)); // For linear indexing
2686 822103 : Real64 GndReflSolarRad = 0.0;
2687 822103 : Real64 GndSolarRadInc = max(state.dataEnvrn->BeamSolarRad * state.dataEnvrn->SOLCOS(3) + state.dataEnvrn->DifSolarRad, 0.0);
2688 :
2689 52861738 : for (int SurfNum = 1; SurfNum <= state.dataSurface->TotSurfaces; ++SurfNum) {
2690 52039635 : state.dataSurface->Surface(SurfNum).IncSolMultiplier = GetSurfIncidentSolarMultiplier(state, SurfNum);
2691 : }
2692 52861738 : for (int SurfNum = 1; SurfNum <= state.dataSurface->TotSurfaces; ++SurfNum) {
2693 52039635 : Real64 SurfIncSolarMultiplier = state.dataSurface->Surface(SurfNum).IncSolMultiplier;
2694 52039635 : state.dataSurface->SurfSkySolarInc(SurfNum) =
2695 52039635 : state.dataEnvrn->DifSolarRad * SurfIncSolarMultiplier * state.dataSolarShading->SurfAnisoSkyMult(SurfNum);
2696 52039635 : if (state.dataSurface->Surface(SurfNum).UseSurfPropertyGndSurfRefl) {
2697 9408 : GndReflSolarRad = GndSolarRadInc * SurfIncSolarMultiplier *
2698 4704 : state.dataSurface->GroundSurfsProperty(state.dataSurface->Surface(SurfNum).SurfPropertyGndSurfIndex).SurfsReflAvg;
2699 4704 : Surface(SurfNum).GndReflSolarRad = GndReflSolarRad;
2700 : } else {
2701 52034931 : GndReflSolarRad = state.dataEnvrn->GndSolarRad * SurfIncSolarMultiplier;
2702 : }
2703 52039635 : state.dataSurface->SurfGndSolarInc(SurfNum) = GndReflSolarRad * Surface(SurfNum).ViewFactorGround;
2704 52039635 : state.dataSurface->SurfWinSkyGndSolarInc(SurfNum) = state.dataSurface->SurfGndSolarInc(SurfNum);
2705 52039635 : state.dataSurface->SurfWinBmGndSolarInc(SurfNum) = 0.0;
2706 : }
2707 822103 : if (state.dataSurface->CalcSolRefl) {
2708 : // [ lSH ] == ( HourOfDay, SurfNum ) // [ lSP ] == ( PreviousHour, SurfNum )
2709 5881 : Array1D<Real64>::size_type lSH = state.dataSurface->SurfReflFacBmToBmSolObs.index(state.dataGlobal->HourOfDay, 1) - 1;
2710 5881 : Array1D<Real64>::size_type lSP = state.dataSurface->SurfReflFacBmToBmSolObs.index(state.dataGlobal->PreviousHour, 1) - 1;
2711 : // For Complex Fenestrations:
2712 74557 : for (int SurfNum = 1; SurfNum <= state.dataSurface->TotSurfaces; ++SurfNum) {
2713 68676 : Real64 SurfIncSolarMultiplier = state.dataSurface->Surface(SurfNum).IncSolMultiplier;
2714 :
2715 68676 : Real64 GndSurfReflectance = 0.0;
2716 68676 : if (state.dataSurface->Surface(SurfNum).UseSurfPropertyGndSurfRefl) {
2717 0 : GndSurfReflectance =
2718 0 : state.dataSurface->GroundSurfsProperty(state.dataSurface->Surface(SurfNum).SurfPropertyGndSurfIndex).SurfsReflAvg;
2719 : } else {
2720 68676 : GndSurfReflectance = state.dataEnvrn->GndReflectance;
2721 : }
2722 68676 : Real64 currDifSolarRad = state.dataEnvrn->DifSolarRad * SurfIncSolarMultiplier;
2723 68676 : Real64 currBeamSolarRad = state.dataEnvrn->BeamSolarRad * SurfIncSolarMultiplier;
2724 68676 : state.dataSurface->SurfWinSkyGndSolarInc(SurfNum) =
2725 68676 : currDifSolarRad * GndSurfReflectance * state.dataSurface->SurfReflFacSkySolGnd(SurfNum);
2726 68676 : state.dataSurface->SurfWinBmGndSolarInc(SurfNum) =
2727 68676 : currBeamSolarRad * state.dataEnvrn->SOLCOS(3) * GndSurfReflectance * state.dataSurface->SurfBmToDiffReflFacGnd(SurfNum);
2728 68676 : state.dataSurface->SurfBmToBmReflFacObs(SurfNum) =
2729 137352 : state.dataGlobal->WeightNow * state.dataSurface->SurfReflFacBmToBmSolObs[lSH + SurfNum] +
2730 68676 : state.dataGlobal->WeightPreviousHour * state.dataSurface->SurfReflFacBmToBmSolObs[lSP + SurfNum];
2731 68676 : state.dataSurface->SurfBmToDiffReflFacObs(SurfNum) =
2732 137352 : state.dataGlobal->WeightNow * state.dataSurface->SurfReflFacBmToDiffSolObs[lSH + SurfNum] +
2733 68676 : state.dataGlobal->WeightPreviousHour * state.dataSurface->SurfReflFacBmToDiffSolObs[lSP + SurfNum];
2734 68676 : state.dataSurface->SurfBmToDiffReflFacGnd(SurfNum) =
2735 137352 : state.dataGlobal->WeightNow * state.dataSurface->SurfReflFacBmToDiffSolGnd[lSH + SurfNum] +
2736 68676 : state.dataGlobal->WeightPreviousHour * state.dataSurface->SurfReflFacBmToDiffSolGnd[lSP + SurfNum];
2737 : // TH2 CR 9056
2738 68676 : state.dataSurface->SurfSkySolarInc(SurfNum) +=
2739 137352 : currBeamSolarRad * (state.dataSurface->SurfBmToBmReflFacObs(SurfNum) + state.dataSurface->SurfBmToDiffReflFacObs(SurfNum)) +
2740 68676 : currDifSolarRad * state.dataSurface->SurfReflFacSkySolObs(SurfNum);
2741 68676 : state.dataSurface->SurfGndSolarInc(SurfNum) =
2742 137352 : currBeamSolarRad * state.dataEnvrn->SOLCOS(3) * GndSurfReflectance * state.dataSurface->SurfBmToDiffReflFacGnd(SurfNum) +
2743 68676 : currDifSolarRad * GndSurfReflectance * state.dataSurface->SurfReflFacSkySolGnd(SurfNum);
2744 68676 : state.dataSurface->SurfSkyDiffReflFacGnd(SurfNum) = state.dataSurface->SurfReflFacSkySolGnd(SurfNum);
2745 : }
2746 : }
2747 :
2748 822103 : CalcWindowProfileAngles(state);
2749 :
2750 822103 : if (state.dataHeatBal->CalcWindowRevealReflection) CalcBeamSolarOnWinRevealSurface(state);
2751 :
2752 822103 : if (state.dataWindowManager->inExtWindowModel->isExternalLibraryModel() && state.dataWindowManager->winOpticalModel->isSimplifiedModel()) {
2753 826 : CalcAbsorbedOnExteriorOpaqueSurfaces(state);
2754 826 : if (state.dataWindowManager->winOpticalModel->isSimplifiedModel()) {
2755 826 : CalcInteriorSolarDistributionWCESimple(state);
2756 : }
2757 : } else {
2758 821277 : CalcInteriorSolarDistribution(state);
2759 : }
2760 :
2761 6666610 : for (int enclosureNum = 1; enclosureNum <= state.dataViewFactor->NumOfSolarEnclosures; ++enclosureNum) {
2762 :
2763 : // TH 3/24/2010 - QBV is not used!
2764 : // unused QBV(ZoneNum) = (CBZone(ZoneNum) + EnclSolDB(ZoneNum))*BeamSolarRad
2765 :
2766 : // RJH 08/30/07 - QDV does not seem to ever be used. NOT USED!
2767 : // QDV(ZoneNum) = EnclSolDS(ZoneNum)*DifSolarRad &
2768 : // +EnclSolDG(ZoneNum)*GndSolarRad
2769 :
2770 : // Original QD calc used only for EnclSolQSDifSol and daylighting calcs
2771 : // QDforDaylight(ZoneNum) = EnclSolDB(ZoneNum)*BeamSolarRad &
2772 : // +EnclSolDS(ZoneNum)*DifSolarRad &
2773 : // +EnclSolDG(ZoneNum)*GndSolarRad
2774 :
2775 : // Beam from interior windows (EnclSolDBIntWin) reflected from floor is counted in DayltgInterReflIllFrIntWins,
2776 : // EnclSolDB needs to subtract this part since it is already counted in EnclSolDB.
2777 : // Use EnclSolInitialDifSolReflW (Rob's previous work) as it better counts initial distribution of
2778 : // diffuse solar rather than using weighted area*absorptance
2779 5844507 : state.dataHeatBal->EnclSolQDforDaylight(enclosureNum) =
2780 11689014 : (state.dataHeatBal->EnclSolDB(enclosureNum) - state.dataHeatBal->EnclSolDBIntWin(enclosureNum)) * state.dataEnvrn->BeamSolarRad +
2781 11689014 : state.dataHeatBal->EnclSolDBSSG(enclosureNum) + state.dataHeatBal->EnclSolInitialDifSolReflW(enclosureNum);
2782 :
2783 : // to exclude diffuse solar now absorbed/transmitted in CalcWinTransDifSolInitialDistribution
2784 : // EnclSolDB(ZoneNum) is Diffuse Solar from beam reflected from interior surfaces
2785 : // and transmitted through interior windows
2786 : // EnclSolDB is a factor that when multiplied by BeamSolarRad [W/m2] gives Watts
2787 : // QD(ZoneNum) = EnclSolDB(ZoneNum)*BeamSolarRad &
2788 : // +EnclSolDS(ZoneNum)*DifSolarRad &
2789 : // +EnclSolDG(ZoneNum)*GndSolarRad
2790 17533521 : state.dataHeatBal->EnclSolQD(enclosureNum) = state.dataHeatBal->EnclSolDB(enclosureNum) * state.dataEnvrn->BeamSolarRad +
2791 11689014 : state.dataHeatBal->EnclSolDBSSG(enclosureNum) +
2792 5844507 : state.dataHeatBal->EnclSolInitialDifSolReflW(enclosureNum);
2793 : }
2794 :
2795 : // Flux of diffuse solar in each zone
2796 :
2797 6666610 : for (int enclNum = 1; enclNum <= state.dataViewFactor->NumOfSolarEnclosures; ++enclNum) {
2798 5844507 : state.dataHeatBal->EnclSolQSDifSol(enclNum) = state.dataHeatBal->EnclSolQDforDaylight(enclNum);
2799 : }
2800 :
2801 822103 : if (state.dataHeatBalSurf->InterZoneWindow) {
2802 18955 : for (int enclNum = 1; enclNum <= state.dataViewFactor->NumOfSolarEnclosures; ++enclNum) {
2803 15164 : if (state.dataHeatBalSurf->EnclSolRecDifShortFromZ(enclNum)) {
2804 9612 : Real64 EnclSolQSDifSol_sum(0.0); // Accumulator
2805 9612 : auto lZone(state.dataHeatBalSurf->ZoneFractDifShortZtoZ.index(enclNum,
2806 9612 : 1)); // Tuned Linear indexing
2807 48060 : for (int otherEnclNum = 1; otherEnclNum <= state.dataViewFactor->NumOfSolarEnclosures; ++otherEnclNum, ++lZone) {
2808 38448 : if ((otherEnclNum != enclNum) && (state.dataHeatBalSurf->EnclSolRecDifShortFromZ(otherEnclNum))) {
2809 35464 : EnclSolQSDifSol_sum += state.dataHeatBalSurf->ZoneFractDifShortZtoZ[lZone] *
2810 17732 : state.dataHeatBal->EnclSolQDforDaylight(otherEnclNum); // [ lZone ] == ( enclNum, otherEnclNum )
2811 : }
2812 : }
2813 9612 : state.dataHeatBal->EnclSolQSDifSol(enclNum) += EnclSolQSDifSol_sum;
2814 : }
2815 : }
2816 : }
2817 :
2818 6666610 : for (int enclNum = 1; enclNum <= state.dataViewFactor->NumOfSolarEnclosures; ++enclNum) {
2819 5844507 : if (state.dataHeatBalSurf->InterZoneWindow)
2820 15164 : state.dataHeatBal->EnclSolQSDifSol(enclNum) *=
2821 15164 : state.dataHeatBalSurf->ZoneFractDifShortZtoZ(enclNum, enclNum) * state.dataViewFactor->EnclSolInfo(enclNum).solVMULT;
2822 : else
2823 5829343 : state.dataHeatBal->EnclSolQSDifSol(enclNum) *= state.dataViewFactor->EnclSolInfo(enclNum).solVMULT;
2824 : }
2825 :
2826 : // RJH - 09-12-07 commented out report varariable calcs here since they refer to old distribution method
2827 : // DO SurfNum = 1, TotSurfaces
2828 : // IF (.NOT. Surface(SurfNum)%HeatTransSurf) CYCLE
2829 : //!!! Following may need to be removed or changed when shelves are considered in adjacent reflection calculations
2830 : // IF (Surface(SurfNum)%Class == SurfaceClass::Shading) CYCLE
2831 : // ZoneNum = Surface(SurfNum)%Zone
2832 : // Diffuse solar entering zone through exterior windows is assumed to be uniformly
2833 : // distributed on inside face of surfaces of zone
2834 : // DifIncInsSurfIntensRep(SurfNum) = (EnclSolDS(ZoneNum)*DifSolarRad + EnclSolDG(ZoneNum)*GndSolarRad) / &
2835 : // Zone(ZoneNum)%TotalSurfArea
2836 : // DifIncInsSurfAmountRep(SurfNum) = (Surface(SurfNum)%Area + SurfaceWindow(SurfNum)%DividerArea) * &
2837 : // DifIncInsSurfIntensRep(SurfNum)
2838 : // DifIncInsSurfAmountRepEnergy(SurfNum) = DifIncInsSurfAmountRep(SurfNum) * TimeStepZoneSec
2839 : // END DO
2840 :
2841 : // Calculate Exterior Incident Short Wave (i.e. Solar) Radiation on shading surfaces
2842 822103 : if (state.dataSurface->BuildingShadingCount || state.dataSurface->FixedShadingCount || state.dataSurface->AttachedShadingCount) {
2843 1766595 : for (int SurfNum = state.dataSurface->ShadingSurfaceFirst; SurfNum <= state.dataSurface->ShadingSurfaceLast; SurfNum++) {
2844 1502136 : Real64 GndSurfReflectance = 0.0;
2845 1502136 : if (state.dataSurface->Surface(SurfNum).UseSurfPropertyGndSurfRefl) {
2846 0 : GndSurfReflectance =
2847 0 : state.dataSurface->GroundSurfsProperty(state.dataSurface->Surface(SurfNum).SurfPropertyGndSurfIndex).SurfsReflAvg;
2848 : } else {
2849 1502136 : GndSurfReflectance = state.dataEnvrn->GndReflectance;
2850 : }
2851 : // Cosine of incidence angle and solar incident on outside of surface, for reporting
2852 1502136 : Real64 CosInc = state.dataHeatBal->SurfCosIncAng(state.dataGlobal->HourOfDay, state.dataGlobal->TimeStep, SurfNum);
2853 1502136 : state.dataHeatBal->SurfCosIncidenceAngle(SurfNum) = CosInc;
2854 1502136 : Real64 SurfIncSolarMultiplier = state.dataSurface->Surface(SurfNum).IncSolMultiplier;
2855 1502136 : Real64 currDifSolarRad = state.dataEnvrn->DifSolarRad * SurfIncSolarMultiplier;
2856 1502136 : Real64 currBeamSolarRad = state.dataEnvrn->BeamSolarRad * SurfIncSolarMultiplier;
2857 : // Incident direct (unreflected) beam
2858 1502136 : state.dataHeatBal->SurfQRadSWOutIncidentBeam(SurfNum) =
2859 1502136 : currBeamSolarRad * state.dataHeatBal->SurfSunlitFrac(state.dataGlobal->HourOfDay, state.dataGlobal->TimeStep, SurfNum) * CosInc;
2860 : // Incident (unreflected) diffuse solar from sky -- TDD_Diffuser calculated differently
2861 1502136 : state.dataHeatBal->SurfQRadSWOutIncidentSkyDiffuse(SurfNum) = currDifSolarRad * state.dataSolarShading->SurfAnisoSkyMult(SurfNum);
2862 : // Incident diffuse solar from sky diffuse reflected from ground plus beam reflected from ground
2863 1502136 : state.dataHeatBal->SurfQRadSWOutIncidentGndDiffuse(SurfNum) = state.dataSurface->SurfGndSolarInc(SurfNum);
2864 : // Incident diffuse solar from beam-to-diffuse reflection from ground
2865 1502136 : state.dataHeatBal->SurfQRadSWOutIncBmToDiffReflGnd(SurfNum) =
2866 1502136 : currBeamSolarRad * state.dataEnvrn->SOLCOS(3) * GndSurfReflectance * state.dataSurface->SurfBmToDiffReflFacGnd(SurfNum);
2867 : // Incident diffuse solar from sky diffuse reflection from ground
2868 1502136 : state.dataHeatBal->SurfQRadSWOutIncSkyDiffReflGnd(SurfNum) =
2869 1502136 : currDifSolarRad * GndSurfReflectance * state.dataSurface->SurfSkyDiffReflFacGnd(SurfNum);
2870 : // Total incident solar. Beam and sky reflection from obstructions, if calculated, is included
2871 : // in SkySolarInc.
2872 1502136 : state.dataHeatBal->SurfQRadSWOutIncident(SurfNum) =
2873 3004272 : state.dataHeatBal->SurfQRadSWOutIncidentBeam(SurfNum) + state.dataHeatBal->SurfQRadSWOutIncidentSkyDiffuse(SurfNum) +
2874 3004272 : state.dataHeatBal->SurfQRadSWOutIncBmToDiffReflGnd(SurfNum) + state.dataHeatBal->SurfQRadSWOutIncSkyDiffReflGnd(SurfNum);
2875 : }
2876 : }
2877 :
2878 1644206 : Array1D<Real64> currBeamSolar(state.dataSurface->TotSurfaces); // Local variable for BeamSolarRad
2879 :
2880 21723483 : for (int SurfNum : state.dataSurface->AllExtSolarSurfaceList) {
2881 20901380 : Real64 SurfIncSolarMultiplier = state.dataSurface->Surface(SurfNum).IncSolMultiplier;
2882 : // Regular surface
2883 20901380 : currBeamSolar(SurfNum) = state.dataEnvrn->BeamSolarRad * SurfIncSolarMultiplier;
2884 20901380 : Real64 currDifSolarRad = state.dataEnvrn->DifSolarRad * SurfIncSolarMultiplier;
2885 : // Cosine of incidence angle and solar incident on outside of surface, for reporting
2886 20901380 : state.dataHeatBal->SurfCosIncidenceAngle(SurfNum) =
2887 20901380 : state.dataHeatBal->SurfCosIncAng(state.dataGlobal->HourOfDay, state.dataGlobal->TimeStep, SurfNum);
2888 :
2889 : // Report variables for various incident solar quantities
2890 : // Incident direct (unreflected) beam
2891 20901380 : state.dataHeatBal->SurfQRadSWOutIncidentBeam(SurfNum) =
2892 41802760 : currBeamSolar(SurfNum) * state.dataHeatBal->SurfSunlitFrac(state.dataGlobal->HourOfDay, state.dataGlobal->TimeStep, SurfNum) *
2893 20901380 : state.dataHeatBal->SurfCosIncidenceAngle(SurfNum);
2894 :
2895 20901380 : Real64 GndSurfReflectance = 0.0;
2896 20901380 : if (state.dataSurface->Surface(SurfNum).UseSurfPropertyGndSurfRefl) {
2897 3528 : GndSurfReflectance =
2898 3528 : state.dataSurface->GroundSurfsProperty(state.dataSurface->Surface(SurfNum).SurfPropertyGndSurfIndex).SurfsReflAvg;
2899 : } else {
2900 20897852 : GndSurfReflectance = state.dataEnvrn->GndReflectance;
2901 : }
2902 : // Incident (unreflected) diffuse solar from sky -- TDD_Diffuser calculated differently
2903 20901380 : state.dataHeatBal->SurfQRadSWOutIncidentSkyDiffuse(SurfNum) = currDifSolarRad * state.dataSolarShading->SurfAnisoSkyMult(SurfNum);
2904 : // Incident diffuse solar from sky diffuse reflected from ground plus beam reflected from ground
2905 20901380 : state.dataHeatBal->SurfQRadSWOutIncidentGndDiffuse(SurfNum) = state.dataSurface->SurfGndSolarInc(SurfNum);
2906 : // Incident diffuse solar from beam-to-diffuse reflection from ground
2907 20901380 : state.dataHeatBal->SurfQRadSWOutIncBmToDiffReflGnd(SurfNum) =
2908 20901380 : currBeamSolar(SurfNum) * state.dataEnvrn->SOLCOS(3) * GndSurfReflectance * state.dataSurface->SurfBmToDiffReflFacGnd(SurfNum);
2909 :
2910 : // Incident diffuse solar from sky diffuse reflection from ground
2911 20901380 : state.dataHeatBal->SurfQRadSWOutIncSkyDiffReflGnd(SurfNum) =
2912 20901380 : currDifSolarRad * GndSurfReflectance * state.dataSurface->SurfSkyDiffReflFacGnd(SurfNum);
2913 : // Total incident solar. Beam and sky reflection from obstructions, if calculated, is included
2914 : // in SkySolarInc.
2915 : // SurfQRadSWOutIncident(SurfNum) = SurfQRadSWOutIncidentBeam(SurfNum) + SkySolarInc + GndSolarInc
2916 : // TH2 CR 9056
2917 20901380 : state.dataHeatBal->SurfQRadSWOutIncident(SurfNum) =
2918 41802760 : state.dataHeatBal->SurfQRadSWOutIncidentBeam(SurfNum) + state.dataHeatBal->SurfQRadSWOutIncidentSkyDiffuse(SurfNum) +
2919 41802760 : state.dataHeatBal->SurfQRadSWOutIncBmToDiffReflGnd(SurfNum) + state.dataHeatBal->SurfQRadSWOutIncSkyDiffReflGnd(SurfNum);
2920 :
2921 20901380 : if (state.dataSurface->CalcSolRefl) {
2922 : // Incident beam solar from beam-to-beam (specular) reflection from obstructions
2923 34945 : state.dataHeatBal->SurfQRadSWOutIncBmToBmReflObs(SurfNum) = state.dataSurface->SurfBmToBmReflFacObs(SurfNum) * currBeamSolar(SurfNum);
2924 : // Incident diffuse solar from beam-to-diffuse reflection from obstructions
2925 34945 : state.dataHeatBal->SurfQRadSWOutIncBmToDiffReflObs(SurfNum) =
2926 34945 : state.dataSurface->SurfBmToDiffReflFacObs(SurfNum) * currBeamSolar(SurfNum);
2927 : // Incident diffuse solar from sky diffuse reflection from obstructions
2928 34945 : state.dataHeatBal->SurfQRadSWOutIncSkyDiffReflObs(SurfNum) = currDifSolarRad * state.dataSurface->SurfReflFacSkySolObs(SurfNum);
2929 : // TH2 CR 9056: Add reflections from obstructions to the total incident
2930 104835 : state.dataHeatBal->SurfQRadSWOutIncident(SurfNum) += state.dataHeatBal->SurfQRadSWOutIncBmToBmReflObs(SurfNum) +
2931 69890 : state.dataHeatBal->SurfQRadSWOutIncBmToDiffReflObs(SurfNum) +
2932 34945 : state.dataHeatBal->SurfQRadSWOutIncSkyDiffReflObs(SurfNum);
2933 : }
2934 : }
2935 823335 : for (int PipeNum = 1; PipeNum <= (int)state.dataDaylightingDevicesData->TDDPipe.size(); ++PipeNum) {
2936 1232 : int const SurfNum = state.dataDaylightingDevicesData->TDDPipe(PipeNum).Diffuser; // TDD: Diffuser object number
2937 1232 : int const SurfNum2 = state.dataDaylightingDevicesData->TDDPipe(PipeNum).Dome; // TDD: DOME object number
2938 1232 : int const ConstrNum = state.dataSurface->SurfActiveConstruction(SurfNum);
2939 :
2940 : // Reconstruct the beam, sky, and ground radiation transmittance of just the TDD:DOME and TDD pipe
2941 : // by dividing out diffuse solar transmittance of TDD:DIFFUSER
2942 1232 : Real64 ConInc = state.dataHeatBal->SurfCosIncAng(state.dataGlobal->HourOfDay, state.dataGlobal->TimeStep, SurfNum2);
2943 :
2944 1232 : state.dataHeatBal->SurfCosIncidenceAngle(SurfNum) = ConInc;
2945 1232 : Real64 SurfIncSolarMultiplier = state.dataSurface->Surface(SurfNum).IncSolMultiplier;
2946 3696 : currBeamSolar(SurfNum) = state.dataEnvrn->BeamSolarRad * SurfIncSolarMultiplier *
2947 2464 : TransTDD(state, PipeNum, ConInc, DataDaylightingDevices::RadType::SolarBeam) /
2948 1232 : state.dataConstruction->Construct(ConstrNum).TransDiff;
2949 :
2950 3696 : state.dataSurface->SurfSkySolarInc(SurfNum) = state.dataEnvrn->DifSolarRad * SurfIncSolarMultiplier *
2951 2464 : state.dataSolarShading->SurfAnisoSkyMult(SurfNum2) *
2952 2464 : TransTDD(state, PipeNum, ConInc, DataDaylightingDevices::RadType::SolarAniso) /
2953 1232 : state.dataConstruction->Construct(ConstrNum).TransDiff;
2954 :
2955 3696 : state.dataSurface->SurfGndSolarInc(SurfNum) = state.dataSurface->SurfGndSolarInc(SurfNum2) *
2956 2464 : state.dataDaylightingDevicesData->TDDPipe(PipeNum).TransSolIso /
2957 1232 : state.dataConstruction->Construct(ConstrNum).TransDiff;
2958 : // Incident direct (unreflected) beam
2959 3696 : state.dataHeatBal->SurfQRadSWOutIncidentBeam(SurfNum) = currBeamSolar(SurfNum) *
2960 3696 : state.dataHeatBal->SurfSunlitFrac(state.dataGlobal->HourOfDay,
2961 1232 : state.dataGlobal->TimeStep,
2962 4928 : SurfNum2) *
2963 : ConInc; // NOTE: sunlit and coninc array set to SurfNum2
2964 :
2965 : // Incident (unreflected) diffuse solar from sky -- TDD_Diffuser calculated differently
2966 1232 : state.dataHeatBal->SurfQRadSWOutIncidentSkyDiffuse(SurfNum) = state.dataSurface->SurfSkySolarInc(SurfNum);
2967 1232 : state.dataHeatBal->SurfQRadSWOutIncident(SurfNum) =
2968 2464 : (state.dataHeatBal->SurfQRadSWOutIncidentBeam(SurfNum) + state.dataHeatBal->SurfQRadSWOutIncidentSkyDiffuse(SurfNum) +
2969 2464 : state.dataHeatBal->SurfQRadSWOutIncBmToDiffReflGnd(SurfNum) + state.dataHeatBal->SurfQRadSWOutIncSkyDiffReflGnd(SurfNum));
2970 : }
2971 :
2972 822719 : for (int ShelfNum = 1; ShelfNum <= (int)state.dataDaylightingDevicesData->Shelf.size(); ++ShelfNum) {
2973 616 : int SurfNum = state.dataDaylightingDevicesData->Shelf(ShelfNum).Window; // Daylighting shelf object number
2974 616 : int OutShelfSurf = state.dataDaylightingDevicesData->Shelf(ShelfNum).OutSurf; // Outside daylighting shelf present if > 0
2975 616 : state.dataHeatBal->SurfCosIncidenceAngle(SurfNum) =
2976 616 : state.dataHeatBal->SurfCosIncAng(state.dataGlobal->HourOfDay, state.dataGlobal->TimeStep, SurfNum);
2977 616 : Real64 SurfIncSolarMultiplier = state.dataSurface->Surface(SurfNum).IncSolMultiplier;
2978 616 : currBeamSolar(SurfNum) = state.dataEnvrn->BeamSolarRad * SurfIncSolarMultiplier;
2979 : // Shelf diffuse solar radiation
2980 : Real64 ShelfSolarRad =
2981 1232 : (currBeamSolar(SurfNum) * state.dataHeatBal->SurfSunlitFrac(state.dataGlobal->HourOfDay, state.dataGlobal->TimeStep, OutShelfSurf) *
2982 1232 : state.dataHeatBal->SurfCosIncAng(state.dataGlobal->HourOfDay, state.dataGlobal->TimeStep, OutShelfSurf) +
2983 616 : state.dataEnvrn->DifSolarRad * SurfIncSolarMultiplier * state.dataSolarShading->SurfAnisoSkyMult(OutShelfSurf)) *
2984 616 : state.dataDaylightingDevicesData->Shelf(ShelfNum).OutReflectSol;
2985 :
2986 616 : Real64 GndReflSolarRad = state.dataEnvrn->GndSolarRad * SurfIncSolarMultiplier;
2987 616 : if (state.dataSurface->Surface(SurfNum).UseSurfPropertyGndSurfRefl) {
2988 0 : GndReflSolarRad = state.dataSurface->Surface(SurfNum).GndReflSolarRad;
2989 : }
2990 : // Add all reflected solar from the outside shelf to the ground solar
2991 : // NOTE: If the shelf blocks part of the view to the ground, the user must reduce the ground view factor!!
2992 616 : state.dataSurface->SurfGndSolarInc(SurfNum) =
2993 616 : GndReflSolarRad * Surface(SurfNum).ViewFactorGround + ShelfSolarRad * state.dataDaylightingDevicesData->Shelf(ShelfNum).ViewFactor;
2994 : }
2995 :
2996 : // Calculate Exterior and Interior Absorbed Short Wave Radiation
2997 6670327 : for (int zoneNum = 1; zoneNum <= state.dataGlobal->NumOfZones; ++zoneNum) {
2998 11701404 : for (int spaceNum : state.dataHeatBal->Zone(zoneNum).spaceIndexes) {
2999 5853180 : auto &thisSpace = state.dataHeatBal->space(spaceNum);
3000 5853180 : int const firstSurfOpaq = thisSpace.OpaqOrIntMassSurfaceFirst;
3001 5853180 : int const lastSurfOpaq = thisSpace.OpaqOrIntMassSurfaceLast;
3002 49246342 : for (int SurfNum = firstSurfOpaq; SurfNum <= lastSurfOpaq; ++SurfNum) {
3003 43393162 : int const ConstrNum = state.dataSurface->Surface(SurfNum).Construction;
3004 43393162 : Real64 SurfIncSolarMultiplier = state.dataSurface->Surface(SurfNum).IncSolMultiplier;
3005 43393162 : currBeamSolar(SurfNum) = state.dataEnvrn->BeamSolarRad * SurfIncSolarMultiplier;
3006 43393162 : if (Surface(SurfNum).ExtSolar) {
3007 : Real64 AbsExt =
3008 12357628 : state.dataHeatBalSurf->SurfAbsSolarExt(SurfNum); // Absorptivity of outer most layer (or movable insulation if present)
3009 12357628 : state.dataHeatBalSurf->SurfOpaqQRadSWOutAbs(SurfNum) =
3010 24715256 : state.dataSurface->SurfOpaqAO(SurfNum) * currBeamSolar(SurfNum) +
3011 12357628 : AbsExt * (state.dataSurface->SurfSkySolarInc(SurfNum) + state.dataSurface->SurfGndSolarInc(SurfNum));
3012 : }
3013 43393162 : if (ConstrNum > 0) {
3014 43393162 : int SurfSolIncPtr = SurfaceScheduledSolarInc(state, SurfNum, ConstrNum);
3015 43393162 : if (SurfSolIncPtr == 0) {
3016 43392574 : if (state.dataConstruction->Construct(ConstrNum).TransDiff <= 0.0) { // Opaque surface
3017 43392574 : int ShelfNum = state.dataSurface->SurfDaylightingShelfInd(SurfNum); // Daylighting shelf object number
3018 43392574 : int InShelfSurf = 0; // Inside daylighting shelf surface number
3019 43392574 : if (ShelfNum > 0) {
3020 0 : InShelfSurf = state.dataDaylightingDevicesData->Shelf(ShelfNum).InSurf; // Inside daylighting shelf present if > 0
3021 : }
3022 43392574 : state.dataHeatBalSurf->SurfOpaqQRadSWInAbs(SurfNum) +=
3023 43392574 : state.dataSurface->SurfOpaqAI(SurfNum) * currBeamSolar(SurfNum);
3024 43392574 : if (InShelfSurf > 0) { // Inside daylighting shelf
3025 : // Shelf surface area is divided by 2 because only one side sees beam (Area was multiplied by 2 during init)
3026 0 : state.dataHeatBalSurf->SurfOpaqInsFaceBeamSolAbsorbed(SurfNum) =
3027 0 : state.dataSurface->SurfOpaqAI(SurfNum) * currBeamSolar(SurfNum) * (0.5 * Surface(SurfNum).Area);
3028 : } else { // Regular surface
3029 43392574 : state.dataHeatBalSurf->SurfOpaqInsFaceBeamSolAbsorbed(SurfNum) =
3030 43392574 : state.dataSurface->SurfOpaqAI(SurfNum) * currBeamSolar(SurfNum) * Surface(SurfNum).Area;
3031 : }
3032 : }
3033 : } else {
3034 588 : state.dataHeatBalSurf->SurfOpaqQRadSWInAbs(SurfNum) += state.dataSurface->SurfOpaqAI(SurfNum);
3035 : }
3036 : }
3037 : }
3038 5853180 : int const firstSurfWin = thisSpace.WindowSurfaceFirst;
3039 5853180 : int const lastSurfWin = thisSpace.WindowSurfaceLast;
3040 12978939 : for (int SurfNum = firstSurfWin; SurfNum <= lastSurfWin; ++SurfNum) {
3041 7125759 : if (Surface(SurfNum).ExtSolar || state.dataSurface->SurfWinOriginalClass(SurfNum) == SurfaceClass::TDD_Diffuser) {
3042 : // Exclude special shading surfaces which required SurfOpaqQRadSWOut calculations above
3043 7117249 : int const ConstrNum = state.dataSurface->SurfActiveConstruction(SurfNum);
3044 7117249 : Real64 CosInc = state.dataHeatBal->SurfCosIncidenceAngle(SurfNum); // Cosine of incidence angle of beam solar on glass
3045 7117249 : Real64 BeamSolar = currBeamSolar(SurfNum); // Local variable for BeamSolarRad
3046 7117249 : Real64 SkySolarInc = state.dataSurface->SurfSkySolarInc(SurfNum); // Sky diffuse solar incident on a surface
3047 7117249 : Real64 GndSolarInc = state.dataSurface->SurfGndSolarInc(SurfNum); // Ground diffuse solar incident on a surface
3048 :
3049 7117249 : WinShadingType ShadeFlag = state.dataSurface->SurfWinShadingFlag(SurfNum);
3050 :
3051 14219777 : if (state.dataSurface->SurfWinWindowModelType(SurfNum) == WindowModel::Detailed &&
3052 7102528 : !state.dataWindowManager->inExtWindowModel->isExternalLibraryModel()) {
3053 7101702 : int TotGlassLay = state.dataConstruction->Construct(ConstrNum).TotGlassLayers; // Number of glass layers
3054 16328601 : for (int Lay = 1; Lay <= TotGlassLay; ++Lay) {
3055 9226899 : AbsDiffWin(Lay) = state.dataConstruction->Construct(ConstrNum).AbsDiff(Lay);
3056 : }
3057 :
3058 7101702 : if (IS_SHADED(ShadeFlag)) { // Shaded window
3059 :
3060 123072 : int const ConstrNumSh = state.dataSurface->SurfWinActiveShadedConstruction(SurfNum); // Shaded window construction
3061 :
3062 123072 : if (ANY_SHADE_SCREEN(ShadeFlag)) { // Shade/screen on
3063 92932 : for (int Lay = 1; Lay <= TotGlassLay; ++Lay) {
3064 59208 : AbsDiffWin(Lay) = state.dataConstruction->Construct(ConstrNumSh).AbsDiff(Lay);
3065 : }
3066 33724 : state.dataSurface->SurfWinExtDiffAbsByShade(SurfNum) =
3067 33724 : state.dataConstruction->Construct(ConstrNumSh).AbsDiffShade * (SkySolarInc + GndSolarInc);
3068 89348 : } else if (ANY_BLIND(ShadeFlag)) { // Blind on
3069 18094 : int SurfWinSlatsAngIndex = state.dataSurface->SurfWinSlatsAngIndex(SurfNum);
3070 18094 : Real64 SurfWinSlatsAngInterpFac = state.dataSurface->SurfWinSlatsAngInterpFac(SurfNum);
3071 : Real64 AbsDiffBlind;
3072 18094 : if (state.dataSurface->SurfWinMovableSlats(SurfNum)) {
3073 3444 : for (int Lay = 1; Lay <= TotGlassLay; ++Lay) {
3074 3444 : AbsDiffWin(Lay) = General::InterpGeneral(
3075 1722 : state.dataConstruction->Construct(ConstrNumSh).BlAbsDiff(SurfWinSlatsAngIndex, Lay),
3076 1722 : state.dataConstruction->Construct(ConstrNumSh)
3077 3444 : .BlAbsDiff(std::min(MaxSlatAngs, SurfWinSlatsAngIndex + 1), Lay),
3078 : SurfWinSlatsAngInterpFac);
3079 3444 : AbsDiffWinGnd(Lay) = General::InterpGeneral(
3080 1722 : state.dataConstruction->Construct(ConstrNumSh).BlAbsDiffGnd(SurfWinSlatsAngIndex, Lay),
3081 1722 : state.dataConstruction->Construct(ConstrNumSh)
3082 3444 : .BlAbsDiffGnd(std::min(MaxSlatAngs, SurfWinSlatsAngIndex + 1), Lay),
3083 : SurfWinSlatsAngInterpFac);
3084 3444 : AbsDiffWinSky(Lay) = General::InterpGeneral(
3085 1722 : state.dataConstruction->Construct(ConstrNumSh).BlAbsDiffSky(SurfWinSlatsAngIndex, Lay),
3086 1722 : state.dataConstruction->Construct(ConstrNumSh)
3087 3444 : .BlAbsDiffSky(std::min(MaxSlatAngs, SurfWinSlatsAngIndex + 1), Lay),
3088 : SurfWinSlatsAngInterpFac);
3089 : }
3090 1722 : AbsDiffBlind =
3091 1722 : General::InterpGeneral(state.dataConstruction->Construct(ConstrNumSh).AbsDiffBlind(SurfWinSlatsAngIndex),
3092 1722 : state.dataConstruction->Construct(ConstrNumSh)
3093 3444 : .AbsDiffBlind(std::min(MaxSlatAngs, SurfWinSlatsAngIndex + 1)),
3094 : SurfWinSlatsAngInterpFac);
3095 : } else {
3096 37182 : for (int Lay = 1; Lay <= TotGlassLay; ++Lay) {
3097 20810 : AbsDiffWin(Lay) = state.dataConstruction->Construct(ConstrNumSh).BlAbsDiff(1, Lay);
3098 20810 : AbsDiffWinGnd(Lay) = state.dataConstruction->Construct(ConstrNumSh).BlAbsDiffGnd(1, Lay);
3099 20810 : AbsDiffWinSky(Lay) = state.dataConstruction->Construct(ConstrNumSh).BlAbsDiffSky(1, Lay);
3100 : }
3101 16372 : AbsDiffBlind = state.dataConstruction->Construct(ConstrNumSh).AbsDiffBlind(1);
3102 : }
3103 18094 : state.dataSurface->SurfWinExtDiffAbsByShade(SurfNum) = AbsDiffBlind * (SkySolarInc + GndSolarInc);
3104 :
3105 18094 : if (state.dataHeatBal->Blind(state.dataSurface->SurfWinBlindNumber(SurfNum)).SlatOrientation ==
3106 : DataWindowEquivalentLayer::Orientation::Horizontal) {
3107 18094 : Real64 ACosTlt = std::abs(Surface(SurfNum).CosTilt);
3108 : Real64 AbsDiffBlindGnd;
3109 : Real64 AbsDiffBlindSky;
3110 18094 : if (state.dataSurface->SurfWinMovableSlats(SurfNum)) {
3111 3444 : AbsDiffBlindGnd = General::InterpGeneral(
3112 1722 : state.dataConstruction->Construct(ConstrNumSh).AbsDiffBlindGnd(SurfWinSlatsAngIndex),
3113 1722 : state.dataConstruction->Construct(ConstrNumSh)
3114 3444 : .AbsDiffBlindGnd(std::min(MaxSlatAngs, SurfWinSlatsAngIndex + 1)),
3115 : SurfWinSlatsAngInterpFac);
3116 3444 : AbsDiffBlindSky = General::InterpGeneral(
3117 1722 : state.dataConstruction->Construct(ConstrNumSh).AbsDiffBlindSky(SurfWinSlatsAngIndex),
3118 1722 : state.dataConstruction->Construct(ConstrNumSh)
3119 3444 : .AbsDiffBlindSky(std::min(MaxSlatAngs, SurfWinSlatsAngIndex + 1)),
3120 : SurfWinSlatsAngInterpFac);
3121 : } else {
3122 16372 : AbsDiffBlindGnd = state.dataConstruction->Construct(ConstrNumSh).AbsDiffBlindGnd(1);
3123 16372 : AbsDiffBlindSky = state.dataConstruction->Construct(ConstrNumSh).AbsDiffBlindSky(1);
3124 : }
3125 18094 : state.dataSurface->SurfWinExtDiffAbsByShade(SurfNum) =
3126 36188 : SkySolarInc * (0.5 * ACosTlt * AbsDiffBlindGnd + (1.0 - 0.5 * ACosTlt) * AbsDiffBlindSky) +
3127 18094 : GndSolarInc * ((1.0 - 0.5 * ACosTlt) * AbsDiffBlindGnd + 0.5 * ACosTlt * AbsDiffBlindSky);
3128 : }
3129 : }
3130 :
3131 : // Correct for shadowing of divider onto interior shading device (note that dividers are
3132 : // not allowed in windows with between-glass shade/blind)
3133 :
3134 123072 : if (ANY_INTERIOR_SHADE_BLIND(ShadeFlag) && state.dataSurface->SurfWinDividerArea(SurfNum) > 0.0)
3135 742 : state.dataSurface->SurfWinExtDiffAbsByShade(SurfNum) *= state.dataSurface->SurfWinGlazedFrac(SurfNum);
3136 :
3137 123072 : if (ShadeFlag == WinShadingType::SwitchableGlazing) { // Switchable glazing
3138 71254 : Real64 SwitchFac = state.dataSurface->SurfWinSwitchingFactor(SurfNum); // Switching factor for switchable glazing
3139 213762 : for (int Lay = 1; Lay <= TotGlassLay; ++Lay) {
3140 142508 : AbsDiffWin(Lay) =
3141 142508 : InterpSw(SwitchFac, AbsDiffWin(Lay), state.dataConstruction->Construct(ConstrNumSh).AbsDiff(Lay));
3142 : }
3143 : }
3144 :
3145 : } // End of check if window has shading device on
3146 :
3147 7101702 : state.dataHeatBal->SurfWinQRadSWwinAbsTot(SurfNum) = 0.0;
3148 16328601 : for (int Lay = 1; Lay <= TotGlassLay; ++Lay) {
3149 9226899 : state.dataHeatBal->SurfWinQRadSWwinAbs(SurfNum, Lay) =
3150 9226899 : AbsDiffWin(Lay) * (SkySolarInc + GndSolarInc) + state.dataSurface->SurfWinA(SurfNum, Lay) * BeamSolar;
3151 : // SurfWinA is from InteriorSolarDistribution
3152 9226899 : if (ANY_BLIND(ShadeFlag)) {
3153 22532 : int ConstrNumSh = Surface(SurfNum).activeShadedConstruction;
3154 22532 : if (state.dataHeatBal->Blind(state.dataSurface->SurfWinBlindNumber(SurfNum)).SlatOrientation ==
3155 : DataWindowEquivalentLayer::Orientation::Horizontal) {
3156 22532 : Real64 ACosTlt = std::abs(Surface(SurfNum).CosTilt); // Absolute value of cosine of surface tilt angle
3157 : Real64 AbsDiffGlassLayGnd; // System glass layer ground diffuse solar absorptance with blind on
3158 : Real64 AbsDiffGlassLaySky; // System glass layer sky diffuse solar absorptance with blind on
3159 22532 : if (state.dataSurface->SurfWinMovableSlats(SurfNum)) {
3160 5166 : AbsDiffGlassLayGnd = General::InterpGeneral(
3161 1722 : state.dataConstruction->Construct(ConstrNumSh)
3162 1722 : .BlAbsDiffGnd(state.dataSurface->SurfWinSlatsAngIndex(SurfNum), Lay),
3163 1722 : state.dataConstruction->Construct(ConstrNumSh)
3164 3444 : .BlAbsDiffGnd(std::min(MaxSlatAngs, state.dataSurface->SurfWinSlatsAngIndex(SurfNum) + 1), Lay),
3165 1722 : state.dataSurface->SurfWinSlatsAngInterpFac(SurfNum));
3166 5166 : AbsDiffGlassLaySky = General::InterpGeneral(
3167 1722 : state.dataConstruction->Construct(ConstrNumSh)
3168 1722 : .BlAbsDiffSky(state.dataSurface->SurfWinSlatsAngIndex(SurfNum), Lay),
3169 1722 : state.dataConstruction->Construct(ConstrNumSh)
3170 3444 : .BlAbsDiffSky(std::min(MaxSlatAngs, state.dataSurface->SurfWinSlatsAngIndex(SurfNum) + 1), Lay),
3171 1722 : state.dataSurface->SurfWinSlatsAngInterpFac(SurfNum));
3172 : } else {
3173 20810 : AbsDiffGlassLayGnd = state.dataConstruction->Construct(ConstrNumSh).BlAbsDiffGnd(1, Lay);
3174 20810 : AbsDiffGlassLaySky = state.dataConstruction->Construct(ConstrNumSh).BlAbsDiffSky(1, Lay);
3175 : }
3176 22532 : state.dataHeatBal->SurfWinQRadSWwinAbs(SurfNum, Lay) =
3177 45064 : SkySolarInc * (0.5 * ACosTlt * AbsDiffGlassLayGnd + (1.0 - 0.5 * ACosTlt) * AbsDiffGlassLaySky) +
3178 45064 : GndSolarInc * ((1.0 - 0.5 * ACosTlt) * AbsDiffGlassLayGnd + 0.5 * ACosTlt * AbsDiffGlassLaySky) +
3179 22532 : state.dataSurface->SurfWinA(SurfNum, Lay) * BeamSolar;
3180 : }
3181 : }
3182 : // Total solar absorbed in solid layer (W), for reporting
3183 9226899 : state.dataHeatBal->SurfWinQRadSWwinAbsLayer(SurfNum, Lay) =
3184 9226899 : state.dataHeatBal->SurfWinQRadSWwinAbs(SurfNum, Lay) * Surface(SurfNum).Area;
3185 :
3186 : // Total solar absorbed in all glass layers (W), for reporting
3187 9226899 : state.dataHeatBal->SurfWinQRadSWwinAbsTot(SurfNum) += state.dataHeatBal->SurfWinQRadSWwinAbsLayer(SurfNum, Lay);
3188 : }
3189 7101702 : state.dataHeatBal->SurfWinQRadSWwinAbsTotEnergy(SurfNum) =
3190 7101702 : state.dataHeatBal->SurfWinQRadSWwinAbsTot(SurfNum) * state.dataGlobal->TimeStepZoneSec;
3191 : // Need to do it this way for now beaucse of scheduled surface gains. They do work only with
3192 : // BSDF windows and overwriting absorbtances will work only for ordinary windows
3193 : // } else if ( SurfaceWindow( SurfNum ).WindowModelType != WindowModel:: BSDF &&
3194 : // SurfaceWindow( SurfNum ).WindowModelType != WindowModel:: EQL &&
3195 : // inExtWindowModel->isExternalLibraryModel() ) {
3196 : // TotSolidLay = Construct( ConstrNum ).TotSolidLayers;
3197 : // for ( Lay = 1; Lay <= TotSolidLay; ++Lay ) {
3198 : // SurfWinQRadSWwinAbs( Lay, SurfNum ) = SurfWinA( Lay, SurfNum ) *
3199 : // ( SurfQRadSWOutIncident( SurfNum ) + QS( Surface( SurfNum ).Zone ) );
3200 : // }
3201 15547 : } else if (state.dataSurface->SurfWinWindowModelType(SurfNum) == WindowModel::BSDF) {
3202 12243 : int TotSolidLay = state.dataConstruction->Construct(ConstrNum).TotSolidLayers;
3203 : // Number of solid layers in fenestration system (glass + shading)
3204 12243 : int CurrentState = state.dataSurface->SurfaceWindow(SurfNum).ComplexFen.CurrentState;
3205 : // Current state for Complex Fenestration
3206 : // Examine for schedule surface gain
3207 : Real64 SurfSolAbs =
3208 12243 : WindowScheduledSolarAbs(state,
3209 : SurfNum,
3210 12243 : ConstrNum); // Pointer to scheduled surface gains object for fenestration systems
3211 :
3212 46277 : for (int Lay = 1; Lay <= TotSolidLay; ++Lay) {
3213 34034 : if (SurfSolAbs != 0) {
3214 294 : state.dataSurface->SurfWinA(SurfNum, Lay) =
3215 294 : GetCurrentScheduleValue(state, state.dataSurface->FenLayAbsSSG(SurfSolAbs).SchedPtrs(Lay));
3216 : // ABWin(Lay) = SurfWinA(SurfNum,Lay)
3217 294 : state.dataHeatBal->SurfWinQRadSWwinAbs(SurfNum, Lay) = state.dataSurface->SurfWinA(SurfNum, Lay);
3218 : } else {
3219 : // Several notes about this equation. First part is accounting for duffuse solar radiation for the ground
3220 : // and from the sky. Second item (SurfWinA(SurfNum,Lay) * BeamSolar) is accounting for absorbed solar
3221 : // radiation originating from beam on exterior side. Third item (SurfWinACFOverlap(SurfNum,Lay)) is
3222 : // accounting for absorptances from beam hitting back of the window which passes through rest of exterior
3223 : // windows
3224 33740 : state.dataHeatBal->SurfWinQRadSWwinAbs(SurfNum, Lay) =
3225 67480 : state.dataSurface->SurfaceWindow(SurfNum).ComplexFen.State(CurrentState).WinSkyFtAbs(Lay) * SkySolarInc +
3226 67480 : state.dataSurface->SurfaceWindow(SurfNum).ComplexFen.State(CurrentState).WinSkyGndAbs(Lay) * GndSolarInc +
3227 67480 : state.dataSurface->SurfWinA(SurfNum, Lay) * BeamSolar +
3228 33740 : state.dataSurface->SurfWinACFOverlap(SurfNum, Lay) * BeamSolar;
3229 : }
3230 : // Total solar absorbed in solid layer (W), for reporting
3231 34034 : state.dataHeatBal->SurfWinQRadSWwinAbsLayer(SurfNum, Lay) =
3232 34034 : state.dataHeatBal->SurfWinQRadSWwinAbs(SurfNum, Lay) * Surface(SurfNum).Area;
3233 :
3234 : // Total solar absorbed in all glass layers (W), for reporting
3235 34034 : state.dataHeatBal->SurfWinQRadSWwinAbsTot(SurfNum) += state.dataHeatBal->SurfWinQRadSWwinAbsLayer(SurfNum, Lay);
3236 : }
3237 12243 : state.dataHeatBal->SurfWinQRadSWwinAbsTotEnergy(SurfNum) =
3238 12243 : state.dataHeatBal->SurfWinQRadSWwinAbsTot(SurfNum) * state.dataGlobal->TimeStepZoneSec;
3239 :
3240 3304 : } else if (state.dataSurface->SurfWinWindowModelType(SurfNum) == WindowModel::EQL) {
3241 2478 : state.dataHeatBal->SurfWinQRadSWwinAbsTot(SurfNum) = 0.0;
3242 : // EQLNum = Construct(Surface(SurfNum)%Construction)%EQLConsPtr
3243 : int TotSolidLay =
3244 2478 : state.dataWindowEquivLayer->CFS(state.dataConstruction->Construct(Surface(SurfNum).Construction).EQLConsPtr).NL;
3245 11564 : for (int Lay = 1; Lay <= TotSolidLay; ++Lay) {
3246 : // Absorbed window components include:
3247 : // (1) beam solar radiation absorbed by all layers in the fenestration
3248 : // (2) sky and ground reflected duffuse solar radiation absorbed by all layers
3249 : // (3) diffuse short wave incident on the inside face of the fenestration. The short wave internal sources
3250 : // include light, ...
3251 9086 : AbsDiffWin(Lay) = state.dataConstruction->Construct(ConstrNum).AbsDiffFrontEQL(Lay);
3252 9086 : state.dataHeatBal->SurfWinQRadSWwinAbs(SurfNum, Lay) =
3253 9086 : state.dataSurface->SurfWinA(SurfNum, Lay) * BeamSolar + AbsDiffWin(Lay) * (SkySolarInc + GndSolarInc);
3254 :
3255 : // Total solar absorbed in solid layer (W), for reporting
3256 9086 : state.dataHeatBal->SurfWinQRadSWwinAbsLayer(SurfNum, Lay) =
3257 9086 : state.dataHeatBal->SurfWinQRadSWwinAbs(SurfNum, Lay) * Surface(SurfNum).Area;
3258 :
3259 : // Total solar absorbed in all glass layers (W), for reporting
3260 9086 : state.dataHeatBal->SurfWinQRadSWwinAbsTot(SurfNum) += state.dataHeatBal->SurfWinQRadSWwinAbsLayer(SurfNum, Lay);
3261 : }
3262 :
3263 2478 : state.dataHeatBal->SurfWinQRadSWwinAbsTotEnergy(SurfNum) =
3264 2478 : state.dataHeatBal->SurfWinQRadSWwinAbsTot(SurfNum) * state.dataGlobal->TimeStepZoneSec;
3265 826 : } else if (state.dataWindowManager->inExtWindowModel->isExternalLibraryModel()) {
3266 826 : int SurfNum2 = SurfNum;
3267 826 : if (state.dataSurface->SurfWinOriginalClass(SurfNum) == SurfaceClass::TDD_Diffuser) {
3268 0 : SurfNum2 = state.dataDaylightingDevicesData->TDDPipe(state.dataSurface->SurfWinTDDPipeNum(SurfNum)).Dome;
3269 : }
3270 :
3271 826 : std::pair<Real64, Real64> incomingAngle = getSunWCEAngles(state, SurfNum2, BSDFDirection::Incoming);
3272 826 : Real64 Theta = incomingAngle.first;
3273 826 : Real64 Phi = incomingAngle.second;
3274 :
3275 : std::shared_ptr<CMultiLayerScattered> aLayer =
3276 1652 : CWindowConstructionsSimplified::instance().getEquivalentLayer(state, WavelengthRange::Solar, ConstrNum);
3277 :
3278 826 : size_t totLayers = aLayer->getNumOfLayers();
3279 1652 : for (size_t Lay = 1; Lay <= totLayers; ++Lay) {
3280 826 : Real64 AbWinDiff = aLayer->getAbsorptanceLayer(Lay, Side::Front, ScatteringSimple::Diffuse, Theta, Phi);
3281 :
3282 826 : state.dataHeatBal->SurfWinQRadSWwinAbs(SurfNum, Lay) =
3283 826 : AbWinDiff * (SkySolarInc + GndSolarInc) + state.dataSurface->SurfWinA(SurfNum, Lay) * BeamSolar;
3284 :
3285 : // Total solar absorbed in solid layer (W), for reporting
3286 826 : state.dataHeatBal->SurfWinQRadSWwinAbsLayer(SurfNum, Lay) =
3287 826 : state.dataHeatBal->SurfWinQRadSWwinAbs(SurfNum, Lay) * Surface(SurfNum).Area;
3288 :
3289 : // Total solar absorbed in all glass layers (W), for reporting
3290 826 : state.dataHeatBal->SurfWinQRadSWwinAbsTot(SurfNum) += state.dataHeatBal->SurfWinQRadSWwinAbsLayer(SurfNum, Lay);
3291 : }
3292 : }
3293 :
3294 : // Solar absorbed by window frame and dividers
3295 7117249 : int FrDivNum = Surface(SurfNum).FrameDivider; // Frame/divider number
3296 7117249 : if (FrDivNum > 0) {
3297 375572 : Real64 FrArea = state.dataSurface->SurfWinFrameArea(SurfNum); // Frame, divider area (m2)
3298 375572 : Real64 FrProjOut = state.dataSurface->FrameDivider(FrDivNum).FrameProjectionOut; // Frame, divider outside projection (m)
3299 375572 : Real64 FrProjIn = state.dataSurface->FrameDivider(FrDivNum).FrameProjectionIn;
3300 375572 : Real64 DivArea = state.dataSurface->SurfWinDividerArea(SurfNum);
3301 375572 : Real64 DivWidth = state.dataSurface->FrameDivider(FrDivNum).DividerWidth;
3302 375572 : Real64 DivProjOut = state.dataSurface->FrameDivider(FrDivNum).DividerProjectionOut;
3303 375572 : Real64 DivProjIn = state.dataSurface->FrameDivider(FrDivNum).DividerProjectionIn;
3304 375572 : Real64 CosIncAngHorProj = 0.0; // Cosine of incidence angle of sun on horizontal faces of a frame or divider projection
3305 375572 : Real64 CosIncAngVertProj = 0.0; // Cosine of incidence angle of sun on vertical faces of a frame or divider projection
3306 375572 : Real64 FracSunLit = 0.0; // Fraction of window sunlit this time step
3307 : Real64 BeamFaceInc; // Beam solar incident window plane this time step (W/m2)
3308 : Real64 DifSolarFaceInc; // Diffuse solar incident on window plane this time step (W/m2)
3309 375572 : Real64 SurfIncSolarMultiplier = state.dataSurface->Surface(SurfNum).IncSolMultiplier;
3310 375572 : Real64 currBeamSolarRad = state.dataEnvrn->BeamSolarRad * SurfIncSolarMultiplier;
3311 375572 : if (FrArea > 0.0 || DivArea > 0.0) {
3312 205972 : FracSunLit = state.dataHeatBal->SurfSunlitFrac(state.dataGlobal->HourOfDay, state.dataGlobal->TimeStep, SurfNum);
3313 205972 : BeamFaceInc = currBeamSolarRad *
3314 205972 : state.dataHeatBal->SurfSunlitFrac(state.dataGlobal->HourOfDay, state.dataGlobal->TimeStep, SurfNum) *
3315 : CosInc;
3316 205972 : DifSolarFaceInc = SkySolarInc + GndSolarInc;
3317 : }
3318 375572 : if (FracSunLit > 0.0) {
3319 166207 : if ((FrArea > 0.0 && (FrProjOut > 0.0 || FrProjIn > 0.0)) ||
3320 2591 : (DivArea > 0.0 && (DivProjOut > 0.0 || DivProjIn > 0.0))) {
3321 : // Dot products used to calculate beam solar incident on faces of
3322 : // frame and divider perpendicular to the glass surface.
3323 : // Note that SOLCOS is the current timestep's solar direction cosines.
3324 : // PhiWin = ASIN(WALCOS(3,SurfNum))
3325 : Real64 PhiWin =
3326 154922 : std::asin(Surface(SurfNum).OutNormVec(3)); // Altitude and azimuth angle of outward window normal (radians)
3327 154922 : Real64 ThWin = std::atan2(Surface(SurfNum).OutNormVec(2), Surface(SurfNum).OutNormVec(1));
3328 154922 : Real64 PhiSun = std::asin(state.dataEnvrn->SOLCOS(3)); // Altitude and azimuth angle of sun (radians)
3329 154922 : Real64 ThSun = std::atan2(state.dataEnvrn->SOLCOS(2), state.dataEnvrn->SOLCOS(1));
3330 154922 : Real64 const cos_PhiWin(std::cos(PhiWin));
3331 154922 : Real64 const cos_PhiSun(std::cos(PhiSun));
3332 154922 : CosIncAngHorProj =
3333 154922 : std::abs(std::sin(PhiWin) * cos_PhiSun * std::cos(ThWin - ThSun) - cos_PhiWin * std::sin(PhiSun));
3334 154922 : CosIncAngVertProj = std::abs(cos_PhiWin * cos_PhiSun * std::sin(ThWin - ThSun));
3335 : }
3336 : }
3337 : // Frame solar
3338 : // (A window shade or blind, if present, is assumed to not shade the frame, so no special
3339 : // treatment of frame solar needed if window has an exterior shade or blind.)
3340 375572 : if (FrArea > 0.0) {
3341 205972 : Real64 FrIncSolarOut = BeamFaceInc; // Total solar incident on outside offrame including solar
3342 205972 : Real64 FrIncSolarIn = 0.0; // Total solar incident on inside offrame including solar on frame projection (W/m2)
3343 205972 : Real64 TransDiffGl = 0.0; // Diffuse solar transmittance
3344 205972 : if (FrProjOut > 0.0 || FrProjIn > 0.0) {
3345 : Real64 BeamFrHorFaceInc =
3346 371116 : currBeamSolarRad * CosIncAngHorProj *
3347 371116 : (Surface(SurfNum).Width - state.dataSurface->FrameDivider(FrDivNum).VertDividers * DivWidth) * FracSunLit /
3348 185558 : FrArea;
3349 : Real64 BeamFrVertFaceInc =
3350 371116 : currBeamSolarRad * CosIncAngVertProj *
3351 371116 : (Surface(SurfNum).Height - state.dataSurface->FrameDivider(FrDivNum).HorDividers * DivWidth) * FracSunLit /
3352 185558 : FrArea;
3353 : // Beam solar on outside of frame
3354 185558 : FrIncSolarOut += (BeamFrHorFaceInc + BeamFrVertFaceInc) * FrProjOut;
3355 185558 : if (FrProjIn > 0.0) {
3356 185558 : Real64 TransGl = POLYF(CosInc, state.dataConstruction->Construct(ConstrNum).TransSolBeamCoef);
3357 185558 : TransDiffGl = state.dataConstruction->Construct(ConstrNum).TransDiff;
3358 185558 : if (ShadeFlag == WinShadingType::SwitchableGlazing) { // Switchable glazing
3359 70512 : Real64 SwitchFac = state.dataSurface->SurfWinSwitchingFactor(SurfNum);
3360 70512 : int ConstrNumSh = Surface(SurfNum).activeShadedConstruction;
3361 70512 : Real64 TransGlSh = POLYF(CosInc, state.dataConstruction->Construct(ConstrNumSh).TransSolBeamCoef);
3362 70512 : TransGl = InterpSw(SwitchFac, TransGl, TransGlSh);
3363 70512 : Real64 TransDiffGlSh = state.dataConstruction->Construct(ConstrNumSh).TransDiff;
3364 70512 : TransDiffGl = InterpSw(SwitchFac, TransDiffGl, TransDiffGlSh);
3365 : }
3366 : // Beam solar on inside of frame
3367 185558 : FrIncSolarIn = (BeamFrHorFaceInc + BeamFrVertFaceInc) * FrProjIn * TransGl;
3368 : }
3369 : }
3370 : // Beam plus diffuse solar on outside of frame
3371 205972 : FrIncSolarOut += DifSolarFaceInc * (1.0 + 0.5 * state.dataSurface->SurfWinProjCorrFrOut(SurfNum));
3372 205972 : state.dataSurface->SurfWinFrameQRadOutAbs(SurfNum) =
3373 205972 : FrIncSolarOut * state.dataSurface->SurfWinFrameSolAbsorp(SurfNum);
3374 : // Add diffuse from beam reflected from window outside reveal surfaces
3375 411944 : state.dataSurface->SurfWinFrameQRadOutAbs(SurfNum) += currBeamSolarRad *
3376 411944 : state.dataSurface->SurfWinOutsRevealDiffOntoFrame(SurfNum) *
3377 205972 : state.dataSurface->SurfWinFrameSolAbsorp(SurfNum);
3378 :
3379 : // Beam plus diffuse solar on inside of frame
3380 205972 : FrIncSolarIn += DifSolarFaceInc * TransDiffGl * 0.5 * state.dataSurface->SurfWinProjCorrFrIn(SurfNum);
3381 205972 : state.dataSurface->SurfWinFrameQRadInAbs(SurfNum) = FrIncSolarIn * state.dataSurface->SurfWinFrameSolAbsorp(SurfNum);
3382 : // Add diffuse from beam reflected from window inside reveal surfaces
3383 411944 : state.dataSurface->SurfWinFrameQRadInAbs(SurfNum) += currBeamSolarRad *
3384 411944 : state.dataSurface->SurfWinInsRevealDiffOntoFrame(SurfNum) *
3385 205972 : state.dataSurface->SurfWinFrameSolAbsorp(SurfNum);
3386 : }
3387 :
3388 : // Divider solar
3389 : // (An exterior shade or blind, when in place, is assumed to completely cover the divider.
3390 : // Dividers are not allowed on windows with between-glass shade/blind so DivProjOut and
3391 : // DivProjIn will be zero in this case.)
3392 375572 : if (DivArea > 0.0) { // Solar absorbed by window divider
3393 105466 : Real64 DividerAbs = state.dataSurface->SurfWinDividerSolAbsorp(SurfNum); // Window divider solar absorptance
3394 105466 : if (state.dataSurface->SurfWinDividerType(SurfNum) == DataSurfaces::FrameDividerType::Suspended) {
3395 : // Suspended (between-glass) divider; account for effect glass on outside of divider
3396 : // (note that outside and inside projection for this type of divider are both zero)
3397 8004 : int MatNumGl = state.dataConstruction->Construct(ConstrNum).LayerPoint(1); // Outer glass layer material number
3398 : Real64 TransGl =
3399 8004 : state.dataMaterial->Material(MatNumGl).Trans; // Outer glass layer material number, switched construction
3400 8004 : Real64 ReflGl = state.dataMaterial->Material(MatNumGl).ReflectSolBeamFront;
3401 8004 : Real64 AbsGl = 1.0 - TransGl - ReflGl;
3402 8004 : Real64 SwitchFac = state.dataSurface->SurfWinSwitchingFactor(SurfNum);
3403 8004 : int ConstrNumSh = Surface(SurfNum).activeShadedConstruction;
3404 8004 : if (ShadeFlag == WinShadingType::SwitchableGlazing) { // Switchable glazing
3405 0 : Real64 MatNumGlSh = state.dataConstruction->Construct(ConstrNumSh).LayerPoint(1);
3406 0 : Real64 TransGlSh = state.dataMaterial->Material(MatNumGlSh).Trans;
3407 0 : Real64 ReflGlSh = state.dataMaterial->Material(MatNumGlSh).ReflectSolBeamFront;
3408 0 : Real64 AbsGlSh = 1.0 - TransGlSh - ReflGlSh;
3409 0 : TransGl = InterpSw(SwitchFac, TransGl, TransGlSh);
3410 0 : ReflGl = InterpSw(SwitchFac, ReflGl, ReflGlSh);
3411 0 : AbsGl = InterpSw(SwitchFac, AbsGl, AbsGlSh);
3412 : }
3413 8004 : Real64 DividerRefl = 1.0 - DividerAbs; // Window divider solar reflectance
3414 8004 : DividerAbs = AbsGl + TransGl * (DividerAbs + DividerRefl * AbsGl) / (1.0 - DividerRefl * ReflGl);
3415 : }
3416 :
3417 105466 : Real64 BeamDivHorFaceInc = 0.0; // Beam solar on divider's horizontal outside projection faces (W/m2)
3418 105466 : Real64 BeamDivVertFaceInc = 0.0; // Beam solar on divider's vertical outside projection faces (W/m2)
3419 : // Beam incident on horizontal and vertical projection faces of divider if no exterior shading
3420 105466 : if (DivProjOut > 0.0 && !ANY_EXTERIOR_SHADE_BLIND_SCREEN(ShadeFlag)) {
3421 190440 : BeamDivHorFaceInc = currBeamSolarRad * CosIncAngHorProj * state.dataSurface->FrameDivider(FrDivNum).HorDividers *
3422 95220 : DivProjOut *
3423 190440 : (Surface(SurfNum).Width - state.dataSurface->FrameDivider(FrDivNum).VertDividers * DivWidth) *
3424 : FracSunLit / DivArea;
3425 95220 : BeamDivVertFaceInc =
3426 190440 : currBeamSolarRad * CosIncAngVertProj * state.dataSurface->FrameDivider(FrDivNum).VertDividers * DivProjOut *
3427 190440 : (Surface(SurfNum).Height - state.dataSurface->FrameDivider(FrDivNum).HorDividers * DivWidth) * FracSunLit /
3428 : DivArea;
3429 : }
3430 105466 : Real64 DivIncSolarOutBm =
3431 : 0.0; // Diffuse solar incident on outside of divider including beam on divider projection (W/m2)
3432 105466 : Real64 DivIncSolarOutDif =
3433 : 0.0; // Diffuse solar incident on outside of divider including diffuse on divider projection (W/m2)
3434 105466 : Real64 DivIncSolarInBm =
3435 : 0.0; // Diffuse solar incident on inside of divider including beam on divider projection (W/m2)
3436 105466 : Real64 DivIncSolarInDif =
3437 : 0.0; // Diffuse solar incident on inside of divider including diffuse on divider projection (W/m2)
3438 210134 : if (!ANY_EXTERIOR_SHADE_BLIND_SCREEN(ShadeFlag) &&
3439 104668 : !ANY_BETWEENGLASS_SHADE_BLIND(ShadeFlag)) { // No exterior or between-glass shading
3440 104668 : DivIncSolarOutBm = BeamFaceInc + BeamDivHorFaceInc + BeamDivVertFaceInc;
3441 104668 : DivIncSolarOutDif = DifSolarFaceInc * (1.0 + state.dataSurface->SurfWinProjCorrDivOut(SurfNum));
3442 104668 : if (DivProjIn > 0.0) {
3443 95220 : Real64 TransGl = POLYF(CosInc, state.dataConstruction->Construct(ConstrNum).TransSolBeamCoef);
3444 95220 : Real64 TransDiffGl = state.dataConstruction->Construct(ConstrNum).TransDiff; // Diffuse solar transmittance
3445 95220 : if (ShadeFlag == WinShadingType::SwitchableGlazing) { // Switchable glazing
3446 70512 : Real64 SwitchFac = state.dataSurface->SurfWinSwitchingFactor(SurfNum);
3447 70512 : int ConstrNumSh = Surface(SurfNum).activeShadedConstruction;
3448 70512 : Real64 TransGlSh = POLYF(CosInc, state.dataConstruction->Construct(ConstrNumSh).TransSolBeamCoef);
3449 : // Outer glass solar trans, refl, absorptance if switched
3450 70512 : TransGl = InterpSw(SwitchFac, TransGl, TransGlSh);
3451 70512 : Real64 TransDiffGlSh = state.dataConstruction->Construct(ConstrNumSh).TransDiff;
3452 : // Diffuse solar transmittance, switched construction
3453 70512 : TransDiffGl = InterpSw(SwitchFac, TransDiffGl, TransDiffGlSh);
3454 : }
3455 : // Beam plus diffuse solar on inside of divider
3456 : // BeamDivHorFaceIncIn - Beam solar on divider's horizontal inside projection faces (W/m2)
3457 : // BeamDivVertFaceIncIn - Beam solar on divider's vertical inside projection faces (W/m2)
3458 : Real64 BeamDivHorFaceIncIn =
3459 190440 : currBeamSolarRad * CosIncAngHorProj * state.dataSurface->FrameDivider(FrDivNum).HorDividers * DivProjIn *
3460 190440 : (Surface(SurfNum).Width - state.dataSurface->FrameDivider(FrDivNum).VertDividers * DivWidth) *
3461 95220 : FracSunLit / DivArea;
3462 : Real64 BeamDivVertFaceIncIn =
3463 95220 : currBeamSolarRad * CosIncAngVertProj * state.dataSurface->FrameDivider(FrDivNum).VertDividers *
3464 95220 : DivProjIn * (Surface(SurfNum).Height - state.dataSurface->FrameDivider(FrDivNum).HorDividers * DivWidth) *
3465 95220 : FracSunLit / DivArea;
3466 95220 : DivIncSolarInBm = TransGl * (BeamDivHorFaceIncIn + BeamDivVertFaceIncIn);
3467 95220 : DivIncSolarInDif = TransDiffGl * DifSolarFaceInc * state.dataSurface->SurfWinProjCorrDivIn(SurfNum);
3468 : }
3469 : } else { // Exterior shade, screen or blind present
3470 :
3471 798 : DivIncSolarOutBm = BeamFaceInc * (1.0 + state.dataSurface->SurfWinProjCorrDivOut(SurfNum));
3472 798 : DivIncSolarOutDif = DifSolarFaceInc * (1.0 + state.dataSurface->SurfWinProjCorrDivOut(SurfNum));
3473 1596 : DivIncSolarInBm = BeamFaceInc * state.dataSurface->SurfWinProjCorrDivIn(SurfNum) *
3474 798 : state.dataConstruction->Construct(ConstrNum).TransDiff;
3475 1596 : DivIncSolarInDif = DifSolarFaceInc * state.dataSurface->SurfWinProjCorrDivIn(SurfNum) *
3476 798 : state.dataConstruction->Construct(ConstrNum).TransDiff;
3477 : }
3478 105466 : if (!ANY_EXTERIOR_SHADE_BLIND_SCREEN(ShadeFlag) && !ANY_BETWEENGLASS_SHADE_BLIND(ShadeFlag)) {
3479 : // No exterior or between-glass shade, screen or blind
3480 104668 : state.dataSurface->SurfWinDividerQRadOutAbs(SurfNum) = DividerAbs * (DivIncSolarOutBm + DivIncSolarOutDif);
3481 104668 : state.dataSurface->SurfWinDividerQRadInAbs(SurfNum) = DividerAbs * (DivIncSolarInBm + DivIncSolarInDif);
3482 : // Exterior shade, screen or blind
3483 798 : } else if (ShadeFlag == WinShadingType::ExtBlind) { // Exterior blind
3484 0 : int BlNum = state.dataSurface->SurfWinBlindNumber(SurfNum);
3485 0 : int SlatsAngIndexLower = state.dataSurface->SurfWinSlatsAngIndex(SurfNum);
3486 0 : int SlatsAngIndexUpper = std::min(MaxProfAngs, SlatsAngIndexLower + 1);
3487 0 : Real64 SlatsAngInterpFac = state.dataSurface->SurfWinSlatsAngInterpFac(SurfNum);
3488 :
3489 : Real64 FrontDiffTrans;
3490 : Real64 TBlBmDif; // Blind diffuse-diffuse solar transmittance
3491 0 : if (state.dataSurface->SurfWinMovableSlats(SurfNum)) {
3492 0 : FrontDiffTrans =
3493 0 : General::InterpGeneral(state.dataHeatBal->Blind(BlNum).SolFrontDiffDiffTrans(SlatsAngIndexLower),
3494 0 : state.dataHeatBal->Blind(BlNum).SolFrontDiffDiffTrans(SlatsAngIndexUpper),
3495 : SlatsAngInterpFac);
3496 0 : TBlBmDif = General::InterpProfSlat(
3497 0 : state.dataHeatBal->Blind(BlNum).SolFrontBeamDiffTrans(SlatsAngIndexLower,
3498 0 : state.dataSurface->SurfWinProfAngIndex(SurfNum)),
3499 0 : state.dataHeatBal->Blind(BlNum).SolFrontBeamDiffTrans(SlatsAngIndexUpper,
3500 0 : state.dataSurface->SurfWinProfAngIndex(SurfNum)),
3501 0 : state.dataHeatBal->Blind(BlNum).SolFrontBeamDiffTrans(
3502 0 : SlatsAngIndexLower, std::min(MaxProfAngs, state.dataSurface->SurfWinProfAngIndex(SurfNum) + 1)),
3503 0 : state.dataHeatBal->Blind(BlNum).SolFrontBeamDiffTrans(
3504 0 : SlatsAngIndexUpper, std::min(MaxProfAngs, state.dataSurface->SurfWinProfAngIndex(SurfNum) + 1)),
3505 : SlatsAngInterpFac,
3506 0 : state.dataSurface->SurfWinProfAngInterpFac(SurfNum));
3507 : } else {
3508 0 : FrontDiffTrans = state.dataHeatBal->Blind(BlNum).SolFrontDiffDiffTrans(1);
3509 0 : TBlBmDif = General::InterpGeneral(
3510 0 : state.dataHeatBal->Blind(BlNum).SolFrontBeamDiffTrans(1, state.dataSurface->SurfWinProfAngIndex(SurfNum)),
3511 0 : state.dataHeatBal->Blind(BlNum).SolFrontBeamDiffTrans(
3512 0 : 1, std::min(MaxProfAngs, state.dataSurface->SurfWinProfAngIndex(SurfNum) + 1)),
3513 : SlatsAngInterpFac);
3514 : }
3515 :
3516 : // TBlBmBm - Blind beam-beam solar transmittance
3517 0 : Real64 TBlBmBm = state.dataSurface->SurfWinBlindBmBmTrans(SurfNum);
3518 0 : state.dataSurface->SurfWinDividerQRadOutAbs(SurfNum) =
3519 0 : DividerAbs * (DivIncSolarOutBm * (TBlBmBm + TBlBmDif) + DivIncSolarOutDif * FrontDiffTrans);
3520 0 : state.dataSurface->SurfWinDividerQRadInAbs(SurfNum) =
3521 0 : DividerAbs * (DivIncSolarInBm * (TBlBmBm + TBlBmDif) + DivIncSolarInDif * FrontDiffTrans);
3522 :
3523 798 : } else if (ShadeFlag == WinShadingType::ExtShade) { // Exterior shade
3524 798 : int ConstrNumSh = Surface(SurfNum).activeShadedConstruction;
3525 798 : state.dataSurface->SurfWinDividerQRadOutAbs(SurfNum) =
3526 798 : DividerAbs *
3527 1596 : state.dataMaterial->Material(state.dataConstruction->Construct(ConstrNumSh).LayerPoint(1)).Trans *
3528 798 : (DivIncSolarOutBm + DivIncSolarOutDif);
3529 798 : state.dataSurface->SurfWinDividerQRadInAbs(SurfNum) =
3530 798 : DividerAbs *
3531 1596 : state.dataMaterial->Material(state.dataConstruction->Construct(ConstrNumSh).LayerPoint(1)).Trans *
3532 798 : (DivIncSolarInBm + DivIncSolarInDif);
3533 :
3534 0 : } else if (ShadeFlag == WinShadingType::ExtScreen) { // Exterior screen
3535 0 : state.dataSurface->SurfWinDividerQRadOutAbs(SurfNum) =
3536 0 : DividerAbs *
3537 0 : (state.dataHeatBal->SurfaceScreens(state.dataSurface->SurfWinScreenNumber(SurfNum)).BmBmTrans +
3538 0 : state.dataHeatBal->SurfaceScreens(state.dataSurface->SurfWinScreenNumber(SurfNum)).BmDifTrans) *
3539 0 : (DivIncSolarOutBm + DivIncSolarOutDif);
3540 0 : state.dataSurface->SurfWinDividerQRadInAbs(SurfNum) =
3541 0 : DividerAbs *
3542 0 : (state.dataHeatBal->SurfaceScreens(state.dataSurface->SurfWinScreenNumber(SurfNum)).BmBmTrans +
3543 0 : state.dataHeatBal->SurfaceScreens(state.dataSurface->SurfWinScreenNumber(SurfNum)).BmDifTrans) *
3544 0 : (DivIncSolarInBm + DivIncSolarInDif);
3545 : }
3546 : }
3547 : }
3548 : } // Surface(SurfNum)%ExtSolar
3549 : } // end of surface window loop
3550 : } // end of space loop
3551 : } // end of zone loop
3552 823335 : for (int PipeNum = 1; PipeNum <= (int)state.dataDaylightingDevicesData->TDDPipe.size(); ++PipeNum) {
3553 1232 : int const SurfNum = state.dataDaylightingDevicesData->TDDPipe(PipeNum).Dome; // TDD: DOME object number
3554 1232 : int const ConstrNum = Surface(SurfNum).Construction;
3555 1232 : int const TotGlassLay = state.dataConstruction->Construct(ConstrNum).TotGlassLayers; // Number of glass layers
3556 1232 : state.dataHeatBal->SurfWinQRadSWwinAbsTot(SurfNum) = 0.0;
3557 2464 : for (int Lay = 1; Lay <= TotGlassLay; ++Lay) {
3558 1232 : AbsDiffWin(Lay) = state.dataConstruction->Construct(ConstrNum).AbsDiff(Lay);
3559 1232 : state.dataHeatBal->SurfWinQRadSWwinAbs(SurfNum, Lay) =
3560 2464 : AbsDiffWin(Lay) * (state.dataSurface->SurfSkySolarInc(SurfNum) + state.dataSurface->SurfGndSolarInc(SurfNum)) +
3561 1232 : state.dataSurface->SurfWinA(SurfNum, Lay) * currBeamSolar(SurfNum);
3562 1232 : state.dataHeatBal->SurfWinQRadSWwinAbsLayer(SurfNum, Lay) =
3563 1232 : state.dataHeatBal->SurfWinQRadSWwinAbs(SurfNum, Lay) * Surface(SurfNum).Area;
3564 1232 : state.dataHeatBal->SurfWinQRadSWwinAbsTot(SurfNum) += state.dataHeatBal->SurfWinQRadSWwinAbsLayer(SurfNum, Lay);
3565 1232 : state.dataHeatBal->SurfWinQRadSWwinAbsTotEnergy(SurfNum) =
3566 1232 : state.dataHeatBal->SurfWinQRadSWwinAbsTot(SurfNum) * state.dataGlobal->TimeStepZoneSec;
3567 : }
3568 : }
3569 :
3570 : // Average absorbed solar for representative surfaces
3571 822103 : if (state.dataSurface->UseRepresentativeSurfaceCalculations) {
3572 9212 : for (int zoneNum = 1; zoneNum <= state.dataGlobal->NumOfZones; ++zoneNum) {
3573 18032 : for (int spaceNum : state.dataHeatBal->Zone(zoneNum).spaceIndexes) {
3574 9016 : auto &thisSpace = state.dataHeatBal->space(spaceNum);
3575 9016 : int firstSurf = thisSpace.OpaqOrIntMassSurfaceFirst;
3576 9016 : int lastSurf = thisSpace.OpaqOrIntMassSurfaceLast;
3577 87612 : for (int surfNum = firstSurf; surfNum <= lastSurf; ++surfNum) {
3578 78596 : auto &surface(state.dataSurface->Surface(surfNum));
3579 78596 : if (surface.ConstituentSurfaceNums.size() > 1) {
3580 2940 : Real64 QoutAtot = 0.0;
3581 2940 : Real64 QinAtot = 0.0;
3582 2940 : Real64 Atot = 0.0;
3583 9212 : for (auto constSurfNum : surface.ConstituentSurfaceNums) {
3584 6272 : QoutAtot += state.dataHeatBalSurf->SurfOpaqQRadSWOutAbs(constSurfNum) * state.dataSurface->Surface(constSurfNum).Area;
3585 6272 : QinAtot += state.dataHeatBalSurf->SurfOpaqQRadSWInAbs(constSurfNum) * state.dataSurface->Surface(constSurfNum).Area;
3586 6272 : Atot += state.dataSurface->Surface(constSurfNum).Area;
3587 : }
3588 :
3589 2940 : state.dataHeatBalSurf->SurfOpaqQRadSWOutAbs(surfNum) = QoutAtot / Atot;
3590 2940 : state.dataHeatBalSurf->SurfOpaqQRadSWInAbs(surfNum) = QinAtot / Atot;
3591 : }
3592 : }
3593 9016 : firstSurf = thisSpace.WindowSurfaceFirst;
3594 9016 : lastSurf = thisSpace.WindowSurfaceLast;
3595 43904 : for (int surfNum = firstSurf; surfNum <= lastSurf; ++surfNum) {
3596 34888 : auto &surface(state.dataSurface->Surface(surfNum));
3597 34888 : if (surface.ExtSolar && surface.ConstituentSurfaceNums.size() > 1) {
3598 3724 : auto &surface(state.dataSurface->Surface(surfNum));
3599 :
3600 : // Absorbed in glazing
3601 : int totalGlassLayers =
3602 3724 : state.dataConstruction->Construct(state.dataSurface->SurfActiveConstruction(surfNum)).TotGlassLayers;
3603 11172 : for (int layer = 1; layer <= totalGlassLayers; ++layer) {
3604 7448 : Real64 QAtot = 0.0;
3605 7448 : Real64 Atot = 0.0;
3606 59584 : for (auto constSurfNum : surface.ConstituentSurfaceNums) {
3607 52136 : QAtot +=
3608 52136 : state.dataHeatBal->SurfWinQRadSWwinAbs(constSurfNum, layer) * state.dataSurface->Surface(constSurfNum).Area;
3609 52136 : Atot += state.dataSurface->Surface(constSurfNum).Area;
3610 : }
3611 :
3612 7448 : state.dataHeatBal->SurfWinQRadSWwinAbs(surfNum, layer) = QAtot / Atot;
3613 : }
3614 :
3615 : // Absorbed by frame and dividers
3616 3724 : if (surface.FrameDivider > 0) {
3617 392 : if (state.dataSurface->SurfWinFrameArea(surfNum) > 0.0) {
3618 0 : Real64 QoutAtot = 0.0;
3619 0 : Real64 QinAtot = 0.0;
3620 0 : Real64 Atot = 0.0;
3621 0 : for (auto constSurfNum : surface.ConstituentSurfaceNums) {
3622 0 : QoutAtot += state.dataSurface->SurfWinFrameQRadOutAbs(constSurfNum) *
3623 0 : state.dataSurface->SurfWinFrameArea(constSurfNum);
3624 0 : QinAtot += state.dataSurface->SurfWinFrameQRadInAbs(constSurfNum) *
3625 0 : state.dataSurface->SurfWinFrameArea(constSurfNum);
3626 0 : Atot += state.dataSurface->SurfWinFrameArea(constSurfNum);
3627 : }
3628 :
3629 0 : state.dataSurface->SurfWinFrameQRadOutAbs(surfNum) = QoutAtot / Atot;
3630 0 : state.dataSurface->SurfWinFrameQRadInAbs(surfNum) = QinAtot / Atot;
3631 : }
3632 392 : if (state.dataSurface->SurfWinDividerArea(surfNum) > 0.0) {
3633 0 : Real64 QoutAtot = 0.0;
3634 0 : Real64 QinAtot = 0.0;
3635 0 : Real64 Atot = 0.0;
3636 0 : for (auto constSurfNum : surface.ConstituentSurfaceNums) {
3637 0 : QoutAtot += state.dataSurface->SurfWinDividerQRadOutAbs(constSurfNum) *
3638 0 : state.dataSurface->SurfWinDividerArea(constSurfNum);
3639 0 : QinAtot += state.dataSurface->SurfWinDividerQRadInAbs(constSurfNum) *
3640 0 : state.dataSurface->SurfWinDividerArea(constSurfNum);
3641 0 : Atot += state.dataSurface->SurfWinDividerArea(constSurfNum);
3642 : }
3643 :
3644 0 : state.dataSurface->SurfWinDividerQRadOutAbs(surfNum) = QoutAtot / Atot;
3645 0 : state.dataSurface->SurfWinDividerQRadInAbs(surfNum) = QinAtot / Atot;
3646 : }
3647 : }
3648 : }
3649 : }
3650 : }
3651 : }
3652 : }
3653 : } // End of sun-up check
3654 2568509 : }
3655 :
3656 2568509 : void InitIntSolarDistribution(EnergyPlusData &state)
3657 : {
3658 :
3659 : // SUBROUTINE INFORMATION:
3660 : // AUTHOR Anonymous
3661 : // DATE WRITTEN July 1977
3662 : // MODIFIED Oct 1999 (FW) to handle movable shades
3663 : // May 2000 (FW) to handle window frame and dividers
3664 : // May 2001 (FW) to handle window blinds
3665 : // Jan 2002 (FW) mods for between-glass shade/blind
3666 : // May 2006 (RR) to handle exterior window screens
3667 : // RE-ENGINEERED Mar98 (RKS)
3668 :
3669 : // PURPOSE OF THIS SUBROUTINE:
3670 : // This subroutine initializes the arrays associated with solar heat
3671 : // gains for both individual surfaces and for zones.
3672 :
3673 : // METHODOLOGY EMPLOYED:
3674 : // If the sun is down, all of the pertinent arrays are zeroed. If the
3675 : // sun is up, various calculations are made.
3676 :
3677 : // REFERENCES:
3678 : // (I)BLAST legacy routine QSUN
3679 :
3680 : using DaylightingDevices::DistributeTDDAbsorbedSolar;
3681 : using General::InterpSw;
3682 : using namespace DataWindowEquivalentLayer;
3683 :
3684 2568509 : auto &Surface(state.dataSurface->Surface);
3685 :
3686 : // COMPUTE TOTAL SHORT-WAVE RADIATION ORIGINATING IN ZONE.
3687 : // Note: If sun is not up, QS is only internal gains
3688 21002924 : for (int enclosureNum = 1; enclosureNum <= state.dataViewFactor->NumOfSolarEnclosures; ++enclosureNum) {
3689 18434415 : Real64 sumSpaceQLTSW = 0.0;
3690 36897156 : for (int spaceNum : state.dataViewFactor->EnclSolInfo(enclosureNum).spaceNums) {
3691 18462741 : sumSpaceQLTSW += state.dataHeatBal->spaceIntGain(spaceNum).QLTSW;
3692 : }
3693 18434415 : state.dataHeatBal->EnclSolQSWRad(enclosureNum) = state.dataHeatBal->EnclSolQD(enclosureNum) + sumSpaceQLTSW;
3694 18434415 : state.dataHeatBal->EnclSolQSWRadLights(enclosureNum) = sumSpaceQLTSW;
3695 : }
3696 :
3697 2568509 : if (state.dataHeatBalSurf->InterZoneWindow) { // DO INTERZONE DISTRIBUTION.
3698 :
3699 60735 : for (int enclosureNum = 1; enclosureNum <= state.dataViewFactor->NumOfSolarEnclosures; ++enclosureNum) {
3700 :
3701 48588 : if (state.dataHeatBalSurf->EnclSolRecDifShortFromZ(enclosureNum)) {
3702 :
3703 141120 : for (int OtherenclosureNum = 1; OtherenclosureNum <= state.dataViewFactor->NumOfSolarEnclosures; ++OtherenclosureNum) {
3704 :
3705 112896 : if ((OtherenclosureNum != enclosureNum) && (state.dataHeatBalSurf->EnclSolRecDifShortFromZ(OtherenclosureNum))) {
3706 44352 : Real64 sumSpaceQLTSW = 0.0;
3707 88704 : for (int spaceNum : state.dataViewFactor->EnclSolInfo(OtherenclosureNum).spaceNums) {
3708 44352 : sumSpaceQLTSW += state.dataHeatBal->spaceIntGain(spaceNum).QLTSW;
3709 : }
3710 44352 : state.dataHeatBal->EnclSolQSWRad(enclosureNum) +=
3711 88704 : state.dataHeatBalSurf->ZoneFractDifShortZtoZ(enclosureNum, OtherenclosureNum) *
3712 44352 : (state.dataHeatBal->EnclSolQD(OtherenclosureNum) + sumSpaceQLTSW);
3713 44352 : state.dataHeatBal->ZoneDifSolFrIntWinsRep(enclosureNum) +=
3714 88704 : state.dataHeatBalSurf->ZoneFractDifShortZtoZ(enclosureNum, OtherenclosureNum) *
3715 44352 : state.dataHeatBal->EnclSolQD(OtherenclosureNum);
3716 44352 : state.dataHeatBal->ZoneDifSolFrIntWinsRepEnergy(enclosureNum) =
3717 44352 : state.dataHeatBal->ZoneDifSolFrIntWinsRep(enclosureNum) * state.dataGlobal->TimeStepZoneSec;
3718 : }
3719 : }
3720 : }
3721 : }
3722 : }
3723 :
3724 : // Beam and diffuse solar on inside surfaces from interior windows (for reporting)
3725 :
3726 2568509 : if (state.dataEnvrn->SunIsUp) {
3727 83718206 : for (int SurfNum = 1; SurfNum <= state.dataSurface->TotSurfaces; ++SurfNum) {
3728 82430116 : if (!Surface(SurfNum).HeatTransSurf) continue;
3729 : //!!! Following may need to be removed or changed when shelves are considered in adjacent reflection calculations
3730 80194121 : if (Surface(SurfNum).Class == SurfaceClass::Shading) continue;
3731 80192992 : int const enclosureNum = Surface(SurfNum).SolarEnclIndex;
3732 80192992 : state.dataHeatBal->SurfIntBmIncInsSurfIntensRep(SurfNum) =
3733 80192992 : state.dataHeatBal->ZoneBmSolFrIntWinsRep(enclosureNum) / state.dataViewFactor->EnclSolInfo(enclosureNum).TotalSurfArea;
3734 80192992 : state.dataHeatBal->SurfIntBmIncInsSurfAmountRep(SurfNum) =
3735 80192992 : state.dataHeatBal->SurfIntBmIncInsSurfIntensRep(SurfNum) * (Surface(SurfNum).Area + state.dataSurface->SurfWinDividerArea(SurfNum));
3736 80192992 : state.dataHeatBal->SurfIntBmIncInsSurfAmountRepEnergy(SurfNum) =
3737 80192992 : state.dataHeatBal->SurfIntBmIncInsSurfAmountRep(SurfNum) * state.dataGlobal->TimeStepZoneSec;
3738 : // IntDifIncInsSurfIntensRep(SurfNum) = ZoneDifSolFrIntWinsRep(ZoneNum)/Zone(ZoneNum)%TotalSurfArea
3739 : // IntDifIncInsSurfAmountRep(SurfNum) = IntDifIncInsSurfIntensRep(SurfNum) * &
3740 : // (Surface(SurfNum)%Area + SurfaceWindow(SurfNum)%DividerArea)
3741 : // IntDifIncInsSurfAmountRepEnergy(SurfNum) = IntDifIncInsSurfAmountRep(SurfNum) * TimeStepZoneSec
3742 : }
3743 : }
3744 :
3745 : // COMPUTE CONVECTIVE GAINS AND ZONE FLUX DENSITY.
3746 21002924 : for (int enclosureNum = 1; enclosureNum <= state.dataViewFactor->NumOfSolarEnclosures; ++enclosureNum) {
3747 18434415 : auto &thisSolEnclosure = state.dataViewFactor->EnclSolInfo(enclosureNum);
3748 18434415 : if (state.dataHeatBalSurf->InterZoneWindow) {
3749 48588 : state.dataHeatBal->EnclSolQSWRad(enclosureNum) *=
3750 48588 : state.dataHeatBalSurf->ZoneFractDifShortZtoZ(enclosureNum, enclosureNum) * thisSolEnclosure.solVMULT;
3751 : // CR 8695, VMULT not based on visible
3752 48588 : state.dataHeatBal->EnclSolQSWRadLights(enclosureNum) *=
3753 48588 : state.dataHeatBalSurf->ZoneFractDifShortZtoZ(enclosureNum, enclosureNum) * thisSolEnclosure.solVMULT;
3754 : } else {
3755 18385827 : state.dataHeatBal->EnclSolQSWRad(enclosureNum) *= thisSolEnclosure.solVMULT;
3756 18385827 : state.dataHeatBal->EnclSolQSWRadLights(enclosureNum) *= thisSolEnclosure.solVMULT;
3757 : }
3758 : }
3759 :
3760 : // COMPUTE RADIANT GAINS ON SURFACES
3761 21015074 : for (int zoneNum = 1; zoneNum <= state.dataGlobal->NumOfZones; ++zoneNum) {
3762 36909306 : for (int spaceNum : state.dataHeatBal->Zone(zoneNum).spaceIndexes) {
3763 18462741 : auto &thisSpace = state.dataHeatBal->space(spaceNum);
3764 18462741 : int const firstSurfOpaque = thisSpace.OpaqOrIntMassSurfaceFirst;
3765 18462741 : int const lastSurfOpaque = thisSpace.OpaqOrIntMassSurfaceLast;
3766 156163195 : for (int SurfNum = firstSurfOpaque; SurfNum <= lastSurfOpaque; ++SurfNum) {
3767 137700454 : int const solEnclosureNum = Surface(SurfNum).SolarEnclIndex;
3768 137700454 : int const ConstrNum = Surface(SurfNum).Construction;
3769 :
3770 137700454 : Real64 AbsIntSurf = state.dataHeatBalSurf->SurfAbsSolarInt(SurfNum);
3771 : // TODO - AbsIntSurfVis = InsideAbsorpSolar instead of InsideAbsorpVis?
3772 137700454 : Real64 AbsIntSurfVis = state.dataConstruction->Construct(ConstrNum)
3773 137700454 : .InsideAbsorpSolar; // Inside opaque surface visible absorptance to fix CR 8695 change to
3774 :
3775 137700454 : state.dataHeatBalSurf->SurfOpaqQRadSWInAbs(SurfNum) += state.dataHeatBal->EnclSolQSWRad(solEnclosureNum) * AbsIntSurf;
3776 137700454 : state.dataHeatBalSurf->SurfQdotRadLightsInPerArea(SurfNum) += state.dataHeatBal->EnclSolQSWRadLights(solEnclosureNum) * AbsIntSurfVis;
3777 :
3778 : // Calculate absorbed solar on outside if movable exterior insulation in place
3779 137761186 : if (state.dataSurface->AnyMovableInsulation &&
3780 60732 : state.dataHeatBalSurf->SurfMovInsulExtPresent(SurfNum)) { // Movable outside insulation in place
3781 4047 : Real64 AbsExt = state.dataHeatBalSurf->SurfAbsSolarExt(SurfNum);
3782 4047 : state.dataHeatBalSurf->SurfQRadSWOutMvIns(SurfNum) =
3783 8094 : state.dataHeatBalSurf->SurfOpaqQRadSWOutAbs(SurfNum) * AbsExt /
3784 4047 : state.dataMaterial->Material(state.dataConstruction->Construct(ConstrNum).LayerPoint(1)).AbsorpSolar;
3785 : // For transparent insulation, allow some sunlight to get through the movable insulation.
3786 : // The equation below is derived by taking what is transmitted through the layer and applying
3787 : // the fraction that is absorbed plus the back reflected portion (first order reflection only)
3788 : // to the plane between the transparent insulation and the exterior surface face.
3789 4047 : state.dataHeatBalSurf->SurfOpaqQRadSWOutAbs(SurfNum) =
3790 8094 : state.dataMaterial->Material(state.dataSurface->SurfMaterialMovInsulExt(SurfNum)).Trans *
3791 8094 : state.dataHeatBalSurf->SurfQRadSWOutMvIns(SurfNum) *
3792 8094 : ((state.dataMaterial->Material(state.dataConstruction->Construct(ConstrNum).LayerPoint(1)).AbsorpSolar / AbsExt) +
3793 4047 : (1 - state.dataMaterial->Material(state.dataConstruction->Construct(ConstrNum).LayerPoint(1)).AbsorpSolar));
3794 : }
3795 : // RJH 08/30/07 - Add SurfWinInitialDifSolInAbs, SurfWinInitialDifSolwinAbs, and SurfWinInitialDifSolAbsByShade
3796 : // calced in CalcWinTransDifSolInitialDistribution to SurfOpaqQRadSWInAbs, SurfWinQRadSWwinAbs, and SurfWinIntSWAbsByShade here
3797 137700454 : state.dataHeatBalSurf->SurfOpaqQRadSWInAbs(SurfNum) += state.dataHeatBalSurf->SurfOpaqInitialDifSolInAbs(SurfNum);
3798 : } // end of opaque
3799 :
3800 18462741 : int const firstSurfWin = thisSpace.WindowSurfaceFirst;
3801 18462741 : int const lastSurfWin = thisSpace.WindowSurfaceLast;
3802 40474011 : for (int SurfNum = firstSurfWin; SurfNum <= lastSurfWin; ++SurfNum) { // Window
3803 22011270 : int const radEnclosureNum = Surface(SurfNum).RadEnclIndex;
3804 22011270 : int const solEnclosureNum = Surface(SurfNum).SolarEnclIndex;
3805 22011270 : int const ConstrNum = state.dataSurface->SurfActiveConstruction(SurfNum);
3806 :
3807 22011270 : if (state.dataSurface->SurfWinWindowModelType(SurfNum) != WindowModel::EQL) {
3808 22003161 : int const ConstrNumSh = state.dataSurface->SurfWinActiveShadedConstruction(SurfNum);
3809 :
3810 22003161 : int TotGlassLayers = state.dataConstruction->Construct(ConstrNum).TotGlassLayers;
3811 22003161 : WinShadingType ShadeFlag = state.dataSurface->SurfWinShadingFlag(SurfNum);
3812 :
3813 : // These calculations are repeated from InitInternalHeatGains for the Zone Component Loads Report
3814 22003161 : Real64 pulseMultipler = 0.01; // use to create a pulse for the load component report computations, the W/sqft pulse for the zone
3815 22003161 : if (!state.dataGlobal->doLoadComponentPulseNow) {
3816 22002885 : state.dataHeatBal->SurfQdotRadIntGainsInPerArea(SurfNum) =
3817 44005770 : state.dataViewFactor->EnclRadInfo(radEnclosureNum).radQThermalRad *
3818 44005770 : state.dataViewFactor->EnclRadInfo(radEnclosureNum).radThermAbsMult * state.dataHeatBalSurf->SurfAbsThermalInt(SurfNum);
3819 : } else {
3820 276 : state.dataHeatBalSurfMgr->curQL = state.dataViewFactor->EnclRadInfo(radEnclosureNum).radQThermalRad;
3821 : // for the loads component report during the special sizing run increase the radiant portion
3822 : // a small amount to create a "pulse" of heat that is used for the
3823 276 : state.dataHeatBalSurfMgr->adjQL =
3824 276 : state.dataHeatBalSurfMgr->curQL + state.dataViewFactor->EnclRadInfo(radEnclosureNum).FloorArea * pulseMultipler;
3825 : // ITABSF is the Inside Thermal Absorptance
3826 : // EnclRadThermAbsMult is a multiplier for each zone/enclosure
3827 : // SurfQdotRadIntGainsInPerArea is the thermal radiation absorbed on inside surfaces
3828 276 : state.dataHeatBal->SurfQdotRadIntGainsInPerArea(SurfNum) =
3829 552 : state.dataHeatBalSurfMgr->adjQL * state.dataViewFactor->EnclRadInfo(radEnclosureNum).radThermAbsMult *
3830 276 : state.dataHeatBalSurf->SurfAbsThermalInt(SurfNum);
3831 : }
3832 :
3833 22003161 : if (NOT_SHADED(ShadeFlag)) { // No window shading
3834 49987066 : for (int IGlass = 1; IGlass <= TotGlassLayers; ++IGlass) {
3835 28155561 : state.dataHeatBal->SurfWinQRadSWwinAbs(SurfNum, IGlass) +=
3836 28155561 : state.dataHeatBal->EnclSolQSWRad(solEnclosureNum) * state.dataConstruction->Construct(ConstrNum).AbsDiffBack(IGlass);
3837 : }
3838 171656 : } else if (ConstrNumSh != 0 && ShadeFlag != WinShadingType::SwitchableGlazing) {
3839 : // Interior, exterior or between-glass shade, screen or blind in place
3840 196878 : for (int IGlass = 1; IGlass <= state.dataConstruction->Construct(ConstrNumSh).TotGlassLayers; ++IGlass) {
3841 122513 : if (ANY_SHADE_SCREEN(ShadeFlag)) {
3842 78441 : state.dataHeatBal->SurfWinQRadSWwinAbs(SurfNum, IGlass) +=
3843 156882 : state.dataHeatBal->EnclSolQSWRad(solEnclosureNum) *
3844 78441 : state.dataConstruction->Construct(ConstrNumSh).AbsDiffBack(IGlass);
3845 44072 : } else if (BITF_TEST_ANY(BITF(ShadeFlag), BITF(WinShadingType::IntBlind) | BITF(WinShadingType::ExtBlind))) {
3846 : Real64 BlAbsDiffBk; // Glass layer back diffuse solar absorptance when blind in place
3847 22368 : if (state.dataSurface->SurfWinMovableSlats(SurfNum)) {
3848 9393 : BlAbsDiffBk = General::InterpGeneral(
3849 3131 : state.dataConstruction->Construct(ConstrNumSh)
3850 3131 : .BlAbsDiffBack(state.dataSurface->SurfWinSlatsAngIndex(SurfNum), IGlass),
3851 3131 : state.dataConstruction->Construct(ConstrNumSh)
3852 6262 : .BlAbsDiffBack(std::min(MaxSlatAngs, state.dataSurface->SurfWinSlatsAngIndex(SurfNum) + 1), IGlass),
3853 3131 : state.dataSurface->SurfWinSlatsAngInterpFac(SurfNum));
3854 : } else {
3855 19237 : BlAbsDiffBk = state.dataConstruction->Construct(ConstrNumSh).BlAbsDiffBack(1, IGlass);
3856 : }
3857 22368 : state.dataHeatBal->SurfWinQRadSWwinAbs(SurfNum, IGlass) +=
3858 22368 : state.dataHeatBal->EnclSolQSWRad(solEnclosureNum) * BlAbsDiffBk;
3859 : }
3860 : }
3861 74365 : if (ShadeFlag == WinShadingType::IntShade) {
3862 67275 : state.dataSurface->SurfWinIntLWAbsByShade(SurfNum) = state.dataViewFactor->EnclRadInfo(radEnclosureNum).radQThermalRad *
3863 44850 : state.dataConstruction->Construct(ConstrNumSh).ShadeAbsorpThermal *
3864 22425 : state.dataViewFactor->EnclRadInfo(radEnclosureNum).radThermAbsMult;
3865 51940 : } else if (ShadeFlag == WinShadingType::IntBlind) {
3866 : Real64 EffBlEmiss; // Blind emissivity (thermal absorptance) as part of glazing system
3867 21262 : if (state.dataSurface->SurfWinMovableSlats(SurfNum)) {
3868 7734 : EffBlEmiss = General::InterpGeneral(
3869 2578 : state.dataSurface->SurfaceWindow(SurfNum).EffShBlindEmiss(state.dataSurface->SurfWinSlatsAngIndex(SurfNum)),
3870 2578 : state.dataSurface->SurfaceWindow(SurfNum).EffShBlindEmiss(
3871 5156 : std::min(MaxSlatAngs, state.dataSurface->SurfWinSlatsAngIndex(SurfNum) + 1)),
3872 2578 : state.dataSurface->SurfWinSlatsAngInterpFac(SurfNum));
3873 : } else {
3874 18684 : EffBlEmiss = state.dataSurface->SurfaceWindow(SurfNum).EffShBlindEmiss(1);
3875 : }
3876 42524 : state.dataSurface->SurfWinIntLWAbsByShade(SurfNum) = state.dataViewFactor->EnclRadInfo(radEnclosureNum).radQThermalRad *
3877 21262 : EffBlEmiss *
3878 21262 : state.dataViewFactor->EnclRadInfo(radEnclosureNum).radThermAbsMult;
3879 : }
3880 74365 : if (ANY_SHADE_SCREEN(ShadeFlag)) {
3881 43167 : state.dataSurface->SurfWinIntSWAbsByShade(SurfNum) =
3882 43167 : state.dataHeatBal->EnclSolQSWRad(solEnclosureNum) * state.dataConstruction->Construct(ConstrNumSh).AbsDiffBackShade;
3883 31198 : } else if (ANY_BLIND(ShadeFlag)) {
3884 : Real64 AbsDiffBkBl;
3885 31198 : if (state.dataSurface->SurfWinMovableSlats(SurfNum)) {
3886 9393 : AbsDiffBkBl = General::InterpGeneral(
3887 3131 : state.dataConstruction->Construct(ConstrNumSh).AbsDiffBackBlind(state.dataSurface->SurfWinSlatsAngIndex(SurfNum)),
3888 3131 : state.dataConstruction->Construct(ConstrNumSh)
3889 6262 : .AbsDiffBackBlind(std::min(MaxSlatAngs, state.dataSurface->SurfWinSlatsAngIndex(SurfNum) + 1)),
3890 3131 : state.dataSurface->SurfWinSlatsAngInterpFac(SurfNum));
3891 : } else {
3892 28067 : AbsDiffBkBl = state.dataConstruction->Construct(ConstrNumSh).AbsDiffBackBlind(1);
3893 : }
3894 31198 : state.dataSurface->SurfWinIntSWAbsByShade(SurfNum) = state.dataHeatBal->EnclSolQSWRad(solEnclosureNum) * AbsDiffBkBl;
3895 : }
3896 : // Correct for divider shadowing
3897 74365 : if (ANY_EXTERIOR_SHADE_BLIND_SCREEN(ShadeFlag)) {
3898 13760 : state.dataSurface->SurfWinIntSWAbsByShade(SurfNum) *= state.dataSurface->SurfWinGlazedFrac(SurfNum);
3899 74365 : }
3900 :
3901 97291 : } else if (ShadeFlag == WinShadingType::SwitchableGlazing) { // Switchable glazing
3902 213762 : for (int IGlass = 1; IGlass <= TotGlassLayers; ++IGlass) {
3903 :
3904 142508 : state.dataHeatBal->SurfWinQRadSWwinAbs(SurfNum, IGlass) +=
3905 285016 : state.dataHeatBal->EnclSolQSWRad(solEnclosureNum) *
3906 285016 : InterpSw(state.dataSurface->SurfWinSwitchingFactor(SurfNum),
3907 142508 : state.dataConstruction->Construct(ConstrNum).AbsDiffBack(IGlass),
3908 142508 : state.dataConstruction->Construct(ConstrNumSh).AbsDiffBack(IGlass));
3909 : }
3910 :
3911 : } // End of shading flag check
3912 :
3913 : // Note that FrameQRadInAbs is initially calculated in InitSolarHeatGains
3914 22003161 : if (state.dataSurface->SurfWinFrameArea(SurfNum) > 0.0)
3915 592428 : state.dataSurface->SurfWinFrameQRadInAbs(SurfNum) +=
3916 1184856 : (state.dataHeatBal->EnclSolQSWRad(solEnclosureNum) * state.dataSurface->SurfWinFrameSolAbsorp(SurfNum) +
3917 1184856 : (state.dataViewFactor->EnclRadInfo(radEnclosureNum).radQThermalRad *
3918 1184856 : state.dataViewFactor->EnclRadInfo(radEnclosureNum).radThermAbsMult +
3919 1184856 : state.dataHeatBalSurf->SurfQdotRadHVACInPerArea(SurfNum)) *
3920 1184856 : state.dataSurface->SurfWinFrameEmis(SurfNum)) *
3921 592428 : (1.0 + 0.5 * state.dataSurface->SurfWinProjCorrFrIn(SurfNum)); // Window has a frame
3922 22003161 : if (state.dataSurface->SurfWinDividerArea(SurfNum) > 0.0) { // Window has dividers
3923 262155 : Real64 DividerThermAbs = state.dataSurface->SurfWinDividerEmis(SurfNum); // Window divider thermal absorptance
3924 262155 : Real64 DividerSolAbs = state.dataSurface->SurfWinDividerSolAbsorp(SurfNum); // Window divider solar absorptance
3925 262155 : if (state.dataSurface->SurfWinDividerType(SurfNum) ==
3926 : DataSurfaces::FrameDividerType::Suspended) { // Suspended divider; account for inside glass
3927 59178 : Real64 MatNumGl = state.dataConstruction->Construct(ConstrNum).LayerPoint(
3928 59178 : state.dataConstruction->Construct(ConstrNum).TotLayers); // Glass layer material number
3929 : Real64 TransGl =
3930 29589 : state.dataMaterial->Material(MatNumGl).Trans; // Glass layer solar transmittance, reflectance, absorptance
3931 29589 : Real64 ReflGl = state.dataMaterial->Material(MatNumGl).ReflectSolBeamBack;
3932 29589 : Real64 AbsGl = 1.0 - TransGl - ReflGl;
3933 29589 : Real64 DividerSolRefl = 1.0 - DividerSolAbs; // Window divider solar reflectance
3934 29589 : DividerSolAbs = AbsGl + TransGl * (DividerSolAbs + DividerSolRefl * AbsGl) / (1.0 - DividerSolRefl * ReflGl);
3935 29589 : DividerThermAbs = state.dataMaterial->Material(MatNumGl).AbsorpThermalBack;
3936 : }
3937 : // Correct for interior shade transmittance
3938 262155 : if (ShadeFlag == WinShadingType::IntShade) {
3939 742 : int MatNumSh = state.dataConstruction->Construct(ConstrNumSh)
3940 742 : .LayerPoint(state.dataConstruction->Construct(ConstrNumSh).TotLayers); // Shade layer material number
3941 742 : DividerSolAbs *= state.dataMaterial->Material(MatNumSh).Trans;
3942 742 : DividerThermAbs *= state.dataMaterial->Material(MatNumSh).TransThermal;
3943 261413 : } else if (ShadeFlag == WinShadingType::IntBlind) {
3944 0 : int BlNum = state.dataSurface->SurfWinBlindNumber(SurfNum);
3945 : Real64 SolBackDiffDiffTrans;
3946 : Real64 IRBackTrans;
3947 0 : if (state.dataSurface->SurfWinMovableSlats(SurfNum)) {
3948 0 : int SurfWinSlatsAngIndex = state.dataSurface->SurfWinSlatsAngIndex(SurfNum);
3949 0 : Real64 SurfWinSlatsAngInterpFac = state.dataSurface->SurfWinSlatsAngInterpFac(SurfNum);
3950 0 : SolBackDiffDiffTrans = General::InterpGeneral(
3951 0 : state.dataHeatBal->Blind(BlNum).SolBackDiffDiffTrans(SurfWinSlatsAngIndex),
3952 0 : state.dataHeatBal->Blind(BlNum).SolBackDiffDiffTrans(std::min(MaxSlatAngs, SurfWinSlatsAngIndex + 1)),
3953 : SurfWinSlatsAngInterpFac);
3954 0 : IRBackTrans = General::InterpGeneral(
3955 0 : state.dataHeatBal->Blind(BlNum).IRBackTrans(SurfWinSlatsAngIndex),
3956 0 : state.dataHeatBal->Blind(BlNum).IRBackTrans(std::min(MaxSlatAngs, SurfWinSlatsAngIndex + 1)),
3957 : SurfWinSlatsAngInterpFac);
3958 : } else {
3959 0 : SolBackDiffDiffTrans = state.dataHeatBal->Blind(BlNum).SolBackDiffDiffTrans(1);
3960 0 : IRBackTrans = state.dataHeatBal->Blind(BlNum).IRBackTrans(1);
3961 : }
3962 0 : DividerSolAbs *= SolBackDiffDiffTrans;
3963 0 : DividerThermAbs *= IRBackTrans;
3964 : }
3965 : // Note that DividerQRadInAbs is initially calculated in InitSolarHeatGains
3966 262155 : state.dataSurface->SurfWinDividerQRadInAbs(SurfNum) +=
3967 524310 : (state.dataHeatBal->EnclSolQSWRad(solEnclosureNum) * DividerSolAbs +
3968 524310 : (state.dataViewFactor->EnclRadInfo(radEnclosureNum).radQThermalRad *
3969 524310 : state.dataViewFactor->EnclRadInfo(radEnclosureNum).radThermAbsMult +
3970 524310 : state.dataHeatBalSurf->SurfQdotRadHVACInPerArea(SurfNum)) *
3971 262155 : DividerThermAbs) *
3972 262155 : (1.0 + state.dataSurface->SurfWinProjCorrDivIn(SurfNum));
3973 : }
3974 : } else {
3975 : // These calculations are repeated from InitInternalHeatGains for the Zone Component Loads Report
3976 8109 : Real64 pulseMultipler = 0.01; // the W/sqft pulse for the zone
3977 8109 : if (!state.dataGlobal->doLoadComponentPulseNow) {
3978 8109 : state.dataHeatBal->SurfQdotRadIntGainsInPerArea(SurfNum) =
3979 16218 : state.dataViewFactor->EnclRadInfo(radEnclosureNum).radQThermalRad *
3980 16218 : state.dataViewFactor->EnclRadInfo(radEnclosureNum).radThermAbsMult * state.dataHeatBalSurf->SurfAbsThermalInt(SurfNum);
3981 : } else {
3982 0 : state.dataHeatBalSurfMgr->curQL = state.dataViewFactor->EnclRadInfo(radEnclosureNum).radQThermalRad;
3983 : // for the loads component report during the special sizing run increase the radiant portion
3984 : // a small amount to create a "pulse" of heat that is used for the
3985 0 : state.dataHeatBalSurfMgr->adjQL =
3986 0 : state.dataHeatBalSurfMgr->curQL + state.dataViewFactor->EnclRadInfo(radEnclosureNum).FloorArea * pulseMultipler;
3987 : // ITABSF is the Inside Thermal Absorptance
3988 : // EnclRadThermAbsMult is a multiplier for each zone/radiant enclosure
3989 : // SurfQdotRadIntGainsInPerArea is the thermal radiation absorbed on inside surfaces
3990 0 : state.dataHeatBal->SurfQdotRadIntGainsInPerArea(SurfNum) =
3991 0 : state.dataHeatBalSurfMgr->adjQL * state.dataViewFactor->EnclRadInfo(radEnclosureNum).radThermAbsMult *
3992 0 : state.dataHeatBalSurf->SurfAbsThermalInt(SurfNum);
3993 : }
3994 : // Radiations absorbed by the window layers coming from zone side
3995 8109 : int EQLNum = state.dataConstruction->Construct(ConstrNum).EQLConsPtr;
3996 37842 : for (int Lay = 1; Lay <= state.dataWindowEquivLayer->CFS(EQLNum).NL; ++Lay) {
3997 29733 : state.dataHeatBal->SurfWinQRadSWwinAbs(SurfNum, Lay) +=
3998 29733 : state.dataHeatBal->EnclSolQSWRad(solEnclosureNum) * state.dataConstruction->Construct(ConstrNum).AbsDiffBackEQL(Lay);
3999 : }
4000 : // Window frame has not been included for equivalent layer model yet
4001 :
4002 : } // end if for IF ( SurfaceWindow(SurfNum)%WindowModelType /= WindowModel:: EQL) THEN
4003 :
4004 22011270 : if (Surface(SurfNum).ExtBoundCond > 0) { // Interzone surface
4005 : // Short-wave radiation absorbed in panes of corresponding window in adjacent zone
4006 27192 : int SurfNumAdjZone = Surface(SurfNum).ExtBoundCond; // Surface number in adjacent zone for interzone surfaces
4007 27192 : if (state.dataSurface->SurfWinWindowModelType(SurfNumAdjZone) != WindowModel::EQL) {
4008 27192 : int TotGlassLayers = state.dataConstruction->Construct(ConstrNum).TotGlassLayers;
4009 54384 : for (int IGlass = 1; IGlass <= TotGlassLayers; ++IGlass) {
4010 27192 : state.dataHeatBal->SurfWinQRadSWwinAbs(SurfNumAdjZone, IGlass) +=
4011 54384 : state.dataHeatBal->EnclSolQSWRad(solEnclosureNum) *
4012 27192 : state.dataConstruction->Construct(Surface(SurfNumAdjZone).Construction).AbsDiff(IGlass);
4013 : // Note that AbsDiff rather than AbsDiffBack is used in the above since the
4014 : // radiation from the current zone is incident on the outside of the adjacent
4015 : // zone's window.
4016 : }
4017 : } else { // IF (SurfaceWindow(SurfNumAdjZone)%WindowModelType == WindowModel:: EQL) THEN
4018 0 : int const AdjConstrNum = Surface(SurfNumAdjZone).Construction;
4019 0 : int const EQLNum = state.dataConstruction->Construct(AdjConstrNum).EQLConsPtr;
4020 0 : for (int Lay = 1; Lay <= state.dataWindowEquivLayer->CFS(EQLNum).NL; ++Lay) {
4021 0 : state.dataHeatBal->SurfWinQRadSWwinAbs(SurfNumAdjZone, Lay) +=
4022 0 : state.dataHeatBal->EnclSolQSWRad(solEnclosureNum) * state.dataConstruction->Construct(ConstrNum).AbsDiffFrontEQL(Lay);
4023 : // Note that AbsDiffFrontEQL rather than AbsDiffBackEQL is used in the above
4024 : // since the radiation from the current zone is incident on the outside of the
4025 : // adjacent zone's window.
4026 : }
4027 : }
4028 : }
4029 :
4030 22011270 : if (state.dataSurface->SurfWinWindowModelType(SurfNum) == WindowModel::Detailed) {
4031 21963621 : int const ConstrNumSh = state.dataSurface->SurfWinActiveShadedConstruction(SurfNum);
4032 21963621 : int TotGlassLayers = state.dataConstruction->Construct(ConstrNum).TotGlassLayers;
4033 21963621 : WinShadingType ShadeFlag = state.dataSurface->SurfWinShadingFlag(SurfNum);
4034 21963621 : if (NOT_SHADED(ShadeFlag)) { // No window shading
4035 49940482 : for (int IGlass = 1; IGlass <= TotGlassLayers; ++IGlass) {
4036 28122480 : state.dataHeatBal->SurfWinQRadSWwinAbs(SurfNum, IGlass) += state.dataHeatBal->SurfWinInitialDifSolwinAbs(SurfNum, IGlass);
4037 : }
4038 145619 : } else if (ShadeFlag == WinShadingType::SwitchableGlazing) { // Switchable glazing
4039 213762 : for (int IGlass = 1; IGlass <= TotGlassLayers; ++IGlass) {
4040 142508 : state.dataHeatBal->SurfWinQRadSWwinAbs(SurfNum, IGlass) += state.dataHeatBal->SurfWinInitialDifSolwinAbs(SurfNum, IGlass);
4041 : }
4042 : } else {
4043 : // Interior, exterior or between-glass shade, screen or blind in place
4044 196878 : for (int IGlass = 1; IGlass <= state.dataConstruction->Construct(ConstrNumSh).TotGlassLayers; ++IGlass) {
4045 122513 : state.dataHeatBal->SurfWinQRadSWwinAbs(SurfNum, IGlass) += state.dataHeatBal->SurfWinInitialDifSolwinAbs(SurfNum, IGlass);
4046 : }
4047 74365 : if (ANY_SHADE_SCREEN(ShadeFlag)) {
4048 43167 : state.dataSurface->SurfWinIntSWAbsByShade(SurfNum) += state.dataSurface->SurfWinInitialDifSolAbsByShade(SurfNum);
4049 31198 : } else if (ANY_BLIND(ShadeFlag)) {
4050 31198 : state.dataSurface->SurfWinIntSWAbsByShade(SurfNum) += state.dataSurface->SurfWinInitialDifSolAbsByShade(SurfNum);
4051 : }
4052 : } // End of shading flag check
4053 47649 : } else if (state.dataSurface->SurfWinWindowModelType(SurfNum) == WindowModel::BSDF) {
4054 39540 : int TotGlassLayers = state.dataConstruction->Construct(ConstrNum).TotGlassLayers;
4055 119289 : for (int IGlass = 1; IGlass <= TotGlassLayers; ++IGlass) {
4056 79749 : state.dataHeatBal->SurfWinQRadSWwinAbs(SurfNum, IGlass) += state.dataHeatBal->SurfWinInitialDifSolwinAbs(SurfNum, IGlass);
4057 : }
4058 8109 : } else if (state.dataSurface->SurfWinWindowModelType(SurfNum) == WindowModel::EQL) {
4059 :
4060 : // ConstrNum = Surface(SurfNum)%Construction
4061 8109 : int EQLNum = state.dataConstruction->Construct(ConstrNum).EQLConsPtr;
4062 :
4063 37842 : for (int Lay = 1; Lay <= state.dataWindowEquivLayer->CFS(EQLNum).NL; ++Lay) {
4064 29733 : state.dataHeatBal->SurfWinQRadSWwinAbs(SurfNum, Lay) += state.dataHeatBal->SurfWinInitialDifSolwinAbs(SurfNum, Lay);
4065 : }
4066 : }
4067 :
4068 : } // End of window
4069 : }
4070 : }
4071 2568509 : DistributeTDDAbsorbedSolar(state);
4072 2568509 : }
4073 :
4074 2568509 : void ComputeIntThermalAbsorpFactors(EnergyPlusData &state)
4075 : {
4076 :
4077 : // SUBROUTINE INFORMATION:
4078 : // AUTHOR Legacy Code (George Walton)
4079 : // DATE WRITTEN Legacy: Dec 1976
4080 : // MODIFIED Nov. 99, FCW: to take into account movable interior shades and switchable glazing
4081 : // June 01, FCW: to take into account interior blinds.
4082 :
4083 : // PURPOSE OF THIS SUBROUTINE:
4084 : // This routine computes the fractions of long-wave radiation from lights, equipment and people
4085 : // that is absorbed by each zone surface.
4086 :
4087 : // METHODOLOGY EMPLOYED:
4088 : // The fraction is assumed to be proportional to the product of the surface area times its thermal absorptivity.
4089 :
4090 : // REFERENCES:
4091 : // BLAST Routine: CITAF - Compute Interior Thermal Absorption Factors
4092 :
4093 21031250 : for (auto &thisEnclosure : state.dataViewFactor->EnclRadInfo) {
4094 18462741 : if (!thisEnclosure.radReCalc) continue;
4095 317188 : for (int spaceNum : thisEnclosure.spaceNums) {
4096 158632 : auto &thisSpace = state.dataHeatBal->space(spaceNum);
4097 158632 : int const firstSurfWin = thisSpace.WindowSurfaceFirst;
4098 158632 : int const lastSurfWin = thisSpace.WindowSurfaceLast;
4099 545875 : for (int SurfNum = firstSurfWin; SurfNum <= lastSurfWin; ++SurfNum) {
4100 387243 : WinShadingType ShadeFlag = state.dataSurface->SurfWinShadingFlag(SurfNum);
4101 387243 : if (ANY_INTERIOR_SHADE_BLIND(ShadeFlag)) {
4102 10798 : Real64 BlindEmiss = state.dataSurface->SurfaceWindow(SurfNum).EffShBlindEmiss(1);
4103 10798 : Real64 GlassEmiss = state.dataSurface->SurfaceWindow(SurfNum).EffGlassEmiss(1);
4104 10798 : state.dataHeatBalSurf->SurfAbsThermalInt(SurfNum) = BlindEmiss + GlassEmiss;
4105 : } else {
4106 376445 : int ConstrNum = state.dataSurface->SurfActiveConstruction(SurfNum);
4107 376445 : state.dataHeatBalSurf->SurfAbsThermalInt(SurfNum) = state.dataConstruction->Construct(ConstrNum).InsideAbsorpThermal;
4108 : }
4109 : }
4110 : }
4111 : }
4112 2568509 : if (state.dataSurface->AnyMovableSlat) {
4113 12150 : for (int SurfNum : state.dataHeatBalSurf->SurfMovSlatsIndexList) {
4114 : // For window with an interior shade or blind, emissivity is a combination of glass and shade/blind emissivity
4115 6075 : WinShadingType ShadeFlag = state.dataSurface->SurfWinShadingFlag(SurfNum);
4116 6075 : if (ANY_INTERIOR_SHADE_BLIND(ShadeFlag)) {
4117 2578 : if (state.dataSurface->SurfWinMovableSlats(SurfNum)) {
4118 : Real64 BlindEmiss;
4119 : Real64 GlassEmiss;
4120 2578 : int SurfWinSlatsAngIndex = state.dataSurface->SurfWinSlatsAngIndex(SurfNum);
4121 2578 : Real64 SurfWinSlatsAngInterpFac = state.dataSurface->SurfWinSlatsAngInterpFac(SurfNum);
4122 5156 : BlindEmiss = General::InterpGeneral(
4123 2578 : state.dataSurface->SurfaceWindow(SurfNum).EffShBlindEmiss(SurfWinSlatsAngIndex),
4124 5156 : state.dataSurface->SurfaceWindow(SurfNum).EffShBlindEmiss(std::min(MaxSlatAngs, SurfWinSlatsAngIndex + 1)),
4125 : SurfWinSlatsAngInterpFac);
4126 5156 : GlassEmiss = General::InterpGeneral(
4127 2578 : state.dataSurface->SurfaceWindow(SurfNum).EffGlassEmiss(SurfWinSlatsAngIndex),
4128 5156 : state.dataSurface->SurfaceWindow(SurfNum).EffGlassEmiss(std::min(MaxSlatAngs, SurfWinSlatsAngIndex + 1)),
4129 : SurfWinSlatsAngInterpFac);
4130 2578 : state.dataHeatBalSurf->SurfAbsThermalInt(SurfNum) = BlindEmiss + GlassEmiss;
4131 : }
4132 : }
4133 : }
4134 : }
4135 :
4136 21031250 : for (auto &thisRadEnclosure : state.dataViewFactor->EnclRadInfo) {
4137 18462741 : if (!thisRadEnclosure.radReCalc) continue;
4138 158556 : Real64 SUM1 = 0.0;
4139 1723138 : for (int const SurfNum : thisRadEnclosure.SurfacePtr) {
4140 1564582 : auto &thisSurf = state.dataSurface->Surface(SurfNum);
4141 1564582 : int const ConstrNum = thisSurf.Construction;
4142 1564582 : WinShadingType ShadeFlag = state.dataSurface->SurfWinShadingFlag(SurfNum);
4143 1564582 : if (ShadeFlag != WinShadingType::SwitchableGlazing) {
4144 1564582 : SUM1 += thisSurf.Area * state.dataHeatBalSurf->SurfAbsThermalInt(SurfNum);
4145 : } else { // Switchable glazing
4146 0 : SUM1 += thisSurf.Area * General::InterpSw(state.dataSurface->SurfWinSwitchingFactor(SurfNum),
4147 0 : state.dataConstruction->Construct(ConstrNum).InsideAbsorpThermal,
4148 0 : state.dataConstruction->Construct(thisSurf.activeShadedConstruction).InsideAbsorpThermal);
4149 : }
4150 :
4151 : // Window frame and divider effects
4152 1564582 : if (state.dataSurface->SurfWinFrameArea(SurfNum) > 0.0)
4153 178918 : SUM1 += state.dataSurface->SurfWinFrameArea(SurfNum) * (1.0 + 0.5 * state.dataSurface->SurfWinProjCorrFrIn(SurfNum)) *
4154 89459 : state.dataSurface->SurfWinFrameEmis(SurfNum);
4155 1564582 : if (state.dataSurface->SurfWinDividerArea(SurfNum) > 0.0) {
4156 88270 : Real64 DividerThermAbs = state.dataSurface->SurfWinDividerEmis(SurfNum); // Window divider thermal absorptance
4157 : // Suspended (between-glass) divider; relevant emissivity is inner glass emissivity
4158 88270 : if (state.dataSurface->SurfWinDividerType(SurfNum) == DataSurfaces::FrameDividerType::Suspended)
4159 95 : DividerThermAbs = state.dataConstruction->Construct(ConstrNum).InsideAbsorpThermal;
4160 88270 : if (ANY_INTERIOR_SHADE_BLIND(ShadeFlag)) {
4161 : // Interior shade or blind in place
4162 14 : int const ConstrNumSh = thisSurf.activeShadedConstruction;
4163 14 : if (state.dataSurface->SurfWinHasShadeOrBlindLayer(SurfNum)) {
4164 : // Shade layer material number
4165 : int MatNumSh =
4166 14 : state.dataConstruction->Construct(ConstrNumSh).LayerPoint(state.dataConstruction->Construct(ConstrNumSh).TotLayers);
4167 : // Shade or blind IR transmittance
4168 14 : Real64 TauShIR = state.dataMaterial->Material(MatNumSh).TransThermal;
4169 : // Effective emissivity of shade or blind
4170 14 : Real64 EffShDevEmiss = state.dataSurface->SurfaceWindow(SurfNum).EffShBlindEmiss(1);
4171 14 : if (ShadeFlag == WinShadingType::IntBlind) {
4172 0 : TauShIR = state.dataHeatBal->Blind(state.dataSurface->SurfWinBlindNumber(SurfNum)).IRBackTrans(1);
4173 0 : if (state.dataSurface->SurfWinMovableSlats(SurfNum)) {
4174 0 : int SurfWinSlatsAngIndex = state.dataSurface->SurfWinSlatsAngIndex(SurfNum);
4175 0 : Real64 SurfWinSlatsAngInterpFac = state.dataSurface->SurfWinSlatsAngInterpFac(SurfNum);
4176 0 : TauShIR = General::InterpGeneral(
4177 0 : state.dataHeatBal->Blind(state.dataSurface->SurfWinBlindNumber(SurfNum)).IRBackTrans(SurfWinSlatsAngIndex),
4178 0 : state.dataHeatBal->Blind(state.dataSurface->SurfWinBlindNumber(SurfNum))
4179 0 : .IRBackTrans(std::min(MaxSlatAngs, SurfWinSlatsAngIndex + 1)),
4180 : SurfWinSlatsAngInterpFac);
4181 0 : EffShDevEmiss = General::InterpGeneral(
4182 0 : state.dataSurface->SurfaceWindow(SurfNum).EffShBlindEmiss(SurfWinSlatsAngIndex),
4183 0 : state.dataSurface->SurfaceWindow(SurfNum).EffShBlindEmiss(std::min(MaxSlatAngs, SurfWinSlatsAngIndex + 1)),
4184 : SurfWinSlatsAngInterpFac);
4185 : }
4186 : }
4187 14 : SUM1 += state.dataSurface->SurfWinDividerArea(SurfNum) * (EffShDevEmiss + DividerThermAbs * TauShIR);
4188 : } else {
4189 : // this is for EMS activated shade/blind but the window construction has no shade/blind layer
4190 0 : SUM1 += state.dataSurface->SurfWinDividerArea(SurfNum) * (1.0 + state.dataSurface->SurfWinProjCorrDivIn(SurfNum)) *
4191 : DividerThermAbs;
4192 : }
4193 : } else {
4194 88256 : SUM1 +=
4195 88256 : state.dataSurface->SurfWinDividerArea(SurfNum) * (1.0 + state.dataSurface->SurfWinProjCorrDivIn(SurfNum)) * DividerThermAbs;
4196 : }
4197 : }
4198 :
4199 : } // End of loop over surfaces in zone/enclosure
4200 158556 : thisRadEnclosure.radThermAbsMult = 1.0 / SUM1;
4201 :
4202 : } // End of loop over enclosures
4203 2568509 : }
4204 :
4205 2568509 : void ComputeIntSWAbsorpFactors(EnergyPlusData &state)
4206 : {
4207 :
4208 : // SUBROUTINE INFORMATION:
4209 : // AUTHOR Legacy (George Walton)
4210 : // DATE WRITTEN Legacy (December 1980)
4211 : // MODIFIED Nov. 99, FW; now called every time step to account for movable
4212 : // window shades and insulation
4213 : // Mar. 00, FW; change name from ComputeVisLightingAbsorpFactors
4214 : // to ComputeIntSWAbsorpFactors
4215 : // May 00, FW; add window frame and divider effects
4216 : // June 01, FW: account for window blinds
4217 : // Nov 01, FW: account for absorptance of exterior shades and interior or exterior blinds
4218 : // Jan 03, FW: add between-glass shade/blind
4219 : // May 06, RR: account for exterior window screens
4220 :
4221 : // PURPOSE OF THIS SUBROUTINE:
4222 : // Computes VMULT, the inverse of the sum of area*(short-wave absorptance+transmittance) for
4223 : // the surfaces in a zone. VMULT is used to calculate the zone interior diffuse short-wave radiation
4224 : // absorbed by the inside of opaque zone surfaces or by the glass and shade/blind layers of zone windows.
4225 :
4226 : // Sets VCONV to zero (VCONV was formerly used to calculate convective gain due to short-wave
4227 : // radiation absorbed by interior window shades).
4228 :
4229 : // REFERENCES:
4230 : // BLAST Routine - CIVAF - Compute Surface Absorption Factors For Short Wave Radiation
4231 : // From Zone Lights And Diffuse Solar.
4232 :
4233 : // Avoid a division by zero of the user has entered a bunch of surfaces with zero absorptivity on the inside
4234 2568509 : Real64 constexpr SmallestAreaAbsProductAllowed(0.01);
4235 :
4236 21031250 : for (auto &thisSolEnclosure : state.dataViewFactor->EnclSolInfo) {
4237 18462741 : if (!thisSolEnclosure.radReCalc) continue;
4238 158556 : Real64 SUM1 = 0.0; // Intermediate calculation value for solar absorbed and transmitted
4239 :
4240 1724317 : for (int const SurfNum : thisSolEnclosure.SurfacePtr) {
4241 1565761 : auto &thisSurf = state.dataSurface->Surface(SurfNum);
4242 1565761 : int const ConstrNum = state.dataSurface->SurfActiveConstruction(SurfNum);
4243 1565761 : if (state.dataConstruction->Construct(ConstrNum).TransDiff <= 0.0) {
4244 : // Opaque surface
4245 1180623 : Real64 AbsIntSurf = state.dataHeatBalSurf->SurfAbsSolarInt(SurfNum); // Inside surface short-wave absorptance
4246 1180623 : SUM1 += thisSurf.Area * AbsIntSurf;
4247 :
4248 : } else {
4249 : // Window
4250 385138 : if (!state.dataConstruction->Construct(thisSurf.Construction).WindowTypeEQL) {
4251 379144 : WinShadingType ShadeFlag = state.dataSurface->SurfWinShadingFlag(SurfNum);
4252 :
4253 379144 : Real64 AbsDiffTotWin = 0.0; // Sum of window layer short-wave absorptances
4254 379144 : int const ConstrNumSh = state.dataSurface->SurfWinActiveShadedConstruction(SurfNum);
4255 379144 : Real64 SwitchFac = state.dataSurface->SurfWinSwitchingFactor(SurfNum);
4256 :
4257 : // Sum of absorptances of glass layers
4258 888601 : for (int Lay = 1; Lay <= state.dataConstruction->Construct(ConstrNum).TotGlassLayers; ++Lay) {
4259 509457 : Real64 AbsDiffLayWin = state.dataConstruction->Construct(ConstrNum).AbsDiffBack(Lay); // Window layer short-wave absorptance
4260 :
4261 : // Window with shade, screen or blind
4262 509457 : if (ConstrNumSh != 0) {
4263 202763 : if (ANY_SHADE_SCREEN(ShadeFlag)) {
4264 6013 : AbsDiffLayWin = state.dataConstruction->Construct(ConstrNumSh).AbsDiffBack(Lay);
4265 196750 : } else if (ANY_BLIND(ShadeFlag)) {
4266 8641 : if (state.dataSurface->SurfWinMovableSlats(SurfNum)) {
4267 9393 : AbsDiffLayWin = General::InterpGeneral(
4268 3131 : state.dataConstruction->Construct(ConstrNumSh)
4269 3131 : .BlAbsDiffBack(state.dataSurface->SurfWinSlatsAngIndex(SurfNum), Lay),
4270 3131 : state.dataConstruction->Construct(ConstrNumSh)
4271 6262 : .BlAbsDiffBack(std::min(MaxSlatAngs, state.dataSurface->SurfWinSlatsAngIndex(SurfNum) + 1), Lay),
4272 3131 : state.dataSurface->SurfWinSlatsAngInterpFac(SurfNum));
4273 : } else {
4274 5510 : AbsDiffLayWin = state.dataConstruction->Construct(ConstrNumSh).BlAbsDiffBack(1, Lay);
4275 : }
4276 : }
4277 : }
4278 :
4279 : // Switchable glazing
4280 509457 : if (ShadeFlag == WinShadingType::SwitchableGlazing)
4281 0 : AbsDiffLayWin =
4282 0 : General::InterpSw(SwitchFac, AbsDiffLayWin, state.dataConstruction->Construct(ConstrNumSh).AbsDiffBack(Lay));
4283 :
4284 509457 : AbsDiffTotWin += AbsDiffLayWin;
4285 : }
4286 :
4287 379144 : Real64 TransDiffWin = state.dataConstruction->Construct(ConstrNum).TransDiff; // Window diffuse short-wave transmittance
4288 379144 : Real64 DiffAbsShade = 0.0; // Diffuse short-wave shade or blind absorptance
4289 :
4290 : // Window with shade, screen or blind
4291 :
4292 379144 : if (ConstrNumSh != 0) {
4293 110375 : if (ANY_SHADE_SCREEN(ShadeFlag)) {
4294 3853 : TransDiffWin = state.dataConstruction->Construct(ConstrNumSh).TransDiff;
4295 3853 : DiffAbsShade = state.dataConstruction->Construct(ConstrNumSh).AbsDiffBackShade;
4296 106522 : } else if (ANY_BLIND(ShadeFlag)) {
4297 8603 : if (state.dataSurface->SurfWinMovableSlats(SurfNum)) {
4298 3131 : int SurfWinSlatsAngIndex = state.dataSurface->SurfWinSlatsAngIndex(SurfNum);
4299 3131 : Real64 SurfWinSlatsAngInterpFac = state.dataSurface->SurfWinSlatsAngInterpFac(SurfNum);
4300 6262 : TransDiffWin = General::InterpGeneral(
4301 3131 : state.dataConstruction->Construct(ConstrNumSh).BlTransDiff(SurfWinSlatsAngIndex),
4302 6262 : state.dataConstruction->Construct(ConstrNumSh).BlTransDiff(std::min(MaxSlatAngs, SurfWinSlatsAngIndex + 1)),
4303 : SurfWinSlatsAngInterpFac);
4304 6262 : DiffAbsShade = General::InterpGeneral(
4305 3131 : state.dataConstruction->Construct(ConstrNumSh).AbsDiffBackBlind(SurfWinSlatsAngIndex),
4306 6262 : state.dataConstruction->Construct(ConstrNumSh).AbsDiffBackBlind(std::min(MaxSlatAngs, SurfWinSlatsAngIndex + 1)),
4307 : SurfWinSlatsAngInterpFac);
4308 : } else {
4309 5472 : TransDiffWin = state.dataConstruction->Construct(ConstrNumSh).BlTransDiff(1);
4310 5472 : DiffAbsShade = state.dataConstruction->Construct(ConstrNumSh).AbsDiffBackBlind(1);
4311 : }
4312 : }
4313 : }
4314 :
4315 : // Switchable glazing
4316 :
4317 379144 : if (ShadeFlag == WinShadingType::SwitchableGlazing)
4318 0 : TransDiffWin = General::InterpSw(SwitchFac, TransDiffWin, state.dataConstruction->Construct(ConstrNumSh).TransDiff);
4319 :
4320 379144 : SUM1 += thisSurf.Area * (TransDiffWin + AbsDiffTotWin + DiffAbsShade);
4321 :
4322 : // Window frame and divider effects (shade area is glazed area plus divider area)
4323 :
4324 379144 : if (state.dataSurface->SurfWinFrameArea(SurfNum) > 0.0)
4325 178918 : SUM1 += state.dataSurface->SurfWinFrameArea(SurfNum) * state.dataSurface->SurfWinFrameSolAbsorp(SurfNum) *
4326 89459 : (1.0 + 0.5 * state.dataSurface->SurfWinProjCorrFrIn(SurfNum));
4327 379144 : if (state.dataSurface->SurfWinDividerArea(SurfNum) > 0.0) {
4328 88270 : Real64 DividerAbs = state.dataSurface->SurfWinDividerSolAbsorp(SurfNum); // Window divider solar absorptance
4329 88270 : if (state.dataSurface->SurfWinDividerType(SurfNum) == DataSurfaces::FrameDividerType::Suspended) {
4330 : // Suspended (between-glass) divider: account for glass on inside of divider
4331 190 : Real64 MatNumGl = state.dataConstruction->Construct(ConstrNum).LayerPoint(
4332 190 : state.dataConstruction->Construct(ConstrNum).TotLayers); // Glass material number
4333 : Real64 TransGl =
4334 95 : state.dataMaterial->Material(MatNumGl).Trans; // Glass layer short-wave transmittance, reflectance, absorptance
4335 95 : Real64 ReflGl = state.dataMaterial->Material(MatNumGl).ReflectSolBeamBack;
4336 95 : Real64 AbsGl = 1.0 - TransGl - ReflGl;
4337 95 : Real64 DividerRefl = 1.0 - DividerAbs; // Window divider short-wave reflectance
4338 95 : DividerAbs = AbsGl + TransGl * (DividerAbs + DividerRefl * AbsGl) / (1.0 - DividerRefl * ReflGl);
4339 : }
4340 88270 : if (ANY_INTERIOR_SHADE_BLIND(ShadeFlag)) {
4341 14 : SUM1 += state.dataSurface->SurfWinDividerArea(SurfNum) * (DividerAbs + DiffAbsShade);
4342 : } else {
4343 88256 : SUM1 += state.dataSurface->SurfWinDividerArea(SurfNum) * (1.0 + state.dataSurface->SurfWinProjCorrDivIn(SurfNum)) *
4344 : DividerAbs;
4345 : }
4346 : }
4347 : } else { // equivalent layer window
4348 : // In equivalent layer window solid layers (Glazing and shades) are treated equally
4349 : // frames and dividers are not supported
4350 5994 : Real64 AbsDiffTotWin = 0.0;
4351 5994 : Real64 AbsDiffLayWin = 0.0;
4352 5994 : Real64 TransDiffWin = state.dataConstruction->Construct(ConstrNum).TransDiff;
4353 28000 : for (int Lay = 1; Lay <= state.dataWindowEquivLayer->CFS(state.dataConstruction->Construct(ConstrNum).EQLConsPtr).NL; ++Lay) {
4354 22006 : AbsDiffLayWin = state.dataConstruction->Construct(ConstrNum).AbsDiffBackEQL(Lay);
4355 22006 : AbsDiffTotWin += AbsDiffLayWin;
4356 : }
4357 5994 : SUM1 += thisSurf.Area * (TransDiffWin + AbsDiffTotWin);
4358 : }
4359 : } // End of check if opaque surface or window
4360 : } // End of loop over surfaces in zone
4361 :
4362 158556 : if (SUM1 > SmallestAreaAbsProductAllowed) { // Everything is okay, proceed with the regular calculation
4363 158551 : thisSolEnclosure.solVMULT = 1.0 / SUM1;
4364 :
4365 : } else { // the sum of area*solar absorptance for all surfaces in the zone is zero--either the user screwed up
4366 : // or they really want to disallow any solar from being absorbed on the inside surfaces. Fire off a
4367 : // nasty warning message and then assume that no solar is ever absorbed (basically everything goes
4368 : // back out whatever window is there. Note that this also assumes that the shade has no effect.
4369 : // That's probably not correct, but how correct is it to assume that no solar is absorbed anywhere
4370 : // in the zone?
4371 5 : if (thisSolEnclosure.solAbsFirstCalc) {
4372 3 : ShowWarningError(state,
4373 2 : "ComputeIntSWAbsorbFactors: Sum of area times inside solar absorption for all surfaces is zero in Zone: " +
4374 : thisSolEnclosure.Name);
4375 1 : thisSolEnclosure.solAbsFirstCalc = false;
4376 : }
4377 5 : thisSolEnclosure.solVMULT = 0.0;
4378 : }
4379 : } // End of enclosure loop
4380 2568509 : }
4381 :
4382 12147 : void ComputeDifSolExcZonesWIZWindows(EnergyPlusData &state, int const NumberOfEnclosures) // Number of solar enclosures
4383 : {
4384 :
4385 : // SUBROUTINE INFORMATION:
4386 : // AUTHOR Legacy Code
4387 : // DATE WRITTEN
4388 : // MODIFIED Jun 2007 - Lawrie - Speed enhancements.
4389 : // RE-ENGINEERED Winkelmann, Lawrie
4390 :
4391 : // PURPOSE OF THIS SUBROUTINE:
4392 : // This subroutine computes the diffuse solar exchange factors between zones with
4393 : // interzone windows.
4394 :
4395 12147 : auto &Surface(state.dataSurface->Surface);
4396 :
4397 12147 : if (!allocated(state.dataHeatBalSurf->ZoneFractDifShortZtoZ)) {
4398 6 : state.dataHeatBalSurf->ZoneFractDifShortZtoZ.allocate(NumberOfEnclosures, NumberOfEnclosures);
4399 6 : state.dataHeatBalSurf->EnclSolRecDifShortFromZ.allocate(NumberOfEnclosures);
4400 6 : state.dataHeatBalSurfMgr->DiffuseArray.allocate(NumberOfEnclosures, NumberOfEnclosures);
4401 : }
4402 :
4403 12147 : state.dataHeatBalSurf->EnclSolRecDifShortFromZ = false;
4404 12147 : state.dataHeatBalSurf->ZoneFractDifShortZtoZ.to_identity();
4405 12147 : state.dataHeatBalSurfMgr->DiffuseArray.to_identity();
4406 :
4407 : // IF (.not. ANY(Zone%HasInterZoneWindow)) RETURN ! this caused massive diffs
4408 12147 : if (state.dataGlobal->KickOffSimulation || state.dataGlobal->KickOffSizing) return;
4409 : // Compute fraction transmitted in one pass.
4410 :
4411 101664 : for (int const SurfNum : state.dataSurface->AllHTWindowSurfaceList) {
4412 89568 : if (Surface(SurfNum).ExtBoundCond <= 0) continue;
4413 27072 : if (Surface(SurfNum).ExtBoundCond == SurfNum) continue;
4414 27072 : if (state.dataConstruction->Construct(Surface(SurfNum).Construction).TransDiff <= 0.0) continue;
4415 :
4416 27072 : int surfEnclNum = Surface(SurfNum).SolarEnclIndex;
4417 27072 : if (!state.dataViewFactor->EnclSolInfo(surfEnclNum).HasInterZoneWindow) continue;
4418 27072 : int MZ = Surface(Surface(SurfNum).ExtBoundCond).SolarEnclIndex;
4419 81216 : state.dataHeatBalSurf->ZoneFractDifShortZtoZ(surfEnclNum, MZ) += state.dataConstruction->Construct(Surface(SurfNum).Construction).TransDiff *
4420 54144 : state.dataViewFactor->EnclSolInfo(surfEnclNum).solVMULT *
4421 27072 : Surface(SurfNum).Area;
4422 27072 : if (state.dataViewFactor->EnclSolInfo(surfEnclNum).solVMULT != 0.0) state.dataHeatBalSurf->EnclSolRecDifShortFromZ(surfEnclNum) = true;
4423 : }
4424 : // Compute fractions for multiple passes.
4425 :
4426 12096 : Array2D<Real64>::size_type l(0u), m(0u), d(0u);
4427 60480 : for (int NZ = 1; NZ <= NumberOfEnclosures; ++NZ, d += NumberOfEnclosures + 1) {
4428 48384 : m = NZ - 1;
4429 48384 : Real64 D_d(0.0); // Local accumulator
4430 241920 : for (int MZ = 1; MZ <= NumberOfEnclosures; ++MZ, ++l, m += NumberOfEnclosures) {
4431 193536 : if (MZ == NZ) continue;
4432 145152 : state.dataHeatBalSurfMgr->DiffuseArray[l] =
4433 290304 : state.dataHeatBalSurf->ZoneFractDifShortZtoZ[l] /
4434 290304 : (1.0 - state.dataHeatBalSurf->ZoneFractDifShortZtoZ[l] *
4435 145152 : state.dataHeatBalSurf->ZoneFractDifShortZtoZ[m]); // [ l ] == ( MZ, NZ ), [ m ] == ( NZ, MZ )
4436 145152 : D_d += state.dataHeatBalSurf->ZoneFractDifShortZtoZ[m] * state.dataHeatBalSurfMgr->DiffuseArray[l];
4437 : }
4438 48384 : state.dataHeatBalSurfMgr->DiffuseArray[d] += D_d; // [ d ] == ( NZ, NZ )
4439 : }
4440 :
4441 12096 : state.dataHeatBalSurf->ZoneFractDifShortZtoZ = state.dataHeatBalSurfMgr->DiffuseArray;
4442 : // added for CR 7999 & 7869
4443 12096 : assert(state.dataHeatBalSurf->ZoneFractDifShortZtoZ.isize1() == NumberOfEnclosures);
4444 12096 : assert(state.dataHeatBalSurf->ZoneFractDifShortZtoZ.isize2() == NumberOfEnclosures);
4445 12096 : l = 0u;
4446 60480 : for (int NZ = 1; NZ <= NumberOfEnclosures; ++NZ) {
4447 161280 : for (int MZ = 1; MZ <= NumberOfEnclosures; ++MZ, ++l) {
4448 141120 : if (MZ == NZ) continue;
4449 108864 : if (state.dataHeatBalSurf->ZoneFractDifShortZtoZ[l] > 0.0) { // [ l ] == ( MZ, NZ )
4450 28224 : state.dataHeatBalSurf->EnclSolRecDifShortFromZ(NZ) = true;
4451 28224 : break;
4452 : }
4453 : }
4454 : }
4455 :
4456 : // Compute fractions for multiple zones.
4457 :
4458 60480 : for (int IZ = 1; IZ <= NumberOfEnclosures; ++IZ) {
4459 48384 : if (!state.dataHeatBalSurf->EnclSolRecDifShortFromZ(IZ)) continue;
4460 :
4461 141120 : for (int JZ = 1; JZ <= NumberOfEnclosures; ++JZ) {
4462 112896 : if (!state.dataHeatBalSurf->EnclSolRecDifShortFromZ(JZ)) continue;
4463 72576 : if (IZ == JZ) continue;
4464 44352 : if (state.dataHeatBalSurfMgr->DiffuseArray(IZ, JZ) == 0.0) continue;
4465 :
4466 120960 : for (int KZ = 1; KZ <= NumberOfEnclosures; ++KZ) {
4467 96768 : if (!state.dataHeatBalSurf->EnclSolRecDifShortFromZ(KZ)) continue;
4468 56448 : if (IZ == KZ) continue;
4469 32256 : if (JZ == KZ) continue;
4470 8064 : if (state.dataHeatBalSurfMgr->DiffuseArray(JZ, KZ) == 0.0) continue;
4471 0 : state.dataHeatBalSurf->ZoneFractDifShortZtoZ(IZ, KZ) +=
4472 0 : state.dataHeatBalSurfMgr->DiffuseArray(JZ, KZ) * state.dataHeatBalSurfMgr->DiffuseArray(IZ, JZ);
4473 :
4474 0 : for (int LZ = 1; LZ <= NumberOfEnclosures; ++LZ) {
4475 0 : if (!state.dataHeatBalSurf->EnclSolRecDifShortFromZ(LZ)) continue;
4476 0 : if (IZ == LZ) continue;
4477 0 : if (JZ == LZ) continue;
4478 0 : if (KZ == LZ) continue;
4479 0 : if (state.dataHeatBalSurfMgr->DiffuseArray(KZ, LZ) == 0.0) continue;
4480 0 : state.dataHeatBalSurf->ZoneFractDifShortZtoZ(IZ, LZ) += state.dataHeatBalSurfMgr->DiffuseArray(KZ, LZ) *
4481 0 : state.dataHeatBalSurfMgr->DiffuseArray(JZ, KZ) *
4482 0 : state.dataHeatBalSurfMgr->DiffuseArray(IZ, JZ);
4483 :
4484 0 : for (int MZ = 1; MZ <= NumberOfEnclosures; ++MZ) {
4485 0 : if (!state.dataHeatBalSurf->EnclSolRecDifShortFromZ(MZ)) continue;
4486 0 : if (IZ == MZ) continue;
4487 0 : if (JZ == MZ) continue;
4488 0 : if (KZ == MZ) continue;
4489 0 : if (LZ == MZ) continue;
4490 0 : if (state.dataHeatBalSurfMgr->DiffuseArray(LZ, MZ) == 0.0) continue;
4491 0 : state.dataHeatBalSurf->ZoneFractDifShortZtoZ(IZ, MZ) +=
4492 0 : state.dataHeatBalSurfMgr->DiffuseArray(LZ, MZ) * state.dataHeatBalSurfMgr->DiffuseArray(KZ, LZ) *
4493 0 : state.dataHeatBalSurfMgr->DiffuseArray(JZ, KZ) * state.dataHeatBalSurfMgr->DiffuseArray(IZ, JZ);
4494 : } // MZ Loop
4495 :
4496 : } // LZ Loop
4497 :
4498 : } // KZ Loop
4499 :
4500 : } // JZ Loop
4501 :
4502 : } // IZ Loop
4503 : }
4504 :
4505 280891 : void InitEMSControlledSurfaceProperties(EnergyPlusData &state)
4506 : {
4507 :
4508 : // SUBROUTINE INFORMATION:
4509 : // AUTHOR B. Griffith
4510 : // DATE WRITTEN April 2011
4511 : // MODIFIED na
4512 : // RE-ENGINEERED na
4513 :
4514 : // PURPOSE OF THIS SUBROUTINE:
4515 : // initialize material and construction surface properties if being overriden by EMS
4516 :
4517 : // METHODOLOGY EMPLOYED:
4518 : // update solar, thermal and visible absorptance values when actuated by EMS
4519 :
4520 : // REFERENCES:
4521 : // na
4522 :
4523 : // USE STATEMENTS:
4524 : // na
4525 :
4526 : // Locals
4527 : // SUBROUTINE ARGUMENT DEFINITIONS:
4528 : // na
4529 :
4530 : // SUBROUTINE PARAMETER DEFINITIONS:
4531 : // na
4532 :
4533 : // INTERFACE BLOCK SPECIFICATIONS:
4534 : // na
4535 :
4536 : // DERIVED TYPE DEFINITIONS:
4537 : // na
4538 :
4539 : // SUBROUTINE LOCAL VARIABLE DECLARATIONS:
4540 : int MaterNum; // do loop counter over materials
4541 : int ConstrNum; // do loop counter over constructions
4542 : int TotLayers; // count of material layers in a construction
4543 : int InsideMaterNum; // integer pointer for inside face's material layer
4544 : int OutsideMaterNum; // integer pointer for outside face's material layer
4545 :
4546 280891 : state.dataGlobal->AnySurfPropOverridesInModel = false;
4547 : // first determine if anything needs to be done, once yes, then always init
4548 7490258 : for (auto const &mat : state.dataMaterial->Material) {
4549 7209367 : if ((mat.AbsorpSolarEMSOverrideOn) || (mat.AbsorpThermalEMSOverrideOn) || (mat.AbsorpVisibleEMSOverrideOn)) {
4550 0 : state.dataGlobal->AnySurfPropOverridesInModel = true;
4551 0 : break;
4552 : }
4553 : }
4554 :
4555 280891 : if (!state.dataGlobal->AnySurfPropOverridesInModel) return; // quick return if nothing has ever needed to be done
4556 :
4557 : // first, loop over materials
4558 0 : for (MaterNum = 1; MaterNum <= state.dataHeatBal->TotMaterials; ++MaterNum) {
4559 0 : if (state.dataMaterial->Material(MaterNum).AbsorpSolarEMSOverrideOn) {
4560 0 : state.dataMaterial->Material(MaterNum).AbsorpSolar =
4561 0 : max(min(state.dataMaterial->Material(MaterNum).AbsorpSolarEMSOverride, 0.9999), 0.0001);
4562 : } else {
4563 0 : state.dataMaterial->Material(MaterNum).AbsorpSolar = state.dataMaterial->Material(MaterNum).AbsorpSolarInput;
4564 : }
4565 0 : if (state.dataMaterial->Material(MaterNum).AbsorpThermalEMSOverrideOn) {
4566 0 : state.dataMaterial->Material(MaterNum).AbsorpThermal =
4567 0 : max(min(state.dataMaterial->Material(MaterNum).AbsorpThermalEMSOverride, 0.9999), 0.0001);
4568 : } else {
4569 0 : state.dataMaterial->Material(MaterNum).AbsorpThermal = state.dataMaterial->Material(MaterNum).AbsorpThermalInput;
4570 : }
4571 0 : if (state.dataMaterial->Material(MaterNum).AbsorpVisibleEMSOverrideOn) {
4572 0 : state.dataMaterial->Material(MaterNum).AbsorpVisible =
4573 0 : max(min(state.dataMaterial->Material(MaterNum).AbsorpVisibleEMSOverride, 0.9999), 0.0001);
4574 : } else {
4575 0 : state.dataMaterial->Material(MaterNum).AbsorpVisible = state.dataMaterial->Material(MaterNum).AbsorpVisibleInput;
4576 : }
4577 : } // loop over materials
4578 :
4579 : // second, loop over constructions
4580 0 : for (ConstrNum = 1; ConstrNum <= state.dataHeatBal->TotConstructs; ++ConstrNum) {
4581 0 : if (state.dataConstruction->Construct(ConstrNum).TypeIsWindow) continue; // only override opaque constructions
4582 0 : TotLayers = state.dataConstruction->Construct(ConstrNum).TotLayers;
4583 0 : if (TotLayers == 0) continue; // error condition
4584 0 : InsideMaterNum = state.dataConstruction->Construct(ConstrNum).LayerPoint(TotLayers);
4585 0 : if (InsideMaterNum != 0) {
4586 0 : state.dataConstruction->Construct(ConstrNum).InsideAbsorpVis = state.dataMaterial->Material(InsideMaterNum).AbsorpVisible;
4587 0 : state.dataConstruction->Construct(ConstrNum).InsideAbsorpSolar = state.dataMaterial->Material(InsideMaterNum).AbsorpSolar;
4588 0 : state.dataConstruction->Construct(ConstrNum).InsideAbsorpThermal = state.dataMaterial->Material(InsideMaterNum).AbsorpThermal;
4589 : }
4590 :
4591 0 : OutsideMaterNum = state.dataConstruction->Construct(ConstrNum).LayerPoint(1);
4592 0 : if (OutsideMaterNum != 0) {
4593 0 : state.dataConstruction->Construct(ConstrNum).OutsideAbsorpVis = state.dataMaterial->Material(OutsideMaterNum).AbsorpVisible;
4594 0 : state.dataConstruction->Construct(ConstrNum).OutsideAbsorpSolar = state.dataMaterial->Material(OutsideMaterNum).AbsorpSolar;
4595 0 : state.dataConstruction->Construct(ConstrNum).OutsideAbsorpThermal = state.dataMaterial->Material(OutsideMaterNum).AbsorpThermal;
4596 : }
4597 : }
4598 : }
4599 :
4600 280891 : void InitEMSControlledConstructions(EnergyPlusData &state)
4601 : {
4602 :
4603 : // SUBROUTINE INFORMATION:
4604 : // AUTHOR B. Griffith
4605 : // DATE WRITTEN Jan 2012
4606 : // MODIFIED na
4607 : // RE-ENGINEERED na
4608 :
4609 : // PURPOSE OF THIS SUBROUTINE:
4610 : // change construction on surface if overriden by EMS
4611 :
4612 280891 : auto &Surface(state.dataSurface->Surface);
4613 :
4614 280891 : state.dataGlobal->AnyConstrOverridesInModel = false;
4615 37904153 : for (int SurfNum = 1; SurfNum <= state.dataSurface->TotSurfaces; ++SurfNum) {
4616 37629321 : if (state.dataSurface->SurfEMSConstructionOverrideON(SurfNum)) {
4617 6059 : state.dataGlobal->AnyConstrOverridesInModel = true;
4618 6059 : break;
4619 : }
4620 : }
4621 280891 : if (!state.dataGlobal->AnyConstrOverridesInModel) return;
4622 :
4623 424130 : for (int SurfNum = 1; SurfNum <= state.dataSurface->TotSurfaces; ++SurfNum) {
4624 :
4625 418071 : if (state.dataSurface->SurfEMSConstructionOverrideON(SurfNum) && (state.dataSurface->SurfEMSConstructionOverrideValue(SurfNum) > 0)) {
4626 :
4627 12118 : if (state.dataConstruction->Construct(state.dataSurface->SurfEMSConstructionOverrideValue(SurfNum))
4628 6059 : .TypeIsWindow) { // okay, allways allow windows
4629 6059 : state.dataRuntimeLang->EMSConstructActuatorChecked(state.dataSurface->SurfEMSConstructionOverrideValue(SurfNum), SurfNum) = true;
4630 6059 : state.dataRuntimeLang->EMSConstructActuatorIsOkay(state.dataSurface->SurfEMSConstructionOverrideValue(SurfNum), SurfNum) = true;
4631 : }
4632 :
4633 12118 : if ((state.dataRuntimeLang->EMSConstructActuatorChecked(state.dataSurface->SurfEMSConstructionOverrideValue(SurfNum), SurfNum)) &&
4634 6059 : (state.dataRuntimeLang->EMSConstructActuatorIsOkay(state.dataSurface->SurfEMSConstructionOverrideValue(SurfNum), SurfNum))) {
4635 :
4636 6059 : Surface(SurfNum).Construction = state.dataSurface->SurfEMSConstructionOverrideValue(SurfNum);
4637 6059 : state.dataConstruction->Construct(Surface(SurfNum).Construction).IsUsed = true;
4638 6059 : state.dataSurface->SurfActiveConstruction(SurfNum) = state.dataSurface->SurfEMSConstructionOverrideValue(SurfNum);
4639 :
4640 : } else { // have not checked yet or is not okay, so see if we need to warn about incompatible
4641 0 : if (!state.dataRuntimeLang->EMSConstructActuatorChecked(state.dataSurface->SurfEMSConstructionOverrideValue(SurfNum), SurfNum)) {
4642 : // check if constructions appear compatible
4643 :
4644 0 : if (Surface(SurfNum).HeatTransferAlgorithm == DataSurfaces::HeatTransferModel::CTF ||
4645 0 : Surface(SurfNum).HeatTransferAlgorithm == DataSurfaces::HeatTransferModel::EMPD) {
4646 : // compare old construction to new construction and see if terms match
4647 : // set as okay and turn false if find a big problem
4648 0 : state.dataRuntimeLang->EMSConstructActuatorIsOkay(state.dataSurface->SurfEMSConstructionOverrideValue(SurfNum), SurfNum) =
4649 : true;
4650 0 : state.dataRuntimeLang->EMSConstructActuatorChecked(state.dataSurface->SurfEMSConstructionOverrideValue(SurfNum), SurfNum) =
4651 : true;
4652 0 : if (state.dataConstruction->Construct(Surface(SurfNum).Construction).NumHistories !=
4653 0 : state.dataConstruction->Construct(state.dataSurface->SurfEMSConstructionOverrideValue(SurfNum)).NumHistories) {
4654 : // thow warning, but allow
4655 0 : ShowWarningError(state,
4656 : "InitEMSControlledConstructions: EMS Construction State Actuator may be unrealistic, incompatible "
4657 : "CTF timescales are being used.");
4658 0 : ShowContinueError(state,
4659 0 : format("Construction named = {} has CTF timesteps = {}",
4660 0 : state.dataConstruction->Construct(Surface(SurfNum).Construction).Name,
4661 0 : state.dataConstruction->Construct(Surface(SurfNum).Construction).NumHistories));
4662 0 : ShowContinueError(
4663 : state,
4664 0 : format("While construction named = {} has CTF timesteps = {}",
4665 0 : state.dataConstruction->Construct(state.dataSurface->SurfEMSConstructionOverrideValue(SurfNum)).Name,
4666 0 : state.dataConstruction->Construct(state.dataSurface->SurfEMSConstructionOverrideValue(SurfNum)).NumHistories));
4667 0 : ShowContinueError(state,
4668 0 : "Transient heat transfer modeling may not be valid for surface name = " + Surface(SurfNum).Name +
4669 : ", and the simulation continues");
4670 : }
4671 0 : if (state.dataConstruction->Construct(Surface(SurfNum).Construction).NumCTFTerms !=
4672 0 : state.dataConstruction->Construct(state.dataSurface->SurfEMSConstructionOverrideValue(SurfNum)).NumCTFTerms) {
4673 : // throw warning, but allow
4674 0 : ShowWarningError(state,
4675 : "InitEMSControlledConstructions: EMS Construction State Actuator may be unrealistic, incompatible "
4676 : "CTF terms are being used.");
4677 0 : ShowContinueError(state,
4678 0 : format("Construction named = {} has number of CTF terms = {}",
4679 0 : state.dataConstruction->Construct(Surface(SurfNum).Construction).Name,
4680 0 : state.dataConstruction->Construct(Surface(SurfNum).Construction).NumCTFTerms));
4681 0 : ShowContinueError(
4682 : state,
4683 0 : format("While construction named = {} has number of CTF terms = {}",
4684 0 : state.dataConstruction->Construct(state.dataSurface->SurfEMSConstructionOverrideValue(SurfNum)).Name,
4685 0 : state.dataConstruction->Construct(state.dataSurface->SurfEMSConstructionOverrideValue(SurfNum)).NumCTFTerms));
4686 0 : ShowContinueError(
4687 : state,
4688 0 : "The actuator is allowed but the transient heat transfer modeling may not be valid for surface name = " +
4689 0 : Surface(SurfNum).Name + ", and the simulation continues");
4690 : }
4691 :
4692 0 : if (state.dataConstruction->Construct(Surface(SurfNum).Construction).SourceSinkPresent) {
4693 0 : if (!state.dataConstruction->Construct(state.dataSurface->SurfEMSConstructionOverrideValue(SurfNum)).SourceSinkPresent) {
4694 : // thow warning, and do not allow
4695 0 : ShowSevereError(state, "InitEMSControlledConstructions: EMS Construction State Actuator not valid.");
4696 0 : ShowContinueError(state,
4697 0 : "Construction named = " + state.dataConstruction->Construct(Surface(SurfNum).Construction).Name +
4698 : " has internal source/sink");
4699 0 : ShowContinueError(
4700 : state,
4701 0 : "While construction named = " +
4702 0 : state.dataConstruction->Construct(state.dataSurface->SurfEMSConstructionOverrideValue(SurfNum)).Name +
4703 : " is not an internal source/sink construction");
4704 0 : ShowContinueError(state,
4705 0 : "This actuator is not allowed for surface name = " + Surface(SurfNum).Name +
4706 : ", and the simulation continues without the override");
4707 :
4708 0 : state.dataRuntimeLang->EMSConstructActuatorIsOkay(state.dataSurface->SurfEMSConstructionOverrideValue(SurfNum),
4709 0 : SurfNum) = false;
4710 : }
4711 : }
4712 :
4713 0 : if (state.dataRuntimeLang->EMSConstructActuatorIsOkay(state.dataSurface->SurfEMSConstructionOverrideValue(SurfNum),
4714 0 : SurfNum)) {
4715 0 : Surface(SurfNum).Construction = state.dataSurface->SurfEMSConstructionOverrideValue(SurfNum);
4716 : }
4717 :
4718 0 : } else if (Surface(SurfNum).HeatTransferAlgorithm == DataSurfaces::HeatTransferModel::CondFD) {
4719 0 : state.dataRuntimeLang->EMSConstructActuatorIsOkay(state.dataSurface->SurfEMSConstructionOverrideValue(SurfNum), SurfNum) =
4720 : true;
4721 0 : state.dataRuntimeLang->EMSConstructActuatorChecked(state.dataSurface->SurfEMSConstructionOverrideValue(SurfNum), SurfNum) =
4722 : true;
4723 0 : if (state.dataHeatBalFiniteDiffMgr->ConstructFD(Surface(SurfNum).Construction).TotNodes !=
4724 0 : state.dataHeatBalFiniteDiffMgr->ConstructFD(state.dataSurface->SurfEMSConstructionOverrideValue(SurfNum)).TotNodes) {
4725 : // thow warning, and do not allow
4726 0 : ShowSevereError(state, "InitEMSControlledConstructions: EMS Construction State Actuator not valid.");
4727 0 : ShowContinueError(state,
4728 0 : format("Construction named = {} has number of finite difference nodes ={}",
4729 0 : state.dataConstruction->Construct(Surface(SurfNum).Construction).Name,
4730 0 : state.dataHeatBalFiniteDiffMgr->ConstructFD(Surface(SurfNum).Construction).TotNodes));
4731 0 : ShowContinueError(
4732 : state,
4733 0 : format("While construction named = {}has number of finite difference nodes ={}",
4734 0 : state.dataConstruction->Construct(state.dataSurface->SurfEMSConstructionOverrideValue(SurfNum)).Name,
4735 0 : state.dataHeatBalFiniteDiffMgr->ConstructFD(state.dataSurface->SurfEMSConstructionOverrideValue(SurfNum))
4736 0 : .TotNodes));
4737 0 : ShowContinueError(state,
4738 0 : "This actuator is not allowed for surface name = " + Surface(SurfNum).Name +
4739 : ", and the simulation continues without the override");
4740 :
4741 0 : state.dataRuntimeLang->EMSConstructActuatorIsOkay(state.dataSurface->SurfEMSConstructionOverrideValue(SurfNum), SurfNum) =
4742 : false;
4743 : }
4744 :
4745 0 : if (state.dataConstruction->Construct(Surface(SurfNum).Construction).SourceSinkPresent) {
4746 0 : if (!state.dataConstruction->Construct(state.dataSurface->SurfEMSConstructionOverrideValue(SurfNum)).SourceSinkPresent) {
4747 : // thow warning, and do not allow
4748 0 : ShowSevereError(state, "InitEMSControlledConstructions: EMS Construction State Actuator not valid.");
4749 0 : ShowContinueError(state,
4750 0 : "Construction named = " + state.dataConstruction->Construct(Surface(SurfNum).Construction).Name +
4751 : " has internal source/sink");
4752 0 : ShowContinueError(
4753 : state,
4754 0 : "While construction named = " +
4755 0 : state.dataConstruction->Construct(state.dataSurface->SurfEMSConstructionOverrideValue(SurfNum)).Name +
4756 : " is not an internal source/sink construction");
4757 0 : ShowContinueError(state,
4758 0 : "This actuator is not allowed for surface name = " + Surface(SurfNum).Name +
4759 : ", and the simulation continues without the override");
4760 :
4761 0 : state.dataRuntimeLang->EMSConstructActuatorIsOkay(state.dataSurface->SurfEMSConstructionOverrideValue(SurfNum),
4762 0 : SurfNum) = false;
4763 : }
4764 : }
4765 :
4766 0 : if (state.dataRuntimeLang->EMSConstructActuatorIsOkay(state.dataSurface->SurfEMSConstructionOverrideValue(SurfNum),
4767 0 : SurfNum)) {
4768 0 : Surface(SurfNum).Construction = state.dataSurface->SurfEMSConstructionOverrideValue(SurfNum);
4769 : }
4770 :
4771 0 : } else if (Surface(SurfNum).HeatTransferAlgorithm == DataSurfaces::HeatTransferModel::HAMT) { // don't allow
4772 0 : ShowSevereError(state,
4773 : "InitEMSControlledConstructions: EMS Construction State Actuator not available with Heat transfer "
4774 : "algorithm CombinedHeatAndMoistureFiniteElement.");
4775 0 : ShowContinueError(state,
4776 0 : "This actuator is not allowed for surface name = " + Surface(SurfNum).Name +
4777 : ", and the simulation continues without the override");
4778 0 : state.dataRuntimeLang->EMSConstructActuatorChecked(state.dataSurface->SurfEMSConstructionOverrideValue(SurfNum), SurfNum) =
4779 : true;
4780 0 : state.dataRuntimeLang->EMSConstructActuatorIsOkay(state.dataSurface->SurfEMSConstructionOverrideValue(SurfNum), SurfNum) =
4781 : false;
4782 :
4783 0 : } else if (Surface(SurfNum).HeatTransferAlgorithm == DataSurfaces::HeatTransferModel::Kiva) { // don't allow
4784 0 : ShowSevereError(state,
4785 : "InitEMSControlledConstructions: EMS Construction State Actuator not available for Surfaces with "
4786 : "Foundation Outside Boundary Condition.");
4787 0 : ShowContinueError(state,
4788 0 : "This actuator is not allowed for surface name = " + Surface(SurfNum).Name +
4789 : ", and the simulation continues without the override");
4790 0 : state.dataRuntimeLang->EMSConstructActuatorChecked(state.dataSurface->SurfEMSConstructionOverrideValue(SurfNum), SurfNum) =
4791 : true;
4792 0 : state.dataRuntimeLang->EMSConstructActuatorIsOkay(state.dataSurface->SurfEMSConstructionOverrideValue(SurfNum), SurfNum) =
4793 : false;
4794 : }
4795 :
4796 : } else {
4797 : // do nothing, has been checked and is not okay with single warning already issued.
4798 : }
4799 : }
4800 : } else {
4801 412012 : Surface(SurfNum).Construction = Surface(SurfNum).ConstructionStoredInputValue;
4802 412012 : state.dataSurface->SurfActiveConstruction(SurfNum) = Surface(SurfNum).ConstructionStoredInputValue;
4803 : }
4804 : }
4805 : }
4806 :
4807 : // End Initialization Section of the Module
4808 : //******************************************************************************
4809 :
4810 : // Begin Algorithm Section of the Module
4811 : //******************************************************************************
4812 :
4813 : // Beginning of Record Keeping subroutines for the HB Module
4814 : // *****************************************************************************
4815 :
4816 3487776 : void UpdateIntermediateSurfaceHeatBalanceResults(EnergyPlusData &state, Optional_int_const ZoneToResimulate)
4817 : {
4818 3487776 : int firstZone = 1;
4819 3487776 : int lastZone = state.dataGlobal->NumOfZones;
4820 :
4821 3487776 : if (present(ZoneToResimulate)) {
4822 808964 : firstZone = ZoneToResimulate;
4823 808964 : lastZone = ZoneToResimulate;
4824 : }
4825 :
4826 23190886 : for (int zoneNum = firstZone; zoneNum <= lastZone; ++zoneNum) {
4827 39422396 : for (int spaceNum : state.dataHeatBal->Zone(zoneNum).spaceIndexes) {
4828 19719286 : auto &thisSpace = state.dataHeatBal->space(spaceNum);
4829 19719286 : int const firstSurf = thisSpace.WindowSurfaceFirst;
4830 19719286 : int const lastSurf = thisSpace.WindowSurfaceLast;
4831 42562048 : for (int surfNum = firstSurf; surfNum <= lastSurf; ++surfNum) {
4832 22842762 : if (state.dataSurface->Surface(surfNum).ExtSolar) { // WindowManager's definition of ZoneWinHeatGain/Loss
4833 22811520 : state.dataHeatBal->ZoneWinHeatGain(zoneNum) += state.dataSurface->SurfWinHeatGain(surfNum);
4834 : }
4835 : }
4836 : // Update zone window heat gain reports (these intermediate values are also used for Sensible Heat Gain Summary in GatherHeatGainReport)
4837 19719286 : if (state.dataHeatBal->ZoneWinHeatGain(zoneNum) >= 0.0) {
4838 11703638 : state.dataHeatBal->ZoneWinHeatGainRep(zoneNum) = state.dataHeatBal->ZoneWinHeatGain(zoneNum);
4839 11703638 : state.dataHeatBal->ZoneWinHeatGainRepEnergy(zoneNum) =
4840 11703638 : state.dataHeatBal->ZoneWinHeatGainRep(zoneNum) * state.dataGlobal->TimeStepZoneSec;
4841 : } else {
4842 8015648 : state.dataHeatBal->ZoneWinHeatLossRep(zoneNum) = -state.dataHeatBal->ZoneWinHeatGain(zoneNum);
4843 8015648 : state.dataHeatBal->ZoneWinHeatLossRepEnergy(zoneNum) =
4844 8015648 : state.dataHeatBal->ZoneWinHeatLossRep(zoneNum) * state.dataGlobal->TimeStepZoneSec;
4845 : }
4846 : }
4847 : }
4848 :
4849 3487776 : if (state.dataSurface->UseRepresentativeSurfaceCalculations) {
4850 687 : UpdateNonRepresentativeSurfaceResults(state, ZoneToResimulate);
4851 : }
4852 :
4853 : // Set normalized properties used for reporting
4854 :
4855 : // Opaque or window surfaces (Skip TDD:DOME objects. Inside temp is handled by TDD:DIFFUSER.)
4856 23190886 : for (int zoneNum = firstZone; zoneNum <= lastZone; ++zoneNum) {
4857 39422396 : for (int spaceNum : state.dataHeatBal->Zone(zoneNum).spaceIndexes) {
4858 19719286 : auto &thisSpace = state.dataHeatBal->space(spaceNum);
4859 19719286 : int const firstSurf = thisSpace.OpaqOrWinSurfaceFirst;
4860 19719286 : int const lastSurf = thisSpace.OpaqOrWinSurfaceLast;
4861 188707914 : for (int surfNum = firstSurf; surfNum <= lastSurf; ++surfNum) {
4862 168988628 : state.dataHeatBalSurf->SurfQdotConvInPerArea(surfNum) =
4863 337977256 : -state.dataHeatBalSurf->SurfHConvInt(surfNum) *
4864 168988628 : (state.dataHeatBalSurf->SurfTempIn(surfNum) - state.dataHeatBalSurfMgr->RefAirTemp(surfNum));
4865 : }
4866 : }
4867 : }
4868 : // Opaque surfaces
4869 23190886 : for (int zoneNum = firstZone; zoneNum <= lastZone; ++zoneNum) {
4870 39422396 : for (int spaceNum : state.dataHeatBal->Zone(zoneNum).spaceIndexes) {
4871 19719286 : auto &thisSpace = state.dataHeatBal->space(spaceNum);
4872 19719286 : int const firstSurf = thisSpace.OpaqOrIntMassSurfaceFirst;
4873 19719286 : int const lastSurf = thisSpace.OpaqOrIntMassSurfaceLast;
4874 165865152 : for (int surfNum = firstSurf; surfNum <= lastSurf; ++surfNum) {
4875 146145866 : state.dataHeatBalSurf->SurfQdotRadSolarInRepPerArea(surfNum) =
4876 146145866 : state.dataHeatBalSurf->SurfOpaqQRadSWInAbs(surfNum) - state.dataHeatBalSurf->SurfQdotRadLightsInPerArea(surfNum);
4877 : }
4878 : }
4879 : }
4880 : // Inside face conduction calculation for Kiva surfaces
4881 3588354 : for (auto surfNum : state.dataSurface->AllHTKivaSurfaceList) {
4882 100578 : state.dataHeatBalSurf->SurfOpaqInsFaceCondFlux(surfNum) =
4883 301734 : -(state.dataHeatBalSurf->SurfQdotConvInPerArea(surfNum) + state.dataHeatBalSurf->SurfQdotRadNetLWInPerArea(surfNum) +
4884 301734 : state.dataHeatBalSurf->SurfQdotRadHVACInPerArea(surfNum) + state.dataHeatBal->SurfQdotRadIntGainsInPerArea(surfNum) +
4885 100578 : state.dataHeatBalSurf->SurfOpaqQRadSWInAbs(surfNum));
4886 : }
4887 3487776 : }
4888 :
4889 687 : void UpdateNonRepresentativeSurfaceResults(EnergyPlusData &state, Optional_int_const ZoneToResimulate)
4890 : {
4891 687 : int firstZone = 1;
4892 687 : int lastZone = state.dataGlobal->NumOfZones;
4893 :
4894 687 : if (present(ZoneToResimulate)) {
4895 0 : firstZone = ZoneToResimulate;
4896 0 : lastZone = ZoneToResimulate;
4897 : }
4898 :
4899 32289 : for (int zoneNum = firstZone; zoneNum <= lastZone; ++zoneNum) {
4900 63204 : for (int spaceNum : state.dataHeatBal->Zone(zoneNum).spaceIndexes) {
4901 31602 : auto &thisSpace = state.dataHeatBal->space(spaceNum);
4902 : // Heat transfer surfaces
4903 31602 : int firstSurf = thisSpace.HTSurfaceFirst;
4904 31602 : int lastSurf = thisSpace.HTSurfaceLast;
4905 429375 : for (int surfNum = firstSurf; surfNum <= lastSurf; ++surfNum) {
4906 397773 : auto &surface(state.dataSurface->Surface(surfNum));
4907 397773 : int repSurfNum = surface.RepresentativeCalcSurfNum;
4908 :
4909 397773 : if (surfNum != repSurfNum) {
4910 : #if 0
4911 : // Check for divergence
4912 : Real64 surfConv = -state.dataHeatBalSurf->SurfHConvInt(surfNum) *
4913 : (state.dataHeatBalSurf->SurfTempIn(surfNum) - state.dataHeatBalSurfMgr->RefAirTemp(surfNum));
4914 : Real64 repSurfConv = -state.dataHeatBalSurf->SurfHConvInt(repSurfNum) *
4915 : (state.dataHeatBalSurf->SurfTempIn(repSurfNum) - state.dataHeatBalSurfMgr->RefAirTemp(repSurfNum));
4916 : Real64 diff = surfConv - repSurfConv;
4917 : if (std::abs(diff) > 3.0 && state.dataSurface->Surface(repSurfNum).ConstituentSurfaceNums.size() == 2) {
4918 : ShowWarningError(state, format("Difference in representative surface convection {:.3R} W/m2", diff));
4919 : ShowContinueErrorTimeStamp(state, "");
4920 : ShowContinueError(state, format(" Original Surface: {}", surface.Name));
4921 : ShowContinueError(state, format(" Inside surface temperature: {:.3R} C", state.dataHeatBalSurf->SurfTempIn(surfNum)));
4922 : ShowContinueError(state,
4923 : format(" Inside convection coefficient: {:.3R} W/m2-K", state.dataHeatBalSurf->SurfHConvInt(surfNum)));
4924 : ShowContinueError(state,
4925 : format(" Sunlit fraction: {:.3R}",
4926 : state.dataHeatBal->SurfSunlitFrac(state.dataGlobal->HourOfDay, state.dataGlobal->TimeStep, surfNum)));
4927 : ShowContinueError(state, format(" Outside absorbed solar: {:.3R} W/m2", state.dataHeatBalSurf->SurfOpaqQRadSWOutAbs(surfNum)));
4928 : ShowContinueError(state,
4929 : format(" Outside long wave radiation: {:.3R} W/m2", state.dataHeatBalSurf->QdotRadOutRepPerArea(surfNum)));
4930 : ShowContinueError(state, format(" Representative Surface: {}", state.dataSurface->Surface(repSurfNum).Name));
4931 : ShowContinueError(state, format(" Inside surface temperature: {:.3R} C", state.dataHeatBalSurf->SurfTempIn(repSurfNum)));
4932 : ShowContinueError(state,
4933 : format(" Inside convection coefficient: {:.3R} W/m2-K", state.dataHeatBalSurf->SurfHConvInt(repSurfNum)));
4934 : ShowContinueError(state,
4935 : format(" Sunlit fraction: {:.3R}",
4936 : state.dataHeatBal->SurfSunlitFrac(state.dataGlobal->HourOfDay, state.dataGlobal->TimeStep, repSurfNum)));
4937 : ShowContinueError(state,
4938 : format(" Outside absorbed solar: {:.3R} W/m2", state.dataHeatBalSurf->SurfOpaqQRadSWOutAbs(repSurfNum)));
4939 : ShowContinueError(
4940 : state, format(" Outside long wave radiation: {:.3R} W/m2", state.dataHeatBalSurf->QdotRadOutRepPerArea(repSurfNum)));
4941 : }
4942 : #endif
4943 :
4944 : // Surface Heat Balance Arrays
4945 89997 : state.dataHeatBalSurf->SurfTempIn(surfNum) = state.dataHeatBalSurf->SurfTempIn(repSurfNum);
4946 89997 : state.dataHeatBalSurf->SurfTempOut(surfNum) = state.dataHeatBalSurf->SurfTempOut(repSurfNum);
4947 89997 : state.dataHeatBal->SurfTempEffBulkAir(surfNum) = state.dataHeatBal->SurfTempEffBulkAir(repSurfNum);
4948 89997 : state.dataHeatBalSurf->SurfHConvInt(surfNum) = state.dataHeatBalSurf->SurfHConvInt(repSurfNum);
4949 89997 : state.dataHeatBalSurf->SurfQdotRadNetLWInPerArea(surfNum) = state.dataHeatBalSurf->SurfQdotRadNetLWInPerArea(repSurfNum);
4950 89997 : state.dataHeatBal->SurfQdotRadIntGainsInPerArea(surfNum) = state.dataHeatBal->SurfQdotRadIntGainsInPerArea(repSurfNum);
4951 89997 : state.dataHeatBalSurf->SurfQdotRadHVACInPerArea(surfNum) = state.dataHeatBalSurf->SurfQdotRadHVACInPerArea(repSurfNum);
4952 :
4953 89997 : state.dataHeatBalSurf->SurfQdotConvOutPerArea(surfNum) = state.dataHeatBalSurf->SurfQdotConvOutPerArea(repSurfNum);
4954 89997 : state.dataHeatBalSurf->SurfHcExt(surfNum) = state.dataHeatBalSurf->SurfHcExt(repSurfNum);
4955 89997 : state.dataHeatBalSurf->SurfQdotRadOutRepPerArea(surfNum) = state.dataHeatBalSurf->SurfQdotRadOutRepPerArea(repSurfNum);
4956 89997 : state.dataHeatBalSurf->SurfHAirExt(surfNum) = state.dataHeatBalSurf->SurfHAirExt(repSurfNum);
4957 89997 : state.dataHeatBalSurf->SurfHSkyExt(surfNum) = state.dataHeatBalSurf->SurfHSkyExt(repSurfNum);
4958 89997 : state.dataHeatBalSurf->SurfHGrdExt(surfNum) = state.dataHeatBalSurf->SurfHGrdExt(repSurfNum);
4959 :
4960 89997 : state.dataSurface->SurfTAirRef(surfNum) = state.dataSurface->SurfTAirRef(repSurfNum);
4961 89997 : if (state.dataSurface->SurfTAirRef(surfNum) != DataSurfaces::RefAirTemp::Invalid) {
4962 0 : state.dataSurface->SurfTAirRefRpt(surfNum) = DataSurfaces::SurfTAirRefReportVals[state.dataSurface->SurfTAirRef(surfNum)];
4963 : }
4964 :
4965 89997 : state.dataSurface->SurfOutConvHfModelEq(surfNum) = state.dataSurface->SurfOutConvHfModelEq(repSurfNum);
4966 89997 : state.dataSurface->SurfOutConvHnModelEq(surfNum) = state.dataSurface->SurfOutConvHnModelEq(repSurfNum);
4967 :
4968 89997 : state.dataHeatBalSurf->SurfQAdditionalHeatSourceInside(surfNum) =
4969 89997 : state.dataHeatBalSurf->SurfQAdditionalHeatSourceInside(repSurfNum);
4970 89997 : state.dataHeatBalSurf->SurfQAdditionalHeatSourceOutside(surfNum) =
4971 89997 : state.dataHeatBalSurf->SurfQAdditionalHeatSourceOutside(repSurfNum);
4972 :
4973 : // Internal (non reporting variables)
4974 89997 : state.dataHeatBalSurf->SurfTempInTmp(surfNum) = state.dataHeatBalSurf->SurfTempInTmp(repSurfNum);
4975 89997 : state.dataHeatBalSurfMgr->RefAirTemp(surfNum) = state.dataHeatBalSurfMgr->RefAirTemp(repSurfNum);
4976 : }
4977 : }
4978 :
4979 : // Opaque surfaces
4980 31602 : firstSurf = thisSpace.OpaqOrIntMassSurfaceFirst;
4981 31602 : lastSurf = thisSpace.OpaqOrIntMassSurfaceLast;
4982 307089 : for (int surfNum = firstSurf; surfNum <= lastSurf; ++surfNum) {
4983 275487 : auto &surface(state.dataSurface->Surface(surfNum));
4984 275487 : int repSurfNum = surface.RepresentativeCalcSurfNum;
4985 :
4986 275487 : if (surfNum != repSurfNum) {
4987 : // Surface Heat Balance Arrays
4988 11679 : state.dataHeatBalSurf->SurfQdotRadLightsInPerArea(surfNum) = state.dataHeatBalSurf->SurfQdotRadLightsInPerArea(repSurfNum);
4989 11679 : state.dataHeatBalSurf->SurfOpaqQRadSWOutAbs(surfNum) = state.dataHeatBalSurf->SurfOpaqQRadSWOutAbs(repSurfNum);
4990 11679 : state.dataHeatBalSurf->SurfOpaqQRadSWInAbs(surfNum) = state.dataHeatBalSurf->SurfOpaqQRadSWInAbs(repSurfNum);
4991 : }
4992 : }
4993 :
4994 : // Window surfaces
4995 31602 : firstSurf = thisSpace.WindowSurfaceFirst;
4996 31602 : lastSurf = thisSpace.WindowSurfaceLast;
4997 153888 : for (int surfNum = firstSurf; surfNum <= lastSurf; ++surfNum) {
4998 122286 : auto &surface(state.dataSurface->Surface(surfNum));
4999 122286 : int repSurfNum = surface.RepresentativeCalcSurfNum;
5000 :
5001 122286 : if (surfNum != repSurfNum) {
5002 78318 : auto areaRatio = surface.Area / state.dataSurface->Surface(surfNum).Area;
5003 :
5004 : // Glazing
5005 78318 : state.dataSurface->SurfWinGainConvGlazToZoneRep(surfNum) =
5006 78318 : state.dataSurface->SurfWinGainConvGlazToZoneRep(repSurfNum) * areaRatio;
5007 78318 : state.dataSurface->SurfWinGainIRGlazToZoneRep(surfNum) = state.dataSurface->SurfWinGainIRGlazToZoneRep(repSurfNum) * areaRatio;
5008 :
5009 : // Frame
5010 78318 : Real64 frameHeatGain = 0.0;
5011 78318 : if (state.dataSurface->SurfWinFrameArea(surfNum) > 0.0) {
5012 0 : auto frameAreaRatio = state.dataSurface->SurfWinFrameArea(surfNum) / state.dataSurface->SurfWinFrameArea(repSurfNum);
5013 0 : state.dataSurface->SurfWinFrameHeatGain(surfNum) = state.dataSurface->SurfWinFrameHeatGain(repSurfNum) * frameAreaRatio;
5014 0 : state.dataSurface->SurfWinFrameHeatLoss(surfNum) = state.dataSurface->SurfWinFrameHeatLoss(repSurfNum) * frameAreaRatio;
5015 0 : state.dataSurface->SurfWinFrameTempIn(surfNum) = state.dataSurface->SurfWinFrameTempIn(repSurfNum);
5016 0 : state.dataSurface->SurfWinFrameTempSurfOut(surfNum) = state.dataSurface->SurfWinFrameTempSurfOut(repSurfNum);
5017 0 : frameHeatGain = state.dataSurface->SurfWinFrameHeatGain(surfNum) - state.dataSurface->SurfWinFrameHeatLoss(surfNum);
5018 : }
5019 :
5020 : // Divider
5021 78318 : Real64 dividerHeatGain = 0.0;
5022 78318 : if (state.dataSurface->SurfWinDividerArea(surfNum) > 0.0) {
5023 0 : auto dividerAreaRatio = state.dataSurface->SurfWinDividerArea(surfNum) / state.dataSurface->SurfWinDividerArea(repSurfNum);
5024 0 : state.dataSurface->SurfWinDividerHeatGain(surfNum) = state.dataSurface->SurfWinDividerHeatGain(repSurfNum) * dividerAreaRatio;
5025 0 : state.dataSurface->SurfWinDividerHeatLoss(surfNum) = state.dataSurface->SurfWinDividerHeatLoss(repSurfNum) * dividerAreaRatio;
5026 0 : state.dataSurface->SurfWinDividerTempIn(surfNum) = state.dataSurface->SurfWinDividerTempIn(repSurfNum);
5027 0 : state.dataSurface->SurfWinDividerTempSurfOut(surfNum) = state.dataSurface->SurfWinDividerTempSurfOut(repSurfNum);
5028 0 : dividerHeatGain = state.dataSurface->SurfWinDividerHeatGain(surfNum) - state.dataSurface->SurfWinDividerHeatLoss(surfNum);
5029 : }
5030 :
5031 78318 : state.dataSurface->SurfWinGainFrameDividerToZoneRep(surfNum) = frameHeatGain + dividerHeatGain;
5032 :
5033 : // Whole window
5034 234954 : state.dataSurface->SurfWinHeatGain(surfNum) = (state.dataSurface->SurfWinHeatGain(repSurfNum) -
5035 156636 : state.dataSurface->SurfWinGainFrameDividerToZoneRep(repSurfNum) * areaRatio) +
5036 78318 : state.dataSurface->SurfWinGainFrameDividerToZoneRep(surfNum);
5037 : }
5038 : }
5039 : }
5040 : }
5041 687 : }
5042 :
5043 2568313 : void UpdateFinalSurfaceHeatBalance(EnergyPlusData &state)
5044 : {
5045 :
5046 : // SUBROUTINE INFORMATION:
5047 : // AUTHOR Rick Strand
5048 : // DATE WRITTEN December 2000
5049 : // MODIFIED na
5050 : // RE-ENGINEERED na
5051 :
5052 : // PURPOSE OF THIS SUBROUTINE:
5053 : // If a radiant system is present and was on for part of the time step,
5054 : // then we probably need to make yet another pass through the heat balance.
5055 : // This is necessary because the heat source/sink to the surface that is
5056 : // the radiant system may have varied during the system time steps.
5057 :
5058 : // METHODOLOGY EMPLOYED:
5059 : // First, determine whether or not the radiant system was running. If
5060 : // any of the Qsource terms are non-zero, then it was running. Then,
5061 : // update the current source terms with the "average" value calculated
5062 : // by the radiant system algorithm. This requires the "USE" of the
5063 : // radiant algorithm module. Finally, using this source value, redo
5064 : // the inside and outside heat balances.
5065 :
5066 : using CoolingPanelSimple::UpdateCoolingPanelSourceValAvg;
5067 : using ElectricBaseboardRadiator::UpdateBBElecRadSourceValAvg;
5068 : using HighTempRadiantSystem::UpdateHTRadSourceValAvg;
5069 : using HWBaseboardRadiator::UpdateBBRadSourceValAvg;
5070 : using LowTempRadiantSystem::UpdateRadSysSourceValAvg;
5071 : using SteamBaseboardRadiator::UpdateBBSteamRadSourceValAvg;
5072 : using SwimmingPool::UpdatePoolSourceValAvg;
5073 :
5074 : bool LowTempRadSysOn; // .TRUE. if a low temperature radiant system is running
5075 : bool HighTempRadSysOn; // .TRUE. if a high temperature radiant system is running
5076 : bool HWBaseboardSysOn; // .TRUE. if a water baseboard heater is running
5077 : bool SteamBaseboardSysOn; // .TRUE. if a steam baseboard heater is running
5078 : bool ElecBaseboardSysOn; // .TRUE. if a steam baseboard heater is running
5079 : bool CoolingPanelSysOn; // true if a simple cooling panel is running
5080 : bool SwimmingPoolOn; // true if a pool is present (running)
5081 :
5082 2568313 : UpdateRadSysSourceValAvg(state, LowTempRadSysOn);
5083 2568313 : UpdateHTRadSourceValAvg(state, HighTempRadSysOn);
5084 2568313 : UpdateBBRadSourceValAvg(state, HWBaseboardSysOn);
5085 2568313 : UpdateBBSteamRadSourceValAvg(state, SteamBaseboardSysOn);
5086 2568313 : UpdateBBElecRadSourceValAvg(state, ElecBaseboardSysOn);
5087 2568313 : UpdateCoolingPanelSourceValAvg(state, CoolingPanelSysOn);
5088 2568313 : UpdatePoolSourceValAvg(state, SwimmingPoolOn);
5089 :
5090 2568313 : if (LowTempRadSysOn || HighTempRadSysOn || HWBaseboardSysOn || SteamBaseboardSysOn || ElecBaseboardSysOn || CoolingPanelSysOn || SwimmingPoolOn) {
5091 : // Solve the zone heat balance 'Detailed' solution
5092 : // Call the outside and inside surface heat balances
5093 82934 : CalcHeatBalanceOutsideSurf(state);
5094 82934 : CalcHeatBalanceInsideSurf(state);
5095 : }
5096 2568313 : }
5097 :
5098 2417443 : void UpdateThermalHistories(EnergyPlusData &state)
5099 : {
5100 :
5101 : // SUBROUTINE INFORMATION:
5102 : // AUTHOR Russ Taylor
5103 : // DATE WRITTEN June 1990
5104 : // MODIFIED na
5105 : // RE-ENGINEERED Mar98 (RKS)
5106 :
5107 : // PURPOSE OF THIS SUBROUTINE:
5108 : // This subroutine updates and shifts the thermal and flux histories.
5109 :
5110 : // METHODOLOGY EMPLOYED:
5111 : // If a surface runs on the user selected subhourly time step, then the
5112 : // history terms for the temperatures and fluxes must simply be updated
5113 : // and shifted. However, if the surface runs at a different (longer) time
5114 : // step, then the "master" history series is used for the interpolated
5115 : // update scheme.
5116 :
5117 : // REFERENCES:
5118 : // (I)BLAST legacy routine UTHRMH
5119 : // Taylor et.al., Impact of Simultaneous Simulation of Buildings and
5120 : // Mechanical Systems in Heat Balance Based Energy Analysis Programs
5121 : // on System Response and Control, Building Simulation '91, IBPSA, Nice, France.
5122 :
5123 2417443 : if (state.dataHeatBalSurfMgr->UpdateThermalHistoriesFirstTimeFlag) {
5124 759 : state.dataHeatBalSurfMgr->QExt1.dimension(state.dataSurface->TotSurfaces, 0.0);
5125 759 : state.dataHeatBalSurfMgr->QInt1.dimension(state.dataSurface->TotSurfaces, 0.0);
5126 759 : state.dataHeatBalSurfMgr->TempInt1.dimension(state.dataSurface->TotSurfaces, 0.0);
5127 759 : state.dataHeatBalSurfMgr->TempExt1.dimension(state.dataSurface->TotSurfaces, 0.0);
5128 759 : state.dataHeatBalSurfMgr->SumTime.dimension(state.dataSurface->TotSurfaces, 0.0);
5129 759 : if (state.dataHeatBal->AnyInternalHeatSourceInInput) {
5130 31 : state.dataHeatBalSurfMgr->Qsrc1.dimension(state.dataSurface->TotSurfaces, 0.0);
5131 31 : state.dataHeatBalSurfMgr->Tsrc1.dimension(state.dataSurface->TotSurfaces, 0.0);
5132 31 : state.dataHeatBalSurfMgr->Tuser1.dimension(state.dataSurface->TotSurfaces, 0.0);
5133 : }
5134 759 : state.dataHeatBalSurfMgr->UpdateThermalHistoriesFirstTimeFlag = false;
5135 : }
5136 :
5137 2417443 : auto &Surface(state.dataSurface->Surface);
5138 :
5139 20604310 : for (int zoneNum = 1; zoneNum <= state.dataGlobal->NumOfZones; ++zoneNum) {
5140 36389910 : for (int spaceNum : state.dataHeatBal->Zone(zoneNum).spaceIndexes) {
5141 18203043 : auto &thisSpace = state.dataHeatBal->space(spaceNum);
5142 18203043 : int const firstSurfOpaq = thisSpace.OpaqOrIntMassSurfaceFirst;
5143 18203043 : int const lastSurfOpaq = thisSpace.OpaqOrIntMassSurfaceLast;
5144 154236873 : for (int SurfNum = firstSurfOpaq; SurfNum <= lastSurfOpaq; ++SurfNum) {
5145 : // Loop through all (heat transfer) surfaces... [ l11 ] = ( 1, 1, SurfNum ), [ l21 ] = ( 2, 1, SurfNum )
5146 136033830 : auto const &surface(Surface(SurfNum));
5147 :
5148 136304598 : if ((surface.HeatTransferAlgorithm != DataSurfaces::HeatTransferModel::CTF) &&
5149 270768 : (surface.HeatTransferAlgorithm != DataSurfaces::HeatTransferModel::EMPD))
5150 120750 : continue;
5151 :
5152 135913080 : int const ConstrNum(surface.Construction);
5153 135913080 : auto const &construct(state.dataConstruction->Construct(ConstrNum));
5154 :
5155 135913080 : if (construct.NumCTFTerms == 0) continue; // Skip surfaces with no history terms
5156 :
5157 : // Sign convention for the various terms in the following two equations
5158 : // is based on the form of the Conduction Transfer Function equation
5159 : // given by:
5160 : // Qin,now = (Sum of)(Y Tout) - (Sum of)(Z Tin) + (Sum of)(F Qin,old) + (Sum of)(V Qsrc)
5161 : // Qout,now = (Sum of)(X Tout) - (Sum of)(Y Tin) + (Sum of)(F Qout,old) + (Sum of)(W Qsrc)
5162 : // In both equations, flux is positive from outside to inside. The V and W terms are for radiant systems only.
5163 :
5164 : // Set current inside flux:
5165 135913080 : Real64 const SurfOutsideTempCurr = state.dataHeatBalSurf->SurfOutsideTempHist(1)(SurfNum);
5166 271826160 : Real64 SurfInsideFluxHistCurr = SurfOutsideTempCurr * construct.CTFCross(0) -
5167 135913080 : state.dataHeatBalSurf->SurfTempIn(SurfNum) * construct.CTFInside(0) +
5168 135913080 : state.dataHeatBalSurf->SurfCTFConstInPart(SurfNum); // Heat source/sink term for radiant systems
5169 : // Only HT opaq surfaces are evaluated, previous if (surface.Class == SurfaceClass::Floor || surface.Class == SurfaceClass::Wall ||
5170 : // surface.Class == SurfaceClass::IntMass || surface.Class == SurfaceClass::Roof || surface.Class == SurfaceClass::Door) checks are
5171 : // reduncant.
5172 135913080 : if (construct.SourceSinkPresent) {
5173 398988 : SurfInsideFluxHistCurr += state.dataHeatBalSurf->SurfQsrcHist(SurfNum, 1) * construct.CTFSourceIn(0);
5174 : }
5175 135913080 : state.dataHeatBalSurf->SurfOpaqInsFaceCond(SurfNum) = surface.Area * SurfInsideFluxHistCurr;
5176 135913080 : state.dataHeatBalSurf->SurfOpaqInsFaceCondFlux(SurfNum) = SurfInsideFluxHistCurr; // for reporting
5177 135913080 : state.dataHeatBalSurf->SurfInsideFluxHist(1)(SurfNum) = SurfInsideFluxHistCurr;
5178 :
5179 : // Update the temperature at the source/sink location (if one is present)
5180 135913080 : if (construct.SourceSinkPresent) {
5181 398988 : state.dataHeatBalSurf->SurfTempSource(SurfNum) = state.dataHeatBalSurf->SurfTsrcHist(SurfNum, 1) =
5182 797976 : SurfOutsideTempCurr * construct.CTFTSourceOut(0) + state.dataHeatBalSurf->SurfTempIn(SurfNum) * construct.CTFTSourceIn(0) +
5183 797976 : state.dataHeatBalSurf->SurfQsrcHist(SurfNum, 1) * construct.CTFTSourceQ(0) +
5184 398988 : state.dataHeatBalFanSys->CTFTsrcConstPart(SurfNum);
5185 398988 : state.dataHeatBalSurf->SurfTempUserLoc(SurfNum) = state.dataHeatBalSurf->SurfTuserHist(SurfNum, 1) =
5186 797976 : SurfOutsideTempCurr * construct.CTFTUserOut(0) + state.dataHeatBalSurf->SurfTempIn(SurfNum) * construct.CTFTUserIn(0) +
5187 797976 : state.dataHeatBalSurf->SurfQsrcHist(SurfNum, 1) * construct.CTFTUserSource(0) +
5188 398988 : state.dataHeatBalFanSys->CTFTuserConstPart(SurfNum);
5189 : }
5190 :
5191 135913080 : if (surface.ExtBoundCond > 0) continue; // Don't need to evaluate outside for partitions
5192 :
5193 : // Set current outside flux:
5194 46530623 : if (construct.SourceSinkPresent) {
5195 350370 : state.dataHeatBalSurf->SurfOutsideFluxHist(1)(SurfNum) =
5196 700740 : SurfOutsideTempCurr * construct.CTFOutside(0) - state.dataHeatBalSurf->SurfTempIn(SurfNum) * construct.CTFCross(0) +
5197 700740 : state.dataHeatBalSurf->SurfQsrcHist(SurfNum, 1) * construct.CTFSourceOut(0) +
5198 350370 : state.dataHeatBalSurf->SurfCTFConstOutPart(SurfNum); // Heat source/sink term for radiant systems
5199 : } else {
5200 138540759 : state.dataHeatBalSurf->SurfOutsideFluxHist(1)(SurfNum) = SurfOutsideTempCurr * construct.CTFOutside(0) -
5201 92360506 : state.dataHeatBalSurf->SurfTempIn(SurfNum) * construct.CTFCross(0) +
5202 46180253 : state.dataHeatBalSurf->SurfCTFConstOutPart(SurfNum);
5203 : }
5204 : // switch sign for balance at outside face
5205 46530623 : state.dataHeatBalSurf->SurfOpaqOutFaceCondFlux(SurfNum) = -state.dataHeatBalSurf->SurfOutsideFluxHist(1)(SurfNum);
5206 46530623 : state.dataHeatBalSurf->SurfOpaqOutFaceCond(SurfNum) = surface.Area * state.dataHeatBalSurf->SurfOpaqOutFaceCondFlux(SurfNum);
5207 : }
5208 : }
5209 : } // ...end of loop over all (heat transfer) surfaces...
5210 :
5211 2417443 : if (state.dataHeatBal->SimpleCTFOnly && !state.dataGlobal->AnyConstrOverridesInModel) {
5212 : // Temporarily save the rvalue references of the last term arrays
5213 4026960 : Array1D<Real64> insideTemp(std::move(state.dataHeatBalSurf->SurfInsideTempHist(state.dataHeatBal->MaxCTFTerms + 1)));
5214 4026960 : Array1D<Real64> outsideTemp(std::move(state.dataHeatBalSurf->SurfOutsideTempHist(state.dataHeatBal->MaxCTFTerms + 1)));
5215 4026960 : Array1D<Real64> insideFlux(std::move(state.dataHeatBalSurf->SurfInsideFluxHist(state.dataHeatBal->MaxCTFTerms + 1)));
5216 4026960 : Array1D<Real64> outsideFlux(std::move(state.dataHeatBalSurf->SurfOutsideFluxHist(state.dataHeatBal->MaxCTFTerms + 1)));
5217 : // Shifting its internal pointer to data to the new object; Using the (Array1D && a) overload of the "=" operator
5218 18016212 : for (int HistTermNum = state.dataHeatBal->MaxCTFTerms + 1; HistTermNum >= 3; --HistTermNum) {
5219 16002732 : state.dataHeatBalSurf->SurfInsideTempHist(HistTermNum) = std::move(state.dataHeatBalSurf->SurfInsideTempHist(HistTermNum - 1));
5220 16002732 : state.dataHeatBalSurf->SurfOutsideTempHist(HistTermNum) = std::move(state.dataHeatBalSurf->SurfOutsideTempHist(HistTermNum - 1));
5221 16002732 : state.dataHeatBalSurf->SurfInsideFluxHist(HistTermNum) = std::move(state.dataHeatBalSurf->SurfInsideFluxHist(HistTermNum - 1));
5222 16002732 : state.dataHeatBalSurf->SurfOutsideFluxHist(HistTermNum) = std::move(state.dataHeatBalSurf->SurfOutsideFluxHist(HistTermNum - 1));
5223 : }
5224 : // Reuse the pointers of the last term arrays for the second term arrays
5225 2013480 : state.dataHeatBalSurf->SurfInsideTempHist(2) = std::move(insideTemp);
5226 2013480 : state.dataHeatBalSurf->SurfOutsideTempHist(2) = std::move(outsideTemp);
5227 2013480 : state.dataHeatBalSurf->SurfInsideFluxHist(2) = std::move(insideFlux);
5228 2013480 : state.dataHeatBalSurf->SurfOutsideFluxHist(2) = std::move(outsideFlux);
5229 : // Hard copy the values of the the 1st term to the 2nd (copying data instead of pointers to protect the 1st term arrays used in run time)
5230 2013480 : state.dataHeatBalSurf->SurfInsideTempHist(2) = state.dataHeatBalSurf->SurfInsideTempHist(1);
5231 2013480 : state.dataHeatBalSurf->SurfOutsideTempHist(2) = state.dataHeatBalSurf->SurfOutsideTempHist(1);
5232 2013480 : state.dataHeatBalSurf->SurfInsideFluxHist(2) = state.dataHeatBalSurf->SurfInsideFluxHist(1);
5233 2013480 : state.dataHeatBalSurf->SurfOutsideFluxHist(2) = state.dataHeatBalSurf->SurfOutsideFluxHist(1);
5234 2013480 : return;
5235 : }
5236 :
5237 2556208 : for (int zoneNum = 1; zoneNum <= state.dataGlobal->NumOfZones; ++zoneNum) {
5238 4304490 : for (int spaceNum : state.dataHeatBal->Zone(zoneNum).spaceIndexes) {
5239 2152245 : auto &thisSpace = state.dataHeatBal->space(spaceNum);
5240 2152245 : int const firstSurfOpaq = thisSpace.OpaqOrIntMassSurfaceFirst;
5241 2152245 : int const lastSurfOpaq = thisSpace.OpaqOrIntMassSurfaceLast;
5242 17615022 : for (int SurfNum = firstSurfOpaq; SurfNum <= lastSurfOpaq; ++SurfNum) {
5243 : // Loop through all (heat transfer) surfaces... [ l11 ] = ( 1, 1, SurfNum ), [ l21 ] = ( 2, 1, SurfNum )
5244 15462777 : if ((Surface(SurfNum).HeatTransferAlgorithm != DataSurfaces::HeatTransferModel::CTF) &&
5245 0 : (Surface(SurfNum).HeatTransferAlgorithm != DataSurfaces::HeatTransferModel::EMPD))
5246 0 : continue;
5247 15462777 : if (state.dataHeatBalSurf->SurfCurrNumHist(SurfNum) == 0) { // First time step in a block for a surface, update arrays
5248 12082460 : state.dataHeatBalSurfMgr->TempExt1(SurfNum) = state.dataHeatBalSurf->SurfOutsideTempHist(1)(SurfNum);
5249 12082460 : state.dataHeatBalSurfMgr->TempInt1(SurfNum) = state.dataHeatBalSurf->SurfInsideTempHist(1)(SurfNum);
5250 12082460 : state.dataHeatBalSurfMgr->QExt1(SurfNum) = state.dataHeatBalSurf->SurfOutsideFluxHist(1)(SurfNum);
5251 12082460 : state.dataHeatBalSurfMgr->QInt1(SurfNum) = state.dataHeatBalSurf->SurfInsideFluxHist(1)(SurfNum);
5252 : }
5253 : }
5254 : }
5255 :
5256 : } // ...end of loop over all (heat transfer) surfaces...
5257 403963 : if (state.dataHeatBal->AnyInternalHeatSourceInInput) {
5258 433362 : for (int zoneNum = 1; zoneNum <= state.dataGlobal->NumOfZones; ++zoneNum) {
5259 656118 : for (int spaceNum : state.dataHeatBal->Zone(zoneNum).spaceIndexes) {
5260 328059 : auto &thisSpace = state.dataHeatBal->space(spaceNum);
5261 328059 : int const firstSurfOpaq = thisSpace.OpaqOrIntMassSurfaceFirst;
5262 328059 : int const lastSurfOpaq = thisSpace.OpaqOrIntMassSurfaceLast;
5263 2550273 : for (int SurfNum = firstSurfOpaq; SurfNum <= lastSurfOpaq; ++SurfNum) {
5264 : // Loop through all (heat transfer) surfaces... [ l11 ] = ( 1, 1, SurfNum ), [ l21 ] = ( 2, 1, SurfNum )
5265 2222214 : if ((Surface(SurfNum).HeatTransferAlgorithm != DataSurfaces::HeatTransferModel::CTF) &&
5266 0 : (Surface(SurfNum).HeatTransferAlgorithm != DataSurfaces::HeatTransferModel::EMPD))
5267 0 : continue;
5268 2222214 : if (state.dataHeatBalSurf->SurfCurrNumHist(SurfNum) == 0) { // First time step in a block for a surface, update arrays
5269 2210088 : state.dataHeatBalSurfMgr->Tsrc1(SurfNum) = state.dataHeatBalSurf->SurfTsrcHist(SurfNum, 1);
5270 2210088 : state.dataHeatBalSurfMgr->Tuser1(SurfNum) = state.dataHeatBalSurf->SurfTuserHist(SurfNum, 1);
5271 2210088 : state.dataHeatBalSurfMgr->Qsrc1(SurfNum) = state.dataHeatBalSurf->SurfQsrcHist(SurfNum, 1);
5272 : }
5273 : }
5274 : }
5275 : } // ...end of loop over all (heat transfer) surfaces...
5276 : }
5277 :
5278 : // SHIFT TEMPERATURE AND FLUX HISTORIES:
5279 : // SHIFT AIR TEMP AND FLUX SHIFT VALUES WHEN AT BOTTOM OF ARRAY SPACE.
5280 2556208 : for (int zoneNum = 1; zoneNum <= state.dataGlobal->NumOfZones; ++zoneNum) {
5281 4304490 : for (int spaceNum : state.dataHeatBal->Zone(zoneNum).spaceIndexes) {
5282 2152245 : auto &thisSpace = state.dataHeatBal->space(spaceNum);
5283 2152245 : int const firstSurfOpaq = thisSpace.OpaqOrIntMassSurfaceFirst;
5284 2152245 : int const lastSurfOpaq = thisSpace.OpaqOrIntMassSurfaceLast;
5285 17615022 : for (int SurfNum = firstSurfOpaq; SurfNum <= lastSurfOpaq; ++SurfNum) {
5286 15462777 : auto const &surface(Surface(SurfNum));
5287 :
5288 15462777 : if ((surface.HeatTransferAlgorithm != DataSurfaces::HeatTransferModel::CTF) &&
5289 0 : (surface.HeatTransferAlgorithm != DataSurfaces::HeatTransferModel::EMPD))
5290 0 : continue;
5291 :
5292 15462777 : int const ConstrNum(surface.Construction);
5293 15462777 : auto const &construct(state.dataConstruction->Construct(ConstrNum));
5294 :
5295 15462777 : ++state.dataHeatBalSurf->SurfCurrNumHist(SurfNum);
5296 15462777 : state.dataHeatBalSurfMgr->SumTime(SurfNum) = double(state.dataHeatBalSurf->SurfCurrNumHist(SurfNum)) * state.dataGlobal->TimeStepZone;
5297 :
5298 15462777 : if (state.dataHeatBalSurf->SurfCurrNumHist(SurfNum) == construct.NumHistories) {
5299 12080868 : state.dataHeatBalSurf->SurfCurrNumHist(SurfNum) = 0;
5300 :
5301 12080868 : if (construct.NumCTFTerms > 1) {
5302 11910813 : int const numCTFTerms(construct.NumCTFTerms);
5303 105560604 : for (int HistTermNum = numCTFTerms + 1; HistTermNum >= 3; --HistTermNum) { // Tuned Linear indexing
5304 93649791 : state.dataHeatBalSurf->SurfInsideTempHistMaster(HistTermNum)(SurfNum) =
5305 93649791 : state.dataHeatBalSurf->SurfInsideTempHistMaster(HistTermNum - 1)(SurfNum);
5306 93649791 : state.dataHeatBalSurf->SurfOutsideTempHistMaster(HistTermNum)(SurfNum) =
5307 93649791 : state.dataHeatBalSurf->SurfOutsideTempHistMaster(HistTermNum - 1)(SurfNum);
5308 93649791 : state.dataHeatBalSurf->SurfInsideFluxHistMaster(HistTermNum)(SurfNum) =
5309 93649791 : state.dataHeatBalSurf->SurfInsideFluxHistMaster(HistTermNum - 1)(SurfNum);
5310 93649791 : state.dataHeatBalSurf->SurfOutsideFluxHistMaster(HistTermNum)(SurfNum) =
5311 93649791 : state.dataHeatBalSurf->SurfOutsideFluxHistMaster(HistTermNum - 1)(SurfNum);
5312 93649791 : state.dataHeatBalSurf->SurfOutsideTempHist(HistTermNum)(SurfNum) =
5313 93649791 : state.dataHeatBalSurf->SurfOutsideTempHistMaster(HistTermNum - 1)(SurfNum);
5314 93649791 : state.dataHeatBalSurf->SurfInsideTempHist(HistTermNum)(SurfNum) =
5315 93649791 : state.dataHeatBalSurf->SurfInsideTempHistMaster(HistTermNum - 1)(SurfNum);
5316 93649791 : state.dataHeatBalSurf->SurfOutsideFluxHist(HistTermNum)(SurfNum) =
5317 93649791 : state.dataHeatBalSurf->SurfOutsideFluxHistMaster(HistTermNum - 1)(SurfNum);
5318 93649791 : state.dataHeatBalSurf->SurfInsideFluxHist(HistTermNum)(SurfNum) =
5319 93649791 : state.dataHeatBalSurf->SurfInsideFluxHistMaster(HistTermNum - 1)(SurfNum);
5320 : }
5321 : }
5322 :
5323 12080868 : state.dataHeatBalSurf->SurfOutsideTempHistMaster(2)(SurfNum) = state.dataHeatBalSurfMgr->TempExt1(SurfNum);
5324 12080868 : state.dataHeatBalSurf->SurfInsideTempHistMaster(2)(SurfNum) = state.dataHeatBalSurfMgr->TempInt1(SurfNum);
5325 12080868 : state.dataHeatBalSurf->SurfOutsideFluxHistMaster(2)(SurfNum) = state.dataHeatBalSurfMgr->QExt1(SurfNum);
5326 12080868 : state.dataHeatBalSurf->SurfInsideFluxHistMaster(2)(SurfNum) = state.dataHeatBalSurfMgr->QInt1(SurfNum);
5327 :
5328 12080868 : state.dataHeatBalSurf->SurfOutsideTempHist(2)(SurfNum) = state.dataHeatBalSurf->SurfOutsideTempHistMaster(2)(SurfNum);
5329 12080868 : state.dataHeatBalSurf->SurfInsideTempHist(2)(SurfNum) = state.dataHeatBalSurf->SurfInsideTempHistMaster(2)(SurfNum);
5330 12080868 : state.dataHeatBalSurf->SurfOutsideFluxHist(2)(SurfNum) = state.dataHeatBalSurf->SurfOutsideFluxHistMaster(2)(SurfNum);
5331 12080868 : state.dataHeatBalSurf->SurfInsideFluxHist(2)(SurfNum) = state.dataHeatBalSurf->SurfInsideFluxHistMaster(2)(SurfNum);
5332 : } else {
5333 3381909 : Real64 const sum_steps(state.dataHeatBalSurfMgr->SumTime(SurfNum) / construct.CTFTimeStep);
5334 3381909 : if (construct.NumCTFTerms > 1) {
5335 3381909 : int const numCTFTerms(construct.NumCTFTerms);
5336 48952843 : for (int HistTermNum = numCTFTerms + 1; HistTermNum >= 3; --HistTermNum) { // Tuned Linear indexing
5337 : // TH(SideNum, TermNum, SurfNum) = (THM(SideNum, TermNum, SurfNum) -
5338 : // (THM(SideNum, TermNum, SurfNum) - THM(SideNum, TermNum - 1, SurfNum)) * sum_steps;
5339 45570934 : Real64 const THM_Out_1(state.dataHeatBalSurf->SurfOutsideTempHistMaster(HistTermNum)(SurfNum));
5340 45570934 : Real64 const THM_In_1(state.dataHeatBalSurf->SurfInsideTempHistMaster(HistTermNum)(SurfNum));
5341 45570934 : Real64 const THM_Out_2(state.dataHeatBalSurf->SurfOutsideTempHistMaster(HistTermNum - 1)(SurfNum));
5342 45570934 : Real64 const THM_In_2(state.dataHeatBalSurf->SurfInsideTempHistMaster(HistTermNum - 1)(SurfNum));
5343 45570934 : state.dataHeatBalSurf->SurfOutsideTempHist(HistTermNum)(SurfNum) = THM_Out_1 - (THM_Out_1 - THM_Out_2) * sum_steps;
5344 45570934 : state.dataHeatBalSurf->SurfInsideTempHist(HistTermNum)(SurfNum) = THM_In_1 - (THM_In_1 - THM_In_2) * sum_steps;
5345 :
5346 45570934 : Real64 const QHM_Out_1(state.dataHeatBalSurf->SurfOutsideFluxHistMaster(HistTermNum)(SurfNum));
5347 45570934 : Real64 const QHM_In_1(state.dataHeatBalSurf->SurfInsideFluxHistMaster(HistTermNum)(SurfNum));
5348 45570934 : Real64 const QHM_Out_2(state.dataHeatBalSurf->SurfOutsideFluxHistMaster(HistTermNum - 1)(SurfNum));
5349 45570934 : Real64 const QHM_In_2(state.dataHeatBalSurf->SurfInsideFluxHistMaster(HistTermNum - 1)(SurfNum));
5350 45570934 : state.dataHeatBalSurf->SurfOutsideFluxHist(HistTermNum)(SurfNum) = QHM_Out_1 - (QHM_Out_1 - QHM_Out_2) * sum_steps;
5351 45570934 : state.dataHeatBalSurf->SurfInsideFluxHist(HistTermNum)(SurfNum) = QHM_In_1 - (QHM_In_1 - QHM_In_2) * sum_steps;
5352 : }
5353 : }
5354 : // TH( 1, 2, SurfNum ) = THM( 1, 2, SurfNum ) - ( THM( 1, 2, SurfNum ) - TempExt1( SurfNum ) ) * sum_steps;
5355 3381909 : state.dataHeatBalSurf->SurfOutsideTempHist(2)(SurfNum) =
5356 6763818 : state.dataHeatBalSurf->SurfOutsideTempHistMaster(2)(SurfNum) -
5357 3381909 : (state.dataHeatBalSurf->SurfOutsideTempHistMaster(2)(SurfNum) - state.dataHeatBalSurfMgr->TempExt1(SurfNum)) * sum_steps;
5358 3381909 : state.dataHeatBalSurf->SurfInsideTempHist(2)(SurfNum) =
5359 6763818 : state.dataHeatBalSurf->SurfInsideTempHistMaster(2)(SurfNum) -
5360 3381909 : (state.dataHeatBalSurf->SurfInsideTempHistMaster(2)(SurfNum) - state.dataHeatBalSurfMgr->TempInt1(SurfNum)) * sum_steps;
5361 3381909 : state.dataHeatBalSurf->SurfOutsideFluxHist(2)(SurfNum) =
5362 6763818 : state.dataHeatBalSurf->SurfOutsideFluxHistMaster(2)(SurfNum) -
5363 3381909 : (state.dataHeatBalSurf->SurfOutsideFluxHistMaster(2)(SurfNum) - state.dataHeatBalSurfMgr->QExt1(SurfNum)) * sum_steps;
5364 3381909 : state.dataHeatBalSurf->SurfInsideFluxHist(2)(SurfNum) =
5365 6763818 : state.dataHeatBalSurf->SurfInsideFluxHistMaster(2)(SurfNum) -
5366 3381909 : (state.dataHeatBalSurf->SurfInsideFluxHistMaster(2)(SurfNum) - state.dataHeatBalSurfMgr->QInt1(SurfNum)) * sum_steps;
5367 : }
5368 : }
5369 : }
5370 : } // ...end of loop over all (heat transfer) surfaces
5371 :
5372 403963 : if (state.dataHeatBal->AnyInternalHeatSourceInInput) {
5373 433362 : for (int zoneNum = 1; zoneNum <= state.dataGlobal->NumOfZones; ++zoneNum) {
5374 656118 : for (int spaceNum : state.dataHeatBal->Zone(zoneNum).spaceIndexes) {
5375 328059 : auto &thisSpace = state.dataHeatBal->space(spaceNum);
5376 328059 : int const firstSurfOpaq = thisSpace.OpaqOrIntMassSurfaceFirst;
5377 328059 : int const lastSurfOpaq = thisSpace.OpaqOrIntMassSurfaceLast;
5378 2550273 : for (int SurfNum = firstSurfOpaq; SurfNum <= lastSurfOpaq; ++SurfNum) {
5379 2222214 : auto const &surface(Surface(SurfNum));
5380 2222214 : int const ConstrNum(surface.Construction);
5381 2222214 : auto const &construct(state.dataConstruction->Construct(ConstrNum));
5382 2222214 : if (!construct.SourceSinkPresent) continue;
5383 398988 : if ((surface.HeatTransferAlgorithm != DataSurfaces::HeatTransferModel::CTF) &&
5384 0 : (surface.HeatTransferAlgorithm != DataSurfaces::HeatTransferModel::EMPD))
5385 0 : continue;
5386 :
5387 398988 : if (state.dataHeatBalSurf->SurfCurrNumHist(SurfNum) == 0) { // First time step in a block for a surface, update arrays
5388 386832 : if (construct.NumCTFTerms > 1) {
5389 386832 : int const numCTFTerms(construct.NumCTFTerms);
5390 386832 : auto m(state.dataHeatBalSurf->SurfTsrcHistM.index(SurfNum, numCTFTerms));
5391 386832 : auto m1(m + 1);
5392 3834570 : for (int HistTermNum = numCTFTerms + 1; HistTermNum >= 3; --HistTermNum, --m, --m1) { // Tuned Linear indexing
5393 : // SurfTsrcHist( SurfNum, HistTerm ) = SurfTsrcHistM( SurfNum, HHistTerm ) = SurfTsrcHistM( SurfNum, HistTermNum - 1
5394 : // ); SurfQsrcHist( SurfNum, HistTerm ) = SurfQsrcHistM( SurfNum, HHistTerm ) = SurfQsrcHistM( SurfNum, HistTermNum -
5395 : // 1 );
5396 3447738 : state.dataHeatBalSurf->SurfTsrcHist[m1] = state.dataHeatBalSurf->SurfTsrcHistM[m1] =
5397 3447738 : state.dataHeatBalSurf->SurfTsrcHistM[m];
5398 3447738 : state.dataHeatBalSurf->SurfQsrcHist[m1] = state.dataHeatBalSurf->SurfQsrcHistM[m1] =
5399 3447738 : state.dataHeatBalSurf->SurfQsrcHistM[m];
5400 3447738 : state.dataHeatBalSurf->SurfTuserHist[m1] = state.dataHeatBalSurf->SurfTuserHistM[m1] =
5401 3447738 : state.dataHeatBalSurf->SurfTuserHistM[m];
5402 : }
5403 : }
5404 386832 : state.dataHeatBalSurf->SurfTsrcHistM(SurfNum, 2) = state.dataHeatBalSurfMgr->Tsrc1(SurfNum);
5405 386832 : state.dataHeatBalSurf->SurfTuserHistM(SurfNum, 2) = state.dataHeatBalSurfMgr->Tuser1(SurfNum);
5406 386832 : state.dataHeatBalSurf->SurfQsrcHistM(SurfNum, 2) = state.dataHeatBalSurfMgr->Qsrc1(SurfNum);
5407 386832 : state.dataHeatBalSurf->SurfTsrcHist(SurfNum, 2) = state.dataHeatBalSurf->SurfTsrcHistM(SurfNum, 2);
5408 386832 : state.dataHeatBalSurf->SurfTuserHist(SurfNum, 2) = state.dataHeatBalSurf->SurfTuserHistM(SurfNum, 2);
5409 386832 : state.dataHeatBalSurf->SurfQsrcHist(SurfNum, 2) = state.dataHeatBalSurf->SurfQsrcHistM(SurfNum, 2);
5410 : } else {
5411 12156 : Real64 const sum_steps(state.dataHeatBalSurfMgr->SumTime(SurfNum) / construct.CTFTimeStep);
5412 :
5413 12156 : if (construct.NumCTFTerms > 1) {
5414 12156 : int const numCTFTerms(construct.NumCTFTerms);
5415 12156 : auto m(state.dataHeatBalSurf->SurfTsrcHistM.index(SurfNum, numCTFTerms));
5416 12156 : auto m1(m + 1);
5417 158028 : for (int HistTermNum = numCTFTerms + 1; HistTermNum >= 3; --HistTermNum, --m, --m1) { // Tuned Linear indexing [ l ] == ()
5418 : // Real64 const SurfTsrcHistM_elem( SurfTsrcHistM( SurfNum, HistTermNum ) );
5419 : // SurfTsrcHist( SurfNum, HistTermNum ) = SurfTsrcHistM_elem - ( SurfTsrcHistM_elem - SurfTsrcHistM( SurfNum,
5420 : // HistTermNum
5421 : // - 1 ) ) * sum_steps; Real64 const QsrcHistM_elem( SurfQsrcHistM( SurfNum, HistTermNum ) ); SurfQsrcHist( SurfNum,
5422 : // HistTermNum ) = QsrcHistM_elem - ( QsrcHistM_elem - SurfQsrcHistM( SurfNum, HistTermNum - 1 ) ) * sum_steps;
5423 145872 : Real64 const TsrcHistM_m1(state.dataHeatBalSurf->SurfTsrcHistM[m1]);
5424 145872 : state.dataHeatBalSurf->SurfTsrcHist[m1] =
5425 145872 : TsrcHistM_m1 - (TsrcHistM_m1 - state.dataHeatBalSurf->SurfTsrcHistM[m]) * sum_steps;
5426 145872 : Real64 const QsrcHistM_m1(state.dataHeatBalSurf->SurfQsrcHistM[m1]);
5427 145872 : state.dataHeatBalSurf->SurfQsrcHist[m1] =
5428 145872 : QsrcHistM_m1 - (QsrcHistM_m1 - state.dataHeatBalSurf->SurfQsrcHistM[m]) * sum_steps;
5429 145872 : Real64 const TuserHistM_m1(state.dataHeatBalSurf->SurfTuserHistM[m1]);
5430 145872 : state.dataHeatBalSurf->SurfTuserHist[m1] =
5431 145872 : TuserHistM_m1 - (TuserHistM_m1 - state.dataHeatBalSurf->SurfTuserHistM[m]) * sum_steps;
5432 : }
5433 : }
5434 : // Tuned Linear indexing
5435 : // SurfTsrcHist( SurfNum, 2 ) = SurfTsrcHistM( SurfNum, 2 ) - ( SurfTsrcHistM( SurfNum, 2 ) - Tsrc1( SurfNum ) ) * sum_steps;
5436 : // SurfQsrcHist( SurfNum, 2 ) = SurfQsrcHistM( SurfNum, 2 ) - ( SurfQsrcHistM( SurfNum, 2 ) - Qsrc1( SurfNum ) ) * sum_steps;
5437 12156 : auto const l2(state.dataHeatBalSurf->SurfTsrcHist.index(SurfNum, 2));
5438 12156 : state.dataHeatBalSurf->SurfTsrcHist[l2] =
5439 24312 : state.dataHeatBalSurf->SurfTsrcHistM[l2] -
5440 12156 : (state.dataHeatBalSurf->SurfTsrcHistM[l2] - state.dataHeatBalSurfMgr->Tsrc1(SurfNum)) * sum_steps;
5441 12156 : state.dataHeatBalSurf->SurfQsrcHist[l2] =
5442 24312 : state.dataHeatBalSurf->SurfQsrcHistM[l2] -
5443 12156 : (state.dataHeatBalSurf->SurfQsrcHistM[l2] - state.dataHeatBalSurfMgr->Qsrc1(SurfNum)) * sum_steps;
5444 12156 : state.dataHeatBalSurf->SurfTuserHist[l2] =
5445 24312 : state.dataHeatBalSurf->SurfTuserHistM[l2] -
5446 12156 : (state.dataHeatBalSurf->SurfTuserHistM[l2] - state.dataHeatBalSurfMgr->Tuser1(SurfNum)) * sum_steps;
5447 : }
5448 : }
5449 : }
5450 : } // ...end of loop over all (heat transfer) surfaces...
5451 : } // ...end of AnyInternalHeatSourceInInput
5452 : }
5453 :
5454 3487776 : void CalculateZoneMRT(EnergyPlusData &state,
5455 : Optional_int_const ZoneToResimulate) // if passed in, then only calculate surfaces that have this zone
5456 : {
5457 :
5458 : // SUBROUTINE INFORMATION:
5459 : // AUTHOR Rick Strand
5460 : // DATE WRITTEN November 2000
5461 : // MODIFIED na
5462 : // RE-ENGINEERED na
5463 :
5464 : // PURPOSE OF THIS SUBROUTINE:
5465 : // Calculates the current zone MRT for thermal comfort and radiation
5466 : // calculation purposes.
5467 :
5468 : Real64 SumAET; // Intermediate calculational variable (area*emissivity*T) sum
5469 :
5470 3487776 : auto &Surface(state.dataSurface->Surface);
5471 :
5472 3487776 : if (state.dataHeatBalSurfMgr->CalculateZoneMRTfirstTime) {
5473 771 : state.dataHeatBalSurfMgr->SurfaceAE.allocate(state.dataSurface->TotSurfaces);
5474 771 : state.dataHeatBalSurfMgr->ZoneAESum.allocate(state.dataGlobal->NumOfZones);
5475 771 : state.dataHeatBalSurfMgr->SurfaceAE = 0.0;
5476 771 : state.dataHeatBalSurfMgr->ZoneAESum = 0.0;
5477 44533 : for (int SurfNum = 1; SurfNum <= state.dataSurface->TotSurfaces; ++SurfNum) {
5478 43762 : if (Surface(SurfNum).HeatTransSurf) {
5479 42207 : state.dataHeatBalSurfMgr->SurfaceAE(SurfNum) =
5480 42207 : Surface(SurfNum).Area * state.dataConstruction->Construct(Surface(SurfNum).Construction).InsideAbsorpThermal;
5481 42207 : int ZoneNum = Surface(SurfNum).Zone;
5482 42207 : if (ZoneNum > 0) state.dataHeatBalSurfMgr->ZoneAESum(ZoneNum) += state.dataHeatBalSurfMgr->SurfaceAE(SurfNum);
5483 : }
5484 : }
5485 : }
5486 :
5487 25190732 : for (int ZoneNum = 1; ZoneNum <= state.dataGlobal->NumOfZones; ++ZoneNum) {
5488 21702956 : if (present(ZoneToResimulate) && (ZoneNum != ZoneToResimulate)) continue;
5489 19703110 : SumAET = 0.0;
5490 39422396 : for (int spaceNum : state.dataHeatBal->Zone(ZoneNum).spaceIndexes) {
5491 19719286 : auto &thisSpace = state.dataHeatBal->space(spaceNum);
5492 188711964 : for (int SurfNum = thisSpace.HTSurfaceFirst; SurfNum <= thisSpace.HTSurfaceLast; ++SurfNum) {
5493 168992678 : SumAET += state.dataHeatBalSurfMgr->SurfaceAE(SurfNum) * state.dataHeatBalSurf->SurfTempIn(SurfNum);
5494 : }
5495 19719286 : if (state.dataHeatBalSurfMgr->ZoneAESum(ZoneNum) > 0.01) {
5496 19717261 : state.dataHeatBal->ZoneMRT(ZoneNum) = SumAET / state.dataHeatBalSurfMgr->ZoneAESum(ZoneNum);
5497 : } else {
5498 2025 : if (state.dataHeatBalSurfMgr->CalculateZoneMRTfirstTime) {
5499 3 : ShowWarningError(state,
5500 2 : "Zone areas*inside surface emissivities are summing to zero, for Zone=\"" +
5501 3 : state.dataHeatBal->Zone(ZoneNum).Name + "\"");
5502 1 : ShowContinueError(state, "As a result, MRT will be set to MAT for that zone");
5503 : }
5504 2025 : state.dataHeatBal->ZoneMRT(ZoneNum) = state.dataZoneTempPredictorCorrector->zoneHeatBalance(ZoneNum).MAT;
5505 : }
5506 : }
5507 : }
5508 :
5509 3487776 : state.dataHeatBalSurfMgr->CalculateZoneMRTfirstTime = false;
5510 3487776 : }
5511 :
5512 : // End of Record Keeping subroutines for the HB Module
5513 : // *****************************************************************************
5514 :
5515 : // Beginning of Reporting subroutines for the HB Module
5516 : // *****************************************************************************
5517 :
5518 2568313 : void CalcThermalResilience(EnergyPlusData &state)
5519 : {
5520 : // This function calculate timestep-wise heat index and humidex.
5521 :
5522 : // The computation of the heat index is a refinement of a result obtained by multiple regression analysis
5523 : // carried out by Lans P. Rothfusz and described in a 1990 National Weather Service (NWS)
5524 : // Technical Attachment (SR 90-23).
5525 : // Reference: https://www.wpc.ncep.noaa.gov/html/heatindex_equation.shtml
5526 :
5527 : // The current formula for determining the humidex was developed by J. M. Masterton and F. A. Richardson of
5528 : // Canada's Atmospheric Environment Service in 1979.
5529 : // Reference: Masterson, J., and F. Richardson, 1979: Humidex, a method of quantifying human
5530 : // discomfort due to excessive heat and humidity CLI 1-79, Environment Canada, Atmosheric Environment Servic
5531 : // using OutputProcessor::ReqRepVars;
5532 2568313 : if (state.dataHeatBalSurfMgr->ManageSurfaceHeatBalancefirstTime) {
5533 5585 : for (int ZoneNum = 1; ZoneNum <= state.dataGlobal->NumOfZones; ++ZoneNum) {
5534 19256 : SetupOutputVariable(state,
5535 : "Zone Heat Index",
5536 : OutputProcessor::Unit::C,
5537 4814 : state.dataHeatBal->Resilience(ZoneNum).ZoneHeatIndex,
5538 : OutputProcessor::SOVTimeStepType::Zone,
5539 : OutputProcessor::SOVStoreType::State,
5540 9628 : state.dataHeatBal->Zone(ZoneNum).Name);
5541 19256 : SetupOutputVariable(state,
5542 : "Zone Humidity Index",
5543 : OutputProcessor::Unit::None,
5544 4814 : state.dataHeatBal->Resilience(ZoneNum).ZoneHumidex,
5545 : OutputProcessor::SOVTimeStepType::Zone,
5546 : OutputProcessor::SOVStoreType::State,
5547 9628 : state.dataHeatBal->Zone(ZoneNum).Name);
5548 : }
5549 21128 : for (int Loop = 1; Loop <= state.dataOutputProcessor->NumOfReqVariables; ++Loop) {
5550 20357 : if (state.dataOutputProcessor->ReqRepVars(Loop).VarName == "Zone Heat Index") {
5551 0 : state.dataHeatBalSurfMgr->reportVarHeatIndex = true;
5552 20357 : } else if (state.dataOutputProcessor->ReqRepVars(Loop).VarName == "Zone Humidity Index") {
5553 0 : state.dataHeatBalSurfMgr->reportVarHumidex = true;
5554 : }
5555 : }
5556 : }
5557 :
5558 : // Calculate Heat Index and Humidex.
5559 : // The heat index equation set is fit to Fahrenheit units, so the zone air temperature values are first convert to F,
5560 : // then heat index is calculated and converted back to C.
5561 2568313 : if (state.dataHeatBalSurfMgr->reportVarHeatIndex || state.dataOutRptTab->displayThermalResilienceSummary) {
5562 : // Constance for heat index regression equation of Rothfusz.
5563 942558 : Real64 constexpr c1 = -42.379;
5564 942558 : Real64 constexpr c2 = 2.04901523;
5565 942558 : Real64 constexpr c3 = 10.14333127;
5566 942558 : Real64 constexpr c4 = -.22475541;
5567 942558 : Real64 constexpr c5 = -.00683783;
5568 942558 : Real64 constexpr c6 = -.05481717;
5569 942558 : Real64 constexpr c7 = .00122874;
5570 942558 : Real64 constexpr c8 = .00085282;
5571 942558 : Real64 constexpr c9 = -.00000199;
5572 5667186 : for (int ZoneNum = 1; ZoneNum <= state.dataGlobal->NumOfZones; ++ZoneNum) {
5573 4724628 : Real64 const ZoneT = state.dataZoneTempPredictorCorrector->zoneHeatBalance(ZoneNum).ZTAV;
5574 4724628 : Real64 const ZoneW = state.dataZoneTempPredictorCorrector->zoneHeatBalance(ZoneNum).ZoneAirHumRatAvg;
5575 4724628 : Real64 const ZoneRH = Psychrometrics::PsyRhFnTdbWPb(state, ZoneT, ZoneW, state.dataEnvrn->OutBaroPress) * 100.0;
5576 4724628 : Real64 const ZoneTF = ZoneT * (9.0 / 5.0) + 32.0;
5577 : Real64 HI;
5578 :
5579 4724628 : if (ZoneTF < 80) {
5580 4016756 : HI = 0.5 * (ZoneTF + 61.0 + (ZoneTF - 68.0) * 1.2 + (ZoneRH * 0.094));
5581 : } else {
5582 2123616 : HI = c1 + c2 * ZoneTF + c3 * ZoneRH + c4 * ZoneTF * ZoneRH + c5 * ZoneTF * ZoneTF + c6 * ZoneRH * ZoneRH +
5583 1415744 : c7 * ZoneTF * ZoneTF * ZoneRH + c8 * ZoneTF * ZoneRH * ZoneRH + c9 * ZoneTF * ZoneTF * ZoneRH * ZoneRH;
5584 707872 : if (ZoneRH < 13 && ZoneTF < 112) {
5585 29848 : HI -= (13 - ZoneRH) / 4 * std::sqrt((17 - abs(ZoneTF - 95)) / 17);
5586 678024 : } else if (ZoneRH > 85 && ZoneTF < 87) {
5587 8362 : HI += (ZoneRH - 85) / 10 * (87 - ZoneTF) / 5;
5588 : }
5589 : }
5590 4724628 : HI = (HI - 32.0) * (5.0 / 9.0);
5591 4724628 : state.dataHeatBal->Resilience(ZoneNum).ZoneHeatIndex = HI;
5592 : }
5593 : }
5594 2568313 : if (state.dataHeatBalSurfMgr->reportVarHumidex || state.dataOutRptTab->displayThermalResilienceSummary) {
5595 5667186 : for (int ZoneNum = 1; ZoneNum <= state.dataGlobal->NumOfZones; ++ZoneNum) {
5596 4724628 : Real64 const ZoneW = state.dataZoneTempPredictorCorrector->zoneHeatBalance(ZoneNum).ZoneAirHumRatAvg;
5597 4724628 : Real64 const ZoneT = state.dataZoneTempPredictorCorrector->zoneHeatBalance(ZoneNum).ZTAV;
5598 4724628 : Real64 const TDewPointK = Psychrometrics::PsyTdpFnWPb(state, ZoneW, state.dataEnvrn->OutBaroPress) + DataGlobalConstants::KelvinConv;
5599 4724628 : Real64 const e = 6.11 * std::exp(5417.7530 * ((1 / 273.16) - (1 / TDewPointK)));
5600 4724628 : Real64 const h = 5.0 / 9.0 * (e - 10.0);
5601 4724628 : Real64 const Humidex = ZoneT + h;
5602 4724628 : state.dataHeatBal->Resilience(ZoneNum).ZoneHumidex = Humidex;
5603 : }
5604 : }
5605 2568313 : }
5606 :
5607 942558 : void ReportThermalResilience(EnergyPlusData &state)
5608 : {
5609 :
5610 942558 : int HINoBins = 5; // Heat Index range - number of bins
5611 942558 : int HumidexNoBins = 5; // Humidex range - number of bins
5612 942558 : int SETNoBins = 5; // SET report column numbers
5613 942558 : int ColdHourOfSafetyNoBins = 5; // Cold Stress Hour of Safety number of columns
5614 942558 : int HeatHourOfSafetyNoBins = 5; // Heat Stress Hour of Safety number of columns
5615 942558 : int UnmetDegreeHourNoBins = 6; // Unmet Degree Hour number of columns
5616 942558 : int DiscomfortWtExceedHourNoBins = 4; // Unmet Degree Hour number of columns
5617 :
5618 1885116 : Array1D_bool reportPeriodFlags;
5619 942558 : if (state.dataWeatherManager->TotReportPers > 0) {
5620 5376 : reportPeriodFlags.dimension(state.dataWeatherManager->TotThermalReportPers, false);
5621 10752 : General::findReportPeriodIdx(
5622 10752 : state, state.dataWeatherManager->ThermalReportPeriodInput, state.dataWeatherManager->TotThermalReportPers, reportPeriodFlags);
5623 : }
5624 :
5625 942558 : auto &ort(state.dataOutRptTab);
5626 949470 : for (int i = 1; i <= state.dataWeatherManager->TotThermalReportPers; i++) {
5627 6912 : if (reportPeriodFlags(i)) {
5628 0 : int curResMeterNumber = ort->meterNumTotalsBEPS(1);
5629 0 : state.dataWeatherManager->ThermalReportPeriodInput(i).totalElectricityUse += GetCurrentMeterValue(state, curResMeterNumber);
5630 : }
5631 : }
5632 :
5633 942558 : if (state.dataHeatBalSurfMgr->reportThermalResilienceFirstTime) {
5634 656 : if (state.dataHeatBal->TotPeople == 0) state.dataHeatBalSurfMgr->hasPierceSET = false;
5635 3453 : for (int iPeople = 1; iPeople <= state.dataHeatBal->TotPeople; ++iPeople) {
5636 2797 : if (!state.dataHeatBal->People(iPeople).Pierce) {
5637 2786 : state.dataHeatBalSurfMgr->hasPierceSET = false;
5638 : }
5639 : }
5640 4109 : for (int ZoneNum = 1; ZoneNum <= state.dataGlobal->NumOfZones; ++ZoneNum) {
5641 : // the whole period
5642 : // user specified reporting period
5643 3458 : for (int i = 1; i <= state.dataWeatherManager->TotThermalReportPers; i++) {
5644 5 : state.dataHeatBalFanSys->ZoneHeatIndexHourBinsRepPeriod(ZoneNum, i).assign(HINoBins, 0.0);
5645 5 : state.dataHeatBalFanSys->ZoneHeatIndexOccuHourBinsRepPeriod(ZoneNum, i).assign(HINoBins, 0.0);
5646 5 : state.dataHeatBalFanSys->ZoneHeatIndexOccupiedHourBinsRepPeriod(ZoneNum, i).assign(HINoBins, 0.0);
5647 5 : state.dataHeatBalFanSys->ZoneHumidexHourBinsRepPeriod(ZoneNum, i).assign(HumidexNoBins, 0.0);
5648 5 : state.dataHeatBalFanSys->ZoneHumidexOccupiedHourBinsRepPeriod(ZoneNum, i).assign(HumidexNoBins, 0.0);
5649 5 : state.dataHeatBalFanSys->ZoneHumidexOccuHourBinsRepPeriod(ZoneNum, i).assign(HumidexNoBins, 0.0);
5650 5 : if (state.dataHeatBalSurfMgr->hasPierceSET) {
5651 5 : state.dataHeatBalFanSys->ZoneLowSETHoursRepPeriod(ZoneNum, i).assign(SETNoBins, 0.0);
5652 5 : state.dataHeatBalFanSys->ZoneHighSETHoursRepPeriod(ZoneNum, i).assign(SETNoBins, 0.0);
5653 : }
5654 5 : state.dataHeatBalFanSys->ZoneColdHourOfSafetyBinsRepPeriod(ZoneNum, i).assign(ColdHourOfSafetyNoBins, 0.0);
5655 5 : state.dataHeatBalFanSys->ZoneHeatHourOfSafetyBinsRepPeriod(ZoneNum, i).assign(HeatHourOfSafetyNoBins, 0.0);
5656 5 : state.dataHeatBalFanSys->ZoneUnmetDegreeHourBinsRepPeriod(ZoneNum, i).assign(UnmetDegreeHourNoBins, 0.0);
5657 5 : state.dataHeatBalFanSys->ZoneDiscomfortWtExceedOccuHourBinsRepPeriod(ZoneNum, i).assign(DiscomfortWtExceedHourNoBins, 0.0);
5658 5 : state.dataHeatBalFanSys->ZoneDiscomfortWtExceedOccupiedHourBinsRepPeriod(ZoneNum, i).assign(DiscomfortWtExceedHourNoBins, 0.0);
5659 : }
5660 3453 : state.dataHeatBalFanSys->lowSETLongestHoursRepPeriod = 0.0;
5661 3453 : state.dataHeatBalFanSys->highSETLongestHoursRepPeriod = 0.0;
5662 3453 : state.dataHeatBalFanSys->lowSETLongestStartRepPeriod = 0.0;
5663 3453 : state.dataHeatBalFanSys->highSETLongestStartRepPeriod = 0.0;
5664 : }
5665 656 : state.dataHeatBalSurfMgr->lowSETLongestHours.assign(state.dataGlobal->NumOfZones, 0.0);
5666 656 : state.dataHeatBalSurfMgr->highSETLongestHours.assign(state.dataGlobal->NumOfZones, 0.0);
5667 656 : state.dataHeatBalSurfMgr->lowSETLongestStart.assign(state.dataGlobal->NumOfZones, 0.0);
5668 656 : state.dataHeatBalSurfMgr->highSETLongestStart.assign(state.dataGlobal->NumOfZones, 0.0);
5669 656 : state.dataHeatBalSurfMgr->reportThermalResilienceFirstTime = false;
5670 : }
5671 :
5672 : // Count hours only during weather simulation periods
5673 942558 : if (DataGlobalConstants::KindOfSim::RunPeriodWeather == state.dataGlobal->KindOfSim && !state.dataGlobal->WarmupFlag) {
5674 : // use default value if there are no user inputs
5675 70176 : Real64 ColdTempThresh = 15.56;
5676 70176 : Real64 HeatTempThresh = 30.0;
5677 : // Trace current time step Zone Pierce SET; NaN if no occupant or SET not calculated
5678 : // Record last time step SET to trace SET unmet duration;
5679 :
5680 70176 : Real64 valueNotInit = -999.0;
5681 70176 : Real64 nearThreshold = 1.0;
5682 491232 : for (int ZoneNum = 1; ZoneNum <= state.dataGlobal->NumOfZones; ++ZoneNum) {
5683 421056 : state.dataHeatBal->Resilience(ZoneNum).PierceSET = valueNotInit;
5684 421056 : state.dataHeatBal->Resilience(ZoneNum).PMV = valueNotInit;
5685 : }
5686 421056 : for (int iPeople = 1; iPeople <= state.dataHeatBal->TotPeople; ++iPeople) {
5687 350880 : int ZoneNum = state.dataHeatBal->People(iPeople).ZonePtr;
5688 701760 : state.dataHeatBal->Resilience(ZoneNum).ZoneNumOcc = state.dataHeatBal->People(iPeople).NumberOfPeople *
5689 350880 : GetCurrentScheduleValue(state, state.dataHeatBal->People(iPeople).NumberOfPeoplePtr);
5690 350880 : state.dataHeatBal->Resilience(ZoneNum).ZonePierceSETLastStep = state.dataHeatBal->Resilience(ZoneNum).ZonePierceSET;
5691 350880 : if (state.dataHeatBal->People(iPeople).Pierce) {
5692 0 : state.dataHeatBal->Resilience(ZoneNum).ZonePierceSET = state.dataThermalComforts->ThermalComfortData(iPeople).PierceSET;
5693 : } else {
5694 350880 : state.dataHeatBal->Resilience(ZoneNum).ZonePierceSET = -1;
5695 : }
5696 :
5697 350880 : Real64 NumOcc = state.dataHeatBal->Resilience(ZoneNum).ZoneNumOcc;
5698 350880 : Real64 Temperature = state.dataZoneTempPredictorCorrector->zoneHeatBalance(ZoneNum).ZTAV;
5699 350880 : ColdTempThresh = state.dataHeatBal->People(iPeople).ColdStressTempThresh;
5700 350880 : bool &CrossedColdThresh = state.dataHeatBal->Resilience(ZoneNum).CrossedColdThresh;
5701 350880 : if (Temperature > ColdTempThresh) { // safe
5702 350880 : if (!CrossedColdThresh) {
5703 : // compute the number of hours before threshold is reached
5704 350880 : state.dataHeatBal->Resilience(ZoneNum).ZoneColdHourOfSafetyBins[0] += state.dataGlobal->TimeStepZone;
5705 : }
5706 : } else { // danger
5707 : // compute the total number of hours when the zone temperature falls in the dangerous range throughout the reporting period
5708 0 : state.dataHeatBal->Resilience(ZoneNum).ZoneColdHourOfSafetyBins[2] += state.dataGlobal->TimeStepZone;
5709 0 : state.dataHeatBal->Resilience(ZoneNum).ZoneColdHourOfSafetyBins[3] += NumOcc * state.dataGlobal->TimeStepZone;
5710 0 : state.dataHeatBal->Resilience(ZoneNum).ZoneColdHourOfSafetyBins[4] += (NumOcc > 0) * state.dataGlobal->TimeStepZone;
5711 : // first time crossing threshold
5712 0 : if (!CrossedColdThresh) {
5713 : // compute the time when the zone crosses the threshold temperature
5714 : int encodedMonDayHrMin;
5715 0 : General::EncodeMonDayHrMin(encodedMonDayHrMin,
5716 0 : state.dataEnvrn->Month,
5717 0 : state.dataEnvrn->DayOfMonth,
5718 0 : state.dataGlobal->HourOfDay,
5719 0 : state.dataGlobal->TimeStepZone * (state.dataGlobal->TimeStep - 1) * 60);
5720 : // fixme: not sure how to aggregate by zone
5721 0 : state.dataHeatBal->Resilience(ZoneNum).ZoneColdHourOfSafetyBins[1] = encodedMonDayHrMin;
5722 0 : CrossedColdThresh = true;
5723 : }
5724 : }
5725 350880 : HeatTempThresh = state.dataHeatBal->People(iPeople).HeatStressTempThresh;
5726 350880 : bool &CrossedHeatThresh = state.dataHeatBal->Resilience(ZoneNum).CrossedHeatThresh;
5727 350880 : if (Temperature < HeatTempThresh) { // safe
5728 349911 : if (!CrossedHeatThresh) {
5729 : // compute the number of hours before threshold is reached
5730 245354 : state.dataHeatBal->Resilience(ZoneNum).ZoneHeatHourOfSafetyBins[0] += state.dataGlobal->TimeStepZone;
5731 : }
5732 : } else { // danger
5733 : // compute the total number of hours when the zone temperature falls in the dangerous range throughout the reporting period
5734 969 : state.dataHeatBal->Resilience(ZoneNum).ZoneHeatHourOfSafetyBins[2] += state.dataGlobal->TimeStepZone;
5735 969 : state.dataHeatBal->Resilience(ZoneNum).ZoneHeatHourOfSafetyBins[3] += NumOcc * state.dataGlobal->TimeStepZone;
5736 969 : state.dataHeatBal->Resilience(ZoneNum).ZoneHeatHourOfSafetyBins[4] += (NumOcc > 0) * state.dataGlobal->TimeStepZone;
5737 : // first time crossing threshold
5738 969 : if (!CrossedHeatThresh) {
5739 : // compute the time when the zone crosses the threshold temperature
5740 : int encodedMonDayHrMin;
5741 20 : General::EncodeMonDayHrMin(encodedMonDayHrMin,
5742 5 : state.dataEnvrn->Month,
5743 5 : state.dataEnvrn->DayOfMonth,
5744 5 : state.dataGlobal->HourOfDay,
5745 5 : state.dataGlobal->TimeStepZone * (state.dataGlobal->TimeStep - 1) * 60);
5746 5 : state.dataHeatBal->Resilience(ZoneNum).ZoneHeatHourOfSafetyBins[1] = encodedMonDayHrMin;
5747 5 : CrossedHeatThresh = true;
5748 : }
5749 : }
5750 :
5751 350880 : Real64 VeryHotPMVThresh = 3.0;
5752 350880 : Real64 WarmPMVThresh = 0.7;
5753 350880 : Real64 CoolPMVThresh = -0.7;
5754 350880 : Real64 VeryColdPMVThresh = -3.0;
5755 350880 : Real64 PMV = state.dataThermalComforts->ThermalComfortData(iPeople).FangerPMV;
5756 350880 : if (PMV < VeryColdPMVThresh) {
5757 0 : state.dataHeatBal->Resilience(ZoneNum).ZoneDiscomfortWtExceedOccuHourBins[0] +=
5758 0 : (VeryColdPMVThresh - PMV) * NumOcc * state.dataGlobal->TimeStepZone;
5759 0 : state.dataHeatBal->Resilience(ZoneNum).ZoneDiscomfortWtExceedOccupiedHourBins[0] +=
5760 0 : (VeryColdPMVThresh - PMV) * (NumOcc > 0) * state.dataGlobal->TimeStepZone;
5761 : }
5762 350880 : if (PMV < CoolPMVThresh) {
5763 0 : state.dataHeatBal->Resilience(ZoneNum).ZoneDiscomfortWtExceedOccuHourBins[1] +=
5764 0 : (CoolPMVThresh - PMV) * NumOcc * state.dataGlobal->TimeStepZone;
5765 0 : state.dataHeatBal->Resilience(ZoneNum).ZoneDiscomfortWtExceedOccupiedHourBins[1] +=
5766 0 : (CoolPMVThresh - PMV) * (NumOcc > 0) * state.dataGlobal->TimeStepZone;
5767 : }
5768 350880 : if (PMV > WarmPMVThresh) {
5769 0 : state.dataHeatBal->Resilience(ZoneNum).ZoneDiscomfortWtExceedOccuHourBins[2] +=
5770 0 : (PMV - WarmPMVThresh) * NumOcc * state.dataGlobal->TimeStepZone;
5771 0 : state.dataHeatBal->Resilience(ZoneNum).ZoneDiscomfortWtExceedOccupiedHourBins[2] +=
5772 0 : (PMV - WarmPMVThresh) * (NumOcc > 0) * state.dataGlobal->TimeStepZone;
5773 : }
5774 350880 : if (PMV > VeryHotPMVThresh) {
5775 0 : state.dataHeatBal->Resilience(ZoneNum).ZoneDiscomfortWtExceedOccuHourBins[3] +=
5776 0 : (PMV - VeryHotPMVThresh) * NumOcc * state.dataGlobal->TimeStepZone;
5777 0 : state.dataHeatBal->Resilience(ZoneNum).ZoneDiscomfortWtExceedOccupiedHourBins[3] +=
5778 0 : (PMV - VeryHotPMVThresh) * (NumOcc > 0) * state.dataGlobal->TimeStepZone;
5779 : }
5780 :
5781 : // check whether PierceSET changed for people in a zone
5782 350880 : if (state.dataHeatBal->Resilience(ZoneNum).PierceSET < valueNotInit + nearThreshold) {
5783 350880 : state.dataHeatBal->Resilience(ZoneNum).PierceSET = state.dataHeatBal->Resilience(ZoneNum).ZonePierceSET;
5784 : } else {
5785 0 : if (state.dataHeatBal->Resilience(ZoneNum).PierceSET != state.dataHeatBal->Resilience(ZoneNum).ZonePierceSET) {
5786 0 : ShowRecurringWarningErrorAtEnd(state,
5787 0 : fmt::format("Zone {} has multiple people objects with different PierceSet.", ZoneNum),
5788 0 : state.dataHeatBalFanSys->PierceSETerrorIndex);
5789 : }
5790 : }
5791 :
5792 : // check whether PierceSET, PMV, etc. changed for different people in a zone
5793 350880 : if (state.dataHeatBal->Resilience(ZoneNum).PMV < valueNotInit + nearThreshold) {
5794 350880 : state.dataHeatBal->Resilience(ZoneNum).PMV = PMV;
5795 : } else {
5796 0 : if (state.dataHeatBal->Resilience(ZoneNum).PMV != PMV) {
5797 0 : ShowRecurringWarningErrorAtEnd(state,
5798 0 : fmt::format("Zone {} has multiple people objects with different PMV.", ZoneNum),
5799 0 : state.dataHeatBalFanSys->PMVerrorIndex);
5800 : }
5801 : }
5802 :
5803 350880 : for (int i = 1; i <= state.dataWeatherManager->TotThermalReportPers; i++) {
5804 0 : if (reportPeriodFlags(i)) {
5805 0 : int ReportPeriodIdx = i;
5806 0 : ColdTempThresh = state.dataHeatBal->People(iPeople).ColdStressTempThresh;
5807 0 : bool &CrossedColdThreshRepPeriod = state.dataHeatBalFanSys->CrossedColdThreshRepPeriod(ZoneNum, ReportPeriodIdx);
5808 0 : if (Temperature > ColdTempThresh) { // safe
5809 0 : if (!CrossedColdThreshRepPeriod) {
5810 : // compute the number of hours before threshold is reached
5811 0 : state.dataHeatBalFanSys->ZoneColdHourOfSafetyBinsRepPeriod(ZoneNum, ReportPeriodIdx)[0] += state.dataGlobal->TimeStepZone;
5812 : }
5813 : } else { // danger
5814 : // compute the total number of hours when the zone temperature falls in the dangerous range throughout the reporting period
5815 0 : state.dataHeatBalFanSys->ZoneColdHourOfSafetyBinsRepPeriod(ZoneNum, ReportPeriodIdx)[2] += state.dataGlobal->TimeStepZone;
5816 0 : state.dataHeatBalFanSys->ZoneColdHourOfSafetyBinsRepPeriod(ZoneNum, ReportPeriodIdx)[3] +=
5817 0 : NumOcc * state.dataGlobal->TimeStepZone;
5818 0 : state.dataHeatBalFanSys->ZoneColdHourOfSafetyBinsRepPeriod(ZoneNum, ReportPeriodIdx)[4] +=
5819 0 : (NumOcc > 0) * state.dataGlobal->TimeStepZone;
5820 : // first time crossing threshold
5821 0 : if (!CrossedColdThreshRepPeriod) {
5822 : // compute the time when the zone crosses the threshold temperature
5823 : int encodedMonDayHrMin;
5824 0 : General::EncodeMonDayHrMin(encodedMonDayHrMin,
5825 0 : state.dataEnvrn->Month,
5826 0 : state.dataEnvrn->DayOfMonth,
5827 0 : state.dataGlobal->HourOfDay,
5828 0 : state.dataGlobal->TimeStepZone * (state.dataGlobal->TimeStep - 1) * 60);
5829 : // fixme: not sure how to aggregate by zone
5830 0 : state.dataHeatBalFanSys->ZoneColdHourOfSafetyBinsRepPeriod(ZoneNum, ReportPeriodIdx)[1] = encodedMonDayHrMin;
5831 0 : CrossedColdThreshRepPeriod = true;
5832 : }
5833 : }
5834 0 : HeatTempThresh = state.dataHeatBal->People(iPeople).HeatStressTempThresh;
5835 0 : bool &CrossedHeatThreshRepPeriod = state.dataHeatBalFanSys->CrossedHeatThreshRepPeriod(ZoneNum, ReportPeriodIdx);
5836 0 : if (Temperature < HeatTempThresh) { // safe
5837 0 : if (!CrossedHeatThreshRepPeriod) {
5838 : // compute the number of hours before threshold is reached
5839 0 : state.dataHeatBalFanSys->ZoneHeatHourOfSafetyBinsRepPeriod(ZoneNum, ReportPeriodIdx)[0] += state.dataGlobal->TimeStepZone;
5840 : }
5841 : } else { // danger
5842 : // compute the total number of hours when the zone temperature falls in the dangerous range throughout the reporting period
5843 0 : state.dataHeatBalFanSys->ZoneHeatHourOfSafetyBinsRepPeriod(ZoneNum, ReportPeriodIdx)[2] += state.dataGlobal->TimeStepZone;
5844 0 : state.dataHeatBalFanSys->ZoneHeatHourOfSafetyBinsRepPeriod(ZoneNum, ReportPeriodIdx)[3] +=
5845 0 : NumOcc * state.dataGlobal->TimeStepZone;
5846 0 : state.dataHeatBalFanSys->ZoneHeatHourOfSafetyBinsRepPeriod(ZoneNum, ReportPeriodIdx)[4] +=
5847 0 : (NumOcc > 0) * state.dataGlobal->TimeStepZone;
5848 : // first time crossing threshold
5849 0 : if (!CrossedHeatThreshRepPeriod) {
5850 : // compute the time when the zone crosses the threshold temperature
5851 : int encodedMonDayHrMin;
5852 0 : General::EncodeMonDayHrMin(encodedMonDayHrMin,
5853 0 : state.dataEnvrn->Month,
5854 0 : state.dataEnvrn->DayOfMonth,
5855 0 : state.dataGlobal->HourOfDay,
5856 0 : state.dataGlobal->TimeStepZone * (state.dataGlobal->TimeStep - 1) * 60);
5857 0 : state.dataHeatBalFanSys->ZoneHeatHourOfSafetyBinsRepPeriod(ZoneNum, ReportPeriodIdx)[1] = encodedMonDayHrMin;
5858 0 : CrossedHeatThreshRepPeriod = true;
5859 : }
5860 : }
5861 :
5862 0 : Real64 VeryHotPMVThresh = 3.0;
5863 0 : Real64 WarmPMVThresh = 0.7;
5864 0 : Real64 CoolPMVThresh = -0.7;
5865 0 : Real64 VeryColdPMVThresh = -3.0;
5866 0 : Real64 PMV = state.dataThermalComforts->ThermalComfortData(iPeople).FangerPMV;
5867 0 : if (PMV < VeryColdPMVThresh) {
5868 0 : state.dataHeatBalFanSys->ZoneDiscomfortWtExceedOccuHourBinsRepPeriod(ZoneNum, ReportPeriodIdx)[0] +=
5869 0 : (VeryColdPMVThresh - PMV) * NumOcc * state.dataGlobal->TimeStepZone;
5870 0 : state.dataHeatBalFanSys->ZoneDiscomfortWtExceedOccupiedHourBinsRepPeriod(ZoneNum, ReportPeriodIdx)[0] +=
5871 0 : (VeryColdPMVThresh - PMV) * (NumOcc > 0) * state.dataGlobal->TimeStepZone;
5872 : }
5873 0 : if (PMV < CoolPMVThresh) {
5874 0 : state.dataHeatBalFanSys->ZoneDiscomfortWtExceedOccuHourBinsRepPeriod(ZoneNum, ReportPeriodIdx)[1] +=
5875 0 : (CoolPMVThresh - PMV) * NumOcc * state.dataGlobal->TimeStepZone;
5876 0 : state.dataHeatBalFanSys->ZoneDiscomfortWtExceedOccupiedHourBinsRepPeriod(ZoneNum, ReportPeriodIdx)[1] +=
5877 0 : (CoolPMVThresh - PMV) * (NumOcc > 0) * state.dataGlobal->TimeStepZone;
5878 : }
5879 0 : if (PMV > WarmPMVThresh) {
5880 0 : state.dataHeatBalFanSys->ZoneDiscomfortWtExceedOccuHourBinsRepPeriod(ZoneNum, ReportPeriodIdx)[2] +=
5881 0 : (PMV - WarmPMVThresh) * NumOcc * state.dataGlobal->TimeStepZone;
5882 0 : state.dataHeatBalFanSys->ZoneDiscomfortWtExceedOccupiedHourBinsRepPeriod(ZoneNum, ReportPeriodIdx)[2] +=
5883 0 : (PMV - WarmPMVThresh) * (NumOcc > 0) * state.dataGlobal->TimeStepZone;
5884 : }
5885 0 : if (PMV > VeryHotPMVThresh) {
5886 0 : state.dataHeatBalFanSys->ZoneDiscomfortWtExceedOccuHourBinsRepPeriod(ZoneNum, ReportPeriodIdx)[3] +=
5887 0 : (PMV - VeryHotPMVThresh) * NumOcc * state.dataGlobal->TimeStepZone;
5888 0 : state.dataHeatBalFanSys->ZoneDiscomfortWtExceedOccupiedHourBinsRepPeriod(ZoneNum, ReportPeriodIdx)[3] +=
5889 0 : (PMV - VeryHotPMVThresh) * (NumOcc > 0) * state.dataGlobal->TimeStepZone;
5890 : }
5891 : }
5892 : }
5893 : }
5894 491232 : for (int ZoneNum = 1; ZoneNum <= state.dataGlobal->NumOfZones; ++ZoneNum) {
5895 421056 : Real64 HI = state.dataHeatBal->Resilience(ZoneNum).ZoneHeatIndex;
5896 421056 : Real64 Humidex = state.dataHeatBal->Resilience(ZoneNum).ZoneHumidex;
5897 :
5898 421056 : Real64 NumOcc = state.dataHeatBal->Resilience(ZoneNum).ZoneNumOcc;
5899 421056 : if (HI <= 26.7) {
5900 405660 : state.dataHeatBal->Resilience(ZoneNum).ZoneHeatIndexHourBins[0] += state.dataGlobal->TimeStepZone;
5901 405660 : state.dataHeatBal->Resilience(ZoneNum).ZoneHeatIndexOccuHourBins[0] += NumOcc * state.dataGlobal->TimeStepZone;
5902 405660 : state.dataHeatBal->Resilience(ZoneNum).ZoneHeatIndexOccupiedHourBins[0] += (NumOcc > 0) * state.dataGlobal->TimeStepZone;
5903 15396 : } else if (HI > 26.7 && HI <= 32.2) {
5904 15275 : state.dataHeatBal->Resilience(ZoneNum).ZoneHeatIndexHourBins[1] += state.dataGlobal->TimeStepZone;
5905 15275 : state.dataHeatBal->Resilience(ZoneNum).ZoneHeatIndexOccuHourBins[1] += NumOcc * state.dataGlobal->TimeStepZone;
5906 15275 : state.dataHeatBal->Resilience(ZoneNum).ZoneHeatIndexOccupiedHourBins[1] += (NumOcc > 0) * state.dataGlobal->TimeStepZone;
5907 121 : } else if (HI > 32.2 && HI <= 39.4) {
5908 121 : state.dataHeatBal->Resilience(ZoneNum).ZoneHeatIndexHourBins[2] += state.dataGlobal->TimeStepZone;
5909 121 : state.dataHeatBal->Resilience(ZoneNum).ZoneHeatIndexOccuHourBins[2] += NumOcc * state.dataGlobal->TimeStepZone;
5910 121 : state.dataHeatBal->Resilience(ZoneNum).ZoneHeatIndexOccupiedHourBins[2] += (NumOcc > 0) * state.dataGlobal->TimeStepZone;
5911 0 : } else if (HI > 39.4 && HI <= 51.7) {
5912 0 : state.dataHeatBal->Resilience(ZoneNum).ZoneHeatIndexHourBins[3] += state.dataGlobal->TimeStepZone;
5913 0 : state.dataHeatBal->Resilience(ZoneNum).ZoneHeatIndexOccuHourBins[3] += NumOcc * state.dataGlobal->TimeStepZone;
5914 0 : state.dataHeatBal->Resilience(ZoneNum).ZoneHeatIndexOccupiedHourBins[3] += (NumOcc > 0) * state.dataGlobal->TimeStepZone;
5915 : } else {
5916 0 : state.dataHeatBal->Resilience(ZoneNum).ZoneHeatIndexHourBins[4] += state.dataGlobal->TimeStepZone;
5917 0 : state.dataHeatBal->Resilience(ZoneNum).ZoneHeatIndexOccuHourBins[4] += NumOcc * state.dataGlobal->TimeStepZone;
5918 0 : state.dataHeatBal->Resilience(ZoneNum).ZoneHeatIndexOccupiedHourBins[4] += (NumOcc > 0) * state.dataGlobal->TimeStepZone;
5919 : }
5920 :
5921 421056 : if (Humidex <= 29) {
5922 404701 : state.dataHeatBal->Resilience(ZoneNum).ZoneHumidexHourBins[0] += state.dataGlobal->TimeStepZone;
5923 404701 : state.dataHeatBal->Resilience(ZoneNum).ZoneHumidexOccuHourBins[0] += NumOcc * state.dataGlobal->TimeStepZone;
5924 404701 : state.dataHeatBal->Resilience(ZoneNum).ZoneHumidexOccupiedHourBins[0] += (NumOcc > 0) * state.dataGlobal->TimeStepZone;
5925 16355 : } else if (Humidex > 29 && Humidex <= 40) {
5926 16355 : state.dataHeatBal->Resilience(ZoneNum).ZoneHumidexHourBins[1] += state.dataGlobal->TimeStepZone;
5927 16355 : state.dataHeatBal->Resilience(ZoneNum).ZoneHumidexOccuHourBins[1] += NumOcc * state.dataGlobal->TimeStepZone;
5928 16355 : state.dataHeatBal->Resilience(ZoneNum).ZoneHumidexOccupiedHourBins[1] += (NumOcc > 0) * state.dataGlobal->TimeStepZone;
5929 0 : } else if (Humidex > 40 && Humidex <= 45) {
5930 0 : state.dataHeatBal->Resilience(ZoneNum).ZoneHumidexHourBins[2] += state.dataGlobal->TimeStepZone;
5931 0 : state.dataHeatBal->Resilience(ZoneNum).ZoneHumidexOccuHourBins[2] += NumOcc * state.dataGlobal->TimeStepZone;
5932 0 : state.dataHeatBal->Resilience(ZoneNum).ZoneHumidexOccupiedHourBins[2] += (NumOcc > 0) * state.dataGlobal->TimeStepZone;
5933 0 : } else if (Humidex > 45 && Humidex <= 50) {
5934 0 : state.dataHeatBal->Resilience(ZoneNum).ZoneHumidexHourBins[3] += state.dataGlobal->TimeStepZone;
5935 0 : state.dataHeatBal->Resilience(ZoneNum).ZoneHumidexOccuHourBins[3] += NumOcc * state.dataGlobal->TimeStepZone;
5936 0 : state.dataHeatBal->Resilience(ZoneNum).ZoneHumidexOccupiedHourBins[3] += (NumOcc > 0) * state.dataGlobal->TimeStepZone;
5937 : } else {
5938 0 : state.dataHeatBal->Resilience(ZoneNum).ZoneHumidexHourBins[4] += state.dataGlobal->TimeStepZone;
5939 0 : state.dataHeatBal->Resilience(ZoneNum).ZoneHumidexOccuHourBins[4] += NumOcc * state.dataGlobal->TimeStepZone;
5940 0 : state.dataHeatBal->Resilience(ZoneNum).ZoneHumidexOccupiedHourBins[4] += (NumOcc > 0) * state.dataGlobal->TimeStepZone;
5941 : }
5942 :
5943 421056 : Real64 Temperature = state.dataZoneTempPredictorCorrector->zoneHeatBalance(ZoneNum).ZTAV;
5944 421056 : Real64 CoolingSetpoint = state.dataHeatBalFanSys->ZoneThermostatSetPointHi(ZoneNum);
5945 421056 : Real64 HeatingSetpoint = state.dataHeatBalFanSys->ZoneThermostatSetPointLo(ZoneNum);
5946 :
5947 421056 : if ((CoolingSetpoint > 0) && (Temperature > CoolingSetpoint)) {
5948 8566 : state.dataHeatBal->Resilience(ZoneNum).ZoneUnmetDegreeHourBins[0] += (Temperature - CoolingSetpoint) * state.dataGlobal->TimeStepZone;
5949 8566 : state.dataHeatBal->Resilience(ZoneNum).ZoneUnmetDegreeHourBins[1] +=
5950 8566 : NumOcc * (Temperature - CoolingSetpoint) * state.dataGlobal->TimeStepZone;
5951 8566 : state.dataHeatBal->Resilience(ZoneNum).ZoneUnmetDegreeHourBins[2] +=
5952 8566 : (NumOcc > 0) * (Temperature - CoolingSetpoint) * state.dataGlobal->TimeStepZone;
5953 : }
5954 421056 : if ((HeatingSetpoint > 0) && (Temperature < HeatingSetpoint)) {
5955 16208 : state.dataHeatBal->Resilience(ZoneNum).ZoneUnmetDegreeHourBins[3] += (HeatingSetpoint - Temperature) * state.dataGlobal->TimeStepZone;
5956 16208 : state.dataHeatBal->Resilience(ZoneNum).ZoneUnmetDegreeHourBins[4] +=
5957 16208 : NumOcc * (HeatingSetpoint - Temperature) * state.dataGlobal->TimeStepZone;
5958 16208 : state.dataHeatBal->Resilience(ZoneNum).ZoneUnmetDegreeHourBins[5] +=
5959 16208 : (NumOcc > 0) * (HeatingSetpoint - Temperature) * state.dataGlobal->TimeStepZone;
5960 : }
5961 :
5962 421056 : if (state.dataHeatBalSurfMgr->hasPierceSET) {
5963 : int encodedMonDayHrMin;
5964 0 : Real64 PierceSET = state.dataHeatBal->Resilience(ZoneNum).ZonePierceSET;
5965 0 : Real64 PierceSETLast = state.dataHeatBal->Resilience(ZoneNum).ZonePierceSETLastStep;
5966 :
5967 0 : if (PierceSET <= 12.2) {
5968 0 : state.dataHeatBal->Resilience(ZoneNum).ZoneLowSETHours[0] += (12.2 - PierceSET) * state.dataGlobal->TimeStepZone;
5969 0 : state.dataHeatBal->Resilience(ZoneNum).ZoneLowSETHours[1] += (12.2 - PierceSET) * NumOcc * state.dataGlobal->TimeStepZone;
5970 0 : state.dataHeatBal->Resilience(ZoneNum).ZoneLowSETHours[2] += (12.2 - PierceSET) * (NumOcc > 0) * state.dataGlobal->TimeStepZone;
5971 : // Reset duration when last step is out of range.
5972 0 : if (PierceSETLast == -1 || PierceSETLast > 12.2) {
5973 0 : General::EncodeMonDayHrMin(encodedMonDayHrMin,
5974 0 : state.dataEnvrn->Month,
5975 0 : state.dataEnvrn->DayOfMonth,
5976 0 : state.dataGlobal->HourOfDay,
5977 0 : state.dataGlobal->TimeStepZone * (state.dataGlobal->TimeStep - 1) * 60);
5978 0 : state.dataHeatBalSurfMgr->lowSETLongestHours[ZoneNum - 1] = 0;
5979 0 : state.dataHeatBalSurfMgr->lowSETLongestStart[ZoneNum - 1] = encodedMonDayHrMin;
5980 : }
5981 : // Keep the longest duration record.
5982 0 : state.dataHeatBalSurfMgr->lowSETLongestHours[ZoneNum - 1] += state.dataGlobal->TimeStepZone;
5983 0 : if (state.dataHeatBalSurfMgr->lowSETLongestHours[ZoneNum - 1] > state.dataHeatBal->Resilience(ZoneNum).ZoneLowSETHours[3] &&
5984 0 : state.dataHeatBal->Resilience(ZoneNum).ZoneNumOcc > 0) {
5985 0 : state.dataHeatBal->Resilience(ZoneNum).ZoneLowSETHours[3] = state.dataHeatBalSurfMgr->lowSETLongestHours[ZoneNum - 1];
5986 0 : state.dataHeatBal->Resilience(ZoneNum).ZoneLowSETHours[4] = state.dataHeatBalSurfMgr->lowSETLongestStart[ZoneNum - 1];
5987 : }
5988 0 : } else if (PierceSET > 30) {
5989 0 : state.dataHeatBal->Resilience(ZoneNum).ZoneHighSETHours[0] += (PierceSET - 30) * state.dataGlobal->TimeStepZone;
5990 0 : state.dataHeatBal->Resilience(ZoneNum).ZoneHighSETHours[1] += (PierceSET - 30) * NumOcc * state.dataGlobal->TimeStepZone;
5991 0 : state.dataHeatBal->Resilience(ZoneNum).ZoneHighSETHours[2] += (PierceSET - 30) * (NumOcc > 0) * state.dataGlobal->TimeStepZone;
5992 0 : if (PierceSETLast == -1 || PierceSETLast <= 30) {
5993 0 : General::EncodeMonDayHrMin(encodedMonDayHrMin,
5994 0 : state.dataEnvrn->Month,
5995 0 : state.dataEnvrn->DayOfMonth,
5996 0 : state.dataGlobal->HourOfDay,
5997 0 : state.dataGlobal->TimeStepZone * (state.dataGlobal->TimeStep - 1) * 60);
5998 0 : state.dataHeatBalSurfMgr->highSETLongestHours[ZoneNum - 1] = 0;
5999 0 : state.dataHeatBalSurfMgr->highSETLongestStart[ZoneNum - 1] = encodedMonDayHrMin;
6000 : }
6001 0 : state.dataHeatBalSurfMgr->highSETLongestHours[ZoneNum - 1] += state.dataGlobal->TimeStepZone;
6002 0 : if (state.dataHeatBalSurfMgr->highSETLongestHours[ZoneNum - 1] > state.dataHeatBal->Resilience(ZoneNum).ZoneHighSETHours[3] &&
6003 0 : state.dataHeatBal->Resilience(ZoneNum).ZoneNumOcc > 0) {
6004 0 : state.dataHeatBal->Resilience(ZoneNum).ZoneHighSETHours[3] = state.dataHeatBalSurfMgr->highSETLongestHours[ZoneNum - 1];
6005 0 : state.dataHeatBal->Resilience(ZoneNum).ZoneHighSETHours[4] = state.dataHeatBalSurfMgr->highSETLongestStart[ZoneNum - 1];
6006 : }
6007 : }
6008 :
6009 0 : if (state.dataHeatBal->Resilience(ZoneNum).ZoneNumOcc == 0) {
6010 0 : state.dataHeatBalSurfMgr->lowSETLongestHours[ZoneNum - 1] = 0;
6011 0 : state.dataHeatBalSurfMgr->highSETLongestHours[ZoneNum - 1] = 0;
6012 : }
6013 : }
6014 :
6015 421056 : for (int i = 1; i <= state.dataWeatherManager->TotThermalReportPers; i++) {
6016 0 : if (reportPeriodFlags(i)) {
6017 0 : int ReportPeriodIdx = i;
6018 :
6019 0 : if (HI <= 26.7) {
6020 0 : state.dataHeatBalFanSys->ZoneHeatIndexHourBinsRepPeriod(ZoneNum, ReportPeriodIdx)[0] += state.dataGlobal->TimeStepZone;
6021 0 : state.dataHeatBalFanSys->ZoneHeatIndexOccuHourBinsRepPeriod(ZoneNum, ReportPeriodIdx)[0] +=
6022 0 : NumOcc * state.dataGlobal->TimeStepZone;
6023 0 : state.dataHeatBalFanSys->ZoneHeatIndexOccupiedHourBinsRepPeriod(ZoneNum, ReportPeriodIdx)[0] +=
6024 0 : (NumOcc > 0) * state.dataGlobal->TimeStepZone;
6025 0 : } else if (HI > 26.7 && HI <= 32.2) {
6026 0 : state.dataHeatBalFanSys->ZoneHeatIndexHourBinsRepPeriod(ZoneNum, ReportPeriodIdx)[1] += state.dataGlobal->TimeStepZone;
6027 0 : state.dataHeatBalFanSys->ZoneHeatIndexOccuHourBinsRepPeriod(ZoneNum, ReportPeriodIdx)[1] +=
6028 0 : NumOcc * state.dataGlobal->TimeStepZone;
6029 0 : state.dataHeatBalFanSys->ZoneHeatIndexOccupiedHourBinsRepPeriod(ZoneNum, ReportPeriodIdx)[1] +=
6030 0 : (NumOcc > 0) * state.dataGlobal->TimeStepZone;
6031 0 : } else if (HI > 32.2 && HI <= 39.4) {
6032 0 : state.dataHeatBalFanSys->ZoneHeatIndexHourBinsRepPeriod(ZoneNum, ReportPeriodIdx)[2] += state.dataGlobal->TimeStepZone;
6033 0 : state.dataHeatBalFanSys->ZoneHeatIndexOccuHourBinsRepPeriod(ZoneNum, ReportPeriodIdx)[2] +=
6034 0 : NumOcc * state.dataGlobal->TimeStepZone;
6035 0 : state.dataHeatBalFanSys->ZoneHeatIndexOccupiedHourBinsRepPeriod(ZoneNum, ReportPeriodIdx)[2] +=
6036 0 : (NumOcc > 0) * state.dataGlobal->TimeStepZone;
6037 0 : } else if (HI > 39.4 && HI <= 51.7) {
6038 0 : state.dataHeatBalFanSys->ZoneHeatIndexHourBinsRepPeriod(ZoneNum, ReportPeriodIdx)[3] += state.dataGlobal->TimeStepZone;
6039 0 : state.dataHeatBalFanSys->ZoneHeatIndexOccuHourBinsRepPeriod(ZoneNum, ReportPeriodIdx)[3] +=
6040 0 : NumOcc * state.dataGlobal->TimeStepZone;
6041 0 : state.dataHeatBalFanSys->ZoneHeatIndexOccupiedHourBinsRepPeriod(ZoneNum, ReportPeriodIdx)[3] +=
6042 0 : (NumOcc > 0) * state.dataGlobal->TimeStepZone;
6043 : } else {
6044 0 : state.dataHeatBalFanSys->ZoneHeatIndexHourBinsRepPeriod(ZoneNum, ReportPeriodIdx)[4] += state.dataGlobal->TimeStepZone;
6045 0 : state.dataHeatBalFanSys->ZoneHeatIndexOccuHourBinsRepPeriod(ZoneNum, ReportPeriodIdx)[4] +=
6046 0 : NumOcc * state.dataGlobal->TimeStepZone;
6047 0 : state.dataHeatBalFanSys->ZoneHeatIndexOccupiedHourBinsRepPeriod(ZoneNum, ReportPeriodIdx)[4] +=
6048 0 : (NumOcc > 0) * state.dataGlobal->TimeStepZone;
6049 : }
6050 :
6051 0 : if (Humidex <= 29) {
6052 0 : state.dataHeatBalFanSys->ZoneHumidexHourBinsRepPeriod(ZoneNum, ReportPeriodIdx)[0] += state.dataGlobal->TimeStepZone;
6053 0 : state.dataHeatBalFanSys->ZoneHumidexOccuHourBinsRepPeriod(ZoneNum, ReportPeriodIdx)[0] +=
6054 0 : NumOcc * state.dataGlobal->TimeStepZone;
6055 0 : state.dataHeatBalFanSys->ZoneHumidexOccupiedHourBinsRepPeriod(ZoneNum, ReportPeriodIdx)[0] +=
6056 0 : (NumOcc > 0) * state.dataGlobal->TimeStepZone;
6057 0 : } else if (Humidex > 29 && Humidex <= 40) {
6058 0 : state.dataHeatBalFanSys->ZoneHumidexHourBinsRepPeriod(ZoneNum, ReportPeriodIdx)[1] += state.dataGlobal->TimeStepZone;
6059 0 : state.dataHeatBalFanSys->ZoneHumidexOccuHourBinsRepPeriod(ZoneNum, ReportPeriodIdx)[1] +=
6060 0 : NumOcc * state.dataGlobal->TimeStepZone;
6061 0 : state.dataHeatBalFanSys->ZoneHumidexOccupiedHourBinsRepPeriod(ZoneNum, ReportPeriodIdx)[1] +=
6062 0 : (NumOcc > 0) * state.dataGlobal->TimeStepZone;
6063 0 : } else if (Humidex > 40 && Humidex <= 45) {
6064 0 : state.dataHeatBalFanSys->ZoneHumidexHourBinsRepPeriod(ZoneNum, ReportPeriodIdx)[2] += state.dataGlobal->TimeStepZone;
6065 0 : state.dataHeatBalFanSys->ZoneHumidexOccuHourBinsRepPeriod(ZoneNum, ReportPeriodIdx)[2] +=
6066 0 : NumOcc * state.dataGlobal->TimeStepZone;
6067 0 : state.dataHeatBalFanSys->ZoneHumidexOccupiedHourBinsRepPeriod(ZoneNum, ReportPeriodIdx)[2] +=
6068 0 : (NumOcc > 0) * state.dataGlobal->TimeStepZone;
6069 0 : } else if (Humidex > 45 && Humidex <= 50) {
6070 0 : state.dataHeatBalFanSys->ZoneHumidexHourBinsRepPeriod(ZoneNum, ReportPeriodIdx)[3] += state.dataGlobal->TimeStepZone;
6071 0 : state.dataHeatBalFanSys->ZoneHumidexOccuHourBinsRepPeriod(ZoneNum, ReportPeriodIdx)[3] +=
6072 0 : NumOcc * state.dataGlobal->TimeStepZone;
6073 0 : state.dataHeatBalFanSys->ZoneHumidexOccupiedHourBinsRepPeriod(ZoneNum, ReportPeriodIdx)[3] +=
6074 0 : (NumOcc > 0) * state.dataGlobal->TimeStepZone;
6075 : } else {
6076 0 : state.dataHeatBalFanSys->ZoneHumidexHourBinsRepPeriod(ZoneNum, ReportPeriodIdx)[4] += state.dataGlobal->TimeStepZone;
6077 0 : state.dataHeatBalFanSys->ZoneHumidexOccuHourBinsRepPeriod(ZoneNum, ReportPeriodIdx)[4] +=
6078 0 : NumOcc * state.dataGlobal->TimeStepZone;
6079 0 : state.dataHeatBalFanSys->ZoneHumidexOccupiedHourBinsRepPeriod(ZoneNum, ReportPeriodIdx)[4] +=
6080 0 : (NumOcc > 0) * state.dataGlobal->TimeStepZone;
6081 : }
6082 :
6083 0 : if (state.dataHeatBalSurfMgr->hasPierceSET) {
6084 : int encodedMonDayHrMin;
6085 0 : Real64 PierceSET = state.dataHeatBal->Resilience(ZoneNum).ZonePierceSET;
6086 0 : Real64 PierceSETLast = state.dataHeatBal->Resilience(ZoneNum).ZonePierceSETLastStep;
6087 0 : if (PierceSET <= 12.2) {
6088 0 : state.dataHeatBalFanSys->ZoneLowSETHoursRepPeriod(ZoneNum, ReportPeriodIdx)[0] +=
6089 0 : (12.2 - PierceSET) * state.dataGlobal->TimeStepZone;
6090 0 : state.dataHeatBalFanSys->ZoneLowSETHoursRepPeriod(ZoneNum, ReportPeriodIdx)[1] +=
6091 0 : (12.2 - PierceSET) * NumOcc * state.dataGlobal->TimeStepZone;
6092 0 : state.dataHeatBalFanSys->ZoneLowSETHoursRepPeriod(ZoneNum, ReportPeriodIdx)[2] +=
6093 0 : (12.2 - PierceSET) * (NumOcc > 0) * state.dataGlobal->TimeStepZone;
6094 : // Reset duration when last step is out of range
6095 0 : if (PierceSETLast == -1 || PierceSETLast > 12.2) {
6096 0 : General::EncodeMonDayHrMin(encodedMonDayHrMin,
6097 0 : state.dataEnvrn->Month,
6098 0 : state.dataEnvrn->DayOfMonth,
6099 0 : state.dataGlobal->HourOfDay,
6100 0 : state.dataGlobal->TimeStepZone * (state.dataGlobal->TimeStep - 1) * 60);
6101 0 : state.dataHeatBalFanSys->lowSETLongestHoursRepPeriod(ZoneNum, ReportPeriodIdx) = 0;
6102 0 : state.dataHeatBalFanSys->lowSETLongestStartRepPeriod(ZoneNum, ReportPeriodIdx) = encodedMonDayHrMin;
6103 0 : } else if (General::isReportPeriodBeginning(state, ReportPeriodIdx)) { // or when it is the start of the period
6104 0 : General::EncodeMonDayHrMin(encodedMonDayHrMin,
6105 0 : state.dataEnvrn->Month,
6106 0 : state.dataEnvrn->DayOfMonth,
6107 0 : state.dataGlobal->HourOfDay,
6108 0 : state.dataGlobal->TimeStepZone * state.dataGlobal->TimeStep * 60);
6109 0 : state.dataHeatBalFanSys->highSETLongestHoursRepPeriod(ZoneNum, ReportPeriodIdx) = 0;
6110 0 : state.dataHeatBalFanSys->highSETLongestStartRepPeriod(ZoneNum, ReportPeriodIdx) = encodedMonDayHrMin;
6111 : }
6112 : // Keep the longest duration record.
6113 0 : state.dataHeatBalFanSys->lowSETLongestHoursRepPeriod(ZoneNum, ReportPeriodIdx) += state.dataGlobal->TimeStepZone;
6114 0 : if (state.dataHeatBalFanSys->lowSETLongestHoursRepPeriod(ZoneNum, ReportPeriodIdx) >
6115 0 : state.dataHeatBalFanSys->ZoneLowSETHoursRepPeriod(ZoneNum, ReportPeriodIdx)[3] &&
6116 0 : state.dataHeatBal->Resilience(ZoneNum).ZoneNumOcc > 0) {
6117 0 : state.dataHeatBalFanSys->ZoneLowSETHoursRepPeriod(ZoneNum, ReportPeriodIdx)[3] =
6118 0 : state.dataHeatBalFanSys->lowSETLongestHoursRepPeriod(ZoneNum, ReportPeriodIdx);
6119 0 : state.dataHeatBalFanSys->ZoneLowSETHoursRepPeriod(ZoneNum, ReportPeriodIdx)[4] =
6120 0 : state.dataHeatBalFanSys->lowSETLongestStartRepPeriod(ZoneNum, ReportPeriodIdx);
6121 : }
6122 0 : } else if (PierceSET > 30) {
6123 0 : state.dataHeatBalFanSys->ZoneHighSETHoursRepPeriod(ZoneNum, ReportPeriodIdx)[0] +=
6124 0 : (PierceSET - 30) * state.dataGlobal->TimeStepZone;
6125 0 : state.dataHeatBalFanSys->ZoneHighSETHoursRepPeriod(ZoneNum, ReportPeriodIdx)[1] +=
6126 0 : (PierceSET - 30) * NumOcc * state.dataGlobal->TimeStepZone;
6127 0 : state.dataHeatBalFanSys->ZoneHighSETHoursRepPeriod(ZoneNum, ReportPeriodIdx)[2] +=
6128 0 : (PierceSET - 30) * (NumOcc > 0) * state.dataGlobal->TimeStepZone;
6129 : // Reset duration when last step is out of range.
6130 0 : if (PierceSETLast == -1 || PierceSETLast <= 30) {
6131 0 : General::EncodeMonDayHrMin(encodedMonDayHrMin,
6132 0 : state.dataEnvrn->Month,
6133 0 : state.dataEnvrn->DayOfMonth,
6134 0 : state.dataGlobal->HourOfDay,
6135 0 : state.dataGlobal->TimeStepZone * (state.dataGlobal->TimeStep - 1) * 60);
6136 0 : state.dataHeatBalFanSys->highSETLongestHoursRepPeriod(ZoneNum, ReportPeriodIdx) = 0;
6137 0 : state.dataHeatBalFanSys->highSETLongestStartRepPeriod(ZoneNum, ReportPeriodIdx) = encodedMonDayHrMin;
6138 0 : } else if (General::isReportPeriodBeginning(state, ReportPeriodIdx)) { // or when it is the start of the period
6139 0 : General::EncodeMonDayHrMin(encodedMonDayHrMin,
6140 0 : state.dataEnvrn->Month,
6141 0 : state.dataEnvrn->DayOfMonth,
6142 0 : state.dataGlobal->HourOfDay,
6143 0 : state.dataGlobal->TimeStepZone * state.dataGlobal->TimeStep * 60);
6144 0 : state.dataHeatBalFanSys->highSETLongestHoursRepPeriod(ZoneNum, ReportPeriodIdx) = 0;
6145 0 : state.dataHeatBalFanSys->highSETLongestStartRepPeriod(ZoneNum, ReportPeriodIdx) = encodedMonDayHrMin;
6146 : }
6147 0 : state.dataHeatBalFanSys->highSETLongestHoursRepPeriod(ZoneNum, ReportPeriodIdx) += state.dataGlobal->TimeStepZone;
6148 0 : if (state.dataHeatBalFanSys->highSETLongestHoursRepPeriod(ZoneNum, ReportPeriodIdx) >
6149 0 : state.dataHeatBalFanSys->ZoneHighSETHoursRepPeriod(ZoneNum, ReportPeriodIdx)[3] &&
6150 0 : state.dataHeatBal->Resilience(ZoneNum).ZoneNumOcc > 0) {
6151 0 : state.dataHeatBalFanSys->ZoneHighSETHoursRepPeriod(ZoneNum, ReportPeriodIdx)[3] =
6152 0 : state.dataHeatBalFanSys->highSETLongestHoursRepPeriod(ZoneNum, ReportPeriodIdx);
6153 0 : state.dataHeatBalFanSys->ZoneHighSETHoursRepPeriod(ZoneNum, ReportPeriodIdx)[4] =
6154 0 : state.dataHeatBalFanSys->highSETLongestStartRepPeriod(ZoneNum, ReportPeriodIdx);
6155 : }
6156 : }
6157 0 : if (state.dataHeatBal->Resilience(ZoneNum).ZoneNumOcc == 0) {
6158 0 : state.dataHeatBalFanSys->lowSETLongestHoursRepPeriod(ZoneNum, ReportPeriodIdx) = 0;
6159 0 : state.dataHeatBalFanSys->highSETLongestHoursRepPeriod(ZoneNum, ReportPeriodIdx) = 0;
6160 : }
6161 : }
6162 :
6163 0 : Real64 Temperature = state.dataZoneTempPredictorCorrector->zoneHeatBalance(ZoneNum).ZTAV;
6164 0 : Real64 CoolingSetpoint = state.dataHeatBalFanSys->ZoneThermostatSetPointHi(ZoneNum);
6165 0 : Real64 HeatingSetpoint = state.dataHeatBalFanSys->ZoneThermostatSetPointLo(ZoneNum);
6166 :
6167 0 : if ((CoolingSetpoint > 0) && (Temperature > CoolingSetpoint)) {
6168 0 : state.dataHeatBalFanSys->ZoneUnmetDegreeHourBinsRepPeriod(ZoneNum, ReportPeriodIdx)[0] +=
6169 0 : (Temperature - CoolingSetpoint) * state.dataGlobal->TimeStepZone;
6170 0 : state.dataHeatBalFanSys->ZoneUnmetDegreeHourBinsRepPeriod(ZoneNum, ReportPeriodIdx)[1] +=
6171 0 : NumOcc * (Temperature - CoolingSetpoint) * state.dataGlobal->TimeStepZone;
6172 0 : state.dataHeatBalFanSys->ZoneUnmetDegreeHourBinsRepPeriod(ZoneNum, ReportPeriodIdx)[2] +=
6173 0 : (NumOcc > 0) * (Temperature - CoolingSetpoint) * state.dataGlobal->TimeStepZone;
6174 : }
6175 0 : if ((HeatingSetpoint > 0) && (Temperature < HeatingSetpoint)) {
6176 0 : state.dataHeatBalFanSys->ZoneUnmetDegreeHourBinsRepPeriod(ZoneNum, ReportPeriodIdx)[3] +=
6177 0 : (HeatingSetpoint - Temperature) * state.dataGlobal->TimeStepZone;
6178 0 : state.dataHeatBalFanSys->ZoneUnmetDegreeHourBinsRepPeriod(ZoneNum, ReportPeriodIdx)[4] +=
6179 0 : NumOcc * (HeatingSetpoint - Temperature) * state.dataGlobal->TimeStepZone;
6180 0 : state.dataHeatBalFanSys->ZoneUnmetDegreeHourBinsRepPeriod(ZoneNum, ReportPeriodIdx)[5] +=
6181 0 : (NumOcc > 0) * (HeatingSetpoint - Temperature) * state.dataGlobal->TimeStepZone;
6182 : }
6183 : }
6184 : }
6185 : } // loop over zones
6186 : }
6187 942558 : }
6188 :
6189 17922 : void ReportCO2Resilience(EnergyPlusData &state)
6190 : {
6191 17922 : int NoBins = 3;
6192 17922 : if (state.dataHeatBalSurfMgr->reportCO2ResilienceFirstTime) {
6193 4109 : for (int ZoneNum = 1; ZoneNum <= state.dataGlobal->NumOfZones; ++ZoneNum) {
6194 3456 : for (int i = 1; i <= state.dataWeatherManager->TotCO2ReportPers; i++) {
6195 3 : state.dataHeatBalFanSys->ZoneCO2LevelHourBinsRepPeriod(ZoneNum, i).assign(NoBins, 0.0);
6196 3 : state.dataHeatBalFanSys->ZoneCO2LevelOccuHourBinsRepPeriod(ZoneNum, i).assign(NoBins, 0.0);
6197 3 : state.dataHeatBalFanSys->ZoneCO2LevelOccupiedHourBinsRepPeriod(ZoneNum, i).assign(NoBins, 0.0);
6198 : }
6199 : }
6200 656 : state.dataHeatBalSurfMgr->reportCO2ResilienceFirstTime = false;
6201 656 : if (!state.dataContaminantBalance->Contaminant.CO2Simulation) {
6202 642 : if (state.dataOutRptTab->displayCO2ResilienceSummaryExplicitly) {
6203 0 : ShowWarningError(state,
6204 : "Writing Annual CO2 Resilience Summary - CO2 Level Hours reports: "
6205 : "Zone Air CO2 Concentration output is required, "
6206 : "but no ZoneAirContaminantBalance object is defined.");
6207 : }
6208 642 : state.dataOutRptTab->displayCO2ResilienceSummary = false;
6209 642 : return;
6210 : }
6211 : }
6212 :
6213 17280 : if (DataGlobalConstants::KindOfSim::RunPeriodWeather == state.dataGlobal->KindOfSim && !state.dataGlobal->WarmupFlag) {
6214 0 : for (int iPeople = 1; iPeople <= state.dataHeatBal->TotPeople; ++iPeople) {
6215 0 : int ZoneNum = state.dataHeatBal->People(iPeople).ZonePtr;
6216 0 : state.dataHeatBal->Resilience(ZoneNum).ZoneNumOcc = state.dataHeatBal->People(iPeople).NumberOfPeople *
6217 0 : GetCurrentScheduleValue(state, state.dataHeatBal->People(iPeople).NumberOfPeoplePtr);
6218 : }
6219 :
6220 0 : Array1D_bool reportPeriodFlags;
6221 0 : if (state.dataWeatherManager->TotReportPers > 0) {
6222 0 : reportPeriodFlags.dimension(state.dataWeatherManager->TotCO2ReportPers, false);
6223 0 : General::findReportPeriodIdx(
6224 0 : state, state.dataWeatherManager->CO2ReportPeriodInput, state.dataWeatherManager->TotCO2ReportPers, reportPeriodFlags);
6225 : }
6226 :
6227 0 : auto &ort(state.dataOutRptTab);
6228 0 : for (int i = 1; i <= state.dataWeatherManager->TotCO2ReportPers; i++) {
6229 0 : if (reportPeriodFlags(i)) {
6230 0 : int curResMeterNumber = ort->meterNumTotalsBEPS(1);
6231 0 : state.dataWeatherManager->CO2ReportPeriodInput(i).totalElectricityUse += GetCurrentMeterValue(state, curResMeterNumber);
6232 : }
6233 : }
6234 :
6235 0 : for (int ZoneNum = 1; ZoneNum <= state.dataGlobal->NumOfZones; ++ZoneNum) {
6236 0 : Real64 ZoneAirCO2 = state.dataContaminantBalance->ZoneAirCO2Avg(ZoneNum);
6237 :
6238 0 : Real64 NumOcc = state.dataHeatBal->Resilience(ZoneNum).ZoneNumOcc;
6239 0 : if (ZoneAirCO2 <= 1000) {
6240 0 : state.dataHeatBal->Resilience(ZoneNum).ZoneCO2LevelHourBins[0] += state.dataGlobal->TimeStepZone;
6241 0 : state.dataHeatBal->Resilience(ZoneNum).ZoneCO2LevelOccuHourBins[0] += NumOcc * state.dataGlobal->TimeStepZone;
6242 0 : state.dataHeatBal->Resilience(ZoneNum).ZoneCO2LevelOccupiedHourBins[0] += (NumOcc > 0) * state.dataGlobal->TimeStepZone;
6243 0 : } else if (ZoneAirCO2 > 1000 && ZoneAirCO2 <= 5000) {
6244 0 : state.dataHeatBal->Resilience(ZoneNum).ZoneCO2LevelHourBins[1] += state.dataGlobal->TimeStepZone;
6245 0 : state.dataHeatBal->Resilience(ZoneNum).ZoneCO2LevelOccuHourBins[1] += NumOcc * state.dataGlobal->TimeStepZone;
6246 0 : state.dataHeatBal->Resilience(ZoneNum).ZoneCO2LevelOccupiedHourBins[1] += (NumOcc > 0) * state.dataGlobal->TimeStepZone;
6247 : } else {
6248 0 : state.dataHeatBal->Resilience(ZoneNum).ZoneCO2LevelHourBins[2] += state.dataGlobal->TimeStepZone;
6249 0 : state.dataHeatBal->Resilience(ZoneNum).ZoneCO2LevelOccuHourBins[2] += NumOcc * state.dataGlobal->TimeStepZone;
6250 0 : state.dataHeatBal->Resilience(ZoneNum).ZoneCO2LevelOccupiedHourBins[2] += (NumOcc > 0) * state.dataGlobal->TimeStepZone;
6251 : }
6252 0 : for (int i = 1; i <= state.dataWeatherManager->TotCO2ReportPers; i++) {
6253 0 : if (reportPeriodFlags(i)) {
6254 0 : int ReportPeriodIdx = i;
6255 0 : if (ZoneAirCO2 <= 1000) {
6256 0 : state.dataHeatBalFanSys->ZoneCO2LevelHourBinsRepPeriod(ZoneNum, ReportPeriodIdx)[0] += state.dataGlobal->TimeStepZone;
6257 0 : state.dataHeatBalFanSys->ZoneCO2LevelOccuHourBinsRepPeriod(ZoneNum, ReportPeriodIdx)[0] +=
6258 0 : NumOcc * state.dataGlobal->TimeStepZone;
6259 0 : state.dataHeatBalFanSys->ZoneCO2LevelOccupiedHourBinsRepPeriod(ZoneNum, ReportPeriodIdx)[0] +=
6260 0 : (NumOcc > 0) * state.dataGlobal->TimeStepZone;
6261 0 : } else if (ZoneAirCO2 > 1000 && ZoneAirCO2 <= 5000) {
6262 0 : state.dataHeatBalFanSys->ZoneCO2LevelHourBinsRepPeriod(ZoneNum, ReportPeriodIdx)[1] += state.dataGlobal->TimeStepZone;
6263 0 : state.dataHeatBalFanSys->ZoneCO2LevelOccuHourBinsRepPeriod(ZoneNum, ReportPeriodIdx)[1] +=
6264 0 : NumOcc * state.dataGlobal->TimeStepZone;
6265 0 : state.dataHeatBalFanSys->ZoneCO2LevelOccupiedHourBinsRepPeriod(ZoneNum, ReportPeriodIdx)[1] +=
6266 0 : (NumOcc > 0) * state.dataGlobal->TimeStepZone;
6267 : } else {
6268 0 : state.dataHeatBalFanSys->ZoneCO2LevelHourBinsRepPeriod(ZoneNum, ReportPeriodIdx)[2] += state.dataGlobal->TimeStepZone;
6269 0 : state.dataHeatBalFanSys->ZoneCO2LevelOccuHourBinsRepPeriod(ZoneNum, ReportPeriodIdx)[2] +=
6270 0 : NumOcc * state.dataGlobal->TimeStepZone;
6271 0 : state.dataHeatBalFanSys->ZoneCO2LevelOccupiedHourBinsRepPeriod(ZoneNum, ReportPeriodIdx)[2] +=
6272 0 : (NumOcc > 0) * state.dataGlobal->TimeStepZone;
6273 : }
6274 : }
6275 : }
6276 : }
6277 : } // loop over zones
6278 : }
6279 :
6280 90411 : void ReportVisualResilience(EnergyPlusData &state)
6281 : {
6282 90411 : int NoBins = 4;
6283 90411 : if (state.dataHeatBalSurfMgr->reportVisualResilienceFirstTime) {
6284 4109 : for (int ZoneNum = 1; ZoneNum <= state.dataGlobal->NumOfZones; ++ZoneNum) {
6285 3456 : for (int i = 1; i <= state.dataWeatherManager->TotVisualReportPers; i++) {
6286 3 : state.dataHeatBalFanSys->ZoneLightingLevelHourBinsRepPeriod(ZoneNum, i).assign(NoBins, 0.0);
6287 3 : state.dataHeatBalFanSys->ZoneLightingLevelOccuHourBinsRepPeriod(ZoneNum, i).assign(NoBins, 0.0);
6288 3 : state.dataHeatBalFanSys->ZoneLightingLevelOccupiedHourBinsRepPeriod(ZoneNum, i).assign(NoBins, 0.0);
6289 : }
6290 : }
6291 656 : state.dataHeatBalSurfMgr->reportVisualResilienceFirstTime = false;
6292 656 : if ((int)state.dataDaylightingData->daylightControl.size() == 0) {
6293 603 : if (state.dataOutRptTab->displayVisualResilienceSummaryExplicitly) {
6294 0 : ShowWarningError(state,
6295 : "Writing Annual Visual Resilience Summary - Lighting Level Hours reports: "
6296 : "Zone Average Daylighting Reference Point Illuminance output is required, "
6297 : "but no Daylighting Control Object is defined.");
6298 : }
6299 603 : state.dataOutRptTab->displayVisualResilienceSummary = false;
6300 603 : return;
6301 : }
6302 : }
6303 :
6304 89808 : if (DataGlobalConstants::KindOfSim::RunPeriodWeather == state.dataGlobal->KindOfSim && !state.dataGlobal->WarmupFlag) {
6305 0 : for (int iPeople = 1; iPeople <= state.dataHeatBal->TotPeople; ++iPeople) {
6306 0 : int ZoneNum = state.dataHeatBal->People(iPeople).ZonePtr;
6307 0 : state.dataHeatBal->Resilience(ZoneNum).ZoneNumOcc = state.dataHeatBal->People(iPeople).NumberOfPeople *
6308 0 : GetCurrentScheduleValue(state, state.dataHeatBal->People(iPeople).NumberOfPeoplePtr);
6309 : }
6310 : // Accumulate across daylighting controls first
6311 0 : for (int ZoneNum = 1; ZoneNum <= state.dataGlobal->NumOfZones; ++ZoneNum) {
6312 0 : state.dataDaylightingData->ZoneDaylight(ZoneNum).zoneAvgIllumSum = 0.0;
6313 : }
6314 0 : for (int daylightCtrlNum = 1; daylightCtrlNum <= (int)state.dataDaylightingData->daylightControl.size(); ++daylightCtrlNum) {
6315 0 : auto &thisDaylightControl = state.dataDaylightingData->daylightControl(daylightCtrlNum);
6316 0 : if (thisDaylightControl.PowerReductionFactor > 0) {
6317 0 : for (int refPt = 1; refPt <= thisDaylightControl.TotalDaylRefPoints; ++refPt) {
6318 0 : state.dataDaylightingData->ZoneDaylight(thisDaylightControl.zoneIndex).zoneAvgIllumSum +=
6319 0 : thisDaylightControl.IllumSetPoint(refPt);
6320 : }
6321 : } else {
6322 0 : for (int refPt = 1; refPt <= thisDaylightControl.TotalDaylRefPoints; ++refPt) {
6323 0 : state.dataDaylightingData->ZoneDaylight(thisDaylightControl.zoneIndex).zoneAvgIllumSum +=
6324 0 : thisDaylightControl.DaylIllumAtRefPt(refPt);
6325 : }
6326 : }
6327 : }
6328 :
6329 0 : Array1D_bool reportPeriodFlags;
6330 0 : if (state.dataWeatherManager->TotReportPers > 0) {
6331 0 : reportPeriodFlags.dimension(state.dataWeatherManager->TotVisualReportPers, false);
6332 0 : General::findReportPeriodIdx(
6333 0 : state, state.dataWeatherManager->VisualReportPeriodInput, state.dataWeatherManager->TotVisualReportPers, reportPeriodFlags);
6334 : }
6335 :
6336 0 : auto &ort(state.dataOutRptTab);
6337 0 : for (int i = 1; i <= state.dataWeatherManager->TotVisualReportPers; i++) {
6338 0 : if (reportPeriodFlags(i)) {
6339 0 : int curResMeterNumber = ort->meterNumTotalsBEPS(1);
6340 0 : state.dataWeatherManager->VisualReportPeriodInput(i).totalElectricityUse += GetCurrentMeterValue(state, curResMeterNumber);
6341 : }
6342 : }
6343 :
6344 0 : for (int ZoneNum = 1; ZoneNum <= state.dataGlobal->NumOfZones; ++ZoneNum) {
6345 0 : if (state.dataDaylightingData->ZoneDaylight(ZoneNum).totRefPts == 0) continue;
6346 : // Now divide by total reference points to get average
6347 : Real64 avgZoneIllum =
6348 0 : state.dataDaylightingData->ZoneDaylight(ZoneNum).zoneAvgIllumSum / state.dataDaylightingData->ZoneDaylight(ZoneNum).totRefPts;
6349 :
6350 0 : Real64 NumOcc = state.dataHeatBal->Resilience(ZoneNum).ZoneNumOcc;
6351 0 : if (avgZoneIllum <= 100) {
6352 0 : state.dataHeatBal->Resilience(ZoneNum).ZoneLightingLevelHourBins[0] += state.dataGlobal->TimeStepZone;
6353 0 : state.dataHeatBal->Resilience(ZoneNum).ZoneLightingLevelOccuHourBins[0] += NumOcc * state.dataGlobal->TimeStepZone;
6354 0 : state.dataHeatBal->Resilience(ZoneNum).ZoneLightingLevelOccupiedHourBins[0] += (NumOcc > 0) * state.dataGlobal->TimeStepZone;
6355 0 : } else if (avgZoneIllum > 100 && avgZoneIllum <= 300) {
6356 0 : state.dataHeatBal->Resilience(ZoneNum).ZoneLightingLevelHourBins[1] += state.dataGlobal->TimeStepZone;
6357 0 : state.dataHeatBal->Resilience(ZoneNum).ZoneLightingLevelOccuHourBins[1] += NumOcc * state.dataGlobal->TimeStepZone;
6358 0 : state.dataHeatBal->Resilience(ZoneNum).ZoneLightingLevelOccupiedHourBins[1] += (NumOcc > 0) * state.dataGlobal->TimeStepZone;
6359 0 : } else if (avgZoneIllum > 300 && avgZoneIllum <= 500) {
6360 0 : state.dataHeatBal->Resilience(ZoneNum).ZoneLightingLevelHourBins[2] += state.dataGlobal->TimeStepZone;
6361 0 : state.dataHeatBal->Resilience(ZoneNum).ZoneLightingLevelOccuHourBins[2] += NumOcc * state.dataGlobal->TimeStepZone;
6362 0 : state.dataHeatBal->Resilience(ZoneNum).ZoneLightingLevelOccupiedHourBins[2] += (NumOcc > 0) * state.dataGlobal->TimeStepZone;
6363 : } else {
6364 0 : state.dataHeatBal->Resilience(ZoneNum).ZoneLightingLevelHourBins[3] += state.dataGlobal->TimeStepZone;
6365 0 : state.dataHeatBal->Resilience(ZoneNum).ZoneLightingLevelOccuHourBins[3] += NumOcc * state.dataGlobal->TimeStepZone;
6366 0 : state.dataHeatBal->Resilience(ZoneNum).ZoneLightingLevelOccupiedHourBins[3] += (NumOcc > 0) * state.dataGlobal->TimeStepZone;
6367 : }
6368 0 : for (int i = 1; i <= state.dataWeatherManager->TotVisualReportPers; i++) {
6369 0 : if (reportPeriodFlags(i)) {
6370 0 : int ReportPeriodIdx = i;
6371 0 : if (avgZoneIllum <= 100) {
6372 0 : state.dataHeatBalFanSys->ZoneLightingLevelHourBinsRepPeriod(ZoneNum, ReportPeriodIdx)[0] += state.dataGlobal->TimeStepZone;
6373 0 : state.dataHeatBalFanSys->ZoneLightingLevelOccuHourBinsRepPeriod(ZoneNum, ReportPeriodIdx)[0] +=
6374 0 : NumOcc * state.dataGlobal->TimeStepZone;
6375 0 : state.dataHeatBalFanSys->ZoneLightingLevelOccupiedHourBinsRepPeriod(ZoneNum, ReportPeriodIdx)[0] +=
6376 0 : (NumOcc > 0) * state.dataGlobal->TimeStepZone;
6377 0 : } else if (avgZoneIllum > 100 && avgZoneIllum <= 300) {
6378 0 : state.dataHeatBalFanSys->ZoneLightingLevelHourBinsRepPeriod(ZoneNum, ReportPeriodIdx)[1] += state.dataGlobal->TimeStepZone;
6379 0 : state.dataHeatBalFanSys->ZoneLightingLevelOccuHourBinsRepPeriod(ZoneNum, ReportPeriodIdx)[1] +=
6380 0 : NumOcc * state.dataGlobal->TimeStepZone;
6381 0 : state.dataHeatBalFanSys->ZoneLightingLevelOccupiedHourBinsRepPeriod(ZoneNum, ReportPeriodIdx)[1] +=
6382 0 : (NumOcc > 0) * state.dataGlobal->TimeStepZone;
6383 0 : } else if (avgZoneIllum > 300 && avgZoneIllum <= 500) {
6384 0 : state.dataHeatBalFanSys->ZoneLightingLevelHourBinsRepPeriod(ZoneNum, ReportPeriodIdx)[2] += state.dataGlobal->TimeStepZone;
6385 0 : state.dataHeatBalFanSys->ZoneLightingLevelOccuHourBinsRepPeriod(ZoneNum, ReportPeriodIdx)[2] +=
6386 0 : NumOcc * state.dataGlobal->TimeStepZone;
6387 0 : state.dataHeatBalFanSys->ZoneLightingLevelOccupiedHourBinsRepPeriod(ZoneNum, ReportPeriodIdx)[2] +=
6388 0 : (NumOcc > 0) * state.dataGlobal->TimeStepZone;
6389 : } else {
6390 0 : state.dataHeatBalFanSys->ZoneLightingLevelHourBinsRepPeriod(ZoneNum, ReportPeriodIdx)[3] += state.dataGlobal->TimeStepZone;
6391 0 : state.dataHeatBalFanSys->ZoneLightingLevelOccuHourBinsRepPeriod(ZoneNum, ReportPeriodIdx)[3] +=
6392 0 : NumOcc * state.dataGlobal->TimeStepZone;
6393 0 : state.dataHeatBalFanSys->ZoneLightingLevelOccupiedHourBinsRepPeriod(ZoneNum, ReportPeriodIdx)[3] +=
6394 0 : (NumOcc > 0) * state.dataGlobal->TimeStepZone;
6395 : }
6396 : }
6397 : }
6398 : }
6399 : } // loop over zones
6400 : }
6401 :
6402 2568313 : void ReportSurfaceHeatBalance(EnergyPlusData &state)
6403 : {
6404 :
6405 : // SUBROUTINE INFORMATION:
6406 : // AUTHOR Linda Lawrie
6407 : // DATE WRITTEN Oct 2000
6408 :
6409 : // PURPOSE OF THIS SUBROUTINE:
6410 : // This subroutine puts the reporting part of the HBSurface Module in one area.
6411 :
6412 : using SolarShading::ReportSurfaceShading;
6413 2568313 : ReportSurfaceShading(state);
6414 :
6415 2568313 : if (state.dataSurface->UseRepresentativeSurfaceCalculations) {
6416 687 : ReportNonRepresentativeSurfaceResults(state);
6417 : }
6418 :
6419 : // Set derived surface output variables and other record keeping - after iterations are complete - all HT surfaces
6420 :
6421 : // Opaque or window surfaces
6422 21013702 : for (int zoneNum = 1; zoneNum <= state.dataGlobal->NumOfZones; ++zoneNum) {
6423 36906954 : for (int spaceNum : state.dataHeatBal->Zone(zoneNum).spaceIndexes) {
6424 18461565 : auto &thisSpace = state.dataHeatBal->space(spaceNum);
6425 18461565 : int const firstSurf = thisSpace.OpaqOrWinSurfaceFirst;
6426 18461565 : int const lastSurf = thisSpace.OpaqOrWinSurfaceLast;
6427 178164273 : for (int surfNum = firstSurf; surfNum <= lastSurf; ++surfNum) {
6428 159702708 : auto &surface(state.dataSurface->Surface(surfNum));
6429 : // Inside Face Convection - sign convention is positive means energy going into inside face from the air.
6430 159702708 : state.dataHeatBalSurf->SurfQdotConvInRep(surfNum) = surface.Area * state.dataHeatBalSurf->SurfQdotConvInPerArea(surfNum);
6431 159702708 : state.dataHeatBalSurf->SurfQConvInReport(surfNum) =
6432 159702708 : state.dataHeatBalSurf->SurfQdotConvInRep(surfNum) * state.dataGlobal->TimeStepZoneSec;
6433 :
6434 159702708 : state.dataHeatBalSurf->SurfQdotRadNetSurfInRep(surfNum) = state.dataHeatBalSurf->SurfQdotRadNetLWInPerArea(surfNum) * surface.Area;
6435 159702708 : state.dataHeatBalSurf->SurfQRadNetSurfInReport(surfNum) =
6436 159702708 : state.dataHeatBalSurf->SurfQdotRadNetSurfInRep(surfNum) * state.dataGlobal->TimeStepZoneSec;
6437 :
6438 159702708 : state.dataHeatBalSurf->SurfQdotRadIntGainsInRep(surfNum) = state.dataHeatBal->SurfQdotRadIntGainsInPerArea(surfNum) * surface.Area;
6439 159702708 : state.dataHeatBalSurf->SurfQRadIntGainsInReport(surfNum) =
6440 159702708 : state.dataHeatBalSurf->SurfQdotRadIntGainsInRep(surfNum) * state.dataGlobal->TimeStepZoneSec;
6441 :
6442 159702708 : state.dataHeatBalSurf->SurfQdotRadHVACInRep(surfNum) = state.dataHeatBalSurf->SurfQdotRadHVACInPerArea(surfNum) * surface.Area;
6443 159702708 : state.dataHeatBalSurf->SurfQRadHVACInReport(surfNum) =
6444 159702708 : state.dataHeatBalSurf->SurfQdotRadHVACInRep(surfNum) * state.dataGlobal->TimeStepZoneSec;
6445 :
6446 159702708 : state.dataHeatBalSurf->SurfQdotConvOutRep(surfNum) = state.dataHeatBalSurf->SurfQdotConvOutPerArea(surfNum) * surface.Area;
6447 :
6448 159702708 : state.dataHeatBalSurf->SurfQConvOutReport(surfNum) =
6449 159702708 : state.dataHeatBalSurf->SurfQdotConvOutRep(surfNum) * state.dataGlobal->TimeStepZoneSec;
6450 :
6451 159702708 : state.dataHeatBalSurf->SurfQdotRadOutRep(surfNum) = state.dataHeatBalSurf->SurfQdotRadOutRepPerArea(surfNum) * surface.Area;
6452 159702708 : state.dataHeatBalSurf->SurfQRadOutReport(surfNum) =
6453 159702708 : state.dataHeatBalSurf->SurfQdotRadOutRep(surfNum) * state.dataGlobal->TimeStepZoneSec;
6454 :
6455 : // Calculate surface heat emission to the air, positive values indicates heat transfer from surface to the outside
6456 159702708 : state.dataHeatBalSurf->SurfQAirExtReport(surfNum) =
6457 319405416 : surface.Area * state.dataHeatBalSurf->SurfHAirExt(surfNum) *
6458 159702708 : (state.dataHeatBalSurf->SurfTempOut(surfNum) - state.dataSurface->SurfOutDryBulbTemp(surfNum));
6459 :
6460 : // Subtract since SurfQdotConvOutRep's convention is opposite (positive values indicate heat transfer from the outside to the surface)
6461 159702708 : state.dataHeatBalSurf->SurfQHeatEmiReport(surfNum) =
6462 159702708 : state.dataHeatBalSurf->SurfQAirExtReport(surfNum) - state.dataHeatBalSurf->SurfQdotConvOutRep(surfNum);
6463 : }
6464 : }
6465 : }
6466 :
6467 2568313 : if (state.dataOutRptTab->displayHeatEmissionsSummary) {
6468 938622 : state.dataHeatBalSurf->SumSurfaceHeatEmission = 0.0;
6469 42240186 : for (int SurfNum = 1; SurfNum <= state.dataSurface->TotSurfaces; ++SurfNum) {
6470 41301564 : if (state.dataSurface->Surface(SurfNum).ExtBoundCond == ExternalEnvironment) {
6471 19251810 : state.dataHeatBalSurf->SumSurfaceHeatEmission +=
6472 19251810 : state.dataHeatBalSurf->SurfQHeatEmiReport(SurfNum) * state.dataGlobal->TimeStepZoneSec;
6473 : }
6474 : }
6475 : }
6476 :
6477 : // Window surfaces
6478 21013702 : for (int zoneNum = 1; zoneNum <= state.dataGlobal->NumOfZones; ++zoneNum) {
6479 36906954 : for (int spaceNum : state.dataHeatBal->Zone(zoneNum).spaceIndexes) {
6480 18461565 : auto &thisSpace = state.dataHeatBal->space(spaceNum);
6481 18461565 : int const firstSurf = thisSpace.WindowSurfaceFirst;
6482 18461565 : int const lastSurf = thisSpace.WindowSurfaceLast;
6483 40471659 : for (int surfNum = firstSurf; surfNum <= lastSurf; ++surfNum) {
6484 22010094 : auto &surface(state.dataSurface->Surface(surfNum));
6485 22010094 : state.dataHeatBal->SurfWinInitialDifSolInTransReport(surfNum) =
6486 22010094 : state.dataHeatBalSurf->SurfWinInitialDifSolInTrans(surfNum) * surface.Area;
6487 :
6488 : // Absorbed short wave radiation
6489 : int TotGlassLayers;
6490 22010094 : int const constrNum = state.dataSurface->SurfActiveConstruction(surfNum);
6491 22010094 : int const constrNumSh = state.dataSurface->SurfWinActiveShadedConstruction(surfNum);
6492 22010094 : WinShadingType ShadeFlag = state.dataSurface->SurfWinShadingFlag(surfNum);
6493 22010094 : if (state.dataSurface->SurfWinWindowModelType(surfNum) == WindowModel::EQL) {
6494 8109 : TotGlassLayers = state.dataWindowEquivLayer->CFS(state.dataConstruction->Construct(constrNum).EQLConsPtr).NL;
6495 22001985 : } else if (state.dataSurface->SurfWinWindowModelType(surfNum) == WindowModel::BSDF) {
6496 39540 : TotGlassLayers = state.dataConstruction->Construct(constrNum).TotSolidLayers;
6497 21962445 : } else if (NOT_SHADED(ShadeFlag) || ShadeFlag == WinShadingType::SwitchableGlazing) {
6498 21888080 : TotGlassLayers = state.dataConstruction->Construct(constrNum).TotGlassLayers;
6499 : } else {
6500 : // Interior, exterior or between-glass shade, screen or blind in place
6501 74365 : TotGlassLayers = state.dataConstruction->Construct(constrNumSh).TotGlassLayers;
6502 : }
6503 22010094 : state.dataHeatBal->SurfWinSWwinAbsTotalReport(surfNum) = 0.0;
6504 22010094 : state.dataHeatBal->SurfSWInAbsTotalReport(surfNum) = 0.0;
6505 22010094 : state.dataHeatBal->SurfInitialDifSolInAbsReport(surfNum) = 0.0;
6506 50535204 : for (int lay = 1; lay <= TotGlassLayers; ++lay) {
6507 : // Initial Transmitted Diffuse Solar Absorbed on Inside of Surface[W]
6508 28525110 : state.dataHeatBal->SurfInitialDifSolInAbsReport(surfNum) +=
6509 28525110 : state.dataHeatBal->SurfWinInitialDifSolwinAbs(surfNum, lay) * surface.Area;
6510 : // Total Shortwave Radiation Absorbed on Inside of Surface[W]
6511 28525110 : state.dataHeatBal->SurfSWInAbsTotalReport(surfNum) += state.dataHeatBal->SurfWinQRadSWwinAbs(surfNum, lay) * surface.Area;
6512 : // Total Shortwave Absorbed:All solid Layers[W]
6513 28525110 : state.dataHeatBal->SurfWinSWwinAbsTotalReport(surfNum) += state.dataHeatBal->SurfWinQRadSWwinAbs(surfNum, lay) * surface.Area;
6514 : }
6515 :
6516 : // Window heat gain/loss
6517 22010094 : if (state.dataSurface->SurfWinHeatGain(surfNum) >= 0.0) {
6518 7593707 : state.dataSurface->SurfWinHeatGainRep(surfNum) = state.dataSurface->SurfWinHeatGain(surfNum);
6519 7593707 : state.dataSurface->SurfWinHeatGainRepEnergy(surfNum) =
6520 7593707 : state.dataSurface->SurfWinHeatGainRep(surfNum) * state.dataGlobal->TimeStepZoneSec;
6521 : } else {
6522 14416387 : state.dataSurface->SurfWinHeatLossRep(surfNum) = -state.dataSurface->SurfWinHeatGain(surfNum);
6523 14416387 : state.dataSurface->SurfWinHeatLossRepEnergy(surfNum) =
6524 14416387 : state.dataSurface->SurfWinHeatLossRep(surfNum) * state.dataGlobal->TimeStepZoneSec;
6525 : }
6526 22010094 : state.dataSurface->SurfWinHeatTransferRepEnergy(surfNum) =
6527 22010094 : state.dataSurface->SurfWinHeatGain(surfNum) * state.dataGlobal->TimeStepZoneSec;
6528 22010094 : if (state.dataSurface->SurfWinOriginalClass(surfNum) == DataSurfaces::SurfaceClass::TDD_Diffuser) { // Tubular daylighting device
6529 4050 : int pipeNum = state.dataSurface->SurfWinTDDPipeNum(surfNum);
6530 4050 : state.dataDaylightingDevicesData->TDDPipe(pipeNum).HeatGain = state.dataSurface->SurfWinHeatGainRep(surfNum);
6531 4050 : state.dataDaylightingDevicesData->TDDPipe(pipeNum).HeatLoss = state.dataSurface->SurfWinHeatLossRep(surfNum);
6532 : }
6533 : }
6534 : }
6535 : }
6536 :
6537 2568313 : if (state.dataSurface->AnyMovableInsulation) ReportIntMovInsInsideSurfTemp(state);
6538 :
6539 : // Opaque heat transfer surfaces
6540 21013702 : for (int zoneNum = 1; zoneNum <= state.dataGlobal->NumOfZones; ++zoneNum) {
6541 36906954 : for (int spaceNum : state.dataHeatBal->Zone(zoneNum).spaceIndexes) {
6542 18461565 : auto &thisSpace = state.dataHeatBal->space(spaceNum);
6543 18461565 : int const firstSurf = thisSpace.OpaqOrIntMassSurfaceFirst;
6544 18461565 : int const lastSurf = thisSpace.OpaqOrIntMassSurfaceLast;
6545 156154179 : for (int surfNum = firstSurf; surfNum <= lastSurf; ++surfNum) {
6546 137692614 : auto &surface(state.dataSurface->Surface(surfNum));
6547 :
6548 137692614 : state.dataHeatBal->SurfOpaqSWOutAbsTotalReport(surfNum) = state.dataHeatBalSurf->SurfOpaqQRadSWOutAbs(surfNum) * surface.Area;
6549 137692614 : state.dataHeatBal->SurfOpaqSWOutAbsEnergyReport(surfNum) =
6550 137692614 : state.dataHeatBal->SurfOpaqSWOutAbsTotalReport(surfNum) * state.dataGlobal->TimeStepZoneSec;
6551 :
6552 137692614 : state.dataHeatBalSurf->SurfQdotRadSolarInRep(surfNum) = state.dataHeatBalSurf->SurfQdotRadSolarInRepPerArea(surfNum) * surface.Area;
6553 137692614 : state.dataHeatBalSurf->SurfQRadSolarInReport(surfNum) =
6554 137692614 : state.dataHeatBalSurf->SurfQdotRadSolarInRep(surfNum) * state.dataGlobal->TimeStepZoneSec;
6555 :
6556 137692614 : state.dataHeatBalSurf->SurfQdotRadLightsInRep(surfNum) = state.dataHeatBalSurf->SurfQdotRadLightsInPerArea(surfNum) * surface.Area;
6557 137692614 : state.dataHeatBalSurf->SurfQRadLightsInReport(surfNum) =
6558 137692614 : state.dataHeatBalSurf->SurfQdotRadLightsInRep(surfNum) * state.dataGlobal->TimeStepZoneSec;
6559 :
6560 : // Initial Transmitted Diffuse Solar Absorbed on Inside of Surface[W]
6561 137692614 : state.dataHeatBal->SurfInitialDifSolInAbsReport(surfNum) = state.dataHeatBalSurf->SurfOpaqInitialDifSolInAbs(surfNum) * surface.Area;
6562 : // Total Shortwave Radiation Absorbed on Inside of Surface[W]
6563 137692614 : state.dataHeatBal->SurfSWInAbsTotalReport(surfNum) = state.dataHeatBalSurf->SurfOpaqQRadSWInAbs(surfNum) * surface.Area;
6564 :
6565 : // inside face conduction updates
6566 137692614 : state.dataHeatBalSurf->SurfOpaqInsFaceCond(surfNum) = state.dataHeatBalSurf->SurfOpaqInsFaceCondFlux(surfNum) * surface.Area;
6567 137692614 : state.dataHeatBalSurf->SurfOpaqInsFaceCondEnergy(surfNum) =
6568 137692614 : state.dataHeatBalSurf->SurfOpaqInsFaceCond(surfNum) * state.dataGlobal->TimeStepZoneSec;
6569 137692614 : state.dataHeatBalSurf->SurfOpaqInsFaceCondGainRep(surfNum) = 0.0;
6570 137692614 : state.dataHeatBalSurf->SurfOpaqInsFaceCondLossRep(surfNum) = 0.0;
6571 137692614 : if (state.dataHeatBalSurf->SurfOpaqInsFaceCond(surfNum) >= 0.0) {
6572 66732264 : state.dataHeatBalSurf->SurfOpaqInsFaceCondGainRep(surfNum) = state.dataHeatBalSurf->SurfOpaqInsFaceCond(surfNum);
6573 : } else {
6574 70960350 : state.dataHeatBalSurf->SurfOpaqInsFaceCondLossRep(surfNum) = -state.dataHeatBalSurf->SurfOpaqInsFaceCond(surfNum);
6575 : }
6576 :
6577 : // outside face conduction updates
6578 137692614 : state.dataHeatBalSurf->SurfOpaqOutFaceCond(surfNum) = surface.Area * state.dataHeatBalSurf->SurfOpaqOutFaceCondFlux(surfNum);
6579 137692614 : state.dataHeatBalSurf->SurfOpaqOutFaceCondEnergy(surfNum) =
6580 137692614 : state.dataHeatBalSurf->SurfOpaqOutFaceCond(surfNum) * state.dataGlobal->TimeStepZoneSec;
6581 137692614 : state.dataHeatBalSurf->SurfOpaqExtFaceCondGainRep(surfNum) = 0.0;
6582 137692614 : state.dataHeatBalSurf->SurfOpaqExtFaceCondLossRep(surfNum) = 0.0;
6583 137692614 : if (state.dataHeatBalSurf->SurfOpaqOutFaceCond(surfNum) >= 0.0) {
6584 125475815 : state.dataHeatBalSurf->SurfOpaqExtFaceCondGainRep(surfNum) = state.dataHeatBalSurf->SurfOpaqOutFaceCond(surfNum);
6585 : } else {
6586 12216799 : state.dataHeatBalSurf->SurfOpaqExtFaceCondLossRep(surfNum) = -state.dataHeatBalSurf->SurfOpaqOutFaceCond(surfNum);
6587 : }
6588 : }
6589 156154179 : for (int surfNum = firstSurf; surfNum <= lastSurf; ++surfNum) {
6590 : // do average surface conduction updates
6591 :
6592 137692614 : state.dataHeatBalSurf->SurfOpaqAvgFaceCond(surfNum) =
6593 137692614 : (state.dataHeatBalSurf->SurfOpaqInsFaceCond(surfNum) - state.dataHeatBalSurf->SurfOpaqOutFaceCond(surfNum)) / 2.0;
6594 137692614 : state.dataHeatBalSurf->SurfOpaqAvgFaceCondFlux(surfNum) =
6595 137692614 : (state.dataHeatBalSurf->SurfOpaqInsFaceCondFlux(surfNum) - state.dataHeatBalSurf->SurfOpaqOutFaceCondFlux(surfNum)) / 2.0;
6596 137692614 : state.dataHeatBalSurf->SurfOpaqAvgFaceCondEnergy(surfNum) =
6597 137692614 : state.dataHeatBalSurf->SurfOpaqAvgFaceCond(surfNum) * state.dataGlobal->TimeStepZoneSec;
6598 137692614 : state.dataHeatBalSurf->SurfOpaqAvgFaceCondGainRep(surfNum) = 0.0;
6599 137692614 : state.dataHeatBalSurf->SurfOpaqAvgFaceCondLossRep(surfNum) = 0.0;
6600 137692614 : if (state.dataHeatBalSurf->SurfOpaqAvgFaceCond(surfNum) >= 0.0) {
6601 62194916 : state.dataHeatBalSurf->SurfOpaqAvgFaceCondGainRep(surfNum) = state.dataHeatBalSurf->SurfOpaqAvgFaceCond(surfNum);
6602 : } else {
6603 75497698 : state.dataHeatBalSurf->SurfOpaqAvgFaceCondLossRep(surfNum) = -state.dataHeatBalSurf->SurfOpaqAvgFaceCond(surfNum);
6604 : }
6605 :
6606 : // do surface storage rate updates
6607 137692614 : state.dataHeatBalSurf->SurfOpaqStorageCondFlux(surfNum) =
6608 137692614 : -(state.dataHeatBalSurf->SurfOpaqInsFaceCondFlux(surfNum) + state.dataHeatBalSurf->SurfOpaqOutFaceCondFlux(surfNum));
6609 137692614 : state.dataHeatBalSurf->SurfOpaqStorageCond(surfNum) =
6610 137692614 : -(state.dataHeatBalSurf->SurfOpaqInsFaceCond(surfNum) + state.dataHeatBalSurf->SurfOpaqOutFaceCond(surfNum));
6611 137692614 : state.dataHeatBalSurf->SurfOpaqStorageCondEnergy(surfNum) =
6612 137692614 : state.dataHeatBalSurf->SurfOpaqStorageCond(surfNum) * state.dataGlobal->TimeStepZoneSec;
6613 137692614 : state.dataHeatBalSurf->SurfOpaqStorageCondGainRep(surfNum) = 0.0;
6614 137692614 : state.dataHeatBalSurf->SurfOpaqStorageCondLossRep(surfNum) = 0.0;
6615 137692614 : if (state.dataHeatBalSurf->SurfOpaqStorageCond(surfNum) >= 0.0) {
6616 59137366 : state.dataHeatBalSurf->SurfOpaqStorageCondGainRep(surfNum) = state.dataHeatBalSurf->SurfOpaqStorageCond(surfNum);
6617 : } else {
6618 78555248 : state.dataHeatBalSurf->SurfOpaqStorageCondLossRep(surfNum) = -state.dataHeatBalSurf->SurfOpaqStorageCond(surfNum);
6619 : }
6620 : }
6621 : }
6622 : }
6623 :
6624 2568313 : if (state.dataGlobal->ZoneSizingCalc && state.dataGlobal->CompLoadReportIsReq) {
6625 61962 : int TimeStepInDay = (state.dataGlobal->HourOfDay - 1) * state.dataGlobal->NumOfTimeStepInHour + state.dataGlobal->TimeStep;
6626 433734 : for (int zoneNum = 1; zoneNum <= state.dataGlobal->NumOfZones; ++zoneNum) {
6627 754320 : for (int spaceNum : state.dataHeatBal->Zone(zoneNum).spaceIndexes) {
6628 382548 : auto &thisSpace = state.dataHeatBal->space(spaceNum);
6629 382548 : int firstSurf = thisSpace.OpaqOrIntMassSurfaceFirst;
6630 382548 : int lastSurf = thisSpace.OpaqOrIntMassSurfaceLast;
6631 2863722 : for (int surfNum = firstSurf; surfNum <= lastSurf; ++surfNum) {
6632 2481174 : state.dataOutRptTab->lightSWRadSeq(state.dataSize->CurOverallSimDay, TimeStepInDay, surfNum) =
6633 2481174 : state.dataHeatBalSurf->SurfQdotRadLightsInRep(surfNum);
6634 2481174 : state.dataOutRptTab->feneSolarRadSeq(state.dataSize->CurOverallSimDay, TimeStepInDay, surfNum) =
6635 2481174 : state.dataHeatBalSurf->SurfQdotRadSolarInRep(surfNum);
6636 : }
6637 382548 : firstSurf = thisSpace.OpaqOrWinSurfaceFirst;
6638 382548 : lastSurf = thisSpace.OpaqOrWinSurfaceLast;
6639 3235494 : for (int surfNum = firstSurf; surfNum <= lastSurf; ++surfNum) {
6640 2852946 : auto &surface(state.dataSurface->Surface(surfNum));
6641 2852946 : if (!state.dataGlobal->WarmupFlag) {
6642 406656 : if (state.dataGlobal->isPulseZoneSizing) {
6643 203328 : state.dataOutRptTab->loadConvectedWithPulse(state.dataSize->CurOverallSimDay, TimeStepInDay, surfNum) =
6644 203328 : state.dataHeatBalSurf->SurfQdotConvInRep(surfNum);
6645 : } else {
6646 203328 : state.dataOutRptTab->loadConvectedNormal(state.dataSize->CurOverallSimDay, TimeStepInDay, surfNum) =
6647 203328 : state.dataHeatBalSurf->SurfQdotConvInRep(surfNum);
6648 203328 : state.dataOutRptTab->netSurfRadSeq(state.dataSize->CurOverallSimDay, TimeStepInDay, surfNum) =
6649 203328 : state.dataHeatBalSurf->SurfQdotRadNetLWInPerArea(surfNum) * surface.Area;
6650 : }
6651 : }
6652 : }
6653 : }
6654 : }
6655 : }
6656 :
6657 2568313 : if (state.dataGlobal->DisplayAdvancedReportVariables) {
6658 498258 : for (int zoneNum = 1; zoneNum <= state.dataGlobal->NumOfZones; ++zoneNum) {
6659 753216 : for (int spaceNum : state.dataHeatBal->Zone(zoneNum).spaceIndexes) {
6660 376608 : auto &thisSpace = state.dataHeatBal->space(spaceNum);
6661 376608 : int const firstSurf = thisSpace.OpaqOrIntMassSurfaceFirst;
6662 376608 : int const lastSurf = thisSpace.OpaqOrIntMassSurfaceLast;
6663 3062631 : for (int surfNum = firstSurf; surfNum <= lastSurf; ++surfNum) {
6664 2686023 : state.dataHeatBal->ZoneOpaqSurfInsFaceCond(zoneNum) += state.dataHeatBalSurf->SurfOpaqInsFaceCond(surfNum);
6665 2686023 : state.dataHeatBal->ZoneOpaqSurfExtFaceCond(zoneNum) += state.dataHeatBalSurf->SurfOpaqOutFaceCond(surfNum);
6666 : }
6667 376608 : if (state.dataHeatBal->ZoneOpaqSurfInsFaceCond(zoneNum) >= 0.0) {
6668 172700 : state.dataHeatBal->ZoneOpaqSurfInsFaceCondGainRep(zoneNum) = state.dataHeatBal->ZoneOpaqSurfInsFaceCond(zoneNum);
6669 172700 : state.dataHeatBal->ZnOpqSurfInsFaceCondGnRepEnrg(zoneNum) =
6670 172700 : state.dataHeatBal->ZoneOpaqSurfInsFaceCondGainRep(zoneNum) * state.dataGlobal->TimeStepZoneSec;
6671 : } else {
6672 203908 : state.dataHeatBal->ZoneOpaqSurfInsFaceCondLossRep(zoneNum) = -state.dataHeatBal->ZoneOpaqSurfInsFaceCond(zoneNum);
6673 203908 : state.dataHeatBal->ZnOpqSurfInsFaceCondLsRepEnrg(zoneNum) =
6674 203908 : state.dataHeatBal->ZoneOpaqSurfInsFaceCondLossRep(zoneNum) * state.dataGlobal->TimeStepZoneSec;
6675 : }
6676 :
6677 376608 : if (state.dataHeatBal->ZoneOpaqSurfExtFaceCond(zoneNum) >= 0.0) {
6678 244893 : state.dataHeatBal->ZoneOpaqSurfExtFaceCondGainRep(zoneNum) = state.dataHeatBal->ZoneOpaqSurfExtFaceCond(zoneNum);
6679 244893 : state.dataHeatBal->ZnOpqSurfExtFaceCondGnRepEnrg(zoneNum) =
6680 244893 : state.dataHeatBal->ZoneOpaqSurfExtFaceCondGainRep(zoneNum) * state.dataGlobal->TimeStepZoneSec;
6681 : } else {
6682 131715 : state.dataHeatBal->ZoneOpaqSurfExtFaceCondLossRep(zoneNum) = -state.dataHeatBal->ZoneOpaqSurfExtFaceCond(zoneNum);
6683 131715 : state.dataHeatBal->ZnOpqSurfExtFaceCondLsRepEnrg(zoneNum) =
6684 131715 : state.dataHeatBal->ZoneOpaqSurfExtFaceCondLossRep(zoneNum) * state.dataGlobal->TimeStepZoneSec;
6685 : }
6686 : }
6687 : }
6688 : }
6689 2568313 : }
6690 :
6691 687 : void ReportNonRepresentativeSurfaceResults(EnergyPlusData &state)
6692 : {
6693 32289 : for (int zoneNum = 1; zoneNum <= state.dataGlobal->NumOfZones; ++zoneNum) {
6694 63204 : for (int spaceNum : state.dataHeatBal->Zone(zoneNum).spaceIndexes) {
6695 31602 : auto &thisSpace = state.dataHeatBal->space(spaceNum);
6696 : // Heat transfer surfaces
6697 31602 : int firstSurf = thisSpace.HTSurfaceFirst;
6698 31602 : int lastSurf = thisSpace.HTSurfaceLast;
6699 429375 : for (int surfNum = firstSurf; surfNum <= lastSurf; ++surfNum) {
6700 397773 : auto &surface(state.dataSurface->Surface(surfNum));
6701 397773 : int repSurfNum = surface.RepresentativeCalcSurfNum;
6702 397773 : if (surfNum != repSurfNum) {
6703 89997 : state.dataSurface->SurfIntConvClassificationRpt(surfNum) = state.dataSurface->SurfIntConvClassificationRpt(repSurfNum);
6704 89997 : state.dataSurface->SurfOutConvClassificationRpt(surfNum) = state.dataSurface->SurfOutConvClassificationRpt(repSurfNum);
6705 : }
6706 : }
6707 :
6708 : // Windows
6709 31602 : if (state.dataGlobal->DisplayAdvancedReportVariables) {
6710 0 : firstSurf = thisSpace.WindowSurfaceFirst;
6711 0 : lastSurf = thisSpace.WindowSurfaceLast;
6712 0 : for (int surfNum = firstSurf; surfNum <= lastSurf; ++surfNum) {
6713 0 : auto &surface(state.dataSurface->Surface(surfNum));
6714 0 : int repSurfNum = surface.RepresentativeCalcSurfNum;
6715 0 : if (surfNum != repSurfNum) {
6716 0 : auto areaRatio = surface.Area / state.dataSurface->Surface(surfNum).Area;
6717 0 : state.dataSurface->SurfWinGainConvGlazToZoneRep(surfNum) =
6718 0 : state.dataSurface->SurfWinGainConvGlazToZoneRep(repSurfNum) * areaRatio;
6719 0 : state.dataSurface->SurfWinGainIRGlazToZoneRep(surfNum) =
6720 0 : state.dataSurface->SurfWinGainIRGlazToZoneRep(repSurfNum) * areaRatio;
6721 0 : state.dataSurface->SurfWinLossSWZoneToOutWinRep(surfNum) =
6722 0 : state.dataSurface->SurfWinLossSWZoneToOutWinRep(repSurfNum) * areaRatio;
6723 : }
6724 : }
6725 : }
6726 : }
6727 : }
6728 687 : }
6729 :
6730 10122 : void ReportIntMovInsInsideSurfTemp(EnergyPlusData &state)
6731 : {
6732 10122 : state.dataHeatBalSurf->SurfTempInMovInsRep = state.dataHeatBalSurf->SurfTempIn;
6733 20244 : for (int SurfNum : state.dataHeatBalSurf->SurfMovInsulIndexList) {
6734 10122 : if (state.dataHeatBalSurf->SurfMovInsulIntPresent(SurfNum)) {
6735 6075 : state.dataHeatBalSurf->SurfTempInMovInsRep(SurfNum) = state.dataHeatBalSurf->SurfTempInTmp(SurfNum);
6736 : }
6737 : }
6738 10122 : }
6739 : // End of Reporting subroutines for the HB Module
6740 : // *****************************************************************************
6741 :
6742 : // *****************************************************************************
6743 : // *****************************************************************************
6744 : // *****************************************************************************
6745 : // *****************************************************************************
6746 :
6747 : // Formerly EXTERNAL SUBROUTINES (heavily related to HeatBalanceSurfaceManager) now moved into namespace
6748 :
6749 3482238 : void CalcHeatBalanceOutsideSurf(EnergyPlusData &state,
6750 : Optional_int_const ZoneToResimulate) // if passed in, then only calculate surfaces that have this zone
6751 : {
6752 :
6753 : // SUBROUTINE INFORMATION:
6754 : // AUTHOR George Walton
6755 : // DATE WRITTEN December 1979
6756 : // MODIFIED Jun 1990 (RDT for new CTF arrays);
6757 : // Aug 2000 (RJL for MTF moisture calculations)
6758 : // Sep 2000 (RKS for new radiant exchange algorithm)
6759 : // Dec 2000 (RKS for radiant system model addition)
6760 : // Apr 2002 (COP removed denominator from OSC calculation
6761 : // Jul 2008 (P.Biddulph include calls to HAMT)
6762 : // Jul 2011, M.J. Witte and C.O. Pedersen, add new fields to OSC for last T, max and min
6763 : // Sep 2011 LKL/BG - resimulate only zones needing it for Radiant systems
6764 : // RE-ENGINEERED Mar 1998 (RKS)
6765 :
6766 : // PURPOSE OF THIS SUBROUTINE:
6767 : // This subroutine performs a heat balance on the outside face of each
6768 : // surface in the building.
6769 :
6770 : // METHODOLOGY EMPLOYED:
6771 : // Various boundary conditions are set and additional parameters are set-
6772 : // up. Then, the proper heat balance equation is selected based on the
6773 : // presence of movable insulation, thermal mass of the surface construction,
6774 : // and convection model being used.
6775 :
6776 : // REFERENCES:
6777 : // (I)BLAST legacy routine HBOUT
6778 : // 1989 ASHRAE Handbook of Fundamentals (Figure 1 on p. 22.4, convection correlations)
6779 :
6780 : // Using/Aliasing
6781 : using namespace DataEnvironment;
6782 : using namespace DataHeatBalance;
6783 : using namespace DataHeatBalSurface;
6784 : using namespace DataSurfaces;
6785 : using ConvectionCoefficients::InitExteriorConvectionCoeff;
6786 : using ConvectionCoefficients::SetExtConvectionCoeff;
6787 : using ConvectionCoefficients::SetIntConvectionCoeff;
6788 : using HeatBalanceIntRadExchange::CalcInteriorRadExchange;
6789 : using ScheduleManager::GetCurrentScheduleValue;
6790 : using ScheduleManager::GetScheduleIndex;
6791 : using namespace Psychrometrics;
6792 : using EcoRoofManager::CalcEcoRoof;
6793 :
6794 : // Locals
6795 : // SUBROUTINE ARGUMENT DEFINITIONS:
6796 :
6797 : // SUBROUTINE PARAMETER DEFINITIONS:
6798 3482238 : constexpr const char *RoutineNameGroundTemp("CalcHeatBalanceOutsideSurf:GroundTemp");
6799 3482238 : constexpr const char *RoutineNameGroundTempFC("CalcHeatBalanceOutsideSurf:GroundTempFC");
6800 3482238 : constexpr const char *RoutineNameOtherSideCoefNoCalcExt("CalcHeatBalanceOutsideSurf:OtherSideCoefNoCalcExt");
6801 3482238 : constexpr const char *RoutineNameOtherSideCoefCalcExt("CalcHeatBalanceOutsideSurf:OtherSideCoefCalcExt");
6802 3482238 : constexpr const char *RoutineNameOSCM("CalcHeatBalanceOutsideSurf:OSCM");
6803 3482238 : constexpr const char *RoutineNameExtEnvWetSurf("CalcHeatBalanceOutsideSurf:extEnvWetSurf");
6804 3482238 : constexpr const char *RoutineNameExtEnvDrySurf("CalcHeatBalanceOutsideSurf:extEnvDrySurf");
6805 3482238 : constexpr const char *RoutineNameNoWind("CalcHeatBalanceOutsideSurf:nowind");
6806 3482238 : constexpr const char *RoutineNameOther("CalcHeatBalanceOutsideSurf:interior/other");
6807 3482238 : constexpr const char *RoutineNameIZPart("CalcHeatBalanceOutsideSurf:IZPart");
6808 3482238 : constexpr const char *HBSurfManGroundHAMT("HBSurfMan:Ground:HAMT");
6809 3482238 : constexpr const char *HBSurfManRainHAMT("HBSurfMan:Rain:HAMT");
6810 3482238 : constexpr const char *HBSurfManDrySurfCondFD("HBSurfMan:DrySurf:CondFD");
6811 3482238 : constexpr const char *Outside("Outside");
6812 :
6813 3482238 : bool MovInsulErrorFlag = false; // Movable Insulation error flag
6814 :
6815 : // set ground surfaces average temperature
6816 3482238 : GetGroundSurfacesTemperatureAverage(state);
6817 :
6818 3482238 : auto &Surface(state.dataSurface->Surface);
6819 :
6820 3482238 : if (state.dataHeatBal->AnyInternalHeatSourceInInput) {
6821 24122463 : for (int SurfNum = 1; SurfNum <= state.dataSurface->TotSurfaces; ++SurfNum) {
6822 : // Need to transfer any source/sink for a surface to the local array. Note that
6823 : // the local array is flux (W/m2) while the QRadSysSource is heat transfer (W).
6824 : // This must be done at this location so that this is always updated correctly.
6825 23137866 : if (Surface(SurfNum).Area > 0.0)
6826 23137866 : state.dataHeatBalSurf->SurfQsrcHist(SurfNum, 1) =
6827 23137866 : state.dataHeatBalFanSys->QRadSysSource(SurfNum) / Surface(SurfNum).Area; // Make sure we don't divide by zero...
6828 :
6829 : // next we add source (actually a sink) from any integrated PV
6830 23137866 : if (Surface(SurfNum).Area > 0.0)
6831 23137866 : state.dataHeatBalSurf->SurfQsrcHist(SurfNum, 1) +=
6832 23137866 : state.dataHeatBalFanSys->QPVSysSource(SurfNum) / Surface(SurfNum).Area; // Make sure we don't divide by zero...
6833 : }
6834 : }
6835 :
6836 3482238 : if (present(ZoneToResimulate)) {
6837 2426892 : CalcInteriorRadExchange(
6838 2426892 : state, state.dataHeatBalSurf->SurfInsideTempHist(1), 0, state.dataHeatBalSurf->SurfQdotRadNetLWInPerArea, ZoneToResimulate, Outside);
6839 : } else {
6840 2673274 : CalcInteriorRadExchange(state, state.dataHeatBalSurf->SurfInsideTempHist(1), 0, state.dataHeatBalSurf->SurfQdotRadNetLWInPerArea, _, Outside);
6841 : }
6842 :
6843 25151966 : for (int zoneNum = 1; zoneNum <= state.dataGlobal->NumOfZones; ++zoneNum) { // Loop through all surfaces...
6844 43355632 : for (int spaceNum : state.dataHeatBal->Zone(zoneNum).spaceIndexes) {
6845 21685904 : auto &thisSpace = state.dataHeatBal->space(spaceNum);
6846 205043170 : for (int SurfNum = thisSpace.HTSurfaceFirst; SurfNum <= thisSpace.HTSurfaceLast; ++SurfNum) {
6847 183357266 : if (Surface(SurfNum).Class == SurfaceClass::Window) continue;
6848 159439732 : if (present(ZoneToResimulate)) {
6849 18959488 : if ((zoneNum != ZoneToResimulate) && (state.dataSurface->SurfAdjacentZone(SurfNum) != ZoneToResimulate)) {
6850 11639311 : continue; // skip surfaces that are not associated with this zone
6851 : }
6852 : }
6853 : // Interior windows in partitions use "normal" heat balance calculations
6854 : // For rest, Outside surface temp of windows not needed in Window5 calculation approach.
6855 : // Window layer temperatures are calculated in CalcHeatBalanceInsideSurf
6856 :
6857 : // Initializations for this surface
6858 147800421 : int const ConstrNum = state.dataSurface->SurfActiveConstruction(SurfNum);
6859 147800421 : Real64 HMovInsul = 0.0; // "Convection" coefficient of movable insulation
6860 147800421 : Real64 HSky = 0.0; // "Convection" coefficient from sky to surface
6861 147800421 : Real64 HGround = 0.0; // "Convection" coefficient from ground to surface
6862 147800421 : Real64 HAir = 0.0; // "Convection" coefficient from air to surface (radiation)
6863 147800421 : state.dataHeatBalSurf->SurfHcExt(SurfNum) = 0.0;
6864 147800421 : state.dataHeatBalSurf->SurfHAirExt(SurfNum) = 0.0;
6865 147800421 : state.dataHeatBalSurf->SurfHSkyExt(SurfNum) = 0.0;
6866 147800421 : state.dataHeatBalSurf->SurfHGrdExt(SurfNum) = 0.0;
6867 147800421 : state.dataHeatBalSurf->SurfQRadLWOutSrdSurfs(SurfNum) = 0.0;
6868 :
6869 : // Calculate heat extract due to additional heat flux source term as the surface boundary condition
6870 :
6871 147800421 : if (Surface(SurfNum).OutsideHeatSourceTermSchedule) {
6872 12573 : state.dataHeatBalSurf->SurfQAdditionalHeatSourceOutside(SurfNum) =
6873 12573 : EnergyPlus::ScheduleManager::GetCurrentScheduleValue(state, Surface(SurfNum).OutsideHeatSourceTermSchedule);
6874 : }
6875 :
6876 : // Calculate the current outside surface temperature TH(SurfNum,1,1) for the
6877 : // various different boundary conditions
6878 147800421 : switch (Surface(SurfNum).ExtBoundCond) {
6879 9348947 : case Ground: { // Surface in contact with ground
6880 9348947 : state.dataHeatBalSurf->SurfOutsideTempHist(1)(SurfNum) = state.dataEnvrn->GroundTemp;
6881 :
6882 : // Set the only radiant system heat balance coefficient that is non-zero for this case
6883 9348947 : if (state.dataConstruction->Construct(ConstrNum).SourceSinkPresent)
6884 1391841 : state.dataHeatBalFanSys->RadSysToHBConstCoef(SurfNum) = state.dataHeatBalSurf->SurfOutsideTempHist(1)(SurfNum);
6885 :
6886 : // start HAMT
6887 9348947 : if (Surface(SurfNum).HeatTransferAlgorithm == DataSurfaces::HeatTransferModel::HAMT) {
6888 : // Set variables used in the HAMT moisture balance
6889 26913 : state.dataMstBal->TempOutsideAirFD(SurfNum) = state.dataEnvrn->GroundTemp;
6890 26913 : state.dataMstBal->RhoVaporAirOut(SurfNum) = PsyRhovFnTdbRh(state, state.dataEnvrn->GroundTemp, 1.0, HBSurfManGroundHAMT);
6891 26913 : state.dataMstBal->HConvExtFD(SurfNum) = state.dataHeatBal->HighHConvLimit;
6892 :
6893 26913 : state.dataMstBal->HMassConvExtFD(SurfNum) =
6894 53826 : state.dataMstBal->HConvExtFD(SurfNum) /
6895 134565 : ((PsyRhoAirFnPbTdbW(
6896 : state,
6897 26913 : state.dataEnvrn->OutBaroPress,
6898 26913 : state.dataEnvrn->GroundTemp,
6899 80739 : PsyWFnTdbRhPb(state, state.dataEnvrn->GroundTemp, 1.0, state.dataEnvrn->OutBaroPress, RoutineNameGroundTemp)) +
6900 53826 : state.dataMstBal->RhoVaporAirOut(SurfNum)) *
6901 26913 : PsyCpAirFnW(state.dataEnvrn->OutHumRat));
6902 :
6903 26913 : state.dataMstBal->HSkyFD(SurfNum) = HSky;
6904 26913 : state.dataMstBal->HGrndFD(SurfNum) = HGround;
6905 26913 : state.dataMstBal->HAirFD(SurfNum) = HAir;
6906 : }
6907 : // end HAMT
6908 :
6909 9348947 : if (Surface(SurfNum).HeatTransferAlgorithm == DataSurfaces::HeatTransferModel::CondFD) {
6910 : // Set variables used in the FD moisture balance
6911 416483 : state.dataMstBal->TempOutsideAirFD(SurfNum) = state.dataEnvrn->GroundTemp;
6912 416483 : state.dataMstBal->RhoVaporAirOut(SurfNum) = PsyRhovFnTdbRhLBnd0C(state.dataEnvrn->GroundTemp, 1.0);
6913 416483 : state.dataMstBal->HConvExtFD(SurfNum) = state.dataHeatBal->HighHConvLimit;
6914 416483 : state.dataMstBal->HMassConvExtFD(SurfNum) =
6915 832966 : state.dataMstBal->HConvExtFD(SurfNum) /
6916 2082415 : ((PsyRhoAirFnPbTdbW(
6917 : state,
6918 416483 : state.dataEnvrn->OutBaroPress,
6919 416483 : state.dataEnvrn->GroundTemp,
6920 1249449 : PsyWFnTdbRhPb(state, state.dataEnvrn->GroundTemp, 1.0, state.dataEnvrn->OutBaroPress, RoutineNameGroundTemp)) +
6921 832966 : state.dataMstBal->RhoVaporAirOut(SurfNum)) *
6922 416483 : PsyCpAirFnW(state.dataEnvrn->OutHumRat));
6923 416483 : state.dataMstBal->HSkyFD(SurfNum) = HSky;
6924 416483 : state.dataMstBal->HGrndFD(SurfNum) = HGround;
6925 416483 : state.dataMstBal->HAirFD(SurfNum) = HAir;
6926 : }
6927 : // Added for FCfactor grounds
6928 9348947 : } break;
6929 552681 : case GroundFCfactorMethod: { // Surface in contact with ground
6930 552681 : state.dataHeatBalSurf->SurfOutsideTempHist(1)(SurfNum) = state.dataEnvrn->GroundTempFC;
6931 :
6932 : // Set the only radiant system heat balance coefficient that is non-zero for this case
6933 552681 : if (state.dataConstruction->Construct(ConstrNum).SourceSinkPresent)
6934 0 : state.dataHeatBalFanSys->RadSysToHBConstCoef(SurfNum) = state.dataHeatBalSurf->SurfOutsideTempHist(1)(SurfNum);
6935 :
6936 552681 : if (Surface(SurfNum).HeatTransferAlgorithm == DataSurfaces::HeatTransferModel::HAMT) {
6937 : // Set variables used in the HAMT moisture balance
6938 0 : state.dataMstBal->TempOutsideAirFD(SurfNum) = state.dataEnvrn->GroundTempFC;
6939 0 : state.dataMstBal->RhoVaporAirOut(SurfNum) = PsyRhovFnTdbRh(state, state.dataEnvrn->GroundTempFC, 1.0, HBSurfManGroundHAMT);
6940 0 : state.dataMstBal->HConvExtFD(SurfNum) = state.dataHeatBal->HighHConvLimit;
6941 :
6942 0 : state.dataMstBal->HMassConvExtFD(SurfNum) =
6943 0 : state.dataMstBal->HConvExtFD(SurfNum) /
6944 0 : ((PsyRhoAirFnPbTdbW(
6945 : state,
6946 0 : state.dataEnvrn->OutBaroPress,
6947 0 : state.dataEnvrn->GroundTempFC,
6948 0 : PsyWFnTdbRhPb(state, state.dataEnvrn->GroundTempFC, 1.0, state.dataEnvrn->OutBaroPress, RoutineNameGroundTempFC)) +
6949 0 : state.dataMstBal->RhoVaporAirOut(SurfNum)) *
6950 0 : PsyCpAirFnW(state.dataEnvrn->OutHumRat));
6951 :
6952 0 : state.dataMstBal->HSkyFD(SurfNum) = HSky;
6953 0 : state.dataMstBal->HGrndFD(SurfNum) = HGround;
6954 0 : state.dataMstBal->HAirFD(SurfNum) = HAir;
6955 : }
6956 :
6957 552681 : if (Surface(SurfNum).HeatTransferAlgorithm == DataSurfaces::HeatTransferModel::CondFD) {
6958 : // Set variables used in the FD moisture balance
6959 0 : state.dataMstBal->TempOutsideAirFD(SurfNum) = state.dataEnvrn->GroundTempFC;
6960 0 : state.dataMstBal->RhoVaporAirOut(SurfNum) = PsyRhovFnTdbRhLBnd0C(state.dataEnvrn->GroundTempFC, 1.0);
6961 0 : state.dataMstBal->HConvExtFD(SurfNum) = state.dataHeatBal->HighHConvLimit;
6962 0 : state.dataMstBal->HMassConvExtFD(SurfNum) =
6963 0 : state.dataMstBal->HConvExtFD(SurfNum) /
6964 0 : ((PsyRhoAirFnPbTdbW(
6965 : state,
6966 0 : state.dataEnvrn->OutBaroPress,
6967 0 : state.dataEnvrn->GroundTempFC,
6968 0 : PsyWFnTdbRhPb(state, state.dataEnvrn->GroundTempFC, 1.0, state.dataEnvrn->OutBaroPress, RoutineNameGroundTempFC)) +
6969 0 : state.dataMstBal->RhoVaporAirOut(SurfNum)) *
6970 0 : PsyCpAirFnW(state.dataEnvrn->OutHumRat));
6971 0 : state.dataMstBal->HSkyFD(SurfNum) = HSky;
6972 0 : state.dataMstBal->HGrndFD(SurfNum) = HGround;
6973 0 : state.dataMstBal->HAirFD(SurfNum) = HAir;
6974 : }
6975 552681 : } break;
6976 84183 : case OtherSideCoefNoCalcExt: {
6977 : // Use Other Side Coefficients to determine the surface film coefficient and
6978 : // the exterior boundary condition temperature
6979 :
6980 84183 : int OPtr = Surface(SurfNum).OSCPtr;
6981 : // Set surface temp from previous timestep
6982 84183 : if (state.dataGlobal->BeginTimeStepFlag) {
6983 83933 : state.dataSurface->OSC(OPtr).TOutsideSurfPast = state.dataHeatBalSurf->SurfOutsideTempHist(1)(SurfNum);
6984 : }
6985 :
6986 84183 : if (state.dataSurface->OSC(OPtr).ConstTempScheduleIndex != 0) { // Determine outside temperature from schedule
6987 76659 : state.dataSurface->OSC(OPtr).ConstTemp = GetCurrentScheduleValue(state, state.dataSurface->OSC(OPtr).ConstTempScheduleIndex);
6988 : }
6989 :
6990 : // Allow for modification of TemperatureCoefficient with unitary sine wave.
6991 : Real64 ConstantTempCoef; // Temperature Coefficient as input or modified using sine wave COP mod
6992 84183 : if (state.dataSurface->OSC(OPtr).SinusoidalConstTempCoef) { // Sine wave C4
6993 3465 : ConstantTempCoef =
6994 3465 : std::sin(2 * DataGlobalConstants::Pi * state.dataGlobal->CurrentTime / state.dataSurface->OSC(OPtr).SinusoidPeriod);
6995 : } else {
6996 80718 : ConstantTempCoef = state.dataSurface->OSC(OPtr).ConstTempCoef;
6997 : }
6998 :
6999 84183 : state.dataSurface->OSC(OPtr).OSCTempCalc =
7000 168366 : (state.dataSurface->OSC(OPtr).ZoneAirTempCoef * state.dataZoneTempPredictorCorrector->zoneHeatBalance(zoneNum).MAT +
7001 168366 : state.dataSurface->OSC(OPtr).ExtDryBulbCoef * state.dataSurface->SurfOutDryBulbTemp(SurfNum) +
7002 168366 : ConstantTempCoef * state.dataSurface->OSC(OPtr).ConstTemp +
7003 168366 : state.dataSurface->OSC(OPtr).GroundTempCoef * state.dataEnvrn->GroundTemp +
7004 168366 : state.dataSurface->OSC(OPtr).WindSpeedCoef * state.dataSurface->SurfOutWindSpeed(SurfNum) *
7005 168366 : state.dataSurface->SurfOutDryBulbTemp(SurfNum) +
7006 84183 : state.dataSurface->OSC(OPtr).TPreviousCoef * state.dataSurface->OSC(OPtr).TOutsideSurfPast);
7007 :
7008 : // Enforce max/min limits if applicable
7009 84183 : if (state.dataSurface->OSC(OPtr).MinLimitPresent)
7010 33255 : state.dataSurface->OSC(OPtr).OSCTempCalc =
7011 33255 : max(state.dataSurface->OSC(OPtr).MinTempLimit, state.dataSurface->OSC(OPtr).OSCTempCalc);
7012 84183 : if (state.dataSurface->OSC(OPtr).MaxLimitPresent)
7013 33255 : state.dataSurface->OSC(OPtr).OSCTempCalc =
7014 33255 : min(state.dataSurface->OSC(OPtr).MaxTempLimit, state.dataSurface->OSC(OPtr).OSCTempCalc);
7015 :
7016 84183 : state.dataHeatBalSurf->SurfOutsideTempHist(1)(SurfNum) = state.dataSurface->OSC(OPtr).OSCTempCalc;
7017 :
7018 : // Set the only radiant system heat balance coefficient that is non-zero for this case
7019 84183 : if (state.dataConstruction->Construct(ConstrNum).SourceSinkPresent)
7020 0 : state.dataHeatBalFanSys->RadSysToHBConstCoef(SurfNum) = state.dataHeatBalSurf->SurfOutsideTempHist(1)(SurfNum);
7021 :
7022 168366 : if (Surface(SurfNum).HeatTransferAlgorithm == DataSurfaces::HeatTransferModel::CondFD ||
7023 84183 : Surface(SurfNum).HeatTransferAlgorithm == DataSurfaces::HeatTransferModel::HAMT) {
7024 : // Set variables used in the FD moisture balance and HAMT
7025 0 : state.dataMstBal->TempOutsideAirFD(SurfNum) = state.dataHeatBalSurf->SurfOutsideTempHist(1)(SurfNum);
7026 0 : state.dataMstBal->RhoVaporAirOut(SurfNum) =
7027 0 : PsyRhovFnTdbWPb(state.dataMstBal->TempOutsideAirFD(SurfNum), state.dataEnvrn->OutHumRat, state.dataEnvrn->OutBaroPress);
7028 0 : state.dataMstBal->HConvExtFD(SurfNum) = state.dataHeatBal->HighHConvLimit;
7029 0 : state.dataMstBal->HMassConvExtFD(SurfNum) =
7030 0 : state.dataMstBal->HConvExtFD(SurfNum) / ((PsyRhoAirFnPbTdbW(state,
7031 0 : state.dataEnvrn->OutBaroPress,
7032 0 : state.dataMstBal->TempOutsideAirFD(SurfNum),
7033 : PsyWFnTdbRhPb(state,
7034 0 : state.dataMstBal->TempOutsideAirFD(SurfNum),
7035 : 1.0,
7036 0 : state.dataEnvrn->OutBaroPress,
7037 0 : RoutineNameOtherSideCoefNoCalcExt)) +
7038 0 : state.dataMstBal->RhoVaporAirOut(SurfNum)) *
7039 0 : PsyCpAirFnW(state.dataEnvrn->OutHumRat));
7040 0 : state.dataMstBal->HSkyFD(SurfNum) = HSky;
7041 0 : state.dataMstBal->HGrndFD(SurfNum) = HGround;
7042 0 : state.dataMstBal->HAirFD(SurfNum) = HAir;
7043 : }
7044 : // This ends the calculations for this surface and goes on to the next SurfNum
7045 84183 : } break;
7046 1353 : case OtherSideCoefCalcExt: { // A surface with other side coefficients that define the outside environment
7047 : // First, set up the outside convection coefficient and the exterior temperature
7048 : // boundary condition for the surface
7049 1353 : int OPtr = Surface(SurfNum).OSCPtr;
7050 : // Set surface temp from previous timestep
7051 1353 : if (state.dataGlobal->BeginTimeStepFlag) {
7052 1347 : state.dataSurface->OSC(OPtr).TOutsideSurfPast = state.dataHeatBalSurf->SurfOutsideTempHist(1)(SurfNum);
7053 : }
7054 :
7055 1353 : if (state.dataSurface->OSC(OPtr).ConstTempScheduleIndex != 0) { // Determine outside temperature from schedule
7056 0 : state.dataSurface->OSC(OPtr).ConstTemp = GetCurrentScheduleValue(state, state.dataSurface->OSC(OPtr).ConstTempScheduleIndex);
7057 : }
7058 :
7059 1353 : state.dataHeatBalSurf->SurfHcExt(SurfNum) = state.dataSurface->OSC(OPtr).SurfFilmCoef;
7060 :
7061 1353 : state.dataSurface->OSC(OPtr).OSCTempCalc =
7062 2706 : (state.dataSurface->OSC(OPtr).ZoneAirTempCoef * state.dataZoneTempPredictorCorrector->zoneHeatBalance(zoneNum).MAT +
7063 2706 : state.dataSurface->OSC(OPtr).ExtDryBulbCoef * state.dataSurface->SurfOutDryBulbTemp(SurfNum) +
7064 2706 : state.dataSurface->OSC(OPtr).ConstTempCoef * state.dataSurface->OSC(OPtr).ConstTemp +
7065 2706 : state.dataSurface->OSC(OPtr).GroundTempCoef * state.dataEnvrn->GroundTemp +
7066 2706 : state.dataSurface->OSC(OPtr).WindSpeedCoef * state.dataSurface->SurfOutWindSpeed(SurfNum) *
7067 2706 : state.dataSurface->SurfOutDryBulbTemp(SurfNum) +
7068 1353 : state.dataSurface->OSC(OPtr).TPreviousCoef * state.dataSurface->OSC(OPtr).TOutsideSurfPast);
7069 :
7070 : // Enforce max/min limits if applicable
7071 1353 : if (state.dataSurface->OSC(OPtr).MinLimitPresent)
7072 0 : state.dataSurface->OSC(OPtr).OSCTempCalc =
7073 0 : max(state.dataSurface->OSC(OPtr).MinTempLimit, state.dataSurface->OSC(OPtr).OSCTempCalc);
7074 1353 : if (state.dataSurface->OSC(OPtr).MaxLimitPresent)
7075 0 : state.dataSurface->OSC(OPtr).OSCTempCalc =
7076 0 : min(state.dataSurface->OSC(OPtr).MaxTempLimit, state.dataSurface->OSC(OPtr).OSCTempCalc);
7077 :
7078 1353 : Real64 TempExt = state.dataSurface->OSC(OPtr).OSCTempCalc;
7079 :
7080 : // Set the only radiant system heat balance coefficient that is non-zero for this case
7081 1353 : if (state.dataConstruction->Construct(ConstrNum).SourceSinkPresent)
7082 0 : state.dataHeatBalFanSys->RadSysToHBConstCoef(SurfNum) = state.dataHeatBalSurf->SurfOutsideTempHist(1)(SurfNum);
7083 :
7084 2706 : if (Surface(SurfNum).HeatTransferAlgorithm == DataSurfaces::HeatTransferModel::CondFD ||
7085 1353 : Surface(SurfNum).HeatTransferAlgorithm == DataSurfaces::HeatTransferModel::HAMT) {
7086 : // Set variables used in the FD moisture balance and HAMT
7087 0 : state.dataMstBal->TempOutsideAirFD(SurfNum) = TempExt;
7088 0 : state.dataMstBal->RhoVaporAirOut(SurfNum) =
7089 0 : PsyRhovFnTdbWPb(state.dataMstBal->TempOutsideAirFD(SurfNum), state.dataEnvrn->OutHumRat, state.dataEnvrn->OutBaroPress);
7090 0 : state.dataMstBal->HConvExtFD(SurfNum) = state.dataHeatBalSurf->SurfHcExt(SurfNum);
7091 0 : state.dataMstBal->HMassConvExtFD(SurfNum) =
7092 0 : state.dataMstBal->HConvExtFD(SurfNum) / ((PsyRhoAirFnPbTdbW(state,
7093 0 : state.dataEnvrn->OutBaroPress,
7094 0 : state.dataMstBal->TempOutsideAirFD(SurfNum),
7095 : PsyWFnTdbRhPb(state,
7096 0 : state.dataMstBal->TempOutsideAirFD(SurfNum),
7097 : 1.0,
7098 0 : state.dataEnvrn->OutBaroPress,
7099 0 : RoutineNameOtherSideCoefCalcExt)) +
7100 0 : state.dataMstBal->RhoVaporAirOut(SurfNum)) *
7101 0 : PsyCpAirFnW(state.dataEnvrn->OutHumRat));
7102 0 : state.dataMstBal->HSkyFD(SurfNum) = state.dataHeatBalSurf->SurfHSkyExt(SurfNum);
7103 0 : state.dataMstBal->HGrndFD(SurfNum) = state.dataHeatBalSurf->SurfHGrdExt(SurfNum);
7104 0 : state.dataMstBal->HAirFD(SurfNum) = state.dataHeatBalSurf->SurfHAirExt(SurfNum);
7105 : }
7106 :
7107 : // Call the outside surface temp calculation and pass the necessary terms
7108 1353 : if (Surface(SurfNum).HeatTransferAlgorithm == DataSurfaces::HeatTransferModel::CTF ||
7109 0 : Surface(SurfNum).HeatTransferAlgorithm == DataSurfaces::HeatTransferModel::EMPD) {
7110 1353 : CalcOutsideSurfTemp(state, SurfNum, zoneNum, ConstrNum, HMovInsul, TempExt, MovInsulErrorFlag);
7111 1353 : if (MovInsulErrorFlag) ShowFatalError(state, "CalcOutsideSurfTemp: Program terminates due to preceding conditions.");
7112 : }
7113 : // This ends the calculations for this surface and goes on to the next SurfNum
7114 1353 : } break;
7115 106269 : case OtherSideCondModeledExt: { // A surface with other side conditions determined from seperate, dynamic component
7116 : // modeling that defines the "outside environment"
7117 : // First, set up the outside convection coefficient and the exterior temperature
7118 : // boundary condition for the surface
7119 106269 : int OPtr = Surface(SurfNum).OSCMPtr;
7120 : // EMS overrides
7121 106269 : if (state.dataSurface->OSCM(OPtr).EMSOverrideOnTConv)
7122 0 : state.dataSurface->OSCM(OPtr).TConv = state.dataSurface->OSCM(OPtr).EMSOverrideTConvValue;
7123 106269 : if (state.dataSurface->OSCM(OPtr).EMSOverrideOnHConv)
7124 0 : state.dataSurface->OSCM(OPtr).HConv = state.dataSurface->OSCM(OPtr).EMSOverrideHConvValue;
7125 106269 : if (state.dataSurface->OSCM(OPtr).EMSOverrideOnTRad)
7126 0 : state.dataSurface->OSCM(OPtr).TRad = state.dataSurface->OSCM(OPtr).EMSOverrideTRadValue;
7127 106269 : if (state.dataSurface->OSCM(OPtr).EMSOverrideOnHrad)
7128 0 : state.dataSurface->OSCM(OPtr).HRad = state.dataSurface->OSCM(OPtr).EMSOverrideHradValue;
7129 106269 : state.dataHeatBalSurf->SurfHcExt(SurfNum) = state.dataSurface->OSCM(OPtr).HConv;
7130 :
7131 106269 : Real64 TempExt = state.dataSurface->OSCM(OPtr).TConv;
7132 :
7133 : // Set the only radiant system heat balance coefficient that is non-zero for this case
7134 106269 : if (state.dataConstruction->Construct(ConstrNum).SourceSinkPresent)
7135 0 : state.dataHeatBalFanSys->RadSysToHBConstCoef(SurfNum) = state.dataHeatBalSurf->SurfOutsideTempHist(1)(SurfNum);
7136 :
7137 212538 : if (Surface(SurfNum).HeatTransferAlgorithm == DataSurfaces::HeatTransferModel::CondFD ||
7138 106269 : Surface(SurfNum).HeatTransferAlgorithm == DataSurfaces::HeatTransferModel::HAMT) {
7139 : // Set variables used in the FD moisture balance and HAMT
7140 0 : state.dataMstBal->TempOutsideAirFD(SurfNum) = TempExt;
7141 0 : state.dataMstBal->RhoVaporAirOut(SurfNum) =
7142 0 : PsyRhovFnTdbWPb(state.dataMstBal->TempOutsideAirFD(SurfNum), state.dataEnvrn->OutHumRat, state.dataEnvrn->OutBaroPress);
7143 0 : state.dataMstBal->HConvExtFD(SurfNum) = state.dataHeatBalSurf->SurfHcExt(SurfNum);
7144 0 : state.dataMstBal->HMassConvExtFD(SurfNum) =
7145 0 : state.dataMstBal->HConvExtFD(SurfNum) /
7146 0 : ((PsyRhoAirFnPbTdbW(
7147 : state,
7148 0 : state.dataEnvrn->OutBaroPress,
7149 0 : state.dataMstBal->TempOutsideAirFD(SurfNum),
7150 : PsyWFnTdbRhPb(
7151 0 : state, state.dataMstBal->TempOutsideAirFD(SurfNum), 1.0, state.dataEnvrn->OutBaroPress, RoutineNameOSCM)) +
7152 0 : state.dataMstBal->RhoVaporAirOut(SurfNum)) *
7153 0 : PsyCpAirFnW(state.dataEnvrn->OutHumRat));
7154 0 : state.dataMstBal->HSkyFD(SurfNum) = state.dataSurface->OSCM(OPtr).HRad; // CR 8046, use sky term for surface to baffle IR
7155 0 : state.dataMstBal->HGrndFD(SurfNum) = 0.0; // CR 8046, null out and use only sky term for surface to baffle IR
7156 0 : state.dataMstBal->HAirFD(SurfNum) = 0.0; // CR 8046, null out and use only sky term for surface to baffle IR
7157 : }
7158 :
7159 : // Call the outside surface temp calculation and pass the necessary terms
7160 106269 : if (Surface(SurfNum).HeatTransferAlgorithm == DataSurfaces::HeatTransferModel::CTF ||
7161 0 : Surface(SurfNum).HeatTransferAlgorithm == DataSurfaces::HeatTransferModel::EMPD) {
7162 :
7163 106269 : if (state.dataSurface->SurfExtCavityPresent(SurfNum)) {
7164 8124 : CalcExteriorVentedCavity(state, SurfNum);
7165 : }
7166 :
7167 106269 : CalcOutsideSurfTemp(state, SurfNum, zoneNum, ConstrNum, HMovInsul, TempExt, MovInsulErrorFlag);
7168 106269 : if (MovInsulErrorFlag) ShowFatalError(state, "CalcOutsideSurfTemp: Program terminates due to preceding conditions.");
7169 :
7170 0 : } else if (Surface(SurfNum).HeatTransferAlgorithm == DataSurfaces::HeatTransferModel::CondFD ||
7171 0 : Surface(SurfNum).HeatTransferAlgorithm == DataSurfaces::HeatTransferModel::HAMT) {
7172 0 : if (state.dataSurface->SurfExtCavityPresent(SurfNum)) {
7173 0 : CalcExteriorVentedCavity(state, SurfNum);
7174 : }
7175 : }
7176 : // This ends the calculations for this surface and goes on to the next SurfNum
7177 106269 : } break;
7178 42720605 : case ExternalEnvironment: {
7179 : // checking the EcoRoof presented in the external environment
7180 : // recompute each load by calling ecoroof
7181 :
7182 : Real64 TempExt;
7183 :
7184 43164425 : if (state.dataSurface->SurfExtEcoRoof(SurfNum)) {
7185 443820 : CalcEcoRoof(state, SurfNum, zoneNum, ConstrNum, TempExt);
7186 443820 : continue;
7187 : }
7188 : // Roughness index of the exterior surface
7189 42276785 : DataSurfaces::SurfaceRoughness RoughSurf = state.dataHeatBalSurf->SurfRoughnessExt(SurfNum);
7190 : // Thermal absoptance of the exterior surface
7191 42276785 : Real64 AbsThermSurf = state.dataHeatBalSurf->SurfAbsThermalExt(SurfNum);
7192 42276785 : HMovInsul = 0;
7193 : // Check for outside movable insulation
7194 42276785 : if (state.dataSurface->AnyMovableInsulation && state.dataHeatBalSurf->SurfMovInsulExtPresent(SurfNum)) {
7195 4047 : HMovInsul = state.dataHeatBalSurf->SurfMovInsulHExt(SurfNum);
7196 : }
7197 :
7198 : // Check for exposure to wind (exterior environment)
7199 42276785 : if (Surface(SurfNum).ExtWind) {
7200 :
7201 : // Calculate exterior heat transfer coefficients with windspeed (windspeed is calculated internally in subroutine)
7202 42100160 : InitExteriorConvectionCoeff(state,
7203 : SurfNum,
7204 : HMovInsul,
7205 : RoughSurf,
7206 : AbsThermSurf,
7207 42100160 : state.dataHeatBalSurf->SurfOutsideTempHist(1)(SurfNum),
7208 42100160 : state.dataHeatBalSurf->SurfHcExt(SurfNum),
7209 42100160 : state.dataHeatBalSurf->SurfHSkyExt(SurfNum),
7210 42100160 : state.dataHeatBalSurf->SurfHGrdExt(SurfNum),
7211 42100160 : state.dataHeatBalSurf->SurfHAirExt(SurfNum));
7212 :
7213 42100160 : if (state.dataEnvrn->IsRain) { // Raining: since wind exposed, outside surface gets wet
7214 :
7215 7100 : if (state.dataSurface->SurfExtConvCoeffIndex(SurfNum) <= 0) { // Reset SurfHcExt because of wetness
7216 7100 : state.dataHeatBalSurf->SurfHcExt(SurfNum) = 1000.0;
7217 : } else { // User set
7218 0 : state.dataHeatBalSurf->SurfHcExt(SurfNum) = SetExtConvectionCoeff(state, SurfNum);
7219 : }
7220 :
7221 7100 : TempExt = state.dataSurface->SurfOutWetBulbTemp(SurfNum);
7222 :
7223 : // start HAMT
7224 7100 : if (Surface(SurfNum).HeatTransferAlgorithm == DataSurfaces::HeatTransferModel::HAMT) {
7225 : // Set variables used in the HAMT moisture balance
7226 0 : state.dataMstBal->TempOutsideAirFD(SurfNum) = TempExt;
7227 0 : state.dataMstBal->RhoVaporAirOut(SurfNum) =
7228 0 : PsyRhovFnTdbRh(state, state.dataMstBal->TempOutsideAirFD(SurfNum), 1.0, HBSurfManRainHAMT);
7229 0 : state.dataMstBal->HConvExtFD(SurfNum) = state.dataHeatBalSurf->SurfHcExt(SurfNum);
7230 0 : state.dataMstBal->HMassConvExtFD(SurfNum) =
7231 0 : state.dataMstBal->HConvExtFD(SurfNum) /
7232 0 : ((PsyRhoAirFnPbTdbW(state,
7233 0 : state.dataEnvrn->OutBaroPress,
7234 0 : state.dataMstBal->TempOutsideAirFD(SurfNum),
7235 : PsyWFnTdbRhPb(state,
7236 0 : state.dataMstBal->TempOutsideAirFD(SurfNum),
7237 : 1.0,
7238 0 : state.dataEnvrn->OutBaroPress,
7239 0 : RoutineNameExtEnvWetSurf)) +
7240 0 : state.dataMstBal->RhoVaporAirOut(SurfNum)) *
7241 0 : PsyCpAirFnW(state.dataEnvrn->OutHumRat));
7242 0 : state.dataMstBal->HSkyFD(SurfNum) = state.dataHeatBalSurf->SurfHSkyExt(SurfNum);
7243 0 : state.dataMstBal->HGrndFD(SurfNum) = state.dataHeatBalSurf->SurfHGrdExt(SurfNum);
7244 0 : state.dataMstBal->HAirFD(SurfNum) = state.dataHeatBalSurf->SurfHAirExt(SurfNum);
7245 : }
7246 : // end HAMT
7247 7100 : if (Surface(SurfNum).HeatTransferAlgorithm == DataSurfaces::HeatTransferModel::CondFD) {
7248 : // Set variables used in the FD moisture balance
7249 0 : state.dataMstBal->TempOutsideAirFD(SurfNum) = TempExt;
7250 0 : state.dataMstBal->RhoVaporAirOut(SurfNum) = PsyRhovFnTdbRhLBnd0C(state.dataMstBal->TempOutsideAirFD(SurfNum), 1.0);
7251 0 : state.dataMstBal->HConvExtFD(SurfNum) = state.dataHeatBalSurf->SurfHcExt(SurfNum);
7252 0 : state.dataMstBal->HMassConvExtFD(SurfNum) =
7253 0 : state.dataMstBal->HConvExtFD(SurfNum) /
7254 0 : ((PsyRhoAirFnPbTdbW(state,
7255 0 : state.dataEnvrn->OutBaroPress,
7256 0 : state.dataMstBal->TempOutsideAirFD(SurfNum),
7257 : PsyWFnTdbRhPb(state,
7258 0 : state.dataMstBal->TempOutsideAirFD(SurfNum),
7259 : 1.0,
7260 0 : state.dataEnvrn->OutBaroPress,
7261 0 : RoutineNameExtEnvWetSurf)) +
7262 0 : state.dataMstBal->RhoVaporAirOut(SurfNum)) *
7263 0 : PsyCpAirFnW(state.dataEnvrn->OutHumRat));
7264 0 : state.dataMstBal->HSkyFD(SurfNum) = state.dataHeatBalSurf->SurfHSkyExt(SurfNum);
7265 0 : state.dataMstBal->HGrndFD(SurfNum) = state.dataHeatBalSurf->SurfHGrdExt(SurfNum);
7266 0 : state.dataMstBal->HAirFD(SurfNum) = state.dataHeatBalSurf->SurfHAirExt(SurfNum);
7267 : }
7268 :
7269 : } else { // Surface is dry, use the normal correlation
7270 :
7271 42093060 : TempExt = state.dataSurface->SurfOutDryBulbTemp(SurfNum);
7272 :
7273 82418030 : if (Surface(SurfNum).HeatTransferAlgorithm == DataSurfaces::HeatTransferModel::CondFD ||
7274 40324970 : Surface(SurfNum).HeatTransferAlgorithm == DataSurfaces::HeatTransferModel::HAMT) {
7275 : // Set variables used in the FD moisture balance and HAMT
7276 1912741 : state.dataMstBal->TempOutsideAirFD(SurfNum) = TempExt;
7277 5738223 : state.dataMstBal->RhoVaporAirOut(SurfNum) = PsyRhovFnTdbWPb(
7278 5738223 : state.dataMstBal->TempOutsideAirFD(SurfNum), state.dataEnvrn->OutHumRat, state.dataEnvrn->OutBaroPress);
7279 1912741 : state.dataMstBal->HConvExtFD(SurfNum) = state.dataHeatBalSurf->SurfHcExt(SurfNum);
7280 1912741 : state.dataMstBal->HMassConvExtFD(SurfNum) =
7281 3825482 : state.dataMstBal->HConvExtFD(SurfNum) /
7282 9563705 : ((PsyRhoAirFnPbTdbW(state,
7283 1912741 : state.dataEnvrn->OutBaroPress,
7284 1912741 : state.dataMstBal->TempOutsideAirFD(SurfNum),
7285 : PsyWFnTdbRhPb(state,
7286 1912741 : state.dataMstBal->TempOutsideAirFD(SurfNum),
7287 : 1.0,
7288 1912741 : state.dataEnvrn->OutBaroPress,
7289 3825482 : RoutineNameExtEnvDrySurf)) +
7290 3825482 : state.dataMstBal->RhoVaporAirOut(SurfNum)) *
7291 1912741 : PsyCpAirFnW(state.dataEnvrn->OutHumRat));
7292 : // check for saturation conditions of air
7293 : // Local temporary saturated vapor density for checking
7294 1912741 : Real64 RhoVaporSat = PsyRhovFnTdbRh(state, state.dataMstBal->TempOutsideAirFD(SurfNum), 1.0, HBSurfManDrySurfCondFD);
7295 1912741 : if (state.dataMstBal->RhoVaporAirOut(SurfNum) > RhoVaporSat) state.dataMstBal->RhoVaporAirOut(SurfNum) = RhoVaporSat;
7296 1912741 : state.dataMstBal->HSkyFD(SurfNum) = state.dataHeatBalSurf->SurfHSkyExt(SurfNum);
7297 1912741 : state.dataMstBal->HGrndFD(SurfNum) = state.dataHeatBalSurf->SurfHGrdExt(SurfNum);
7298 1912741 : state.dataMstBal->HAirFD(SurfNum) = state.dataHeatBalSurf->SurfHAirExt(SurfNum);
7299 : }
7300 : }
7301 :
7302 : } else { // No wind
7303 :
7304 : // Calculate exterior heat transfer coefficients for windspeed = 0
7305 176625 : InitExteriorConvectionCoeff(state,
7306 : SurfNum,
7307 : HMovInsul,
7308 : RoughSurf,
7309 : AbsThermSurf,
7310 176625 : state.dataHeatBalSurf->SurfOutsideTempHist(1)(SurfNum),
7311 176625 : state.dataHeatBalSurf->SurfHcExt(SurfNum),
7312 176625 : state.dataHeatBalSurf->SurfHSkyExt(SurfNum),
7313 176625 : state.dataHeatBalSurf->SurfHGrdExt(SurfNum),
7314 176625 : state.dataHeatBalSurf->SurfHAirExt(SurfNum));
7315 :
7316 176625 : TempExt = state.dataSurface->SurfOutDryBulbTemp(SurfNum);
7317 :
7318 346524 : if (Surface(SurfNum).HeatTransferAlgorithm == DataSurfaces::HeatTransferModel::CondFD ||
7319 169899 : Surface(SurfNum).HeatTransferAlgorithm == DataSurfaces::HeatTransferModel::HAMT) {
7320 : // Set variables used in the FD moisture balance and HAMT
7321 6726 : state.dataMstBal->TempOutsideAirFD(SurfNum) = TempExt;
7322 20178 : state.dataMstBal->RhoVaporAirOut(SurfNum) = PsyRhovFnTdbWPb(
7323 20178 : state.dataMstBal->TempOutsideAirFD(SurfNum), state.dataEnvrn->OutHumRat, state.dataEnvrn->OutBaroPress);
7324 6726 : state.dataMstBal->HConvExtFD(SurfNum) = state.dataHeatBalSurf->SurfHcExt(SurfNum);
7325 6726 : state.dataMstBal->HMassConvExtFD(SurfNum) =
7326 47082 : state.dataMstBal->HConvExtFD(SurfNum) / ((PsyRhoAirFnPbTdbW(state,
7327 6726 : state.dataEnvrn->OutBaroPress,
7328 6726 : state.dataMstBal->TempOutsideAirFD(SurfNum),
7329 : PsyWFnTdbRhPb(state,
7330 6726 : state.dataMstBal->TempOutsideAirFD(SurfNum),
7331 : 1.0,
7332 6726 : state.dataEnvrn->OutBaroPress,
7333 13452 : RoutineNameNoWind)) +
7334 13452 : state.dataMstBal->RhoVaporAirOut(SurfNum)) *
7335 6726 : PsyCpAirFnW(state.dataEnvrn->OutHumRat));
7336 6726 : state.dataMstBal->HSkyFD(SurfNum) = state.dataHeatBalSurf->SurfHSkyExt(SurfNum);
7337 6726 : state.dataMstBal->HGrndFD(SurfNum) = state.dataHeatBalSurf->SurfHGrdExt(SurfNum);
7338 6726 : state.dataMstBal->HAirFD(SurfNum) = state.dataHeatBalSurf->SurfHAirExt(SurfNum);
7339 : }
7340 : }
7341 : // Calculate LWR from surrounding surfaces if defined for an exterior surface
7342 42276785 : if (state.dataSurface->Surface(SurfNum).SurfHasSurroundingSurfProperty) {
7343 5412 : int SrdSurfsNum = state.dataSurface->Surface(SurfNum).SurfSurroundingSurfacesNum;
7344 : // Absolute temperature of the outside surface of an exterior surface
7345 5412 : Real64 TSurf = state.dataHeatBalSurf->SurfOutsideTempHist(1)(SurfNum) + DataGlobalConstants::KelvinConv;
7346 18942 : for (int SrdSurfNum = 1; SrdSurfNum <= state.dataSurface->SurroundingSurfsProperty(SrdSurfsNum).TotSurroundingSurface;
7347 : SrdSurfNum++) {
7348 : // View factor of a surrounding surface
7349 13530 : Real64 SrdSurfViewFac = state.dataSurface->SurroundingSurfsProperty(SrdSurfsNum).SurroundingSurfs(SrdSurfNum).ViewFactor;
7350 : // Absolute temperature of a surrounding surface
7351 : Real64 SrdSurfTempAbs =
7352 13530 : GetCurrentScheduleValue(
7353 13530 : state, state.dataSurface->SurroundingSurfsProperty(SrdSurfsNum).SurroundingSurfs(SrdSurfNum).TempSchNum) +
7354 13530 : DataGlobalConstants::KelvinConv;
7355 13530 : state.dataHeatBalSurf->SurfQRadLWOutSrdSurfs(SurfNum) +=
7356 13530 : DataGlobalConstants::StefanBoltzmann * AbsThermSurf * SrdSurfViewFac * (pow_4(SrdSurfTempAbs) - pow_4(TSurf));
7357 : }
7358 : }
7359 :
7360 86534291 : if (Surface(SurfNum).HeatTransferAlgorithm == DataSurfaces::HeatTransferModel::CTF ||
7361 44200302 : Surface(SurfNum).HeatTransferAlgorithm == DataSurfaces::HeatTransferModel::EMPD ||
7362 1923517 : Surface(SurfNum).Class == SurfaceClass::TDD_Dome) {
7363 40357318 : CalcOutsideSurfTemp(state, SurfNum, zoneNum, ConstrNum, HMovInsul, TempExt, MovInsulErrorFlag);
7364 40357318 : if (MovInsulErrorFlag) ShowFatalError(state, "CalcOutsideSurfTemp: Program terminates due to preceding conditions.");
7365 42276785 : }
7366 42276785 : } break;
7367 100578 : case KivaFoundation: {
7368 : DataSurfaces::SurfaceRoughness RoughSurf =
7369 100578 : state.dataMaterial->Material(state.dataConstruction->Construct(ConstrNum).LayerPoint(1)).Roughness;
7370 100578 : Real64 AbsThermSurf = state.dataMaterial->Material(state.dataConstruction->Construct(ConstrNum).LayerPoint(1)).AbsorpThermal;
7371 :
7372 : // Set Kiva exterior convection algorithms
7373 100578 : InitExteriorConvectionCoeff(state,
7374 : SurfNum,
7375 : HMovInsul,
7376 : RoughSurf,
7377 : AbsThermSurf,
7378 100578 : state.dataHeatBalSurf->SurfOutsideTempHist(1)(SurfNum),
7379 100578 : state.dataHeatBalSurf->SurfHcExt(SurfNum),
7380 100578 : state.dataHeatBalSurf->SurfHSkyExt(SurfNum),
7381 100578 : state.dataHeatBalSurf->SurfHGrdExt(SurfNum),
7382 100578 : state.dataHeatBalSurf->SurfHAirExt(SurfNum));
7383 100578 : } break;
7384 94885805 : default: { // for interior or other zone surfaces
7385 :
7386 94885805 : if (Surface(SurfNum).ExtBoundCond == SurfNum) { // Regular partition/internal mass
7387 :
7388 28484595 : state.dataHeatBalSurf->SurfOutsideTempHist(1)(SurfNum) = state.dataHeatBalSurf->SurfTempIn(SurfNum);
7389 :
7390 : // No need to set any radiant system heat balance coefficients here--will be done during inside heat balance
7391 :
7392 56848611 : if (Surface(SurfNum).HeatTransferAlgorithm == DataSurfaces::HeatTransferModel::CondFD ||
7393 28364016 : Surface(SurfNum).HeatTransferAlgorithm == DataSurfaces::HeatTransferModel::HAMT) {
7394 : // Set variables used in the FD moisture balance HAMT
7395 120579 : state.dataMstBal->TempOutsideAirFD(SurfNum) = state.dataHeatBalSurf->SurfTempIn(SurfNum);
7396 120579 : state.dataMstBal->RhoVaporAirOut(SurfNum) = state.dataMstBal->RhoVaporAirIn(SurfNum);
7397 120579 : state.dataMstBal->HConvExtFD(SurfNum) = state.dataHeatBalSurf->SurfHConvInt(SurfNum);
7398 120579 : state.dataMstBal->HMassConvExtFD(SurfNum) =
7399 241158 : state.dataMstBal->HConvExtFD(SurfNum) /
7400 602895 : ((PsyRhoAirFnPbTdbW(
7401 : state,
7402 120579 : state.dataEnvrn->OutBaroPress,
7403 120579 : state.dataMstBal->TempOutsideAirFD(SurfNum),
7404 : PsyWFnTdbRhPb(
7405 361737 : state, state.dataMstBal->TempOutsideAirFD(SurfNum), 1.0, state.dataEnvrn->OutBaroPress, RoutineNameOther)) +
7406 241158 : state.dataMstBal->RhoVaporAirOut(SurfNum)) *
7407 120579 : PsyCpAirFnW(state.dataEnvrn->OutHumRat));
7408 120579 : state.dataMstBal->HSkyFD(SurfNum) = 0.0;
7409 120579 : state.dataMstBal->HGrndFD(SurfNum) = 0.0;
7410 120579 : state.dataMstBal->HAirFD(SurfNum) = 0.0;
7411 : }
7412 :
7413 : } else { // Interzone partition
7414 :
7415 66401210 : state.dataHeatBalSurf->SurfOutsideTempHist(1)(SurfNum) =
7416 66401210 : state.dataHeatBalSurf->SurfInsideTempHist(1)(Surface(SurfNum).ExtBoundCond);
7417 :
7418 : // No need to set any radiant system heat balance coefficients here--will be done during inside heat balance
7419 :
7420 131656154 : if (Surface(SurfNum).HeatTransferAlgorithm == DataSurfaces::HeatTransferModel::CondFD ||
7421 65254944 : Surface(SurfNum).HeatTransferAlgorithm == DataSurfaces::HeatTransferModel::HAMT) {
7422 : // Set variables used in the FD moisture balance and HAMT
7423 1146266 : state.dataMstBal->TempOutsideAirFD(SurfNum) = state.dataHeatBalSurf->SurfInsideTempHist(1)(Surface(SurfNum).ExtBoundCond);
7424 1146266 : state.dataMstBal->RhoVaporAirOut(SurfNum) = state.dataMstBal->RhoVaporAirIn(Surface(SurfNum).ExtBoundCond);
7425 1146266 : state.dataMstBal->HConvExtFD(SurfNum) = state.dataHeatBalSurf->SurfHConvInt(Surface(SurfNum).ExtBoundCond);
7426 1146266 : state.dataMstBal->HMassConvExtFD(SurfNum) =
7427 8023862 : state.dataMstBal->HConvExtFD(SurfNum) / ((PsyRhoAirFnPbTdbW(state,
7428 1146266 : state.dataEnvrn->OutBaroPress,
7429 1146266 : state.dataMstBal->TempOutsideAirFD(SurfNum),
7430 : PsyWFnTdbRhPb(state,
7431 1146266 : state.dataMstBal->TempOutsideAirFD(SurfNum),
7432 : 1.0,
7433 1146266 : state.dataEnvrn->OutBaroPress,
7434 2292532 : RoutineNameIZPart)) +
7435 2292532 : state.dataMstBal->RhoVaporAirOut(SurfNum)) *
7436 1146266 : PsyCpAirFnW(state.dataEnvrn->OutHumRat));
7437 1146266 : state.dataMstBal->HSkyFD(SurfNum) = 0.0;
7438 1146266 : state.dataMstBal->HGrndFD(SurfNum) = 0.0;
7439 1146266 : state.dataMstBal->HAirFD(SurfNum) = 0.0;
7440 : }
7441 : }
7442 : // This ends the calculations for this surface and goes on to the next SurfNum
7443 94885805 : } break;
7444 : }
7445 :
7446 147356601 : state.dataHeatBalSurf->SurfQdotConvOutPerArea(SurfNum) = GetQdotConvOutPerArea(state, SurfNum);
7447 : }
7448 : }
7449 : } // ...end of DO loop over all surface (actually heat transfer surfaces)
7450 3482238 : }
7451 :
7452 147356601 : Real64 GetQdotConvOutPerArea(EnergyPlusData &state, int const SurfNum)
7453 : {
7454 147356601 : auto &Surface(state.dataSurface->Surface);
7455 147356601 : int OPtr = Surface(SurfNum).OSCMPtr;
7456 147356601 : if (Surface(SurfNum).OSCMPtr > 0) { // Optr is set above in this case, use OSCM boundary data
7457 106269 : return -state.dataSurface->OSCM(OPtr).HConv * (state.dataHeatBalSurf->SurfOutsideTempHist(1)(SurfNum) - state.dataSurface->OSCM(OPtr).TConv);
7458 : } else {
7459 147250332 : if (state.dataEnvrn->IsRain) {
7460 31572 : return -state.dataHeatBalSurf->SurfHcExt(SurfNum) *
7461 31572 : (state.dataHeatBalSurf->SurfOutsideTempHist(1)(SurfNum) - state.dataSurface->SurfOutWetBulbTemp(SurfNum));
7462 : } else {
7463 147218760 : return -state.dataHeatBalSurf->SurfHcExt(SurfNum) *
7464 147218760 : (state.dataHeatBalSurf->SurfOutsideTempHist(1)(SurfNum) - state.dataSurface->SurfOutDryBulbTemp(SurfNum));
7465 : }
7466 : }
7467 : }
7468 :
7469 3487776 : void CalcHeatBalanceInsideSurf(EnergyPlusData &state,
7470 : Optional_int_const ZoneToResimulate) // if passed in, then only calculate surfaces that have this zone
7471 : {
7472 3487776 : auto &Surface(state.dataSurface->Surface);
7473 3487776 : if (state.dataHeatBalSurfMgr->calcHeatBalInsideSurfFirstTime) {
7474 771 : if (state.dataHeatBal->AnyEMPD) {
7475 2 : state.dataHeatBalSurf->MinIterations = MinEMPDIterations;
7476 : }
7477 771 : if (state.dataGlobal->DisplayAdvancedReportVariables) {
7478 63 : SetupOutputVariable(state,
7479 : "Surface Inside Face Heat Balance Calculation Iteration Count",
7480 : OutputProcessor::Unit::None,
7481 21 : state.dataHeatBal->InsideSurfIterations,
7482 : OutputProcessor::SOVTimeStepType::Zone,
7483 : OutputProcessor::SOVStoreType::Summed,
7484 42 : "Simulation");
7485 : }
7486 : // Precompute whether CTF temperature limits will be needed
7487 771 : state.dataHeatBalSurf->Zone_has_mixed_HT_models.resize(state.dataGlobal->NumOfZones + 1, false);
7488 5585 : for (int iZone = 1; iZone <= state.dataGlobal->NumOfZones; ++iZone) {
7489 9632 : for (int spaceNum : state.dataHeatBal->Zone(iZone).spaceIndexes) {
7490 4818 : auto &thisSpace = state.dataHeatBal->space(spaceNum);
7491 46745 : for (int iSurf = thisSpace.HTSurfaceFirst, eSurf = thisSpace.HTSurfaceLast; iSurf <= eSurf; ++iSurf) {
7492 41973 : auto const alg(Surface(iSurf).HeatTransferAlgorithm);
7493 41973 : if ((alg == DataSurfaces::HeatTransferModel::CondFD) || (alg == DataSurfaces::HeatTransferModel::HAMT) ||
7494 : (alg == DataSurfaces::HeatTransferModel::Kiva)) {
7495 46 : state.dataHeatBalSurf->Zone_has_mixed_HT_models[iZone] = true;
7496 46 : break;
7497 : }
7498 : }
7499 : }
7500 : }
7501 771 : state.dataHeatBalSurfMgr->calcHeatBalInsideSurfFirstTime = false;
7502 : }
7503 :
7504 3487776 : if (state.dataGlobal->BeginEnvrnFlag && state.dataHeatBalSurfMgr->calcHeatBalInsideSurEnvrnFlag) {
7505 6218 : state.dataHeatBalSurf->SurfTempInsOld = 23.0;
7506 6218 : state.dataHeatBalSurfMgr->RefAirTemp = 23.0;
7507 6218 : state.dataHeatBal->SurfTempEffBulkAir = 23.0;
7508 6218 : state.dataHeatBalSurfMgr->calcHeatBalInsideSurfWarmupErrCount = 0;
7509 6218 : state.dataHeatBalSurfMgr->calcHeatBalInsideSurEnvrnFlag = false;
7510 :
7511 : // Initialize Kiva instances ground temperatures
7512 6218 : if (state.dataHeatBal->AnyKiva) {
7513 59 : state.dataSurfaceGeometry->kivaManager.initKivaInstances(state);
7514 : }
7515 : }
7516 3487776 : if (!state.dataGlobal->BeginEnvrnFlag) {
7517 3479264 : state.dataHeatBalSurfMgr->calcHeatBalInsideSurEnvrnFlag = true;
7518 : }
7519 :
7520 : // Pass correct list of surfaces to CalcHeatBalanceInsideSurf2
7521 3487776 : bool const PartialResimulate(present(ZoneToResimulate));
7522 :
7523 3487776 : if (!PartialResimulate) {
7524 :
7525 2678812 : if (state.dataHeatBal->AllCTF) {
7526 2469152 : CalcHeatBalanceInsideSurf2CTFOnly(state, 1, state.dataGlobal->NumOfZones, state.dataSurface->AllIZSurfaceList);
7527 : } else {
7528 1048300 : CalcHeatBalanceInsideSurf2(state,
7529 209660 : state.dataSurface->AllHTSurfaceList,
7530 209660 : state.dataSurface->AllIZSurfaceList,
7531 209660 : state.dataSurface->AllHTNonWindowSurfaceList,
7532 209660 : state.dataSurface->AllHTWindowSurfaceList);
7533 : }
7534 : } else {
7535 808964 : auto const &zoneHTSurfList(state.dataHeatBal->Zone(ZoneToResimulate).ZoneHTSurfaceList);
7536 808964 : auto const &zoneIZSurfList(state.dataHeatBal->Zone(ZoneToResimulate).ZoneIZSurfaceList);
7537 808964 : auto const &zoneHTNonWindowSurfList(state.dataHeatBal->Zone(ZoneToResimulate).ZoneHTNonWindowSurfaceList);
7538 808964 : auto const &zoneHTWindowSurfList(state.dataHeatBal->Zone(ZoneToResimulate).ZoneHTWindowSurfaceList);
7539 : // Cannot use CalcHeatBalanceInsideSurf2CTFOnly because resimulated zone includes adjacent interzone surfaces
7540 808964 : CalcHeatBalanceInsideSurf2(state, zoneHTSurfList, zoneIZSurfList, zoneHTNonWindowSurfList, zoneHTWindowSurfList, ZoneToResimulate);
7541 : }
7542 3487776 : CalculateZoneMRT(state, ZoneToResimulate); // Update here so that the proper value of MRT is available to radiant systems
7543 3487776 : UpdateIntermediateSurfaceHeatBalanceResults(state, ZoneToResimulate);
7544 3487776 : }
7545 :
7546 1018624 : void CalcHeatBalanceInsideSurf2(EnergyPlusData &state,
7547 : const std::vector<int> &HTSurfs, // Heat transfer surfaces to simulate (opaque and windows)
7548 : const std::vector<int> &IZSurfs, // Interzone heat transfer surfaces to simulate
7549 : const std::vector<int> &HTNonWindowSurfs, // Non-window heat transfer surfaces to simulate
7550 : const std::vector<int> &HTWindowSurfs, // Window heat transfer surfaces to simulate
7551 : Optional_int_const ZoneToResimulate)
7552 : {
7553 : // SUBROUTINE INFORMATION:
7554 : // AUTHOR George Walton
7555 : // DATE WRITTEN December 1979
7556 : // MODIFIED Jun 1990 (RDT for new CTF arrays)
7557 : // Dec 1999 (FCW for window calculation)
7558 : // May 2000 (FCW for window frame and dividers)
7559 : // Aug 2000 (RJL for MTF moisture calculations)
7560 : // Sep 2000 (RKS for new radiant exchange algorithm)
7561 : // Dec 2000 (RKS for radiant system model addition)
7562 : // Jul 2003 (CC) set the reference temperatures for inside surface heat balance
7563 : // depending on convection algorithms and/or air models used
7564 : // May 2006 (RR account for exterior window screen)
7565 : // Jul 2008 (P. Biddulph include calls to HAMT)
7566 : // Sep 2011 LKL/BG - resimulate only zones needing it for Radiant systems
7567 : // RE-ENGINEERED Mar 1998 (RKS)
7568 :
7569 : // PURPOSE OF THIS SUBROUTINE:
7570 : // This subroutine performs a heat balance on the inside face of each
7571 : // surface in the building.
7572 :
7573 : // METHODOLOGY EMPLOYED:
7574 : // Various boundary conditions are set and additional parameters are set-
7575 : // up. Then, the proper heat balance equation is selected based on whether
7576 : // the surface is a partition or not and on whether or not movable
7577 : // insulation is present on the inside face.
7578 :
7579 : // REFERENCES:
7580 : // (I)BLAST legacy routine HBSRF
7581 :
7582 1018624 : constexpr const char *rhoAirZone("RhoAirZone");
7583 1018624 : constexpr const char *wsurf("Wsurf");
7584 1018624 : constexpr const char *HBSurfManInsideSurf("HB,SurfMan:InsideSurf");
7585 1018624 : constexpr const char *Inside("Inside");
7586 :
7587 : Real64 TempSurfOutTmp; // Local Temporary Surface temperature for the outside surface face
7588 : Real64 SurfTempInSat; // Local temporary surface dew point temperature
7589 :
7590 : Real64 Wsurf; // Moisture ratio for HAMT
7591 : Real64 RhoAirZone; // Zone moisture density for HAMT
7592 : int OtherSideZoneNum; // Zone Number index for other side of an interzone partition HAMT
7593 1018624 : auto &Surface(state.dataSurface->Surface);
7594 :
7595 : // determine reference air temperatures
7596 13242585 : for (int SurfNum : HTSurfs) {
7597 :
7598 : // These conditions are not used in every SurfNum loop here so we don't use them to skip surfaces
7599 12223961 : if (Surface(SurfNum).Class == SurfaceClass::TDD_Dome) continue; // Skip TDD:DOME objects. Inside temp is handled by TDD:DIFFUSER.
7600 12223961 : Real64 RefAirTemp = state.dataSurface->Surface(SurfNum).getInsideAirTemperature(state, SurfNum);
7601 12223961 : state.dataHeatBalSurfMgr->RefAirTemp(SurfNum) = RefAirTemp;
7602 12223961 : state.dataHeatBal->SurfTempEffBulkAir(SurfNum) = state.dataHeatBalSurfMgr->RefAirTemp(SurfNum);
7603 : }
7604 :
7605 : // Following variables must be reset due to possible recall of this routine by radiant and Resimulate routines.
7606 : // CalcWindowHeatBalance is called, then, multiple times and these need to be initialized before each call to
7607 : // CalcWindowHeatBalance.
7608 : // Only for Surface(SurfNum).Class == DataSurfaces::SurfaceClass::Window
7609 1911314 : for (int surfNum : HTWindowSurfs) {
7610 892690 : state.dataSurface->SurfWinHeatGain(surfNum) = 0.0;
7611 892690 : state.dataSurface->SurfWinHeatGainRep(surfNum) = 0.0;
7612 892690 : state.dataSurface->SurfWinHeatLossRep(surfNum) = 0.0;
7613 892690 : state.dataSurface->SurfWinGainConvGlazToZoneRep(surfNum) = 0.0;
7614 892690 : state.dataSurface->SurfWinGainIRGlazToZoneRep(surfNum) = 0.0;
7615 892690 : state.dataSurface->SurfWinLossSWZoneToOutWinRep(surfNum) = 0.0;
7616 892690 : state.dataSurface->SurfWinGainFrameDividerToZoneRep(surfNum) = 0.0;
7617 892690 : state.dataSurface->SurfWinGainConvShadeToZoneRep(surfNum) = 0.0;
7618 892690 : state.dataSurface->SurfWinGainIRShadeToZoneRep(surfNum) = 0.0;
7619 892690 : state.dataSurface->SurfWinFrameQRadOutAbs(surfNum) = 0.0;
7620 892690 : state.dataSurface->SurfWinFrameQRadInAbs(surfNum) = 0.0;
7621 892690 : state.dataSurface->SurfWinDividerQRadOutAbs(surfNum) = 0.0;
7622 892690 : state.dataSurface->SurfWinDividerQRadInAbs(surfNum) = 0.0;
7623 : }
7624 :
7625 1018624 : state.dataHeatBal->InsideSurfIterations = 0;
7626 :
7627 : // Calculate heat extract due to additional heat flux source term as the surface boundary condition
7628 1018624 : if (state.dataSurface->AnyHeatBalanceInsideSourceTerm) {
7629 0 : for (int SurfNum : HTSurfs) {
7630 0 : if (Surface(SurfNum).InsideHeatSourceTermSchedule) {
7631 0 : state.dataHeatBalSurf->SurfQAdditionalHeatSourceInside(SurfNum) =
7632 0 : EnergyPlus::ScheduleManager::GetCurrentScheduleValue(state, Surface(SurfNum).InsideHeatSourceTermSchedule);
7633 : }
7634 : }
7635 : }
7636 :
7637 : // Calculate Kiva instances
7638 1018624 : if (state.dataHeatBal->AnyKiva) {
7639 65691 : if (((state.dataSurfaceGeometry->kivaManager.settings.timestepType == HeatBalanceKivaManager::KivaManager::Settings::HOURLY &&
7640 39572 : state.dataGlobal->TimeStep == 1) ||
7641 43794 : state.dataSurfaceGeometry->kivaManager.settings.timestepType == HeatBalanceKivaManager::KivaManager::Settings::TIMESTEP) &&
7642 4222 : !state.dataGlobal->WarmupFlag) {
7643 576 : state.dataSurfaceGeometry->kivaManager.calcKivaInstances(state);
7644 : }
7645 : }
7646 :
7647 1018624 : bool Converged = false; // .TRUE. if inside heat balance has converged
7648 6962170 : while (!Converged) { // Start of main inside heat balance DO loop...
7649 :
7650 2971773 : state.dataHeatBalSurf->SurfTempInsOld = state.dataHeatBalSurf->SurfTempIn; // Keep track of last iteration's temperature values
7651 :
7652 2971773 : if (state.dataHeatBal->AnyKiva) {
7653 550139 : for (auto &kivaSurf : state.dataSurfaceGeometry->kivaManager.surfaceMap) {
7654 453305 : state.dataHeatBalSurf->SurfTempIn(kivaSurf.first) = kivaSurf.second.results.Trad - DataGlobalConstants::KelvinConv;
7655 : }
7656 : }
7657 :
7658 11887092 : HeatBalanceIntRadExchange::CalcInteriorRadExchange(state,
7659 2971773 : state.dataHeatBalSurf->SurfTempIn,
7660 2971773 : state.dataHeatBal->InsideSurfIterations,
7661 2971773 : state.dataHeatBalSurf->SurfQdotRadNetLWInPerArea,
7662 : ZoneToResimulate,
7663 2971773 : Inside); // Update the radiation balance
7664 :
7665 2971773 : if (state.dataHeatBal->AnyKiva) {
7666 550139 : for (auto &kivaSurf : state.dataSurfaceGeometry->kivaManager.surfaceMap) {
7667 453305 : state.dataHeatBalSurf->SurfTempIn(kivaSurf.first) = state.dataHeatBalSurf->SurfTempInsOld(kivaSurf.first);
7668 : }
7669 : }
7670 :
7671 : // Every 30 iterations, recalculate the inside convection coefficients in case
7672 : // there has been a significant drift in the surface temperatures predicted.
7673 : // This is not fool-proof and it basically means that the outside surface
7674 : // heat balance is in error (potentially) once HConvIn is re-evaluated.
7675 : // The choice of 30 is not significant--just want to do this a couple of
7676 : // times before the iteration limit is hit.
7677 2971773 : if ((state.dataHeatBal->InsideSurfIterations > 0) && (mod(state.dataHeatBal->InsideSurfIterations, ItersReevalConvCoeff) == 0)) {
7678 55 : ConvectionCoefficients::InitInteriorConvectionCoeffs(state, state.dataHeatBalSurf->SurfTempIn, ZoneToResimulate);
7679 : }
7680 :
7681 2971773 : if (state.dataHeatBal->AnyEMPD || state.dataHeatBal->AnyHAMT) {
7682 1432613 : for (int SurfNum : HTSurfs) {
7683 1325098 : auto &surface(Surface(SurfNum));
7684 1325098 : if (surface.Class == SurfaceClass::TDD_Dome) continue; // Skip TDD:DOME objects. Inside temp is handled by TDD:DIFFUSER.
7685 :
7686 : // Calculate the inside surface moisture quantities
7687 : // calculate the inside surface moisture transfer conditions
7688 : // check for saturation conditions of air
7689 1951057 : if ((surface.HeatTransferAlgorithm == DataSurfaces::HeatTransferModel::EMPD) ||
7690 625959 : (surface.HeatTransferAlgorithm == DataSurfaces::HeatTransferModel::HAMT)) {
7691 1052476 : int ZoneNum = Surface(SurfNum).Zone;
7692 1052476 : Real64 const MAT_zone(state.dataZoneTempPredictorCorrector->zoneHeatBalance(ZoneNum).MAT);
7693 1052476 : Real64 const ZoneAirHumRat_zone(max(state.dataZoneTempPredictorCorrector->zoneHeatBalance(ZoneNum).ZoneAirHumRat, 1.0e-5));
7694 1052476 : Real64 const HConvIn_surf(state.dataMstBal->HConvInFD(SurfNum) = state.dataHeatBalSurf->SurfHConvInt(SurfNum));
7695 :
7696 1052476 : state.dataMstBal->RhoVaporAirIn(SurfNum) =
7697 2104952 : min(Psychrometrics::PsyRhovFnTdbWPb_fast(MAT_zone, ZoneAirHumRat_zone, state.dataEnvrn->OutBaroPress),
7698 1052476 : Psychrometrics::PsyRhovFnTdbRh(state, MAT_zone, 1.0, HBSurfManInsideSurf));
7699 1052476 : state.dataMstBal->HMassConvInFD(SurfNum) =
7700 2104952 : HConvIn_surf / (Psychrometrics::PsyRhoAirFnPbTdbW_fast(state, state.dataEnvrn->OutBaroPress, MAT_zone, ZoneAirHumRat_zone) *
7701 1052476 : Psychrometrics::PsyCpAirFnW_fast(ZoneAirHumRat_zone));
7702 : }
7703 : }
7704 : }
7705 :
7706 39813721 : for (int SurfNum : HTNonWindowSurfs) {
7707 : // Perform heat balance on the inside face of the surface ...
7708 : // The following are possibilities here:
7709 : // (a) the surface is a pool (no movable insulation, no source/sink, only CTF solution algorithm)
7710 : // (b) the surface is a partition, in which case the temperature of both sides are the same
7711 : // (c) standard (or interzone) opaque surface with no movable insulation, normal heat balance equation
7712 : // (d) standard (or interzone) window: call to CalcWindowHeatBalance to get window layer temperatures
7713 : // (e) standard opaque surface with movable insulation, special two-part equation
7714 : // In the surface calculation there are the following Algorithm types for opaque surfaces that
7715 : // do not have movable insulation:
7716 : // (a) the regular CTF calc (SolutionAlgo = UseCTF)
7717 : // (b) the EMPD calc (Solutionalgo = UseEMPD)
7718 : // (c) the CondFD calc (SolutionAlgo = UseCondFD)
7719 : // (d) the HAMT calc (solutionalgo = UseHAMT).
7720 :
7721 36841948 : auto &surface(Surface(SurfNum));
7722 36841948 : if (state.dataSurface->UseRepresentativeSurfaceCalculations) {
7723 0 : int repSurfNum = surface.RepresentativeCalcSurfNum;
7724 0 : if (SurfNum != repSurfNum) continue;
7725 : }
7726 36841948 : int const ZoneNum = Surface(SurfNum).Zone;
7727 36841948 : Real64 &TH11(state.dataHeatBalSurf->SurfOutsideTempHist(1)(SurfNum));
7728 36841948 : int const ConstrNum = surface.Construction;
7729 36841948 : auto const &construct(state.dataConstruction->Construct(ConstrNum));
7730 36841948 : Real64 const MAT_zone(state.dataZoneTempPredictorCorrector->zoneHeatBalance(ZoneNum).MAT);
7731 36841948 : Real64 const HConvIn_surf(state.dataMstBal->HConvInFD(SurfNum) = state.dataHeatBalSurf->SurfHConvInt(SurfNum));
7732 :
7733 36841948 : if (surface.ExtBoundCond == SurfNum) {
7734 : // CR6869 -- let Window HB take care of it IF (Surface(SurfNum)%ExtBoundCond == SurfNum) THEN
7735 : // Surface is adiabatic
7736 1407497 : if (surface.HeatTransferAlgorithm == DataSurfaces::HeatTransferModel::CTF ||
7737 245715 : surface.HeatTransferAlgorithm == DataSurfaces::HeatTransferModel::EMPD) { // Regular CTF Surface and/or EMPD surface
7738 :
7739 916067 : if (surface.HeatTransferAlgorithm == DataSurfaces::HeatTransferModel::EMPD) {
7740 0 : MoistureBalanceEMPDManager::CalcMoistureBalanceEMPD(
7741 0 : state, SurfNum, state.dataHeatBalSurf->SurfTempInTmp(SurfNum), MAT_zone, SurfTempInSat);
7742 : }
7743 : // Pre-calculate a few terms
7744 916067 : if (state.dataHeatBalSurf->AnyRadiantSystems(SurfNum))
7745 6401 : state.dataHeatBalSurf->SurfQdotRadHVACInPerArea(SurfNum) = GetSurfQdotRadHVACInPerArea(state, SurfNum);
7746 : Real64 const TempTerm(
7747 1832134 : state.dataHeatBalSurf->SurfCTFConstInPart(SurfNum) + state.dataHeatBal->SurfQdotRadIntGainsInPerArea(SurfNum) +
7748 2748201 : state.dataHeatBalSurf->SurfOpaqQRadSWInAbs(SurfNum) + state.dataHeatBalSurf->SurfQAdditionalHeatSourceInside(SurfNum) +
7749 2748201 : HConvIn_surf * state.dataHeatBalSurfMgr->RefAirTemp(SurfNum) + state.dataHeatBalSurf->SurfQdotRadHVACInPerArea(SurfNum) +
7750 916067 : state.dataHeatBalSurf->SurfQdotRadNetLWInPerArea(SurfNum) +
7751 916067 : (state.dataHeatBalFanSys->QRadSurfAFNDuct(SurfNum) / state.dataGlobal->TimeStepZoneSec));
7752 916067 : Real64 const TempDiv(1.0 / (construct.CTFInside(0) - construct.CTFCross(0) + HConvIn_surf + IterDampConst));
7753 : // Calculate the current inside surface temperature
7754 1832134 : if ((!state.dataSurface->SurfIsPool(SurfNum)) ||
7755 0 : ((state.dataSurface->SurfIsPool(SurfNum)) &&
7756 0 : (std::abs(state.dataHeatBalFanSys->QPoolSurfNumerator(SurfNum)) < PoolIsOperatingLimit) &&
7757 0 : (std::abs(state.dataHeatBalFanSys->PoolHeatTransCoefs(SurfNum)) < PoolIsOperatingLimit))) {
7758 916067 : if (construct.SourceSinkPresent) {
7759 0 : state.dataHeatBalSurf->SurfTempInTmp(SurfNum) =
7760 0 : (TempTerm + construct.CTFSourceIn(0) * state.dataHeatBalSurf->SurfQsrcHist(SurfNum, 1) +
7761 0 : IterDampConst * state.dataHeatBalSurf->SurfTempInsOld(SurfNum)) *
7762 : TempDiv; // Constant portion of conduction eq (history terms) | LW radiation from internal sources | SW radiation
7763 : // from internal sources | Convection from surface to zone air | Net radiant exchange with other zone
7764 : // surfaces | Heat source/sink term for radiant systems | (if there is one present) | Radiant flux from a
7765 : // high temperature radiant heater | Radiant flux from a hot water baseboard heater | Radiant flux from a
7766 : // steam baseboard heater | Radiant flux from an electric baseboard heater | Iterative damping term (for
7767 : // stability) | Conduction term (both partition sides same temp) | Conduction term (both partition sides
7768 : // same temp) | Convection and damping term | Radiation from AFN ducts
7769 : } else {
7770 916067 : state.dataHeatBalSurf->SurfTempInTmp(SurfNum) =
7771 916067 : (TempTerm + IterDampConst * state.dataHeatBalSurf->SurfTempInsOld(SurfNum)) *
7772 : TempDiv; // Constant portion of conduction eq (history terms) | LW radiation from internal sources | SW radiation
7773 : // from internal sources | Convection from surface to zone air | Net radiant exchange with other zone
7774 : // surfaces | Heat source/sink term for radiant systems | (if there is one present) | Radiant flux from a
7775 : // high temperature radiant heater | Radiant flux from a hot water baseboard heater | Radiant flux from a
7776 : // steam baseboard heater | Radiant flux from an electric baseboard heater | Iterative damping term (for
7777 : // stability) | Conduction term (both partition sides same temp) | Conduction term (both partition sides
7778 : // same temp) | Convection and damping term | Radiation from AFN ducts
7779 : }
7780 : } else { // this is a pool and it has been simulated this time step
7781 0 : state.dataHeatBalSurf->SurfTempInTmp(SurfNum) =
7782 0 : (state.dataHeatBalSurf->SurfCTFConstInPart(SurfNum) + state.dataHeatBalFanSys->QPoolSurfNumerator(SurfNum) +
7783 0 : IterDampConst * state.dataHeatBalSurf->SurfTempInsOld(SurfNum)) /
7784 0 : (construct.CTFInside(0) - construct.CTFCross(0) + state.dataHeatBalFanSys->PoolHeatTransCoefs(SurfNum) +
7785 : IterDampConst); // Constant part of conduction eq (history terms) | Pool modified terms (see
7786 : // non-pool equation for details) | Iterative damping term (for stability) |
7787 : // Conduction term (both partition sides same temp) | Pool and damping term
7788 : }
7789 916067 : if (surface.HeatTransferAlgorithm == DataSurfaces::HeatTransferModel::EMPD) {
7790 0 : state.dataHeatBalSurf->SurfTempInTmp(SurfNum) -=
7791 0 : state.dataMstBalEMPD->HeatFluxLatent(SurfNum) * TempDiv; // Conduction term (both partition sides same temp) |
7792 : // Conduction term (both partition sides same temp) |
7793 : // Convection and damping term
7794 0 : if (SurfTempInSat > state.dataHeatBalSurf->SurfTempInTmp(SurfNum)) {
7795 0 : state.dataHeatBalSurf->SurfTempInTmp(SurfNum) = SurfTempInSat; // Surface temp cannot be below dew point
7796 : }
7797 : }
7798 : // if any mixed heat transfer models in zone, apply limits to CTF result
7799 916067 : if (state.dataHeatBalSurf->Zone_has_mixed_HT_models[ZoneNum])
7800 344062 : state.dataHeatBalSurf->SurfTempInTmp(SurfNum) =
7801 688124 : max(MinSurfaceTempLimit,
7802 344062 : min(state.dataHeatBalSurf->MaxSurfaceTempLimit,
7803 344062 : state.dataHeatBalSurf->SurfTempInTmp(SurfNum))); // Limit Check //Tuned Precomputed condition to eliminate loop
7804 :
7805 916067 : if (construct.SourceSinkPresent) { // Set the appropriate parameters for the radiant system
7806 :
7807 : // Radiant system does not need the damping coefficient terms (hopefully) // Partitions are assumed to be symmetric
7808 0 : Real64 const RadSysDiv(1.0 / (construct.CTFInside(0) - construct.CTFCross(0) + HConvIn_surf));
7809 0 : state.dataHeatBalFanSys->RadSysToHBConstCoef(SurfNum) = state.dataHeatBalFanSys->RadSysTiHBConstCoef(SurfNum) =
7810 0 : TempTerm * RadSysDiv; // Constant portion of conduction eq (history terms) | LW radiation from internal sources | SW
7811 : // radiation from internal sources | Convection from surface to zone air | Radiant flux from
7812 : // high temperature radiant heater | Radiant flux from a hot water baseboard heater | Radiant
7813 : // flux from a steam baseboard heater | Radiant flux from an electric baseboard heater | Net
7814 : // radiant exchange with other zone surfaces | Cond term (both partition sides same temp) | Cond
7815 : // term (both partition sides same temp) | Convection and damping term
7816 0 : state.dataHeatBalFanSys->RadSysToHBTinCoef(SurfNum) = state.dataHeatBalFanSys->RadSysTiHBToutCoef(SurfNum) =
7817 : 0.0; // The outside temp is assumed to be equal to the inside temp for a partition
7818 0 : state.dataHeatBalFanSys->RadSysToHBQsrcCoef(SurfNum) = state.dataHeatBalFanSys->RadSysTiHBQsrcCoef(SurfNum) =
7819 0 : construct.CTFSourceIn(0) * RadSysDiv; // QTF term for the source | Cond term (both partition sides same temp) | Cond
7820 : // term (both partition sides same temp) | Convection and damping term
7821 916067 : }
7822 :
7823 245715 : } else if (surface.HeatTransferAlgorithm == DataSurfaces::HeatTransferModel::CondFD ||
7824 0 : surface.HeatTransferAlgorithm == DataSurfaces::HeatTransferModel::HAMT) {
7825 :
7826 245715 : if (surface.HeatTransferAlgorithm == DataSurfaces::HeatTransferModel::HAMT)
7827 0 : HeatBalanceHAMTManager::ManageHeatBalHAMT(state,
7828 : SurfNum,
7829 0 : state.dataHeatBalSurf->SurfTempInTmp(SurfNum),
7830 : TempSurfOutTmp); // HAMT
7831 :
7832 245715 : if (surface.HeatTransferAlgorithm == DataSurfaces::HeatTransferModel::CondFD) {
7833 491430 : HeatBalFiniteDiffManager::ManageHeatBalFiniteDiff(
7834 491430 : state, SurfNum, state.dataHeatBalSurf->SurfTempInTmp(SurfNum), TempSurfOutTmp);
7835 : }
7836 :
7837 245715 : TH11 = TempSurfOutTmp;
7838 : }
7839 :
7840 1161782 : state.dataHeatBalSurf->SurfTempIn(SurfNum) = state.dataHeatBalSurf->SurfTempInTmp(SurfNum);
7841 :
7842 : } else { // Standard surface or interzone surface
7843 35680166 : bool movableInsulPresent = state.dataSurface->AnyMovableInsulation && state.dataHeatBalSurf->SurfMovInsulIntPresent(SurfNum);
7844 35680166 : if (!movableInsulPresent) { // No movable insulation present, normal heat balance equation
7845 :
7846 46897573 : if (surface.HeatTransferAlgorithm == DataSurfaces::HeatTransferModel::CTF ||
7847 11217407 : surface.HeatTransferAlgorithm == DataSurfaces::HeatTransferModel::EMPD) { // Regular CTF Surface and/or EMPD surface
7848 :
7849 25161898 : if (surface.HeatTransferAlgorithm == DataSurfaces::HeatTransferModel::EMPD) {
7850 699139 : MoistureBalanceEMPDManager::CalcMoistureBalanceEMPD(
7851 699139 : state, SurfNum, state.dataHeatBalSurf->SurfTempInTmp(SurfNum), MAT_zone, SurfTempInSat);
7852 : }
7853 : // Pre-calculate a few terms
7854 25161898 : if (state.dataHeatBalSurf->AnyRadiantSystems(SurfNum))
7855 7278966 : state.dataHeatBalSurf->SurfQdotRadHVACInPerArea(SurfNum) = GetSurfQdotRadHVACInPerArea(state, SurfNum);
7856 : Real64 const TempTerm(
7857 50323796 : state.dataHeatBalSurf->SurfCTFConstInPart(SurfNum) + state.dataHeatBal->SurfQdotRadIntGainsInPerArea(SurfNum) +
7858 75485694 : state.dataHeatBalSurf->SurfOpaqQRadSWInAbs(SurfNum) + state.dataHeatBalSurf->SurfQAdditionalHeatSourceInside(SurfNum) +
7859 75485694 : HConvIn_surf * state.dataHeatBalSurfMgr->RefAirTemp(SurfNum) + state.dataHeatBalSurf->SurfQdotRadHVACInPerArea(SurfNum) +
7860 25161898 : state.dataHeatBalSurf->SurfQdotRadNetLWInPerArea(SurfNum) +
7861 25161898 : (state.dataHeatBalFanSys->QRadSurfAFNDuct(SurfNum) / state.dataGlobal->TimeStepZoneSec));
7862 25161898 : Real64 const TempDiv(1.0 / (construct.CTFInside(0) + HConvIn_surf + IterDampConst));
7863 : // Calculate the current inside surface temperature
7864 50323796 : if ((!state.dataSurface->SurfIsPool(SurfNum)) ||
7865 0 : ((state.dataSurface->SurfIsPool(SurfNum)) &&
7866 0 : (std::abs(state.dataHeatBalFanSys->QPoolSurfNumerator(SurfNum)) < PoolIsOperatingLimit) &&
7867 0 : (std::abs(state.dataHeatBalFanSys->PoolHeatTransCoefs(SurfNum)) < PoolIsOperatingLimit))) {
7868 25161898 : if (construct.SourceSinkPresent) {
7869 1713103 : state.dataHeatBalSurf->SurfTempInTmp(SurfNum) =
7870 3426206 : (TempTerm + construct.CTFSourceIn(0) * state.dataHeatBalSurf->SurfQsrcHist(SurfNum, 1) +
7871 3426206 : IterDampConst * state.dataHeatBalSurf->SurfTempInsOld(SurfNum) + construct.CTFCross(0) * TH11) *
7872 : TempDiv; // Constant part of conduction eq (history terms) | LW radiation from internal sources | SW
7873 : // radiation from internal sources | Convection from surface to zone air | Net radiant exchange
7874 : // with other zone surfaces | Heat source/sink term for radiant systems | (if there is one
7875 : // present) | Radiant flux from high temp radiant heater | Radiant flux from a hot water
7876 : // baseboard heater | Radiant flux from a steam baseboard heater | Radiant flux from an electric
7877 : // baseboard heater | Iterative damping term (for stability) | Current conduction from | the
7878 : // outside surface | Coefficient for conduction (current time) | Convection and damping term |
7879 : // Radiation from AFN ducts
7880 : } else {
7881 23448795 : state.dataHeatBalSurf->SurfTempInTmp(SurfNum) =
7882 23448795 : (TempTerm + IterDampConst * state.dataHeatBalSurf->SurfTempInsOld(SurfNum) + construct.CTFCross(0) * TH11) *
7883 : TempDiv; // Constant part of conduction eq (history terms) | LW radiation from internal sources | SW
7884 : // radiation from internal sources | Convection from surface to zone air | Net radiant exchange
7885 : // with other zone surfaces | Heat source/sink term for radiant systems | (if there is one
7886 : // present) | Radiant flux from high temp radiant heater | Radiant flux from a hot water
7887 : // baseboard heater | Radiant flux from a steam baseboard heater | Radiant flux from an electric
7888 : // baseboard heater | Iterative damping term (for stability) | Current conduction from | the
7889 : // outside surface | Coefficient for conduction (current time) | Convection and damping term |
7890 : // Radiation from AFN ducts
7891 : }
7892 : } else { // surface is a pool and the pool has been simulated this time step
7893 0 : state.dataHeatBalSurf->SurfTempInTmp(SurfNum) =
7894 0 : (state.dataHeatBalSurf->SurfCTFConstInPart(SurfNum) + state.dataHeatBalFanSys->QPoolSurfNumerator(SurfNum) +
7895 0 : IterDampConst * state.dataHeatBalSurf->SurfTempInsOld(SurfNum) + construct.CTFCross(0) * TH11) /
7896 0 : (construct.CTFInside(0) + state.dataHeatBalFanSys->PoolHeatTransCoefs(SurfNum) +
7897 : IterDampConst); // Constant part of conduction eq (history terms) | Pool modified terms
7898 : // (see non-pool equation for details) | Iterative damping term (for
7899 : // stability) | Current conduction from | the outside surface |
7900 : // Coefficient for conduction (current time) | Pool and damping term
7901 : }
7902 25161898 : if (surface.HeatTransferAlgorithm == DataSurfaces::HeatTransferModel::EMPD) {
7903 699139 : state.dataHeatBalSurf->SurfTempInTmp(SurfNum) -=
7904 699139 : state.dataMstBalEMPD->HeatFluxLatent(SurfNum) *
7905 : TempDiv; // Coefficient for conduction (current time) | Convection and damping term
7906 699139 : if (SurfTempInSat > state.dataHeatBalSurf->SurfTempInTmp(SurfNum)) {
7907 0 : state.dataHeatBalSurf->SurfTempInTmp(SurfNum) = SurfTempInSat; // Surface temp cannot be below dew point
7908 : }
7909 : }
7910 : // if any mixed heat transfer models in zone, apply limits to CTF result
7911 25161898 : if (state.dataHeatBalSurf->Zone_has_mixed_HT_models[ZoneNum])
7912 4134546 : state.dataHeatBalSurf->SurfTempInTmp(SurfNum) = max(
7913 : MinSurfaceTempLimit,
7914 2067273 : min(state.dataHeatBalSurf->MaxSurfaceTempLimit,
7915 2067273 : state.dataHeatBalSurf->SurfTempInTmp(SurfNum))); // Limit Check //Tuned Precomputed condition to eliminate loop
7916 :
7917 25161898 : if (construct.SourceSinkPresent) { // Set the appropriate parameters for the radiant system
7918 :
7919 : // Radiant system does not need the damping coefficient terms (hopefully)
7920 1713103 : Real64 const RadSysDiv(1.0 / (construct.CTFInside(0) + HConvIn_surf));
7921 1713103 : state.dataHeatBalFanSys->RadSysTiHBConstCoef(SurfNum) =
7922 1713103 : TempTerm * RadSysDiv; // Constant portion of cond eq (history terms) | LW radiation from internal sources | SW
7923 : // radiation from internal sources | Convection from surface to zone air | Radiant flux
7924 : // from high temp radiant heater | Radiant flux from a hot water baseboard heater |
7925 : // Radiant flux from a steam baseboard heater | Radiant flux from an electric baseboard
7926 : // heater | Net radiant exchange with other zone surfaces | Cond term (both partition
7927 : // sides same temp) | Convection and damping term
7928 1713103 : state.dataHeatBalFanSys->RadSysTiHBToutCoef(SurfNum) =
7929 1713103 : construct.CTFCross(0) * RadSysDiv; // Outside temp=inside temp for a partition |
7930 : // Cond term (both partition sides same temp) |
7931 : // Convection and damping term
7932 1713103 : state.dataHeatBalFanSys->RadSysTiHBQsrcCoef(SurfNum) =
7933 1713103 : construct.CTFSourceIn(0) * RadSysDiv; // QTF term for the source | Cond term (both
7934 : // partition sides same temp) | Convection and
7935 : // damping term
7936 :
7937 1713103 : if (surface.ExtBoundCond > 0) { // This is an interzone partition and we need to set outside params
7938 : // The inside coefficients of one side are equal to the outside coefficients of the other side. But,
7939 : // the inside coefficients are set up once the heat balance equation for that side has been calculated.
7940 : // For both sides to actually have been set, we have to wait until we get to the second side in the surface
7941 : // derived type. At that point, both inside coefficient sets have been evaluated.
7942 272062 : if (surface.ExtBoundCond < SurfNum) { // Both of the inside coefficients have now been set
7943 136031 : int OtherSideSurfNum = surface.ExtBoundCond;
7944 136031 : state.dataHeatBalFanSys->RadSysToHBConstCoef(OtherSideSurfNum) =
7945 136031 : state.dataHeatBalFanSys->RadSysTiHBConstCoef(SurfNum);
7946 136031 : state.dataHeatBalFanSys->RadSysToHBTinCoef(OtherSideSurfNum) =
7947 136031 : state.dataHeatBalFanSys->RadSysTiHBToutCoef(SurfNum);
7948 136031 : state.dataHeatBalFanSys->RadSysToHBQsrcCoef(OtherSideSurfNum) =
7949 136031 : state.dataHeatBalFanSys->RadSysTiHBQsrcCoef(SurfNum);
7950 136031 : state.dataHeatBalFanSys->RadSysToHBConstCoef(SurfNum) =
7951 136031 : state.dataHeatBalFanSys->RadSysTiHBConstCoef(OtherSideSurfNum);
7952 136031 : state.dataHeatBalFanSys->RadSysToHBTinCoef(SurfNum) =
7953 136031 : state.dataHeatBalFanSys->RadSysTiHBToutCoef(OtherSideSurfNum);
7954 136031 : state.dataHeatBalFanSys->RadSysToHBQsrcCoef(SurfNum) =
7955 136031 : state.dataHeatBalFanSys->RadSysTiHBQsrcCoef(OtherSideSurfNum);
7956 : }
7957 : }
7958 25161898 : }
7959 :
7960 11324910 : } else if (surface.HeatTransferAlgorithm == DataSurfaces::HeatTransferModel::CondFD ||
7961 806642 : surface.HeatTransferAlgorithm == DataSurfaces::HeatTransferModel::HAMT) {
7962 :
7963 10064963 : if (surface.HeatTransferAlgorithm == DataSurfaces::HeatTransferModel::HAMT) {
7964 353337 : if (surface.ExtBoundCond > 0) {
7965 : // HAMT get the correct other side zone zone air temperature --
7966 0 : int OtherSideSurfNum = surface.ExtBoundCond;
7967 : // ZoneNum = surface.Zone;
7968 0 : OtherSideZoneNum = Surface(OtherSideSurfNum).Zone;
7969 0 : state.dataMstBal->TempOutsideAirFD(SurfNum) =
7970 0 : state.dataZoneTempPredictorCorrector->zoneHeatBalance(OtherSideZoneNum).MAT;
7971 : }
7972 353337 : HeatBalanceHAMTManager::ManageHeatBalHAMT(state, SurfNum, state.dataHeatBalSurf->SurfTempInTmp(SurfNum), TempSurfOutTmp);
7973 : }
7974 :
7975 10064963 : if (surface.HeatTransferAlgorithm == DataSurfaces::HeatTransferModel::CondFD)
7976 19423252 : HeatBalFiniteDiffManager::ManageHeatBalFiniteDiff(
7977 19423252 : state, SurfNum, state.dataHeatBalSurf->SurfTempInTmp(SurfNum), TempSurfOutTmp);
7978 :
7979 10064963 : TH11 = TempSurfOutTmp;
7980 :
7981 453305 : } else if (surface.HeatTransferAlgorithm == DataSurfaces::HeatTransferModel::Kiva) {
7982 : // Read Kiva results for each surface
7983 453305 : state.dataHeatBalSurf->SurfTempInTmp(SurfNum) =
7984 453305 : state.dataSurfaceGeometry->kivaManager.surfaceMap[SurfNum].results.Tconv - DataGlobalConstants::KelvinConv;
7985 :
7986 453305 : TH11 = 0.0;
7987 : }
7988 :
7989 35680166 : state.dataHeatBalSurf->SurfTempIn(SurfNum) = state.dataHeatBalSurf->SurfTempInTmp(SurfNum);
7990 :
7991 : } else { // Movable insulation present
7992 0 : Real64 HMovInsul = state.dataHeatBalSurf->SurfMovInsulHInt(SurfNum);
7993 0 : if (construct.SourceSinkPresent) {
7994 :
7995 0 : ShowSevereError(state, "Interior movable insulation is not valid with embedded sources/sinks");
7996 0 : ShowContinueError(state, "Construction " + construct.Name + " contains an internal source or sink but also uses");
7997 0 : ShowContinueError(state,
7998 0 : "interior movable insulation " +
7999 0 : state.dataMaterial->Material(state.dataSurface->SurfMaterialMovInsulInt(SurfNum)).Name +
8000 : " for a surface with that construction.");
8001 0 : ShowContinueError(state,
8002 : "This is not currently allowed because the heat balance equations do not currently accommodate "
8003 : "this combination.");
8004 0 : ShowFatalError(state, "CalcHeatBalanceInsideSurf: Program terminates due to preceding conditions.");
8005 : }
8006 :
8007 0 : Real64 F1 = HMovInsul / (HMovInsul + HConvIn_surf + IterDampConst);
8008 :
8009 0 : if (state.dataHeatBalSurf->AnyRadiantSystems(SurfNum))
8010 0 : state.dataHeatBalSurf->SurfQdotRadHVACInPerArea(SurfNum) = GetSurfQdotRadHVACInPerArea(state, SurfNum);
8011 0 : state.dataHeatBalSurf->SurfTempIn(SurfNum) =
8012 0 : (state.dataHeatBalSurf->SurfCTFConstInPart(SurfNum) + state.dataHeatBalSurf->SurfOpaqQRadSWInAbs(SurfNum) +
8013 0 : construct.CTFCross(0) * TH11 +
8014 0 : F1 * (state.dataHeatBal->SurfQdotRadIntGainsInPerArea(SurfNum) +
8015 0 : HConvIn_surf * state.dataHeatBalSurfMgr->RefAirTemp(SurfNum) +
8016 0 : state.dataHeatBalSurf->SurfQdotRadNetLWInPerArea(SurfNum) + state.dataHeatBalSurf->SurfQdotRadHVACInPerArea(SurfNum) +
8017 0 : state.dataHeatBalSurf->SurfQAdditionalHeatSourceInside(SurfNum) +
8018 0 : IterDampConst * state.dataHeatBalSurf->SurfTempInsOld(SurfNum))) /
8019 0 : (construct.CTFInside(0) + HMovInsul - F1 * HMovInsul); // Convection from surface to zone air
8020 :
8021 0 : state.dataHeatBalSurf->SurfTempInTmp(SurfNum) =
8022 0 : (construct.CTFInside(0) * state.dataHeatBalSurf->SurfTempIn(SurfNum) +
8023 0 : HMovInsul * state.dataHeatBalSurf->SurfTempIn(SurfNum) - state.dataHeatBalSurf->SurfOpaqQRadSWInAbs(SurfNum) -
8024 0 : state.dataHeatBalSurf->SurfCTFConstInPart(SurfNum) - construct.CTFCross(0) * TH11) /
8025 : (HMovInsul);
8026 : // if any mixed heat transfer models in zone, apply limits to CTF result
8027 0 : if (state.dataHeatBalSurf->Zone_has_mixed_HT_models[ZoneNum])
8028 0 : state.dataHeatBalSurf->SurfTempInTmp(SurfNum) =
8029 0 : max(MinSurfaceTempLimit,
8030 0 : min(state.dataHeatBalSurf->MaxSurfaceTempLimit,
8031 0 : state.dataHeatBalSurf->SurfTempInTmp(SurfNum))); // Limit Check //Tuned Precomputed condition to eliminate loop
8032 : }
8033 : }
8034 : }
8035 5931363 : for (int SurfNum : HTWindowSurfs) {
8036 2959590 : auto &surface(Surface(SurfNum));
8037 2959590 : if (state.dataSurface->UseRepresentativeSurfaceCalculations) {
8038 0 : int repSurfNum = surface.RepresentativeCalcSurfNum;
8039 0 : if (SurfNum != repSurfNum) continue;
8040 : }
8041 2959590 : Real64 &TH11(state.dataHeatBalSurf->SurfOutsideTempHist(1)(SurfNum));
8042 2959590 : int const ConstrNum = state.dataSurface->SurfActiveConstruction(SurfNum); // Not const, because storm window may change this
8043 2959590 : auto const &construct(state.dataConstruction->Construct(ConstrNum));
8044 2959590 : if (state.dataSurface->SurfWinOriginalClass(SurfNum) == SurfaceClass::TDD_Diffuser) { // Tubular daylighting device
8045 : // Lookup up the TDD:DOME object
8046 0 : int const pipeNum = state.dataSurface->SurfWinTDDPipeNum(SurfNum);
8047 0 : int const domeNum = state.dataDaylightingDevicesData->TDDPipe(pipeNum).Dome;
8048 : // Ueff = 1 / effective R value between TDD:DOME and TDD:DIFFUSER
8049 0 : Real64 Ueff = 1.0 / state.dataDaylightingDevicesData->TDDPipe(pipeNum).Reff;
8050 :
8051 : // Similar to opaque surface but outside surface temp of TDD:DOME is used, and no embedded sources/sinks.
8052 : // Absorbed shortwave radiation is treated similar to a regular window, but only 1 glass layer is allowed.
8053 : // = SurfWinQRadSWwinAbs(SurfNum,1)/2.0
8054 0 : Real64 const HConvIn_surf(state.dataMstBal->HConvInFD(SurfNum) = state.dataHeatBalSurf->SurfHConvInt(SurfNum));
8055 0 : state.dataHeatBalSurf->SurfTempInTmp(SurfNum) =
8056 0 : (state.dataHeatBal->SurfQdotRadIntGainsInPerArea(SurfNum) + state.dataHeatBal->SurfWinQRadSWwinAbs(SurfNum, 1) / 2.0 +
8057 0 : state.dataHeatBalSurf->SurfQAdditionalHeatSourceInside(SurfNum) + HConvIn_surf * state.dataHeatBalSurfMgr->RefAirTemp(SurfNum) +
8058 0 : state.dataHeatBalSurf->SurfQdotRadNetLWInPerArea(SurfNum) + IterDampConst * state.dataHeatBalSurf->SurfTempInsOld(SurfNum) +
8059 0 : Ueff * state.dataHeatBalSurf->SurfOutsideTempHist(1)(domeNum)) /
8060 0 : (Ueff + HConvIn_surf + IterDampConst); // LW radiation from internal sources | SW radiation from internal sources and
8061 : // solar | Convection from surface to zone air | Net radiant exchange with
8062 : // other zone surfaces | Iterative damping term (for stability) | Current
8063 : // conduction from the outside surface | Coefficient for conduction (current
8064 : // time) | Convection and damping term
8065 0 : state.dataHeatBalSurf->SurfTempIn(SurfNum) = state.dataHeatBalSurf->SurfTempInTmp(SurfNum);
8066 :
8067 : Real64 const Sigma_Temp_4(DataGlobalConstants::StefanBoltzmann *
8068 0 : pow_4(state.dataHeatBalSurf->SurfTempIn(SurfNum) + DataGlobalConstants::KelvinConv));
8069 :
8070 : // Calculate window heat gain for TDD:DIFFUSER since this calculation is usually done in WindowManager
8071 0 : if (state.dataHeatBalSurf->AnyRadiantSystems(SurfNum))
8072 0 : state.dataHeatBalSurf->SurfQdotRadHVACInPerArea(SurfNum) = GetSurfQdotRadHVACInPerArea(state, SurfNum);
8073 0 : state.dataSurface->SurfWinHeatGain(SurfNum) =
8074 0 : state.dataSurface->SurfWinTransSolar(SurfNum) +
8075 0 : HConvIn_surf * surface.Area * (state.dataHeatBalSurf->SurfTempIn(SurfNum) - state.dataHeatBalSurfMgr->RefAirTemp(SurfNum)) +
8076 0 : state.dataConstruction->Construct(surface.Construction).InsideAbsorpThermal * surface.Area *
8077 0 : (Sigma_Temp_4 -
8078 0 : (state.dataSurface->SurfWinIRfromParentZone(SurfNum) + state.dataHeatBalSurf->SurfQdotRadHVACInPerArea(SurfNum))) -
8079 0 : state.dataHeatBal->EnclSolQSWRad(surface.SolarEnclIndex) * surface.Area *
8080 0 : state.dataConstruction->Construct(surface.Construction).TransDiff;
8081 : // Transmitted solar | Convection | IR exchange | IR
8082 : // Zone diffuse interior shortwave reflected back into the TDD
8083 :
8084 : // fill out report vars for components of Window Heat Gain
8085 0 : state.dataSurface->SurfWinGainConvGlazToZoneRep(SurfNum) =
8086 0 : HConvIn_surf * surface.Area * (state.dataHeatBalSurf->SurfTempIn(SurfNum) - state.dataHeatBalSurfMgr->RefAirTemp(SurfNum));
8087 0 : state.dataSurface->SurfWinGainIRGlazToZoneRep(SurfNum) =
8088 0 : state.dataConstruction->Construct(surface.Construction).InsideAbsorpThermal * surface.Area *
8089 0 : (Sigma_Temp_4 - (state.dataSurface->SurfWinIRfromParentZone(SurfNum) + state.dataHeatBalSurf->SurfQdotRadHVACInPerArea(SurfNum)));
8090 0 : state.dataSurface->SurfWinLossSWZoneToOutWinRep(SurfNum) = state.dataHeatBal->EnclSolQSWRad(surface.SolarEnclIndex) * surface.Area *
8091 0 : state.dataConstruction->Construct(surface.Construction).TransDiff;
8092 : } else { // Regular window
8093 2959590 : if (state.dataHeatBal->InsideSurfIterations == 0) { // Do windows only once
8094 : // Get outside convection coeff for exterior window here to avoid calling
8095 : // InitExteriorConvectionCoeff from CalcWindowHeatBalance, which avoids circular reference
8096 : // (HeatBalanceSurfaceManager USEing and WindowManager and
8097 : // WindowManager USEing HeatBalanceSurfaceManager)
8098 892690 : if (surface.ExtBoundCond == ExternalEnvironment) {
8099 : DataSurfaces::SurfaceRoughness RoughSurf =
8100 892690 : state.dataMaterial->Material(construct.LayerPoint(1)).Roughness; // Outside surface roughness
8101 892690 : Real64 EmisOut = state.dataMaterial->Material(construct.LayerPoint(1)).AbsorpThermalFront; // Glass outside surface emissivity
8102 892690 : auto const shading_flag(state.dataSurface->SurfWinShadingFlag(SurfNum));
8103 892690 : if (ANY_EXTERIOR_SHADE_BLIND_SCREEN(shading_flag)) {
8104 : // Exterior shade in place
8105 0 : int const ConstrNumSh = Surface(SurfNum).activeShadedConstruction;
8106 0 : if (ConstrNumSh != 0) {
8107 0 : RoughSurf = state.dataMaterial->Material(state.dataConstruction->Construct(ConstrNumSh).LayerPoint(1)).Roughness;
8108 0 : EmisOut = state.dataMaterial->Material(state.dataConstruction->Construct(ConstrNumSh).LayerPoint(1)).AbsorpThermal;
8109 : }
8110 : }
8111 :
8112 : // Get the outside effective emissivity for Equivalent layer model
8113 892690 : if (construct.WindowTypeEQL) {
8114 0 : EmisOut = WindowEquivalentLayer::EQLWindowOutsideEffectiveEmiss(state, ConstrNum);
8115 : }
8116 : // Set Exterior Convection Coefficient...
8117 892690 : if (state.dataSurface->SurfExtConvCoeffIndex(SurfNum) > 0) {
8118 :
8119 0 : state.dataHeatBalSurf->SurfHcExt(SurfNum) = ConvectionCoefficients::SetExtConvectionCoeff(state, SurfNum);
8120 :
8121 892690 : } else if (surface.ExtWind) { // Window is exposed to wind (and possibly rain)
8122 :
8123 : // Calculate exterior heat transfer coefficients with windspeed (windspeed is calculated internally in
8124 : // subroutine)
8125 892690 : ConvectionCoefficients::InitExteriorConvectionCoeff(state,
8126 : SurfNum,
8127 : 0.0,
8128 : RoughSurf,
8129 : EmisOut,
8130 : TH11,
8131 892690 : state.dataHeatBalSurf->SurfHcExt(SurfNum),
8132 892690 : state.dataHeatBalSurf->SurfHSkyExt(SurfNum),
8133 892690 : state.dataHeatBalSurf->SurfHGrdExt(SurfNum),
8134 892690 : state.dataHeatBalSurf->SurfHAirExt(SurfNum));
8135 :
8136 892690 : if (state.dataEnvrn->IsRain) { // Raining: since wind exposed, outside window surface gets wet
8137 0 : state.dataHeatBalSurf->SurfHcExt(SurfNum) = 1000.0; // Reset SurfHcExt because of wetness
8138 : }
8139 :
8140 : } else { // Not Wind exposed
8141 :
8142 : // Calculate exterior heat transfer coefficients for windspeed = 0
8143 0 : ConvectionCoefficients::InitExteriorConvectionCoeff(state,
8144 : SurfNum,
8145 : 0.0,
8146 : RoughSurf,
8147 : EmisOut,
8148 : TH11,
8149 0 : state.dataHeatBalSurf->SurfHcExt(SurfNum),
8150 0 : state.dataHeatBalSurf->SurfHSkyExt(SurfNum),
8151 0 : state.dataHeatBalSurf->SurfHGrdExt(SurfNum),
8152 0 : state.dataHeatBalSurf->SurfHAirExt(SurfNum));
8153 : }
8154 : } else { // Interior Surface
8155 :
8156 0 : if (state.dataSurface->SurfExtConvCoeffIndex(SurfNum) > 0) {
8157 0 : state.dataHeatBalSurf->SurfHcExt(SurfNum) = ConvectionCoefficients::SetExtConvectionCoeff(state, SurfNum);
8158 : } else {
8159 : // Exterior Convection Coefficient for the Interior or Interzone Window is the Interior Convection Coeff of
8160 : // same
8161 0 : state.dataHeatBalSurf->SurfHcExt(SurfNum) = state.dataHeatBalSurf->SurfHConvInt(surface.ExtBoundCond);
8162 : }
8163 : }
8164 :
8165 : // Following call determines inside surface temperature of glazing, and of
8166 : // frame and/or divider, if present
8167 892690 : CalcWindowHeatBalance(
8168 892690 : state, SurfNum, state.dataHeatBalSurf->SurfHcExt(SurfNum), state.dataHeatBalSurf->SurfTempInTmp(SurfNum), TH11);
8169 :
8170 892690 : state.dataHeatBalSurf->SurfTempIn(SurfNum) = state.dataHeatBalSurf->SurfTempInTmp(SurfNum);
8171 : }
8172 : }
8173 : } // ...end of inside surface heat balance equation selection
8174 :
8175 42773311 : for (int SurfNum : HTSurfs) {
8176 39801538 : int const ZoneNum = Surface(SurfNum).Zone;
8177 39801538 : auto &zone(state.dataHeatBal->Zone(ZoneNum));
8178 39801538 : Real64 &TH11(state.dataHeatBalSurf->SurfOutsideTempHist(1)(SurfNum));
8179 39801538 : Real64 &TH12(state.dataHeatBalSurf->SurfInsideTempHist(1)(SurfNum));
8180 39801538 : TH12 = state.dataHeatBalSurf->SurfTempIn(SurfNum);
8181 39801538 : state.dataHeatBalSurf->SurfTempOut(SurfNum) = TH11; // For reporting
8182 39801538 : if (state.dataSurface->SurfWinOriginalClass(SurfNum) == SurfaceClass::TDD_Dome) continue;
8183 39801538 : if (state.dataSurface->SurfWinOriginalClass(SurfNum) == SurfaceClass::TDD_Diffuser) { // Tubular daylighting device
8184 : // Tubular daylighting devices are treated as one big object with an effective R value.
8185 : // The outside face temperature of the TDD:DOME and the inside face temperature of the
8186 : // TDD:DIFFUSER are calculated with the outside and inside heat balances respectively.
8187 : // Below, the resulting temperatures are copied to the inside face of the TDD:DOME
8188 : // and the outside face of the TDD:DIFFUSER for reporting.
8189 :
8190 : // Set inside temp variables of TDD:DOME equal to inside temp of TDD:DIFFUSER
8191 0 : int domeNum = state.dataDaylightingDevicesData->TDDPipe(state.dataSurface->SurfWinTDDPipeNum(SurfNum)).Dome;
8192 0 : state.dataHeatBalSurf->SurfInsideTempHist(1)(domeNum) = state.dataHeatBalSurf->SurfTempIn(domeNum) =
8193 0 : state.dataHeatBalSurf->SurfTempInTmp(domeNum) = state.dataHeatBalSurf->SurfTempIn(SurfNum);
8194 :
8195 : // Set outside temp reporting variable of TDD:DOME (since it gets skipped otherwise)
8196 : // Reset outside temp variables of TDD:DIFFUSER equal to outside temp of TDD:DOME
8197 0 : TH11 = state.dataHeatBalSurf->SurfTempOut(SurfNum) = state.dataHeatBalSurf->SurfTempOut(domeNum) =
8198 0 : state.dataHeatBalSurf->SurfOutsideTempHist(1)(domeNum);
8199 : }
8200 :
8201 39801538 : if ((TH12 > state.dataHeatBalSurf->MaxSurfaceTempLimit) || (TH12 < MinSurfaceTempLimit)) {
8202 0 : TestSurfTempCalcHeatBalanceInsideSurf(state, TH12, SurfNum, zone, state.dataHeatBalSurfMgr->calcHeatBalInsideSurfWarmupErrCount);
8203 : }
8204 :
8205 : } // ...end of main loops over all surfaces for inside heat balances
8206 :
8207 : // Interzone surface updating: interzone surfaces have other side temperatures
8208 : // which can vary as the simulation iterates through the inside heat
8209 : // balance. This block is intended to "lock" the opposite side (outside)
8210 : // temperatures to the correct value, namely the value calculated by the
8211 : // inside surface heat balance for the other side.
8212 : // assert(state.dataHeatBalSurf->TH.index(1, 1, 1) == 0u); // Assumed for linear indexing below
8213 : // auto const l211(state.dataHeatBalSurf->TH.index(2, 1, 1) - 1);
8214 22052851 : for (int SurfNum : IZSurfs) {
8215 19081078 : int const surfExtBoundCond(Surface(SurfNum).ExtBoundCond);
8216 : // Set the outside surface temperature to the inside surface temperature of the interzone pair.
8217 : // By going through all of the surfaces, this should pick up the other side as well as affect the next iteration.
8218 : // [ SurfNum - 1 ] == ( 1, 1, SurfNum )
8219 : // [ l211 + surfExtBoundCond ] == ( 2, 1, surfExtBoundCond )
8220 19081078 : state.dataHeatBalSurf->SurfTempOut(SurfNum) = state.dataHeatBalSurf->SurfOutsideTempHist(1)(SurfNum) =
8221 19081078 : state.dataHeatBalSurf->SurfInsideTempHist(1)(surfExtBoundCond);
8222 : }
8223 :
8224 2971773 : ++state.dataHeatBal->InsideSurfIterations;
8225 :
8226 : // Convergence check - Loop through all relevant non-window surfaces to check for convergence...
8227 2971773 : Real64 MaxDelTemp = 0.0; // Maximum change in surface temperature for any opaque surface from one iteration to the next
8228 39813721 : for (int SurfNum : HTNonWindowSurfs) {
8229 36841948 : MaxDelTemp = max(std::abs(state.dataHeatBalSurf->SurfTempIn(SurfNum) - state.dataHeatBalSurf->SurfTempInsOld(SurfNum)), MaxDelTemp);
8230 36841948 : if (Surface(SurfNum).HeatTransferAlgorithm == DataSurfaces::HeatTransferModel::CondFD) {
8231 : // also check all internal nodes as well as surface faces
8232 9957341 : MaxDelTemp = max(MaxDelTemp, state.dataHeatBalFiniteDiffMgr->SurfaceFD(SurfNum).MaxNodeDelTemp);
8233 : }
8234 : } // ...end of loop to check for convergence
8235 :
8236 2971773 : if (!state.dataHeatBal->AnyCondFD) {
8237 2008693 : if (MaxDelTemp <= state.dataHeatBal->MaxAllowedDelTemp) Converged = true;
8238 : } else {
8239 963080 : if (MaxDelTemp <= state.dataHeatBal->MaxAllowedDelTempCondFD) Converged = true;
8240 :
8241 : // resets relaxation factor to speed up iterations when under-relaxation is not needed.
8242 963080 : if (state.dataHeatBal->InsideSurfIterations <= 1) {
8243 327964 : state.dataHeatBal->CondFDRelaxFactor = state.dataHeatBal->CondFDRelaxFactorInput;
8244 : }
8245 963080 : if ((state.dataHeatBal->InsideSurfIterations > IterationsForCondFDRelaxChange) && !Converged) {
8246 : // adjust relaxation factor down, assume large number of iterations is result of instability
8247 1364 : state.dataHeatBal->CondFDRelaxFactor *= 0.9;
8248 1364 : if (state.dataHeatBal->CondFDRelaxFactor < 0.1) state.dataHeatBal->CondFDRelaxFactor = 0.1;
8249 : }
8250 : }
8251 :
8252 : #ifdef EP_Count_Calls
8253 : state.dataTimingsData->NumMaxInsideSurfIterations =
8254 : max(state.dataTimingsData->NumMaxInsideSurfIterations, state.dataHeatBal->InsideSurfIterations);
8255 : #endif
8256 :
8257 2971773 : if (state.dataHeatBal->InsideSurfIterations < state.dataHeatBalSurf->MinIterations) Converged = false;
8258 :
8259 2971773 : if (state.dataHeatBal->InsideSurfIterations > MaxIterations) {
8260 0 : if (!state.dataGlobal->WarmupFlag) {
8261 0 : ++state.dataHeatBalSurfMgr->calcHeatBalInsideSurfErrCount;
8262 0 : if (state.dataHeatBalSurfMgr->calcHeatBalInsideSurfErrCount < 16) {
8263 0 : if (!state.dataHeatBal->AnyCondFD) {
8264 0 : ShowWarningError(state,
8265 0 : format("Inside surface heat balance did not converge with Max Temp Difference [C] ={:.3R} vs Max "
8266 : "Allowed Temp Diff [C] ={:.3R}",
8267 : MaxDelTemp,
8268 0 : state.dataHeatBal->MaxAllowedDelTemp));
8269 0 : ShowContinueErrorTimeStamp(state, "");
8270 : } else {
8271 0 : ShowWarningError(state,
8272 0 : format("Inside surface heat balance did not converge with Max Temp Difference [C] ={:.3R} vs Max "
8273 : "Allowed Temp Diff [C] ={:.6R}",
8274 : MaxDelTemp,
8275 0 : state.dataHeatBal->MaxAllowedDelTempCondFD));
8276 0 : ShowContinueErrorTimeStamp(state, "");
8277 : }
8278 : } else {
8279 0 : ShowRecurringWarningErrorAtEnd(state,
8280 : "Inside surface heat balance convergence problem continues",
8281 0 : state.dataHeatBalSurfMgr->calcHeatBalInsideSurfErrPointer,
8282 : MaxDelTemp,
8283 : MaxDelTemp,
8284 : _,
8285 : "[C]",
8286 : "[C]");
8287 : }
8288 : }
8289 0 : break; // iteration loop
8290 : }
8291 :
8292 : } // ...end of main inside heat balance DO loop (ends when Converged)
8293 :
8294 : // Update SumHmXXXX for non-window EMPD or HAMT surfaces
8295 1018624 : if (state.dataHeatBal->AnyEMPD || state.dataHeatBal->AnyHAMT) {
8296 :
8297 : // these SumHmA* variables are only used for EMPD and HAMT and should be reset each time step (and every iteration)
8298 94956 : for (auto &thisZoneHB : state.dataZoneTempPredictorCorrector->zoneHeatBalance) {
8299 54963 : thisZoneHB.SumHmAW = 0.0;
8300 54963 : thisZoneHB.SumHmARa = 0.0;
8301 54963 : thisZoneHB.SumHmARaW = 0.0;
8302 : }
8303 :
8304 381747 : for (int SurfNum : HTNonWindowSurfs) {
8305 341754 : auto const &surface(Surface(SurfNum));
8306 341754 : int ZoneNum = surface.Zone;
8307 341754 : auto &thisZoneHB = state.dataZoneTempPredictorCorrector->zoneHeatBalance(ZoneNum);
8308 :
8309 341754 : if (surface.HeatTransferAlgorithm == DataSurfaces::HeatTransferModel::HAMT) {
8310 171564 : HeatBalanceHAMTManager::UpdateHeatBalHAMT(state, SurfNum);
8311 :
8312 171564 : Real64 const FD_Area_fac(state.dataMstBal->HMassConvInFD(SurfNum) * surface.Area);
8313 :
8314 171564 : thisZoneHB.SumHmAW += FD_Area_fac * (state.dataMstBal->RhoVaporSurfIn(SurfNum) - state.dataMstBal->RhoVaporAirIn(SurfNum));
8315 :
8316 171564 : Real64 const MAT_zone(state.dataZoneTempPredictorCorrector->zoneHeatBalance(surface.Zone).MAT);
8317 514692 : RhoAirZone = Psychrometrics::PsyRhoAirFnPbTdbW(
8318 : state,
8319 171564 : state.dataEnvrn->OutBaroPress,
8320 : MAT_zone,
8321 : Psychrometrics::PsyWFnTdbRhPb(
8322 : state,
8323 : MAT_zone,
8324 171564 : Psychrometrics::PsyRhFnTdbRhov(state, MAT_zone, state.dataMstBal->RhoVaporAirIn(SurfNum), rhoAirZone),
8325 171564 : state.dataEnvrn->OutBaroPress));
8326 :
8327 171564 : Real64 const surfInTemp(state.dataHeatBalSurf->SurfTempInTmp(SurfNum));
8328 171564 : Wsurf =
8329 514692 : Psychrometrics::PsyWFnTdbRhPb(state,
8330 : surfInTemp,
8331 171564 : Psychrometrics::PsyRhFnTdbRhov(state, surfInTemp, state.dataMstBal->RhoVaporSurfIn(SurfNum), wsurf),
8332 171564 : state.dataEnvrn->OutBaroPress);
8333 :
8334 171564 : thisZoneHB.SumHmARa += FD_Area_fac * RhoAirZone;
8335 :
8336 171564 : thisZoneHB.SumHmARaW += FD_Area_fac * state.dataMstBal->RhoVaporSurfIn(SurfNum); // old eq'n: FD_Area_fac * RhoAirZone * Wsurf;
8337 :
8338 170190 : } else if (surface.HeatTransferAlgorithm == DataSurfaces::HeatTransferModel::EMPD) {
8339 : // need to calculate the amount of moisture that is entering or
8340 : // leaving the zone Qm [kg/sec] = hmi * Area * (Del Rhov)
8341 : // {Hmi [m/sec]; Area [m2]; Rhov [kg moist/m3] }
8342 : // Positive values are into the zone and negative values are
8343 : // leaving the zone. SumHmAw is the sum of the moisture entering or
8344 : // leaving the zone from all of the surfaces and is a rate. Multiply
8345 : // by time to get the actual amount affecting the zone volume of air.
8346 :
8347 150018 : MoistureBalanceEMPDManager::UpdateMoistureBalanceEMPD(state, SurfNum);
8348 150018 : state.dataMstBal->RhoVaporSurfIn(SurfNum) = state.dataMstBalEMPD->RVSurface(SurfNum);
8349 150018 : Real64 const FD_Area_fac(state.dataMstBal->HMassConvInFD(SurfNum) * surface.Area);
8350 150018 : thisZoneHB.SumHmAW += FD_Area_fac * (state.dataMstBal->RhoVaporSurfIn(SurfNum) - state.dataMstBal->RhoVaporAirIn(SurfNum));
8351 150018 : Real64 const MAT_zone(state.dataZoneTempPredictorCorrector->zoneHeatBalance(ZoneNum).MAT);
8352 150018 : thisZoneHB.SumHmARa +=
8353 150018 : FD_Area_fac *
8354 600072 : Psychrometrics::PsyRhoAirFnPbTdbW(
8355 : state,
8356 150018 : state.dataEnvrn->OutBaroPress,
8357 : MAT_zone,
8358 : Psychrometrics::PsyWFnTdbRhPb(state,
8359 : MAT_zone,
8360 150018 : Psychrometrics::PsyRhFnTdbRhovLBnd0C(state, MAT_zone, state.dataMstBal->RhoVaporAirIn(SurfNum)),
8361 150018 : state.dataEnvrn->OutBaroPress)); // surfInTemp, PsyWFnTdbRhPb( surfInTemp, PsyRhFnTdbRhovLBnd0C(
8362 : // surfInTemp, RhoVaporAirIn( SurfNum ) ), OutBaroPress ) );
8363 150018 : thisZoneHB.SumHmARaW += FD_Area_fac * state.dataMstBal->RhoVaporSurfIn(SurfNum);
8364 : }
8365 : }
8366 : }
8367 1018624 : }
8368 :
8369 2469152 : void CalcHeatBalanceInsideSurf2CTFOnly(EnergyPlusData &state,
8370 : const int FirstZone, // First zone to simulate
8371 : const int LastZone, // Last zone to simulate
8372 : const std::vector<int> &IZSurfs, // Last zone to simulate
8373 : Optional_int_const ZoneToResimulate)
8374 : {
8375 :
8376 : // This function performs a heat balance on the inside face of each
8377 : // surface in the building. It is a copy of CalcHeatBalanceInsideSurf,
8378 : // simplified for CTF surfaces only.
8379 :
8380 : // REFERENCES:
8381 : // (I)BLAST legacy routine HBSRF
8382 2469152 : auto &Surface(state.dataSurface->Surface);
8383 :
8384 2469152 : constexpr const char *Inside("Inside");
8385 :
8386 2469152 : if (state.dataHeatBalSurfMgr->calcHeatBalInsideSurfCTFOnlyFirstTime) {
8387 : // Set up coefficient arrays that never change - loop over non-window HT surfaces
8388 5478 : for (int zoneNum = FirstZone; zoneNum <= LastZone; ++zoneNum) {
8389 9464 : for (int spaceNum : state.dataHeatBal->Zone(zoneNum).spaceIndexes) {
8390 4734 : auto &thisSpace = state.dataHeatBal->space(spaceNum);
8391 4734 : int const firstSurf = thisSpace.OpaqOrIntMassSurfaceFirst;
8392 4734 : int const lastSurf = thisSpace.OpaqOrIntMassSurfaceLast;
8393 40339 : for (int surfNum = firstSurf; surfNum <= lastSurf; ++surfNum) {
8394 35605 : int const ConstrNum = Surface(surfNum).Construction;
8395 35605 : auto const &construct(state.dataConstruction->Construct(ConstrNum));
8396 35605 : if (Surface(surfNum).ExtBoundCond == surfNum) {
8397 5820 : state.dataHeatBalSurf->SurfIsAdiabatic(surfNum) = 1;
8398 : } else {
8399 29785 : state.dataHeatBalSurf->SurfIsAdiabatic(surfNum) = 0;
8400 : }
8401 35605 : if (construct.SourceSinkPresent) {
8402 127 : state.dataHeatBalSurf->SurfIsSourceOrSink(surfNum) = 1;
8403 : } else {
8404 35478 : state.dataHeatBalSurf->SurfIsSourceOrSink(surfNum) = 0;
8405 : }
8406 : }
8407 : }
8408 : }
8409 :
8410 748 : state.dataHeatBalSurfMgr->calcHeatBalInsideSurfCTFOnlyFirstTime = false;
8411 : }
8412 :
8413 20791201 : for (int zoneNum = FirstZone; zoneNum <= LastZone; ++zoneNum) {
8414 36660274 : for (int spaceNum : state.dataHeatBal->Zone(zoneNum).spaceIndexes) {
8415 18338225 : auto &thisSpace = state.dataHeatBal->space(spaceNum);
8416 : // loop over all heat transfer surface except TDD Dome.
8417 18338225 : int const firstSurf = thisSpace.OpaqOrWinSurfaceFirst;
8418 18338225 : int const lastSurf = thisSpace.OpaqOrWinSurfaceLast;
8419 : // determine reference air temperatures and other variable terms - loop over all surfaces
8420 176974917 : for (int surfNum = firstSurf; surfNum <= lastSurf; ++surfNum) {
8421 158636692 : auto &surface(Surface(surfNum));
8422 158636692 : if (state.dataSurface->UseRepresentativeSurfaceCalculations) {
8423 397773 : int repSurfNum = surface.RepresentativeCalcSurfNum;
8424 397773 : if (surfNum != repSurfNum) continue;
8425 : }
8426 :
8427 158546695 : int const ConstrNum = Surface(surfNum).Construction;
8428 158546695 : auto const &construct(state.dataConstruction->Construct(ConstrNum));
8429 158546695 : state.dataHeatBalSurf->SurfCTFCross0(surfNum) = construct.CTFCross(0);
8430 158546695 : state.dataHeatBalSurf->SurfCTFInside0(surfNum) = construct.CTFInside(0);
8431 158546695 : state.dataHeatBalSurf->SurfCTFSourceIn0(surfNum) = construct.CTFSourceIn(0);
8432 158546695 : state.dataHeatBalSurf->SurfTempOutHist(surfNum) = state.dataHeatBalSurf->SurfOutsideTempHist(1)(surfNum);
8433 158546695 : if (construct.SourceSinkPresent) {
8434 805953 : state.dataHeatBalSurf->SurfQSourceSinkHist(surfNum) = state.dataHeatBalSurf->SurfQsrcHist(surfNum, 1);
8435 : }
8436 :
8437 158546695 : if (state.dataHeatBalSurf->AnyRadiantSystems(surfNum))
8438 1529500 : state.dataHeatBalSurf->SurfQdotRadHVACInPerArea(surfNum) = GetSurfQdotRadHVACInPerArea(state, surfNum);
8439 : // The special heat balance terms for pools are used only when the pool is operating, so IsPool can change
8440 158546695 : if (state.dataSurface->SurfIsPool(surfNum)) {
8441 13656 : if ((std::abs(state.dataHeatBalFanSys->QPoolSurfNumerator(surfNum)) >= PoolIsOperatingLimit) ||
8442 2706 : (std::abs(state.dataHeatBalFanSys->PoolHeatTransCoefs(surfNum)) >= PoolIsOperatingLimit)) {
8443 8244 : state.dataHeatBalSurf->SurfIsOperatingPool(surfNum) = 1;
8444 : } else {
8445 2706 : state.dataHeatBalSurf->SurfIsOperatingPool(surfNum) = 0;
8446 : }
8447 : }
8448 158546695 : Real64 RefAirTemp = state.dataSurface->Surface(surfNum).getInsideAirTemperature(state, surfNum);
8449 158546695 : state.dataHeatBalSurfMgr->RefAirTemp(surfNum) = RefAirTemp;
8450 158546695 : state.dataHeatBal->SurfTempEffBulkAir(surfNum) = state.dataHeatBalSurfMgr->RefAirTemp(surfNum);
8451 : }
8452 :
8453 : // Following variables must be reset due to possible recall of this routine by radiant and Resimulate routines.
8454 : // CalcWindowHeatBalance is called, then, multiple times and these need to be initialized before each call to
8455 : // CalcWindowHeatBalance.
8456 : // Only for Surface(SurfNum).Class == DataSurfaces::SurfaceClass::Window
8457 18338225 : int const firstWindowSurf = thisSpace.WindowSurfaceFirst;
8458 18338225 : int const lastWindowSurf = thisSpace.WindowSurfaceLast;
8459 40288297 : for (int surfNum = firstWindowSurf; surfNum <= lastWindowSurf; ++surfNum) {
8460 21950072 : state.dataSurface->SurfWinHeatGain(surfNum) = 0.0;
8461 21950072 : state.dataSurface->SurfWinHeatGainRep(surfNum) = 0.0;
8462 21950072 : state.dataSurface->SurfWinHeatLossRep(surfNum) = 0.0;
8463 21950072 : state.dataSurface->SurfWinGainConvGlazToZoneRep(surfNum) = 0.0;
8464 21950072 : state.dataSurface->SurfWinGainIRGlazToZoneRep(surfNum) = 0.0;
8465 21950072 : state.dataSurface->SurfWinLossSWZoneToOutWinRep(surfNum) = 0.0;
8466 21950072 : state.dataSurface->SurfWinGainFrameDividerToZoneRep(surfNum) = 0.0;
8467 21950072 : state.dataSurface->SurfWinGainConvShadeToZoneRep(surfNum) = 0.0;
8468 21950072 : state.dataSurface->SurfWinGainIRShadeToZoneRep(surfNum) = 0.0;
8469 21950072 : state.dataSurface->SurfWinFrameQRadOutAbs(surfNum) = 0.0;
8470 21950072 : state.dataSurface->SurfWinFrameQRadInAbs(surfNum) = 0.0;
8471 21950072 : state.dataSurface->SurfWinDividerQRadOutAbs(surfNum) = 0.0;
8472 21950072 : state.dataSurface->SurfWinDividerQRadInAbs(surfNum) = 0.0;
8473 : }
8474 :
8475 : // Calculate heat extract due to additional heat flux source term as the surface boundary condition - all HT surfaces
8476 18338225 : if (state.dataSurface->AnyHeatBalanceInsideSourceTerm) {
8477 314325 : for (int surfNum = firstSurf; surfNum <= lastSurf; ++surfNum) {
8478 289179 : if (Surface(surfNum).InsideHeatSourceTermSchedule) {
8479 4191 : state.dataHeatBalSurf->SurfQAdditionalHeatSourceInside(surfNum) =
8480 4191 : EnergyPlus::ScheduleManager::GetCurrentScheduleValue(state, Surface(surfNum).InsideHeatSourceTermSchedule);
8481 : }
8482 : }
8483 : }
8484 :
8485 : // Set up coefficient arrays prior to calculations and precalc terms that do no change during iteration - non-window surfaces
8486 18338225 : int const firstNonWinSurf = thisSpace.OpaqOrIntMassSurfaceFirst;
8487 18338225 : int const lastNonWinSurf = thisSpace.OpaqOrIntMassSurfaceLast;
8488 18338225 : Real64 const timeStepZoneSeconds = state.dataGlobal->TimeStepZoneSec; // local for vectorization
8489 18338225 : Real64 const iterDampConstant = IterDampConst; // local for vectorization
8490 : // this loop auto-vectorizes
8491 155024845 : for (int surfNum = firstNonWinSurf; surfNum <= lastNonWinSurf; ++surfNum) {
8492 136686620 : auto &surface(Surface(surfNum));
8493 136686620 : if (state.dataSurface->UseRepresentativeSurfaceCalculations) {
8494 275487 : int repSurfNum = surface.RepresentativeCalcSurfNum;
8495 275487 : if (surfNum != repSurfNum) continue;
8496 : }
8497 :
8498 : // Pre-calculate a few terms before the iteration loop
8499 136674941 : state.dataHeatBalSurf->SurfTempTerm(surfNum) =
8500 273349882 : state.dataHeatBalSurf->SurfCTFConstInPart(surfNum) + state.dataHeatBal->SurfQdotRadIntGainsInPerArea(surfNum) +
8501 410024823 : state.dataHeatBalSurf->SurfOpaqQRadSWInAbs(surfNum) + state.dataHeatBalSurf->SurfQAdditionalHeatSourceInside(surfNum) +
8502 273349882 : state.dataHeatBalSurf->SurfHConvInt(surfNum) * state.dataHeatBalSurfMgr->RefAirTemp(surfNum) +
8503 273349882 : state.dataHeatBalSurf->SurfQdotRadHVACInPerArea(surfNum) +
8504 136674941 : (state.dataHeatBalFanSys->QRadSurfAFNDuct(surfNum) / timeStepZoneSeconds);
8505 136674941 : state.dataHeatBalSurf->SurfTempDiv(surfNum) =
8506 410024823 : 1.0 / (state.dataHeatBalSurf->SurfCTFInside0(surfNum) -
8507 273349882 : state.dataHeatBalSurf->SurfIsAdiabatic(surfNum) * state.dataHeatBalSurf->SurfCTFCross0(surfNum) +
8508 273349882 : state.dataHeatBalSurf->SurfIsOperatingPool(surfNum) * state.dataHeatBalFanSys->PoolHeatTransCoefs(surfNum) +
8509 273349882 : (!state.dataHeatBalSurf->SurfIsOperatingPool(surfNum)) * state.dataHeatBalSurf->SurfHConvInt(surfNum) + iterDampConstant);
8510 : }
8511 : }
8512 : }
8513 :
8514 2469152 : state.dataHeatBal->InsideSurfIterations = 0;
8515 2469152 : bool Converged = false; // .TRUE. if inside heat balance has converged
8516 22878298 : while (!Converged) { // Start of main inside heat balance iteration loop...
8517 :
8518 10204573 : state.dataHeatBalSurf->SurfTempInsOld = state.dataHeatBalSurf->SurfTempIn; // Keep track of last iteration's temperature values
8519 :
8520 40818292 : HeatBalanceIntRadExchange::CalcInteriorRadExchange(state,
8521 10204573 : state.dataHeatBalSurf->SurfTempIn,
8522 10204573 : state.dataHeatBal->InsideSurfIterations,
8523 10204573 : state.dataHeatBalSurf->SurfQdotRadNetLWInPerArea,
8524 : ZoneToResimulate,
8525 10204573 : Inside); // Update the radiation balance
8526 :
8527 : // Every 30 iterations, recalculate the inside convection coefficients in case
8528 : // there has been a significant drift in the surface temperatures predicted.
8529 : // This is not fool-proof and it basically means that the outside surface
8530 : // heat balance is in error (potentially) once HConvIn is re-evaluated.
8531 : // The choice of 30 is not significant--just want to do this a couple of
8532 : // times before the iteration limit is hit.
8533 10204573 : if ((state.dataHeatBal->InsideSurfIterations > 0) && (mod(state.dataHeatBal->InsideSurfIterations, ItersReevalConvCoeff) == 0)) {
8534 1706 : ConvectionCoefficients::InitInteriorConvectionCoeffs(state, state.dataHeatBalSurf->SurfTempIn, ZoneToResimulate);
8535 : // Since HConvIn has changed re-calculate a few terms - non-window surfaces
8536 12149 : for (int zoneNum = FirstZone; zoneNum <= LastZone; ++zoneNum) {
8537 20886 : for (int spaceNum : state.dataHeatBal->Zone(zoneNum).spaceIndexes) {
8538 10443 : auto &thisSpace = state.dataHeatBal->space(spaceNum);
8539 10443 : int const firstSurf = thisSpace.OpaqOrIntMassSurfaceFirst;
8540 10443 : int const lastSurf = thisSpace.OpaqOrIntMassSurfaceLast;
8541 :
8542 10443 : Real64 const timeStepZoneSeconds = state.dataGlobal->TimeStepZoneSec; // local for vectorization
8543 10443 : Real64 const iterDampConstant = IterDampConst; // local for vectorization
8544 : // this loop auto-vectorizes
8545 90516 : for (int surfNum = firstSurf; surfNum <= lastSurf; ++surfNum) {
8546 80073 : auto &surface(Surface(surfNum));
8547 80073 : if (state.dataSurface->UseRepresentativeSurfaceCalculations) {
8548 0 : int repSurfNum = surface.RepresentativeCalcSurfNum;
8549 0 : if (surfNum != repSurfNum) continue;
8550 : }
8551 :
8552 80073 : state.dataHeatBalSurf->SurfTempTerm(surfNum) =
8553 160146 : state.dataHeatBalSurf->SurfCTFConstInPart(surfNum) + state.dataHeatBal->SurfQdotRadIntGainsInPerArea(surfNum) +
8554 240219 : state.dataHeatBalSurf->SurfOpaqQRadSWInAbs(surfNum) + state.dataHeatBalSurf->SurfQAdditionalHeatSourceInside(surfNum) +
8555 160146 : state.dataHeatBalSurf->SurfHConvInt(surfNum) * state.dataHeatBalSurfMgr->RefAirTemp(surfNum) +
8556 160146 : state.dataHeatBalSurf->SurfQdotRadHVACInPerArea(surfNum) +
8557 80073 : (state.dataHeatBalFanSys->QRadSurfAFNDuct(surfNum) / timeStepZoneSeconds);
8558 80073 : state.dataHeatBalSurf->SurfTempDiv(surfNum) =
8559 240219 : 1.0 / (state.dataHeatBalSurf->SurfCTFInside0(surfNum) -
8560 160146 : state.dataHeatBalSurf->SurfIsAdiabatic(surfNum) * state.dataHeatBalSurf->SurfCTFCross0(surfNum) +
8561 160146 : state.dataHeatBalSurf->SurfIsOperatingPool(surfNum) * state.dataHeatBalFanSys->PoolHeatTransCoefs(surfNum) +
8562 160146 : (!state.dataHeatBalSurf->SurfIsOperatingPool(surfNum)) * state.dataHeatBalSurf->SurfHConvInt(surfNum) +
8563 : iterDampConstant);
8564 : }
8565 : }
8566 : }
8567 : }
8568 :
8569 : // Loop over non-window surfaces
8570 95846433 : for (int zoneNum = FirstZone; zoneNum <= LastZone; ++zoneNum) {
8571 171358924 : for (int spaceNum : state.dataHeatBal->Zone(zoneNum).spaceIndexes) {
8572 85717064 : auto &thisSpace = state.dataHeatBal->space(spaceNum);
8573 85717064 : int const firstNonWinSurf = thisSpace.OpaqOrIntMassSurfaceFirst;
8574 85717064 : int const lastNonWinSurf = thisSpace.OpaqOrIntMassSurfaceLast;
8575 85717064 : Real64 const iterDampConstant = IterDampConst; // local for vectorization
8576 : // this loop auto-vectorizes
8577 730097584 : for (int surfNum = firstNonWinSurf; surfNum <= lastNonWinSurf; ++surfNum) {
8578 : // Perform heat balance on the inside face of the surface ...
8579 : // The following are possibilities here (this function only does CTF, see CalcHeatBalanceInsideSurf2 for others):
8580 : // (a) the surface is a pool (no movable insulation, no source/sink, only CTF solution algorithm)
8581 : // (b) the surface is adiabatic (a partition), in which case the temperature of both sides are the same
8582 : // (c) standard (or interzone) opaque surface with no movable insulation, normal heat balance equation
8583 : // (d) standard (or interzone) window: call to CalcWindowHeatBalance to get window layer temperatures
8584 : // (e) standard opaque surface with movable insulation, special two-part equation
8585 : // In the surface calculation there are the following Algorithm types for opaque surfaces that
8586 : // do not have movable insulation:
8587 : // (a) the regular CTF calc (SolutionAlgo = UseCTF)
8588 : // (b) the EMPD calc (Solutionalgo = UseEMPD)
8589 : // (c) the CondFD calc (SolutionAlgo = UseCondFD)
8590 : // (d) the HAMT calc (solutionalgo = UseHAMT).
8591 :
8592 : // For adiabatic surface:
8593 : // Adiabatic: TempDiv = (1.0 / (construct.CTFInside(0) - construct.CTFCross(0) + HConvIn_surf + IterDampConst));
8594 : // Adiabatic: SurfTempInTmp(SurfNum) = (TempTerm + IterDampConst * SurfTempInsOld(SurfNum)) * TempDiv;
8595 : // Ad+Source: SurfTempInTmp(SurfNum) = (TempTerm + construct.CTFSourceIn(0) * SurfQsrcHist(SurfNum, 1) + IterDampConst *
8596 : // SurfTempInsOld(SurfNum)) * TempDiv; Ad+Pool: TempDiv = (1.0 / (construct.CTFInside(0) - construct.CTFCross(0) +
8597 : // PoolHeatTransCoefs(SurfNum) + IterDampConst); Ad+Pool: SurfTempInTmp(SurfNum) = (SurfCTFConstInPart(SurfNum) +
8598 : // QPoolSurfNumerator(SurfNum) + IterDampConst * SurfTempInsOld(SurfNum)) * TempDiv;
8599 :
8600 : // For standard or interzone surface:
8601 : // Standard: TempDiv = (1.0 / (construct.CTFInside(0) + HConvIn_surf + IterDampConst));
8602 : // Standard: SurfTempInTmp(SurfNum) = (TempTerm + IterDampConst * SurfTempInsOld(SurfNum) + construct.CTFCross(0) * TH11) *
8603 : // TempDiv; Std+Source: SurfTempInTmp(SurfNum) = (TempTerm + construct.CTFSourceIn(0) * SurfQsrcHist(SurfNum, 1) + IterDampConst
8604 : // * SurfTempInsOld(SurfNum)) * TempDiv; Std+Pool: TempDiv = (1.0 / (construct.CTFInside(0) + PoolHeatTransCoefs(SurfNum) +
8605 : // IterDampConst); Std+Pool: SurfTempInTmp(SurfNum) = (SurfCTFConstInPart(SurfNum) + QPoolSurfNumerator(SurfNum) +
8606 : // IterDampConst* SurfTempInsOld(SurfNum) + construct.CTFCross(0) * TH11) * TempDiv;
8607 :
8608 : // Composite with Adiabatic/Source/Pool flags:
8609 : // TempDiv = (1.0 / (construct.CTFInside(0) - SurfIsAdiabatic*construct.CTFCross(0)+
8610 : // SurfIsOperatingPool*PoolHeatTransCoefs(SurfNum) + IsNotPoolSurf*HConvIn_surf + IterDampConst));
8611 : // SurfTempInTmp(SurfNum) = (IsNotPoolSurf*TempTerm + IsSource*construct.CTFSourceIn(0) * SurfQsrcHist(SurfNum, 1) +
8612 : // SurfIsOperatingPool*SurfCTFConstInPart(SurfNum) + SurfIsOperatingPool*QPoolSurfNumerator(SurfNum)
8613 : // + IterDampConst * SurfTempInsOld(SurfNum)+
8614 : // IsNotAdiabatic*IsNotSource*construct.CTFCross(0)
8615 : // * TH11) * TempDiv;
8616 :
8617 : // Calculate the current inside surface temperature
8618 644380520 : state.dataHeatBalSurf->SurfTempInTmp(surfNum) =
8619 1288761040 : ((!state.dataHeatBalSurf->SurfIsOperatingPool(surfNum)) *
8620 1288761040 : (state.dataHeatBalSurf->SurfTempTerm(surfNum) + state.dataHeatBalSurf->SurfQdotRadNetLWInPerArea(surfNum)) +
8621 1288761040 : state.dataHeatBalSurf->SurfIsSourceOrSink(surfNum) * state.dataHeatBalSurf->SurfCTFSourceIn0(surfNum) *
8622 1288761040 : state.dataHeatBalSurf->SurfQSourceSinkHist(surfNum) +
8623 1288761040 : state.dataHeatBalSurf->SurfIsOperatingPool(surfNum) * state.dataHeatBalSurf->SurfCTFConstInPart(surfNum) +
8624 1288761040 : state.dataHeatBalSurf->SurfIsOperatingPool(surfNum) * state.dataHeatBalFanSys->QPoolSurfNumerator(surfNum) +
8625 1288761040 : iterDampConstant * state.dataHeatBalSurf->SurfTempInsOld(surfNum) +
8626 1288761040 : (!state.dataHeatBalSurf->SurfIsAdiabatic(surfNum)) * state.dataHeatBalSurf->SurfCTFCross0(surfNum) *
8627 1288761040 : state.dataHeatBalSurf->SurfTempOutHist(surfNum)) *
8628 644380520 : state.dataHeatBalSurf->SurfTempDiv(surfNum);
8629 : // Constant part of conduction eq (history terms) | LW radiation from internal sources | SW
8630 : // radiation from internal sources | Convection from surface to zone air | Net radiant
8631 : // exchange with other zone surfaces | Heat source/sink term for radiant systems | (if there
8632 : // is one present) | Radiant flux from high temp radiant heater | Radiant flux from a hot
8633 : // water baseboard heater | Radiant flux from a steam baseboard heater | Radiant flux from
8634 : // an electric baseboard heater | Iterative damping term (for stability) | Current
8635 : // conduction from | the outside surface | Coefficient for conduction (current time) |
8636 : // Convection and damping term | Radiation from AFN ducts
8637 :
8638 644380520 : state.dataHeatBalSurf->SurfTempIn(surfNum) = state.dataHeatBalSurf->SurfTempInTmp(surfNum);
8639 : }
8640 :
8641 : // Loop over non-window surfaces (includes TubularDaylightingDomes)
8642 730097584 : for (int surfNum = firstNonWinSurf; surfNum <= lastNonWinSurf; ++surfNum) {
8643 644380520 : bool movableInsulPresent = state.dataSurface->AnyMovableInsulation && state.dataHeatBalSurf->SurfMovInsulIntPresent(surfNum);
8644 644380520 : if (movableInsulPresent) { // Movable insulation present, recalc surface temps
8645 16982 : Real64 HMovInsul = state.dataHeatBalSurf->SurfMovInsulHInt(surfNum);
8646 16982 : Real64 F1 = HMovInsul / (HMovInsul + state.dataHeatBalSurf->SurfHConvInt(surfNum) + IterDampConst);
8647 16982 : state.dataHeatBalSurf->SurfTempIn(surfNum) =
8648 33964 : (state.dataHeatBalSurf->SurfCTFConstInPart(surfNum) + state.dataHeatBalSurf->SurfOpaqQRadSWInAbs(surfNum) +
8649 33964 : state.dataHeatBalSurf->SurfCTFCross0(surfNum) * state.dataHeatBalSurf->SurfTempOutHist(surfNum) +
8650 50946 : F1 * (state.dataHeatBal->SurfQdotRadIntGainsInPerArea(surfNum) +
8651 33964 : state.dataHeatBalSurf->SurfHConvInt(surfNum) * state.dataHeatBalSurfMgr->RefAirTemp(surfNum) +
8652 33964 : state.dataHeatBalSurf->SurfQdotRadNetLWInPerArea(surfNum) +
8653 33964 : state.dataHeatBalSurf->SurfQdotRadHVACInPerArea(surfNum) +
8654 33964 : state.dataHeatBalSurf->SurfQAdditionalHeatSourceInside(surfNum) +
8655 33964 : IterDampConst * state.dataHeatBalSurf->SurfTempInsOld(surfNum))) /
8656 16982 : (state.dataHeatBalSurf->SurfCTFInside0(surfNum) + HMovInsul - F1 * HMovInsul); // Convection from surface to zone air
8657 :
8658 16982 : state.dataHeatBalSurf->SurfTempInTmp(surfNum) =
8659 33964 : (state.dataHeatBalSurf->SurfCTFInside0(surfNum) * state.dataHeatBalSurf->SurfTempIn(surfNum) +
8660 50946 : HMovInsul * state.dataHeatBalSurf->SurfTempIn(surfNum) - state.dataHeatBalSurf->SurfOpaqQRadSWInAbs(surfNum) -
8661 33964 : state.dataHeatBalSurf->SurfCTFConstInPart(surfNum) -
8662 33964 : state.dataHeatBalSurf->SurfCTFCross0(surfNum) * state.dataHeatBalSurf->SurfTempOutHist(surfNum)) /
8663 : (HMovInsul);
8664 : }
8665 :
8666 644380520 : if (state.dataHeatBal->AnyInternalHeatSourceInInput) {
8667 12453260 : if (state.dataConstruction->Construct(Surface(surfNum).Construction).SourceSinkPresent) {
8668 : // Set the appropriate parameters for the radiant system
8669 : // Radiant system does not need the damping coefficient terms (hopefully)
8670 : Real64 const RadSysDiv(1.0 /
8671 2487853 : (state.dataHeatBalSurf->SurfCTFInside0(surfNum) + state.dataHeatBalSurf->SurfHConvInt(surfNum)));
8672 : Real64 const TempTerm(
8673 4975706 : state.dataHeatBalSurf->SurfCTFConstInPart(surfNum) + state.dataHeatBal->SurfQdotRadIntGainsInPerArea(surfNum) +
8674 4975706 : state.dataHeatBalSurf->SurfOpaqQRadSWInAbs(surfNum) +
8675 4975706 : state.dataHeatBalSurf->SurfQAdditionalHeatSourceInside(surfNum) +
8676 4975706 : state.dataHeatBalSurf->SurfHConvInt(surfNum) * state.dataHeatBalSurfMgr->RefAirTemp(surfNum) +
8677 4975706 : state.dataHeatBalSurf->SurfQdotRadHVACInPerArea(surfNum) + state.dataHeatBalSurf->SurfQdotRadNetLWInPerArea(surfNum) +
8678 2487853 : (state.dataHeatBalFanSys->QRadSurfAFNDuct(surfNum) / state.dataGlobal->TimeStepZoneSec));
8679 2487853 : state.dataHeatBalFanSys->RadSysTiHBConstCoef(surfNum) =
8680 2487853 : TempTerm * RadSysDiv; // Constant portion of cond eq (history terms) | LW radiation from internal sources | SW
8681 : // radiation from internal sources | Convection from surface to zone air | Radiant flux
8682 : // from high temp radiant heater | Radiant flux from a hot water baseboard heater |
8683 : // Radiant flux from a steam baseboard heater | Radiant flux from an electric baseboard
8684 : // heater | Net radiant exchange with other zone surfaces | Cond term (both partition
8685 : // sides same temp) | Convection and damping term
8686 2487853 : state.dataHeatBalFanSys->RadSysTiHBToutCoef(surfNum) =
8687 2487853 : state.dataHeatBalSurf->SurfCTFCross0(surfNum) * RadSysDiv; // Outside temp=inside temp for a partition |
8688 : // Cond term (both partition sides same temp) |
8689 : // Convection and damping term
8690 2487853 : state.dataHeatBalFanSys->RadSysTiHBQsrcCoef(surfNum) =
8691 2487853 : state.dataHeatBalSurf->SurfCTFSourceIn0(surfNum) * RadSysDiv; // QTF term for the source | Cond term (both
8692 : // partition sides same temp) | Convection and
8693 : // damping term
8694 :
8695 2487853 : if (Surface(surfNum).ExtBoundCond > 0) { // This is an interzone partition and we need to set outside params
8696 : // The inside coefficients of one side are equal to the outside coefficients of the other side. But,
8697 : // the inside coefficients are set up once the heat balance equation for that side has been calculated.
8698 : // For both sides to actually have been set, we have to wait until we get to the second side in the surface
8699 : // derived type. At that point, both inside coefficient sets have been evaluated.
8700 998612 : if (Surface(surfNum).ExtBoundCond <= surfNum) { // Both of the inside coefficients have now been set
8701 499306 : int OtherSideSurfNum = Surface(surfNum).ExtBoundCond;
8702 499306 : state.dataHeatBalFanSys->RadSysToHBConstCoef(OtherSideSurfNum) =
8703 499306 : state.dataHeatBalFanSys->RadSysTiHBConstCoef(surfNum);
8704 499306 : state.dataHeatBalFanSys->RadSysToHBTinCoef(OtherSideSurfNum) =
8705 499306 : state.dataHeatBalFanSys->RadSysTiHBToutCoef(surfNum);
8706 499306 : state.dataHeatBalFanSys->RadSysToHBQsrcCoef(OtherSideSurfNum) =
8707 499306 : state.dataHeatBalFanSys->RadSysTiHBQsrcCoef(surfNum);
8708 499306 : state.dataHeatBalFanSys->RadSysToHBConstCoef(surfNum) =
8709 499306 : state.dataHeatBalFanSys->RadSysTiHBConstCoef(OtherSideSurfNum);
8710 499306 : state.dataHeatBalFanSys->RadSysToHBTinCoef(surfNum) =
8711 499306 : state.dataHeatBalFanSys->RadSysTiHBToutCoef(OtherSideSurfNum);
8712 499306 : state.dataHeatBalFanSys->RadSysToHBQsrcCoef(surfNum) =
8713 499306 : state.dataHeatBalFanSys->RadSysTiHBQsrcCoef(OtherSideSurfNum);
8714 : }
8715 : }
8716 : }
8717 : }
8718 : }
8719 :
8720 : // Loop over window surfaces
8721 85717064 : int const firstWindowSurf = thisSpace.WindowSurfaceFirst;
8722 85717064 : int const lastWindowSurf = thisSpace.WindowSurfaceLast;
8723 186940088 : for (int surfNum = firstWindowSurf; surfNum <= lastWindowSurf; ++surfNum) {
8724 101223024 : auto &surface(Surface(surfNum));
8725 101223024 : if (state.dataSurface->UseRepresentativeSurfaceCalculations) {
8726 400322 : int repSurfNum = surface.RepresentativeCalcSurfNum;
8727 400322 : if (surfNum != repSurfNum) continue;
8728 : }
8729 100966638 : Real64 &TH11(state.dataHeatBalSurf->SurfOutsideTempHist(1)(surfNum));
8730 100966638 : int const ConstrNum = state.dataSurface->SurfActiveConstruction(surfNum);
8731 100966638 : auto const &construct(state.dataConstruction->Construct(ConstrNum));
8732 100966638 : if (state.dataSurface->SurfWinOriginalClass(surfNum) == SurfaceClass::TDD_Diffuser) { // Tubular daylighting device
8733 : // Lookup up the TDD:DOME object
8734 20822 : int const pipeNum = state.dataSurface->SurfWinTDDPipeNum(surfNum);
8735 20822 : int const domeNum = state.dataDaylightingDevicesData->TDDPipe(pipeNum).Dome;
8736 : // Ueff = 1 / effective R value between TDD:DOME and TDD:DIFFUSER
8737 20822 : Real64 Ueff = 1.0 / state.dataDaylightingDevicesData->TDDPipe(pipeNum).Reff;
8738 :
8739 : // Similar to opaque surface but outside surface temp of TDD:DOME is used, and no embedded sources/sinks.
8740 : // Absorbed shortwave radiation is treated similar to a regular window, but only 1 glass layer is allowed.
8741 : // = SurfWinQRadSWwinAbs(surfNum,1)/2.0
8742 20822 : Real64 const HConvIn_surf(state.dataMstBal->HConvInFD(surfNum) = state.dataHeatBalSurf->SurfHConvInt(surfNum));
8743 20822 : state.dataHeatBalSurf->SurfTempInTmp(surfNum) =
8744 41644 : (state.dataHeatBal->SurfQdotRadIntGainsInPerArea(surfNum) + state.dataHeatBal->SurfWinQRadSWwinAbs(surfNum, 1) / 2.0 +
8745 41644 : state.dataHeatBalSurf->SurfQAdditionalHeatSourceInside(surfNum) +
8746 41644 : HConvIn_surf * state.dataHeatBalSurfMgr->RefAirTemp(surfNum) +
8747 41644 : state.dataHeatBalSurf->SurfQdotRadNetLWInPerArea(surfNum) +
8748 41644 : IterDampConst * state.dataHeatBalSurf->SurfTempInsOld(surfNum) +
8749 41644 : Ueff * state.dataHeatBalSurf->SurfOutsideTempHist(1)(domeNum)) /
8750 20822 : (Ueff + HConvIn_surf + IterDampConst); // LW radiation from internal sources | SW radiation from internal sources and
8751 : // solar | Convection from surface to zone air | Net radiant exchange with
8752 : // other zone surfaces | Iterative damping term (for stability) | Current
8753 : // conduction from the outside surface | Coefficient for conduction (current
8754 : // time) | Convection and damping term
8755 20822 : state.dataHeatBalSurf->SurfTempIn(surfNum) = state.dataHeatBalSurf->SurfTempInTmp(surfNum);
8756 : Real64 const Sigma_Temp_4(DataGlobalConstants::StefanBoltzmann *
8757 20822 : pow_4(state.dataHeatBalSurf->SurfTempIn(surfNum) + DataGlobalConstants::KelvinConv));
8758 :
8759 : // Calculate window heat gain for TDD:DIFFUSER since this calculation is usually done in WindowManager
8760 20822 : if (state.dataHeatBalSurf->AnyRadiantSystems(surfNum))
8761 0 : state.dataHeatBalSurf->SurfQdotRadHVACInPerArea(surfNum) = GetSurfQdotRadHVACInPerArea(state, surfNum);
8762 20822 : state.dataSurface->SurfWinHeatGain(surfNum) =
8763 41644 : state.dataSurface->SurfWinTransSolar(surfNum) +
8764 41644 : HConvIn_surf * surface.Area *
8765 41644 : (state.dataHeatBalSurf->SurfTempIn(surfNum) - state.dataHeatBalSurfMgr->RefAirTemp(surfNum)) +
8766 41644 : state.dataConstruction->Construct(surface.Construction).InsideAbsorpThermal * surface.Area *
8767 20822 : (Sigma_Temp_4 -
8768 41644 : (state.dataSurface->SurfWinIRfromParentZone(surfNum) + state.dataHeatBalSurf->SurfQdotRadHVACInPerArea(surfNum))) -
8769 41644 : state.dataHeatBal->EnclSolQSWRad(surface.SolarEnclIndex) * surface.Area *
8770 20822 : state.dataConstruction->Construct(surface.Construction)
8771 20822 : .TransDiff; // Transmitted solar | Convection | IR exchange | IR
8772 : // Zone diffuse interior shortwave reflected back into the TDD
8773 :
8774 : // fill out report vars for components of Window Heat Gain
8775 20822 : state.dataSurface->SurfWinGainConvGlazToZoneRep(surfNum) =
8776 41644 : HConvIn_surf * surface.Area *
8777 20822 : (state.dataHeatBalSurf->SurfTempIn(surfNum) - state.dataHeatBalSurfMgr->RefAirTemp(surfNum));
8778 20822 : state.dataSurface->SurfWinGainIRGlazToZoneRep(surfNum) =
8779 41644 : state.dataConstruction->Construct(surface.Construction).InsideAbsorpThermal * surface.Area *
8780 20822 : (Sigma_Temp_4 -
8781 20822 : (state.dataSurface->SurfWinIRfromParentZone(surfNum) + state.dataHeatBalSurf->SurfQdotRadHVACInPerArea(surfNum)));
8782 62466 : state.dataSurface->SurfWinLossSWZoneToOutWinRep(surfNum) = state.dataHeatBal->EnclSolQSWRad(surface.SolarEnclIndex) *
8783 41644 : surface.Area *
8784 20822 : state.dataConstruction->Construct(surface.Construction).TransDiff;
8785 : } else { // Regular window
8786 100945816 : if (state.dataHeatBal->InsideSurfIterations == 0) { // Do windows only once
8787 : // Get outside convection coeff for exterior window here to avoid calling
8788 : // InitExteriorConvectionCoeff from CalcWindowHeatBalance, which avoids circular reference
8789 : // (HeatBalanceSurfaceManager USEing and WindowManager and
8790 : // WindowManager USEing HeatBalanceSurfaceManager)
8791 21867704 : if (surface.ExtBoundCond == ExternalEnvironment) {
8792 : DataSurfaces::SurfaceRoughness RoughSurf =
8793 21840512 : state.dataMaterial->Material(construct.LayerPoint(1)).Roughness; // Outside surface roughness
8794 : Real64 EmisOut =
8795 21840512 : state.dataMaterial->Material(construct.LayerPoint(1)).AbsorpThermalFront; // Glass outside surface emissivity
8796 21840512 : auto const shading_flag(state.dataSurface->SurfWinShadingFlag(surfNum));
8797 21840512 : if (ANY_EXTERIOR_SHADE_BLIND_SCREEN(shading_flag)) {
8798 : // Exterior shade in place
8799 23903 : int const ConstrNumSh = Surface(surfNum).activeShadedConstruction;
8800 23903 : if (ConstrNumSh != 0) {
8801 13760 : RoughSurf =
8802 13760 : state.dataMaterial->Material(state.dataConstruction->Construct(ConstrNumSh).LayerPoint(1)).Roughness;
8803 13760 : EmisOut =
8804 13760 : state.dataMaterial->Material(state.dataConstruction->Construct(ConstrNumSh).LayerPoint(1)).AbsorpThermal;
8805 : }
8806 : }
8807 :
8808 : // Get the outside effective emissivity for Equivalent layer model
8809 21840512 : if (construct.WindowTypeEQL) {
8810 8109 : EmisOut = WindowEquivalentLayer::EQLWindowOutsideEffectiveEmiss(state, ConstrNum);
8811 : }
8812 : // Set Exterior Convection Coefficient...
8813 21840512 : if (state.dataSurface->SurfExtConvCoeffIndex(surfNum) > 0) {
8814 :
8815 0 : state.dataHeatBalSurf->SurfHcExt(surfNum) = ConvectionCoefficients::SetExtConvectionCoeff(state, surfNum);
8816 :
8817 21840512 : } else if (surface.ExtWind) { // Window is exposed to wind (and possibly rain)
8818 :
8819 : // Calculate exterior heat transfer coefficients with windspeed (windspeed is calculated internally in
8820 : // subroutine)
8821 21840512 : ConvectionCoefficients::InitExteriorConvectionCoeff(state,
8822 : surfNum,
8823 : 0.0,
8824 : RoughSurf,
8825 : EmisOut,
8826 : TH11,
8827 21840512 : state.dataHeatBalSurf->SurfHcExt(surfNum),
8828 21840512 : state.dataHeatBalSurf->SurfHSkyExt(surfNum),
8829 21840512 : state.dataHeatBalSurf->SurfHGrdExt(surfNum),
8830 21840512 : state.dataHeatBalSurf->SurfHAirExt(surfNum));
8831 :
8832 21840512 : if (state.dataEnvrn->IsRain) { // Raining: since wind exposed, outside window surface gets wet
8833 4724 : state.dataHeatBalSurf->SurfHcExt(surfNum) = 1000.0; // Reset SurfHcExt because of wetness
8834 : }
8835 :
8836 : } else { // Not Wind exposed
8837 :
8838 : // Calculate exterior heat transfer coefficients for windspeed = 0
8839 0 : ConvectionCoefficients::InitExteriorConvectionCoeff(state,
8840 : surfNum,
8841 : 0.0,
8842 : RoughSurf,
8843 : EmisOut,
8844 : TH11,
8845 0 : state.dataHeatBalSurf->SurfHcExt(surfNum),
8846 0 : state.dataHeatBalSurf->SurfHSkyExt(surfNum),
8847 0 : state.dataHeatBalSurf->SurfHGrdExt(surfNum),
8848 0 : state.dataHeatBalSurf->SurfHAirExt(surfNum));
8849 : }
8850 :
8851 : } else { // Interior Surface
8852 :
8853 27192 : if (state.dataSurface->SurfExtConvCoeffIndex(surfNum) > 0) {
8854 0 : state.dataHeatBalSurf->SurfHcExt(surfNum) = ConvectionCoefficients::SetExtConvectionCoeff(state, surfNum);
8855 : } else {
8856 : // Exterior Convection Coefficient for the Interior or Interzone Window is the Interior Convection Coeff of
8857 : // same
8858 27192 : state.dataHeatBalSurf->SurfHcExt(surfNum) = state.dataHeatBalSurf->SurfHConvInt(surface.ExtBoundCond);
8859 : }
8860 : }
8861 :
8862 : // Following call determines inside surface temperature of glazing, and of
8863 : // frame and/or divider, if present
8864 21867704 : CalcWindowHeatBalance(
8865 21867704 : state, surfNum, state.dataHeatBalSurf->SurfHcExt(surfNum), state.dataHeatBalSurf->SurfTempInTmp(surfNum), TH11);
8866 :
8867 21867704 : state.dataHeatBalSurf->SurfTempIn(surfNum) = state.dataHeatBalSurf->SurfTempInTmp(surfNum);
8868 : }
8869 : }
8870 : }
8871 :
8872 85717064 : int const firstSurf = thisSpace.OpaqOrWinSurfaceFirst;
8873 85717064 : int const lastSurf = thisSpace.OpaqOrWinSurfaceLast;
8874 831320608 : for (int surfNum = firstSurf; surfNum <= lastSurf; ++surfNum) {
8875 745603544 : auto &zone(state.dataHeatBal->Zone(zoneNum));
8876 :
8877 745603544 : Real64 &TH11(state.dataHeatBalSurf->SurfOutsideTempHist(1)(surfNum));
8878 745603544 : Real64 &TH12(state.dataHeatBalSurf->SurfInsideTempHist(1)(surfNum));
8879 745603544 : TH12 = state.dataHeatBalSurf->SurfTempIn(surfNum);
8880 745603544 : state.dataHeatBalSurf->SurfTempOut(surfNum) = TH11; // For reporting
8881 745603544 : if (state.dataSurface->SurfWinOriginalClass(surfNum) == SurfaceClass::TDD_Diffuser) { // Tubular daylighting device
8882 : // Tubular daylighting devices are treated as one big object with an effective R value.
8883 : // The outside face temperature of the TDD:DOME and the inside face temperature of the
8884 : // TDD:DIFFUSER are calculated with the outside and inside heat balances respectively.
8885 : // Below, the resulting temperatures are copied to the inside face of the TDD:DOME
8886 : // and the outside face of the TDD:DIFFUSER for reporting.
8887 :
8888 : // Set inside temp variables of TDD:DOME equal to inside temp of TDD:DIFFUSER
8889 20822 : int domeNum = state.dataDaylightingDevicesData->TDDPipe(state.dataSurface->SurfWinTDDPipeNum(surfNum)).Dome;
8890 20822 : state.dataHeatBalSurf->SurfInsideTempHist(1)(domeNum) = state.dataHeatBalSurf->SurfTempIn(domeNum) =
8891 20822 : state.dataHeatBalSurf->SurfTempInTmp(domeNum) = state.dataHeatBalSurf->SurfTempIn(surfNum);
8892 :
8893 : // Set outside temp reporting variable of TDD:DOME (since it gets skipped otherwise)
8894 : // Reset outside temp variables of TDD:DIFFUSER equal to outside temp of TDD:DOME
8895 20822 : TH11 = state.dataHeatBalSurf->SurfTempOut(surfNum) = state.dataHeatBalSurf->SurfTempOut(domeNum) =
8896 20822 : state.dataHeatBalSurf->SurfOutsideTempHist(1)(domeNum);
8897 : }
8898 :
8899 745603544 : if ((TH12 > state.dataHeatBalSurf->MaxSurfaceTempLimit) || (TH12 < MinSurfaceTempLimit)) {
8900 0 : TestSurfTempCalcHeatBalanceInsideSurf(
8901 0 : state, TH12, surfNum, zone, state.dataHeatBalSurfMgr->calcHeatBalInsideSurfWarmupErrCount);
8902 : }
8903 : }
8904 : }
8905 : } // ...end of main loops over all surfaces for inside heat balances
8906 :
8907 : // Interzone surface updating: interzone surfaces have other side temperatures
8908 : // which can vary as the simulation iterates through the inside heat
8909 : // balance. This block is intended to "lock" the opposite side (outside)
8910 : // temperatures to the correct value, namely the value calculated by the
8911 : // inside surface heat balance for the other side.
8912 : // assert(state.dataHeatBalSurf->TH.index(1, 1, 1) == 0u); // Assumed for linear indexing below
8913 : // auto const l211(state.dataHeatBalSurf->TH.index(2, 1, 1) - 1);
8914 308675469 : for (int SurfNum : IZSurfs) {
8915 298470896 : int const surfExtBoundCond(Surface(SurfNum).ExtBoundCond);
8916 : // Set the outside surface temperature to the inside surface temperature of the interzone pair.
8917 : // By going through all of the surfaces, this should pick up the other side as well as affect the next iteration.
8918 : // [ SurfNum - 1 ] == ( 1, 1, SurfNum )
8919 : // [ l211 + surfExtBoundCond ] == ( 2, 1, surfExtBoundCond )
8920 298470896 : state.dataHeatBalSurf->SurfTempOut(SurfNum) = state.dataHeatBalSurf->SurfOutsideTempHist(1)(SurfNum) =
8921 298470896 : state.dataHeatBalSurf->SurfInsideTempHist(1)(surfExtBoundCond);
8922 298470896 : state.dataHeatBalSurf->SurfTempOutHist(SurfNum) = state.dataHeatBalSurf->SurfTempOut(SurfNum);
8923 : }
8924 :
8925 10204573 : ++state.dataHeatBal->InsideSurfIterations;
8926 :
8927 : // Convergence check - Loop through all relevant non-window surfaces to check for convergence...
8928 10204573 : Real64 MaxDelTemp = 0.0; // Maximum change in surface temperature for any opaque surface from one iteration to the next
8929 95846433 : for (int zoneNum = FirstZone; zoneNum <= LastZone; ++zoneNum) {
8930 171358924 : for (int spaceNum : state.dataHeatBal->Zone(zoneNum).spaceIndexes) {
8931 85717064 : auto &thisSpace = state.dataHeatBal->space(spaceNum);
8932 85717064 : int const firstNonWinSurf = thisSpace.OpaqOrIntMassSurfaceFirst;
8933 85717064 : int const lastNonWinSurf = thisSpace.OpaqOrIntMassSurfaceLast;
8934 730097584 : for (int surfNum = firstNonWinSurf; surfNum <= lastNonWinSurf; ++surfNum) {
8935 644380520 : Real64 delta = state.dataHeatBalSurf->SurfTempIn(surfNum) - state.dataHeatBalSurf->SurfTempInsOld(surfNum);
8936 644380520 : Real64 absDif = std::abs(delta);
8937 644380520 : MaxDelTemp = std::max(absDif, MaxDelTemp);
8938 : }
8939 : }
8940 : } // ...end of loop to check for convergence
8941 :
8942 10204573 : if (MaxDelTemp <= state.dataHeatBal->MaxAllowedDelTemp) Converged = true;
8943 :
8944 : #ifdef EP_Count_Calls
8945 : state.dataTimingsData->NumMaxInsideSurfIterations =
8946 : max(state.dataTimingsData->NumMaxInsideSurfIterations, state.dataHeatBal->InsideSurfIterations);
8947 : #endif
8948 :
8949 10204573 : if (state.dataHeatBal->InsideSurfIterations < state.dataHeatBalSurf->MinIterations) Converged = false;
8950 :
8951 10204573 : if (state.dataHeatBal->InsideSurfIterations > MaxIterations) {
8952 0 : if (!state.dataGlobal->WarmupFlag) {
8953 0 : ++state.dataHeatBalSurfMgr->calcHeatBalInsideSurfErrCount;
8954 0 : if (state.dataHeatBalSurfMgr->calcHeatBalInsideSurfErrCount < 16) {
8955 0 : ShowWarningError(state,
8956 0 : format("Inside surface heat balance did not converge with Max Temp Difference [C] ={:.3R} vs Max Allowed "
8957 : "Temp Diff [C] ={:.6R}",
8958 : MaxDelTemp,
8959 0 : state.dataHeatBal->MaxAllowedDelTempCondFD));
8960 0 : ShowContinueErrorTimeStamp(state, "");
8961 : } else {
8962 0 : ShowRecurringWarningErrorAtEnd(state,
8963 : "Inside surface heat balance convergence problem continues",
8964 0 : state.dataHeatBalSurfMgr->calcHeatBalInsideSurfErrPointer,
8965 : MaxDelTemp,
8966 : MaxDelTemp,
8967 : _,
8968 : "[C]",
8969 : "[C]");
8970 : }
8971 : }
8972 0 : break; // iteration loop
8973 : }
8974 :
8975 : } // ...end of main inside heat balance iteration loop (ends when Converged)
8976 2469152 : }
8977 :
8978 8814867 : Real64 GetSurfQdotRadHVACInPerArea(EnergyPlusData &state, int const SurfNum)
8979 : {
8980 17629734 : return state.dataHeatBalFanSys->SurfQHTRadSys(SurfNum) + state.dataHeatBalFanSys->SurfQHWBaseboard(SurfNum) +
8981 17629734 : state.dataHeatBalFanSys->SurfQSteamBaseboard(SurfNum) + state.dataHeatBalFanSys->SurfQElecBaseboard(SurfNum) +
8982 8814867 : state.dataHeatBalFanSys->SurfQCoolingPanel(SurfNum);
8983 : }
8984 :
8985 0 : void TestSurfTempCalcHeatBalanceInsideSurf(EnergyPlusData &state, Real64 TH12, int const SurfNum, ZoneData &zone, int WarmupSurfTemp)
8986 : {
8987 0 : std::string surfName = state.dataSurface->Surface(SurfNum).Name;
8988 :
8989 0 : if ((TH12 > state.dataHeatBalSurf->MaxSurfaceTempLimit) || (TH12 < MinSurfaceTempLimit)) {
8990 0 : if (state.dataGlobal->WarmupFlag) ++WarmupSurfTemp;
8991 0 : if (!state.dataGlobal->WarmupFlag || WarmupSurfTemp > 10 || state.dataGlobal->DisplayExtraWarnings) {
8992 0 : if (TH12 < MinSurfaceTempLimit) {
8993 0 : if (state.dataSurface->SurfLowTempErrCount(SurfNum) == 0) {
8994 0 : ShowSevereMessage(
8995 0 : state, format("Temperature (low) out of bounds [{:.2R}] for zone=\"{}\", for surface=\"{}\"", TH12, zone.Name, surfName));
8996 0 : ShowContinueErrorTimeStamp(state, "");
8997 0 : if (!zone.TempOutOfBoundsReported) {
8998 0 : ShowContinueError(state, "Zone=\"" + zone.Name + "\", Diagnostic Details:");
8999 0 : if (zone.FloorArea > 0.0) {
9000 0 : ShowContinueError(state, format("...Internal Heat Gain [{:.3R}] W/m2", zone.InternalHeatGains / zone.FloorArea));
9001 : } else {
9002 0 : ShowContinueError(state, format("...Internal Heat Gain (no floor) [{:.3R}] W", zone.InternalHeatGains));
9003 : }
9004 0 : if (state.afn->simulation_control.type == AirflowNetwork::ControlType::NoMultizoneOrDistribution) {
9005 0 : ShowContinueError(state, format("...Infiltration/Ventilation [{:.3R}] m3/s", zone.NominalInfilVent));
9006 0 : ShowContinueError(state, format("...Mixing/Cross Mixing [{:.3R}] m3/s", zone.NominalMixing));
9007 : } else {
9008 0 : ShowContinueError(state, "...Airflow Network Simulation: Nominal Infiltration/Ventilation/Mixing not available.");
9009 : }
9010 0 : if (zone.IsControlled) {
9011 0 : ShowContinueError(state, "...Zone is part of HVAC controlled system.");
9012 : } else {
9013 0 : ShowContinueError(state, "...Zone is not part of HVAC controlled system.");
9014 : }
9015 0 : zone.TempOutOfBoundsReported = true;
9016 : }
9017 0 : ShowRecurringSevereErrorAtEnd(state,
9018 0 : "Temperature (low) out of bounds for zone=" + zone.Name + " for surface=" + surfName,
9019 0 : state.dataSurface->SurfLowTempErrCount(SurfNum),
9020 : TH12,
9021 : TH12,
9022 : _,
9023 : "C",
9024 : "C");
9025 : } else {
9026 0 : ShowRecurringSevereErrorAtEnd(state,
9027 0 : "Temperature (low) out of bounds for zone=" + zone.Name + " for surface=" + surfName,
9028 0 : state.dataSurface->SurfLowTempErrCount(SurfNum),
9029 : TH12,
9030 : TH12,
9031 : _,
9032 : "C",
9033 : "C");
9034 : }
9035 : } else {
9036 0 : if (state.dataSurface->SurfHighTempErrCount(SurfNum) == 0) {
9037 0 : ShowSevereMessage(
9038 0 : state, format("Temperature (high) out of bounds ({:.2R}] for zone=\"{}\", for surface=\"{}\"", TH12, zone.Name, surfName));
9039 0 : ShowContinueErrorTimeStamp(state, "");
9040 0 : if (!zone.TempOutOfBoundsReported) {
9041 0 : ShowContinueError(state, "Zone=\"" + zone.Name + "\", Diagnostic Details:");
9042 0 : if (zone.FloorArea > 0.0) {
9043 0 : ShowContinueError(state, format("...Internal Heat Gain [{:.3R}] W/m2", zone.InternalHeatGains / zone.FloorArea));
9044 : } else {
9045 0 : ShowContinueError(state, format("...Internal Heat Gain (no floor) [{:.3R}] W", zone.InternalHeatGains));
9046 : }
9047 0 : if (state.afn->simulation_control.type == AirflowNetwork::ControlType::NoMultizoneOrDistribution) {
9048 0 : ShowContinueError(state, format("...Infiltration/Ventilation [{:.3R}] m3/s", zone.NominalInfilVent));
9049 0 : ShowContinueError(state, format("...Mixing/Cross Mixing [{:.3R}] m3/s", zone.NominalMixing));
9050 : } else {
9051 0 : ShowContinueError(state, "...Airflow Network Simulation: Nominal Infiltration/Ventilation/Mixing not available.");
9052 : }
9053 0 : if (zone.IsControlled) {
9054 0 : ShowContinueError(state, "...Zone is part of HVAC controlled system.");
9055 : } else {
9056 0 : ShowContinueError(state, "...Zone is not part of HVAC controlled system.");
9057 : }
9058 0 : zone.TempOutOfBoundsReported = true;
9059 : }
9060 0 : ShowRecurringSevereErrorAtEnd(state,
9061 0 : "Temperature (high) out of bounds for zone=" + zone.Name + " for surface=" + surfName,
9062 0 : state.dataSurface->SurfHighTempErrCount(SurfNum),
9063 : TH12,
9064 : TH12,
9065 : _,
9066 : "C",
9067 : "C");
9068 : } else {
9069 0 : ShowRecurringSevereErrorAtEnd(state,
9070 0 : "Temperature (high) out of bounds for zone=" + zone.Name + " for surface=" + surfName,
9071 0 : state.dataSurface->SurfHighTempErrCount(SurfNum),
9072 : TH12,
9073 : TH12,
9074 : _,
9075 : "C",
9076 : "C");
9077 : }
9078 : }
9079 0 : if (zone.EnforcedReciprocity) {
9080 0 : if (WarmupSurfTemp > 3) {
9081 0 : ShowSevereError(state, "CalcHeatBalanceInsideSurf: Zone=\"" + zone.Name + "\" has view factor enforced reciprocity");
9082 0 : ShowContinueError(state, " and is having temperature out of bounds errors. Please correct zone geometry and rerun.");
9083 0 : ShowFatalError(state, "CalcHeatBalanceInsideSurf: Program terminates due to preceding conditions.");
9084 : }
9085 0 : } else if (WarmupSurfTemp > 10) {
9086 0 : ShowFatalError(state, "CalcHeatBalanceInsideSurf: Program terminates due to preceding conditions.");
9087 : }
9088 : }
9089 : }
9090 0 : if ((TH12 > state.dataHeatBalSurf->MaxSurfaceTempLimitBeforeFatal) || (TH12 < MinSurfaceTempLimitBeforeFatal)) {
9091 0 : if (!state.dataGlobal->WarmupFlag) {
9092 0 : if (TH12 < MinSurfaceTempLimitBeforeFatal) {
9093 0 : ShowSevereError(state,
9094 0 : format("Temperature (low) out of bounds [{:.2R}] for zone=\"{}\", for surface=\"{}\"", TH12, zone.Name, surfName));
9095 0 : ShowContinueErrorTimeStamp(state, "");
9096 0 : if (!zone.TempOutOfBoundsReported) {
9097 0 : ShowContinueError(state, "Zone=\"" + zone.Name + "\", Diagnostic Details:");
9098 0 : if (zone.FloorArea > 0.0) {
9099 0 : ShowContinueError(state, format("...Internal Heat Gain [{:.3R}] W/m2", zone.InternalHeatGains / zone.FloorArea));
9100 : } else {
9101 0 : ShowContinueError(state, format("...Internal Heat Gain (no floor) [{:.3R}] W", zone.InternalHeatGains / zone.FloorArea));
9102 : }
9103 0 : if (state.afn->simulation_control.type == AirflowNetwork::ControlType::NoMultizoneOrDistribution) {
9104 0 : ShowContinueError(state, format("...Infiltration/Ventilation [{:.3R}] m3/s", zone.NominalInfilVent));
9105 0 : ShowContinueError(state, format("...Mixing/Cross Mixing [{:.3R}] m3/s", zone.NominalMixing));
9106 : } else {
9107 0 : ShowContinueError(state, "...Airflow Network Simulation: Nominal Infiltration/Ventilation/Mixing not available.");
9108 : }
9109 0 : if (zone.IsControlled) {
9110 0 : ShowContinueError(state, "...Zone is part of HVAC controlled system.");
9111 : } else {
9112 0 : ShowContinueError(state, "...Zone is not part of HVAC controlled system.");
9113 : }
9114 0 : zone.TempOutOfBoundsReported = true;
9115 : }
9116 0 : ShowFatalError(state, "Program terminates due to preceding condition.");
9117 : } else {
9118 0 : ShowSevereError(state,
9119 0 : format("Temperature (high) out of bounds [{:.2R}] for zone=\"{}\", for surface=\"{}\"", TH12, zone.Name, surfName));
9120 0 : ShowContinueErrorTimeStamp(state, "");
9121 0 : if (!zone.TempOutOfBoundsReported) {
9122 0 : ShowContinueError(state, "Zone=\"" + zone.Name + "\", Diagnostic Details:");
9123 0 : if (zone.FloorArea > 0.0) {
9124 0 : ShowContinueError(state, format("...Internal Heat Gain [{:.3R}] W/m2", zone.InternalHeatGains / zone.FloorArea));
9125 : } else {
9126 0 : ShowContinueError(state, format("...Internal Heat Gain (no floor) [{:.3R}] W", zone.InternalHeatGains / zone.FloorArea));
9127 : }
9128 0 : if (state.afn->simulation_control.type == AirflowNetwork::ControlType::NoMultizoneOrDistribution) {
9129 0 : ShowContinueError(state, format("...Infiltration/Ventilation [{:.3R}] m3/s", zone.NominalInfilVent));
9130 0 : ShowContinueError(state, format("...Mixing/Cross Mixing [{:.3R}] m3/s", zone.NominalMixing));
9131 : } else {
9132 0 : ShowContinueError(state, "...Airflow Network Simulation: Nominal Infiltration/Ventilation/Mixing not available.");
9133 : }
9134 0 : if (zone.IsControlled) {
9135 0 : ShowContinueError(state, "...Zone is part of HVAC controlled system.");
9136 : } else {
9137 0 : ShowContinueError(state, "...Zone is not part of HVAC controlled system.");
9138 : }
9139 0 : zone.TempOutOfBoundsReported = true;
9140 : }
9141 0 : ShowFatalError(state, "Program terminates due to preceding condition.");
9142 : }
9143 : } else {
9144 0 : if (TH12 < -10000. || TH12 > 10000.) {
9145 0 : ShowSevereError(
9146 : state,
9147 0 : format("CalcHeatBalanceInsideSurf: The temperature of {:.2R} C for zone=\"{}\", for surface=\"{}\"", TH12, zone.Name, surfName));
9148 0 : ShowContinueError(state, "..is very far out of bounds during warmup. This may be an indication of a malformed zone.");
9149 0 : ShowContinueErrorTimeStamp(state, "");
9150 0 : ShowFatalError(state, "Program terminates due to preceding condition.");
9151 : }
9152 : }
9153 : }
9154 0 : }
9155 :
9156 40464940 : void CalcOutsideSurfTemp(EnergyPlusData &state,
9157 : int const SurfNum, // Surface number DO loop counter
9158 : int const ZoneNum, // Zone number the current surface is attached to
9159 : int const ConstrNum, // Construction index for the current surface
9160 : Real64 const HMovInsul, // "Convection" coefficient of movable insulation
9161 : Real64 const TempExt, // Exterior temperature boundary condition
9162 : bool &ErrorFlag // Error flag for movable insulation problem
9163 : )
9164 : {
9165 :
9166 : // SUBROUTINE INFORMATION:
9167 : // AUTHOR George Walton
9168 : // DATE WRITTEN December 1979
9169 : // MODIFIED Jun 1990 (RDT for new CTF arrays)
9170 : // Jul 2000 (RJL for Moisture algorithms)
9171 : // Sep 2000 (RKS for new radiant exchange algorithm)
9172 : // Dec 2000 (RKS for radiant system model addition)
9173 : // Aug 2010 (BG added radiant heat flow rate reporting)
9174 : // RE-ENGINEERED Mar 1998 (RKS)
9175 :
9176 : // PURPOSE OF THIS SUBROUTINE:
9177 : // This subroutine performs a heat balance on the outside face of each
9178 : // surface in the building. NOTE that this also sets some coefficients
9179 : // that are needed for radiant system modeling. Thus, it is extremely
9180 : // important that if someone makes changes to the heat balance equations
9181 : // at a later date that they must also make changes to the coefficient
9182 : // setting portion of this subroutine as well.
9183 :
9184 : // METHODOLOGY EMPLOYED:
9185 : // Various boundary conditions are set and additional parameters are set-
9186 : // up. Then, the proper heat balance equation is selected based on the
9187 : // presence of movable insulation, thermal mass of the surface construction,
9188 : // and convection model being used.
9189 :
9190 : // REFERENCES:
9191 : // (I)BLAST legacy routine HBOUT
9192 : // 1989 ASHRAE Handbook of Fundamentals (Figure 1 on p. 22.4, convection correlations)
9193 :
9194 : // Using/Aliasing
9195 : using namespace DataEnvironment;
9196 : using namespace DataHeatBalance;
9197 : using namespace DataHeatBalSurface;
9198 : using namespace DataSurfaces;
9199 : using namespace Psychrometrics;
9200 :
9201 : // Determine whether or not movable insulation is present
9202 40464940 : bool MovInsulPresent = (HMovInsul > 0.0); // .TRUE. if movable insulation is currently present for surface
9203 : bool QuickConductionSurf; // .TRUE. if the cross CTF term is relatively large
9204 : Real64 F1; // Intermediate calculation variable
9205 : Real64 F2; // Intermediate calculation variable
9206 : // Determine whether this surface is a "slow conductive" or "quick conductive"
9207 : // surface. Designates are inherited from BLAST. Basically, a "quick" surface
9208 : // requires the inside heat balance to be accounted for in the heat balance
9209 : // while a "slow" surface can used the last time step's value for inside
9210 : // surface temperature.
9211 40464940 : auto &Surface(state.dataSurface->Surface);
9212 40464940 : auto const &construct(state.dataConstruction->Construct(ConstrNum));
9213 40464940 : if (construct.CTFCross(0) > 0.01) {
9214 4868920 : QuickConductionSurf = true;
9215 4868920 : F1 = construct.CTFCross(0) / (construct.CTFInside(0) + state.dataHeatBalSurf->SurfHConvInt(SurfNum));
9216 : } else {
9217 35596020 : QuickConductionSurf = false;
9218 : }
9219 :
9220 40464940 : Real64 TSky = state.dataEnvrn->SkyTemp;
9221 40464940 : Real64 TGround = state.dataEnvrn->OutDryBulbTemp;
9222 :
9223 40464940 : if (state.dataSurface->Surface(SurfNum).SurfHasSurroundingSurfProperty) {
9224 5412 : int SrdSurfsNum = state.dataSurface->Surface(SurfNum).SurfSurroundingSurfacesNum;
9225 5412 : if (state.dataSurface->SurroundingSurfsProperty(SrdSurfsNum).SkyTempSchNum != 0) {
9226 0 : TSky = GetCurrentScheduleValue(state, state.dataSurface->SurroundingSurfsProperty(SrdSurfsNum).SkyTempSchNum);
9227 : }
9228 5412 : if (state.dataSurface->SurroundingSurfsProperty(SrdSurfsNum).GroundTempSchNum != 0) {
9229 0 : TGround = GetCurrentScheduleValue(state, state.dataSurface->SurroundingSurfsProperty(SrdSurfsNum).GroundTempSchNum);
9230 : }
9231 : }
9232 40464940 : if (state.dataSurface->Surface(SurfNum).UseSurfPropertyGndSurfTemp) {
9233 8118 : TGround = state.dataSurface->GroundSurfsProperty(state.dataSurface->Surface(SurfNum).SurfPropertyGndSurfIndex).SurfsTempAvg;
9234 : }
9235 :
9236 : // Now, calculate the outside surface temperature using the proper heat balance equation.
9237 : // Each case has been separated out into its own IF-THEN block for clarity. Additional
9238 : // cases can simply be added anywhere in the following section. This is the last step
9239 : // in the main loop. Once the proper heat balance is done, the simulation goes on to
9240 : // the next SurfNum.
9241 :
9242 : // Outside heat balance case: Tubular daylighting device
9243 40464940 : Real64 &TH11(state.dataHeatBalSurf->SurfOutsideTempHist(1)(SurfNum));
9244 40464940 : if (Surface(SurfNum).Class == SurfaceClass::TDD_Dome) {
9245 :
9246 : // Lookup up the TDD:DIFFUSER object
9247 4050 : int PipeNum = state.dataSurface->SurfWinTDDPipeNum(SurfNum);
9248 4050 : int SurfNum2 = state.dataDaylightingDevicesData->TDDPipe(PipeNum).Diffuser;
9249 4050 : int ZoneNum2 = Surface(SurfNum2).Zone;
9250 4050 : Real64 Ueff = 1.0 / state.dataDaylightingDevicesData->TDDPipe(PipeNum).Reff; // 1 / effective R value between TDD:DOME and TDD:DIFFUSER
9251 4050 : F1 = Ueff / (Ueff + state.dataHeatBalSurf->SurfHConvInt(SurfNum2));
9252 :
9253 : // Similar to opaque surface but inside conditions of TDD:DIFFUSER are used, and no embedded sources/sinks.
9254 : // Absorbed shortwave radiation is treated similar to a regular window, but only 1 glass layer is allowed.
9255 : // SurfOpaqQRadSWOutAbs(SurfNum) does not apply for TDD:DOME, must use SurfWinQRadSWwinAbs(SurfNum,1)/2.0 instead.
9256 : //+Construct(ConstrNum)%CTFSourceOut(0) & TDDs cannot be radiant systems
9257 : // *SurfQsrcHist(1,SurfNum) &
9258 : //+Construct(ConstrNum)%CTFSourceIn(0) & TDDs cannot be radiant systems
9259 : // *SurfQsrcHist(1,SurfNum) &
9260 12150 : TH11 = (state.dataHeatBal->SurfWinQRadSWwinAbs(SurfNum, 1) / 2.0 + state.dataHeatBalSurf->SurfQRadLWOutSrdSurfs(SurfNum) +
9261 8100 : (state.dataHeatBalSurf->SurfHcExt(SurfNum) + state.dataHeatBalSurf->SurfHAirExt(SurfNum)) * TempExt +
9262 12150 : state.dataHeatBalSurf->SurfQAdditionalHeatSourceOutside(SurfNum) + state.dataHeatBalSurf->SurfHSkyExt(SurfNum) * TSky +
9263 8100 : state.dataHeatBalSurf->SurfHGrdExt(SurfNum) * TGround +
9264 12150 : F1 * (state.dataHeatBal->SurfWinQRadSWwinAbs(SurfNum2, 1) / 2.0 + state.dataHeatBal->SurfQdotRadIntGainsInPerArea(SurfNum2) +
9265 8100 : state.dataHeatBalSurf->SurfHConvInt(SurfNum2) * state.dataZoneTempPredictorCorrector->zoneHeatBalance(ZoneNum2).MAT +
9266 8100 : state.dataHeatBalSurf->SurfQdotRadNetLWInPerArea(SurfNum2))) /
9267 8100 : (Ueff + state.dataHeatBalSurf->SurfHcExt(SurfNum) + state.dataHeatBalSurf->SurfHAirExt(SurfNum) +
9268 12150 : state.dataHeatBalSurf->SurfHSkyExt(SurfNum) + state.dataHeatBalSurf->SurfHGrdExt(SurfNum) -
9269 4050 : F1 * Ueff); // Instead of SurfOpaqQRadSWOutAbs(SurfNum) | ODB used to approx ground surface temp | Use TDD:DIFFUSER surface | Use
9270 : // TDD:DIFFUSER surface | Use TDD:DIFFUSER surface and zone | Use TDD:DIFFUSER surface
9271 :
9272 : // Outside heat balance case: No movable insulation, slow conduction
9273 40460890 : } else if ((!MovInsulPresent) && (!QuickConductionSurf)) {
9274 : // Add LWR from surrounding surfaces
9275 35587923 : if (Surface(SurfNum).OSCMPtr == 0) {
9276 35551374 : if (construct.SourceSinkPresent) {
9277 249435 : TH11 = (-state.dataHeatBalSurf->SurfCTFConstOutPart(SurfNum) + state.dataHeatBalSurf->SurfOpaqQRadSWOutAbs(SurfNum) +
9278 166290 : state.dataHeatBalSurf->SurfQRadLWOutSrdSurfs(SurfNum) +
9279 166290 : (state.dataHeatBalSurf->SurfHcExt(SurfNum) + state.dataHeatBalSurf->SurfHAirExt(SurfNum)) * TempExt +
9280 249435 : state.dataHeatBalSurf->SurfQAdditionalHeatSourceOutside(SurfNum) + state.dataHeatBalSurf->SurfHSkyExt(SurfNum) * TSky +
9281 249435 : state.dataHeatBalSurf->SurfHGrdExt(SurfNum) * TGround + construct.CTFCross(0) * state.dataHeatBalSurf->SurfTempIn(SurfNum) +
9282 166290 : construct.CTFSourceOut(0) * state.dataHeatBalSurf->SurfQsrcHist(SurfNum, 1)) /
9283 166290 : (construct.CTFOutside(0) + state.dataHeatBalSurf->SurfHcExt(SurfNum) + state.dataHeatBalSurf->SurfHAirExt(SurfNum) +
9284 166290 : state.dataHeatBalSurf->SurfHSkyExt(SurfNum) +
9285 83145 : state.dataHeatBalSurf->SurfHGrdExt(SurfNum)); // ODB used to approx ground surface temp
9286 : } else {
9287 106404687 : TH11 = (-state.dataHeatBalSurf->SurfCTFConstOutPart(SurfNum) + state.dataHeatBalSurf->SurfOpaqQRadSWOutAbs(SurfNum) +
9288 70936458 : state.dataHeatBalSurf->SurfQRadLWOutSrdSurfs(SurfNum) +
9289 70936458 : (state.dataHeatBalSurf->SurfHcExt(SurfNum) + state.dataHeatBalSurf->SurfHAirExt(SurfNum)) * TempExt +
9290 106404687 : state.dataHeatBalSurf->SurfQAdditionalHeatSourceOutside(SurfNum) + state.dataHeatBalSurf->SurfHSkyExt(SurfNum) * TSky +
9291 106404687 : state.dataHeatBalSurf->SurfHGrdExt(SurfNum) * TGround + construct.CTFCross(0) * state.dataHeatBalSurf->SurfTempIn(SurfNum)) /
9292 70936458 : (construct.CTFOutside(0) + state.dataHeatBalSurf->SurfHcExt(SurfNum) + state.dataHeatBalSurf->SurfHAirExt(SurfNum) +
9293 70936458 : state.dataHeatBalSurf->SurfHSkyExt(SurfNum) +
9294 35468229 : state.dataHeatBalSurf->SurfHGrdExt(SurfNum)); // ODB used to approx ground surface temp
9295 : }
9296 : // Outside Heat Balance case: Other Side Conditions Model
9297 : } else { //( Surface(SurfNum)%OSCMPtr > 0 ) THEN
9298 : // local copies of variables for clarity in radiation terms
9299 : // TODO: - int OSCMPtr; // "Pointer" to OSCM data structure (other side conditions from a model)
9300 36549 : Real64 RadTemp = state.dataSurface->OSCM(Surface(SurfNum).OSCMPtr)
9301 36549 : .TRad; // local value for Effective radiation temperature for OtherSideConditions model
9302 36549 : Real64 HRad = state.dataSurface->OSCM(Surface(SurfNum).OSCMPtr).HRad; // local value for effective (linearized) radiation coefficient
9303 :
9304 : // patterned after "No movable insulation, slow conduction," but with new radiation terms and no sun,
9305 36549 : if (construct.SourceSinkPresent) {
9306 0 : TH11 = (-state.dataHeatBalSurf->SurfCTFConstOutPart(SurfNum) + state.dataHeatBalSurf->SurfHcExt(SurfNum) * TempExt +
9307 0 : state.dataHeatBalSurf->SurfQAdditionalHeatSourceOutside(SurfNum) + HRad * RadTemp +
9308 0 : construct.CTFCross(0) * state.dataHeatBalSurf->SurfTempIn(SurfNum) +
9309 0 : construct.CTFSourceOut(0) * state.dataHeatBalSurf->SurfQsrcHist(SurfNum, 1)) /
9310 0 : (construct.CTFOutside(0) + state.dataHeatBalSurf->SurfHcExt(SurfNum) + HRad);
9311 : } else {
9312 109647 : TH11 = (-state.dataHeatBalSurf->SurfCTFConstOutPart(SurfNum) + state.dataHeatBalSurf->SurfHcExt(SurfNum) * TempExt +
9313 109647 : state.dataHeatBalSurf->SurfQAdditionalHeatSourceOutside(SurfNum) + HRad * RadTemp +
9314 73098 : construct.CTFCross(0) * state.dataHeatBalSurf->SurfTempIn(SurfNum)) /
9315 36549 : (construct.CTFOutside(0) + state.dataHeatBalSurf->SurfHcExt(SurfNum) + HRad);
9316 : }
9317 35587923 : }
9318 : // Outside heat balance case: No movable insulation, quick conduction
9319 4872967 : } else if ((!MovInsulPresent) && (QuickConductionSurf)) {
9320 4868920 : if (Surface(SurfNum).OSCMPtr == 0) {
9321 4799200 : if (construct.SourceSinkPresent) {
9322 73539 : TH11 = (-state.dataHeatBalSurf->SurfCTFConstOutPart(SurfNum) + state.dataHeatBalSurf->SurfOpaqQRadSWOutAbs(SurfNum) +
9323 49026 : state.dataHeatBalSurf->SurfQRadLWOutSrdSurfs(SurfNum) +
9324 49026 : (state.dataHeatBalSurf->SurfHcExt(SurfNum) + state.dataHeatBalSurf->SurfHAirExt(SurfNum)) * TempExt +
9325 73539 : state.dataHeatBalSurf->SurfQAdditionalHeatSourceOutside(SurfNum) + state.dataHeatBalSurf->SurfHSkyExt(SurfNum) * TSky +
9326 49026 : state.dataHeatBalSurf->SurfHGrdExt(SurfNum) * TGround +
9327 49026 : construct.CTFSourceOut(0) * state.dataHeatBalSurf->SurfQsrcHist(SurfNum, 1) +
9328 73539 : F1 * (state.dataHeatBalSurf->SurfCTFConstInPart(SurfNum) + state.dataHeatBalSurf->SurfOpaqQRadSWInAbs(SurfNum) +
9329 49026 : state.dataHeatBal->SurfQdotRadIntGainsInPerArea(SurfNum) +
9330 49026 : state.dataHeatBalSurf->SurfHConvInt(SurfNum) * state.dataZoneTempPredictorCorrector->zoneHeatBalance(ZoneNum).MAT +
9331 49026 : state.dataHeatBalSurf->SurfQdotRadNetLWInPerArea(SurfNum))) /
9332 49026 : (construct.CTFOutside(0) + state.dataHeatBalSurf->SurfHcExt(SurfNum) + state.dataHeatBalSurf->SurfHAirExt(SurfNum) +
9333 73539 : state.dataHeatBalSurf->SurfHSkyExt(SurfNum) + state.dataHeatBalSurf->SurfHGrdExt(SurfNum) -
9334 24513 : F1 * construct.CTFCross(0)); // ODB used to approx ground surface temp | MAT use here is problem for room air models
9335 : } else {
9336 14324061 : TH11 = (-state.dataHeatBalSurf->SurfCTFConstOutPart(SurfNum) + state.dataHeatBalSurf->SurfOpaqQRadSWOutAbs(SurfNum) +
9337 9549374 : state.dataHeatBalSurf->SurfQRadLWOutSrdSurfs(SurfNum) +
9338 9549374 : (state.dataHeatBalSurf->SurfHcExt(SurfNum) + state.dataHeatBalSurf->SurfHAirExt(SurfNum)) * TempExt +
9339 14324061 : state.dataHeatBalSurf->SurfQAdditionalHeatSourceOutside(SurfNum) + state.dataHeatBalSurf->SurfHSkyExt(SurfNum) * TSky +
9340 9549374 : state.dataHeatBalSurf->SurfHGrdExt(SurfNum) * TGround +
9341 14324061 : F1 * (state.dataHeatBalSurf->SurfCTFConstInPart(SurfNum) + state.dataHeatBalSurf->SurfOpaqQRadSWInAbs(SurfNum) +
9342 9549374 : state.dataHeatBal->SurfQdotRadIntGainsInPerArea(SurfNum) +
9343 9549374 : state.dataHeatBalSurf->SurfHConvInt(SurfNum) * state.dataZoneTempPredictorCorrector->zoneHeatBalance(ZoneNum).MAT +
9344 9549374 : state.dataHeatBalSurf->SurfQdotRadNetLWInPerArea(SurfNum))) /
9345 9549374 : (construct.CTFOutside(0) + state.dataHeatBalSurf->SurfHcExt(SurfNum) + state.dataHeatBalSurf->SurfHAirExt(SurfNum) +
9346 14324061 : state.dataHeatBalSurf->SurfHSkyExt(SurfNum) + state.dataHeatBalSurf->SurfHGrdExt(SurfNum) -
9347 4774687 : F1 * construct.CTFCross(0)); // ODB used to approx ground surface temp | MAT use here is problem for room air models
9348 : }
9349 : // Outside Heat Balance case: Other Side Conditions Model
9350 : } else { //( Surface(SurfNum)%OSCMPtr > 0 ) THEN
9351 : // local copies of variables for clarity in radiation terms
9352 69720 : Real64 RadTemp = state.dataSurface->OSCM(Surface(SurfNum).OSCMPtr).TRad;
9353 69720 : Real64 HRad = state.dataSurface->OSCM(Surface(SurfNum).OSCMPtr).HRad;
9354 : // patterned after "No movable insulation, quick conduction," but with new radiation terms and no sun,
9355 69720 : if (construct.SourceSinkPresent) {
9356 0 : TH11 = (-state.dataHeatBalSurf->SurfCTFConstOutPart(SurfNum) + state.dataHeatBalSurf->SurfHcExt(SurfNum) * TempExt +
9357 0 : state.dataHeatBalSurf->SurfQAdditionalHeatSourceOutside(SurfNum) + HRad * RadTemp +
9358 0 : construct.CTFSourceOut(0) * state.dataHeatBalSurf->SurfQsrcHist(SurfNum, 1) +
9359 0 : F1 * (state.dataHeatBalSurf->SurfCTFConstInPart(SurfNum) + state.dataHeatBalSurf->SurfOpaqQRadSWInAbs(SurfNum) +
9360 0 : state.dataHeatBal->SurfQdotRadIntGainsInPerArea(SurfNum) +
9361 0 : construct.CTFSourceIn(0) * state.dataHeatBalSurf->SurfQsrcHist(SurfNum, 1) +
9362 0 : state.dataHeatBalSurf->SurfHConvInt(SurfNum) * state.dataZoneTempPredictorCorrector->zoneHeatBalance(ZoneNum).MAT +
9363 0 : state.dataHeatBalSurf->SurfQdotRadNetLWInPerArea(SurfNum))) /
9364 0 : (construct.CTFOutside(0) + state.dataHeatBalSurf->SurfHcExt(SurfNum) + HRad -
9365 0 : F1 * construct.CTFCross(0)); // MAT use here is problem for room air models
9366 : } else {
9367 209160 : TH11 = (-state.dataHeatBalSurf->SurfCTFConstOutPart(SurfNum) + state.dataHeatBalSurf->SurfHcExt(SurfNum) * TempExt +
9368 209160 : state.dataHeatBalSurf->SurfQAdditionalHeatSourceOutside(SurfNum) + HRad * RadTemp +
9369 209160 : F1 * (state.dataHeatBalSurf->SurfCTFConstInPart(SurfNum) + state.dataHeatBalSurf->SurfOpaqQRadSWInAbs(SurfNum) +
9370 139440 : state.dataHeatBal->SurfQdotRadIntGainsInPerArea(SurfNum) +
9371 139440 : state.dataHeatBalSurf->SurfHConvInt(SurfNum) * state.dataZoneTempPredictorCorrector->zoneHeatBalance(ZoneNum).MAT +
9372 139440 : state.dataHeatBalSurf->SurfQdotRadNetLWInPerArea(SurfNum))) /
9373 139440 : (construct.CTFOutside(0) + state.dataHeatBalSurf->SurfHcExt(SurfNum) + HRad -
9374 69720 : F1 * construct.CTFCross(0)); // MAT use here is problem for room air models
9375 : }
9376 4868920 : }
9377 : // Outside heat balance case: Movable insulation, slow conduction
9378 4047 : } else if ((MovInsulPresent) && (!QuickConductionSurf)) {
9379 :
9380 12141 : F2 = HMovInsul / (HMovInsul + state.dataHeatBalSurf->SurfHcExt(SurfNum) + state.dataHeatBalSurf->SurfHAirExt(SurfNum) +
9381 8094 : state.dataHeatBalSurf->SurfHSkyExt(SurfNum) + state.dataHeatBalSurf->SurfHGrdExt(SurfNum));
9382 :
9383 12141 : TH11 = (-state.dataHeatBalSurf->SurfCTFConstOutPart(SurfNum) + state.dataHeatBalSurf->SurfOpaqQRadSWOutAbs(SurfNum) +
9384 12141 : state.dataHeatBalSurf->SurfQRadLWOutSrdSurfs(SurfNum) + construct.CTFCross(0) * state.dataHeatBalSurf->SurfTempIn(SurfNum) +
9385 12141 : F2 * (state.dataHeatBalSurf->SurfQRadSWOutMvIns(SurfNum) +
9386 8094 : (state.dataHeatBalSurf->SurfHcExt(SurfNum) + state.dataHeatBalSurf->SurfHAirExt(SurfNum)) * TempExt +
9387 12141 : state.dataHeatBalSurf->SurfQAdditionalHeatSourceOutside(SurfNum) + state.dataHeatBalSurf->SurfHSkyExt(SurfNum) * TSky +
9388 8094 : state.dataHeatBalSurf->SurfHGrdExt(SurfNum) * TGround)) /
9389 4047 : (construct.CTFOutside(0) + HMovInsul - F2 * HMovInsul); // ODB used to approx ground surface temp
9390 :
9391 : // Outside heat balance case: Movable insulation, quick conduction
9392 0 : } else if ((MovInsulPresent) && (QuickConductionSurf)) {
9393 :
9394 0 : F2 = HMovInsul / (HMovInsul + state.dataHeatBalSurf->SurfHcExt(SurfNum) + state.dataHeatBalSurf->SurfHAirExt(SurfNum) +
9395 0 : state.dataHeatBalSurf->SurfHSkyExt(SurfNum) + state.dataHeatBalSurf->SurfHGrdExt(SurfNum));
9396 :
9397 0 : TH11 = (-state.dataHeatBalSurf->SurfCTFConstOutPart(SurfNum) + state.dataHeatBalSurf->SurfOpaqQRadSWOutAbs(SurfNum) +
9398 0 : state.dataHeatBalSurf->SurfQRadLWOutSrdSurfs(SurfNum) +
9399 0 : F1 * (state.dataHeatBalSurf->SurfCTFConstInPart(SurfNum) + state.dataHeatBalSurf->SurfOpaqQRadSWInAbs(SurfNum) +
9400 0 : state.dataHeatBal->SurfQdotRadIntGainsInPerArea(SurfNum) +
9401 0 : state.dataHeatBalSurf->SurfHConvInt(SurfNum) * state.dataZoneTempPredictorCorrector->zoneHeatBalance(ZoneNum).MAT +
9402 0 : state.dataHeatBalSurf->SurfQdotRadNetLWInPerArea(SurfNum)) +
9403 0 : F2 * (state.dataHeatBalSurf->SurfQRadSWOutMvIns(SurfNum) +
9404 0 : (state.dataHeatBalSurf->SurfHcExt(SurfNum) + state.dataHeatBalSurf->SurfHAirExt(SurfNum)) * TempExt +
9405 0 : state.dataHeatBalSurf->SurfQAdditionalHeatSourceOutside(SurfNum) + state.dataHeatBalSurf->SurfHSkyExt(SurfNum) * TSky +
9406 0 : state.dataHeatBalSurf->SurfHGrdExt(SurfNum) * TGround)) /
9407 0 : (construct.CTFOutside(0) + HMovInsul - F2 * HMovInsul - F1 * construct.CTFCross(0)); // ODB used to approx ground surface temp
9408 :
9409 : } // ...end of outside heat balance cases IF-THEN block
9410 :
9411 : // multiply out linearized radiation coeffs for reporting
9412 80929880 : Real64 const HExtSurf_fac(-(state.dataHeatBalSurf->SurfHSkyExt(SurfNum) * (TH11 - TSky) +
9413 80929880 : state.dataHeatBalSurf->SurfHAirExt(SurfNum) * (TH11 - TempExt) +
9414 80929880 : state.dataHeatBalSurf->SurfHGrdExt(SurfNum) * (TH11 - TGround)));
9415 : Real64 QRadLWOutSrdSurfsRep;
9416 40464940 : QRadLWOutSrdSurfsRep = 0;
9417 : // Report LWR from surrounding surfaces for current exterior surf temp
9418 : // Current exterior surf temp would be used for the next step LWR calculation.
9419 40464940 : if (state.dataSurface->Surface(SurfNum).SurfHasSurroundingSurfProperty) {
9420 5412 : int SrdSurfsNum = state.dataSurface->Surface(SurfNum).SurfSurroundingSurfacesNum;
9421 18942 : for (int SrdSurfNum = 1; SrdSurfNum <= state.dataSurface->SurroundingSurfsProperty(SrdSurfsNum).TotSurroundingSurface; SrdSurfNum++) {
9422 13530 : Real64 SrdSurfViewFac = state.dataSurface->SurroundingSurfsProperty(SrdSurfsNum).SurroundingSurfs(SrdSurfNum).ViewFactor;
9423 : Real64 SrdSurfTempAbs =
9424 13530 : GetCurrentScheduleValue(state, state.dataSurface->SurroundingSurfsProperty(SrdSurfsNum).SurroundingSurfs(SrdSurfNum).TempSchNum) +
9425 13530 : DataGlobalConstants::KelvinConv;
9426 27060 : QRadLWOutSrdSurfsRep += DataGlobalConstants::StefanBoltzmann *
9427 27060 : state.dataMaterial->Material(state.dataConstruction->Construct(ConstrNum).LayerPoint(1)).AbsorpThermal *
9428 13530 : SrdSurfViewFac * (pow_4(SrdSurfTempAbs) - pow_4(TH11 + DataGlobalConstants::KelvinConv));
9429 : }
9430 : }
9431 40464940 : state.dataHeatBalSurf->SurfQdotRadOutRepPerArea(SurfNum) = HExtSurf_fac + QRadLWOutSrdSurfsRep;
9432 :
9433 : // Set the radiant system heat balance coefficients if this surface is also a radiant system
9434 40464940 : if (construct.SourceSinkPresent) {
9435 :
9436 107658 : if (MovInsulPresent) {
9437 : // Note: if movable insulation is ever added back in correctly, the heat balance equations above must be fixed
9438 0 : ShowSevereError(state, "Exterior movable insulation is not valid with embedded sources/sinks");
9439 0 : ShowContinueError(state, "Construction " + construct.Name + " contains an internal source or sink but also uses");
9440 0 : ShowContinueError(state,
9441 0 : "exterior movable insulation " +
9442 0 : state.dataMaterial->Material(state.dataSurface->SurfMaterialMovInsulExt(SurfNum)).Name +
9443 : " for a surface with that construction.");
9444 0 : ShowContinueError(state,
9445 : "This is not currently allowed because the heat balance equations do not currently accommodate this combination.");
9446 0 : ErrorFlag = true;
9447 0 : return;
9448 :
9449 : } else {
9450 215316 : Real64 const RadSysDiv(1.0 / (construct.CTFOutside(0) + state.dataHeatBalSurf->SurfHcExt(SurfNum) +
9451 322974 : state.dataHeatBalSurf->SurfHAirExt(SurfNum) + state.dataHeatBalSurf->SurfHSkyExt(SurfNum) +
9452 215316 : state.dataHeatBalSurf->SurfHGrdExt(SurfNum)));
9453 :
9454 107658 : state.dataHeatBalFanSys->RadSysToHBConstCoef(SurfNum) =
9455 215316 : (-state.dataHeatBalSurf->SurfCTFConstOutPart(SurfNum) + state.dataHeatBalSurf->SurfOpaqQRadSWOutAbs(SurfNum) +
9456 215316 : state.dataHeatBalSurf->SurfQRadLWOutSrdSurfs(SurfNum) +
9457 215316 : (state.dataHeatBalSurf->SurfHcExt(SurfNum) + state.dataHeatBalSurf->SurfHAirExt(SurfNum)) * TempExt +
9458 215316 : state.dataHeatBalSurf->SurfHSkyExt(SurfNum) * TSky + state.dataHeatBalSurf->SurfHGrdExt(SurfNum) * TGround) *
9459 : RadSysDiv; // ODB used to approx ground surface temp
9460 :
9461 107658 : state.dataHeatBalFanSys->RadSysToHBTinCoef(SurfNum) = construct.CTFCross(0) * RadSysDiv;
9462 :
9463 107658 : state.dataHeatBalFanSys->RadSysToHBQsrcCoef(SurfNum) = construct.CTFSourceOut(0) * RadSysDiv;
9464 : }
9465 : }
9466 : }
9467 :
9468 8124 : void CalcExteriorVentedCavity(EnergyPlusData &state, int const SurfNum) // index of surface
9469 : {
9470 :
9471 : // SUBROUTINE INFORMATION:
9472 : // AUTHOR B Griffith
9473 : // DATE WRITTEN January 2005
9474 : // MODIFIED na
9475 : // RE-ENGINEERED na
9476 :
9477 : // PURPOSE OF THIS SUBROUTINE:
9478 : // manages calculating the temperatures of baffle and air cavity for
9479 : // multi-skin configuration.
9480 :
9481 : // METHODOLOGY EMPLOYED:
9482 : // derived from CalcPassiveTranspiredCollector
9483 :
9484 : // Using/Aliasing
9485 : using ConvectionCoefficients::InitExteriorConvectionCoeff;
9486 : using Psychrometrics::PsyCpAirFnW;
9487 : using Psychrometrics::PsyRhoAirFnPbTdbW;
9488 : using Psychrometrics::PsyWFnTdbTwbPb;
9489 :
9490 : // local working variables
9491 : Real64 AspRat; // Aspect Ratio of gap
9492 : Real64 TmpTscoll;
9493 : Real64 TmpTaPlen;
9494 : Real64 RhoAir;
9495 : Real64 holeArea;
9496 : Real64 HrPlen;
9497 : Real64 HcPlen;
9498 : Real64 Isc;
9499 : Real64 MdotVent;
9500 : Real64 VdotWind;
9501 : Real64 VdotThermal;
9502 : int CavNum; // do loop counter
9503 : int iter; // do loop counter
9504 : int thisOSCM;
9505 : Real64 TempExt;
9506 : Real64 OutHumRatExt;
9507 :
9508 8124 : CavNum = state.dataSurface->SurfExtCavNum(SurfNum);
9509 :
9510 8124 : TempExt = state.dataSurface->SurfOutDryBulbTemp(SurfNum);
9511 :
9512 24372 : OutHumRatExt = PsyWFnTdbTwbPb(
9513 24372 : state, state.dataSurface->SurfOutDryBulbTemp(SurfNum), state.dataSurface->SurfOutWetBulbTemp(SurfNum), state.dataEnvrn->OutBaroPress);
9514 :
9515 8124 : RhoAir = PsyRhoAirFnPbTdbW(state, state.dataEnvrn->OutBaroPress, TempExt, OutHumRatExt);
9516 :
9517 8124 : holeArea = state.dataSurface->ExtVentedCavity(CavNum).ActualArea * state.dataSurface->ExtVentedCavity(CavNum).Porosity;
9518 :
9519 8124 : AspRat = state.dataSurface->ExtVentedCavity(CavNum).HdeltaNPL * 2.0 / state.dataSurface->ExtVentedCavity(CavNum).PlenGapThick;
9520 8124 : TmpTscoll = state.dataSurface->ExtVentedCavity(CavNum).TbaffleLast;
9521 8124 : TmpTaPlen = state.dataSurface->ExtVentedCavity(CavNum).TairLast;
9522 :
9523 : // all the work is done in this routine located in GeneralRoutines.cc
9524 :
9525 32496 : for (iter = 1; iter <= 3; ++iter) { // this is a sequential solution approach.
9526 :
9527 268092 : CalcPassiveExteriorBaffleGap(state,
9528 24372 : state.dataSurface->ExtVentedCavity(CavNum).SurfPtrs,
9529 : holeArea,
9530 24372 : state.dataSurface->ExtVentedCavity(CavNum).Cv,
9531 24372 : state.dataSurface->ExtVentedCavity(CavNum).Cd,
9532 24372 : state.dataSurface->ExtVentedCavity(CavNum).HdeltaNPL,
9533 24372 : state.dataSurface->ExtVentedCavity(CavNum).SolAbsorp,
9534 24372 : state.dataSurface->ExtVentedCavity(CavNum).LWEmitt,
9535 24372 : state.dataSurface->ExtVentedCavity(CavNum).Tilt,
9536 : AspRat,
9537 24372 : state.dataSurface->ExtVentedCavity(CavNum).PlenGapThick,
9538 24372 : state.dataSurface->ExtVentedCavity(CavNum).BaffleRoughness,
9539 24372 : state.dataSurface->ExtVentedCavity(CavNum).QdotSource,
9540 : TmpTscoll,
9541 : TmpTaPlen,
9542 : HcPlen,
9543 : HrPlen,
9544 : Isc,
9545 : MdotVent,
9546 : VdotWind,
9547 : VdotThermal);
9548 :
9549 : } // sequential solution
9550 : // now fill results into derived types
9551 8124 : state.dataSurface->ExtVentedCavity(CavNum).Isc = Isc;
9552 8124 : state.dataSurface->ExtVentedCavity(CavNum).TAirCav = TmpTaPlen;
9553 8124 : state.dataSurface->ExtVentedCavity(CavNum).Tbaffle = TmpTscoll;
9554 8124 : state.dataSurface->ExtVentedCavity(CavNum).HrPlen = HrPlen;
9555 8124 : state.dataSurface->ExtVentedCavity(CavNum).HcPlen = HcPlen;
9556 8124 : state.dataSurface->ExtVentedCavity(CavNum).PassiveACH =
9557 16248 : (MdotVent / RhoAir) *
9558 16248 : (1.0 / (state.dataSurface->ExtVentedCavity(CavNum).ProjArea * state.dataSurface->ExtVentedCavity(CavNum).PlenGapThick)) *
9559 : DataGlobalConstants::SecInHour;
9560 8124 : state.dataSurface->ExtVentedCavity(CavNum).PassiveMdotVent = MdotVent;
9561 8124 : state.dataSurface->ExtVentedCavity(CavNum).PassiveMdotWind = VdotWind * RhoAir;
9562 8124 : state.dataSurface->ExtVentedCavity(CavNum).PassiveMdotTherm = VdotThermal * RhoAir;
9563 :
9564 : // now do some updates
9565 8124 : state.dataSurface->ExtVentedCavity(CavNum).TairLast = state.dataSurface->ExtVentedCavity(CavNum).TAirCav;
9566 8124 : state.dataSurface->ExtVentedCavity(CavNum).TbaffleLast = state.dataSurface->ExtVentedCavity(CavNum).Tbaffle;
9567 :
9568 : // update the OtherSideConditionsModel coefficients.
9569 8124 : thisOSCM = state.dataSurface->ExtVentedCavity(CavNum).OSCMPtr;
9570 :
9571 8124 : state.dataSurface->OSCM(thisOSCM).TConv = state.dataSurface->ExtVentedCavity(CavNum).TAirCav;
9572 8124 : state.dataSurface->OSCM(thisOSCM).HConv = state.dataSurface->ExtVentedCavity(CavNum).HcPlen;
9573 8124 : state.dataSurface->OSCM(thisOSCM).TRad = state.dataSurface->ExtVentedCavity(CavNum).Tbaffle;
9574 8124 : state.dataSurface->OSCM(thisOSCM).HRad = state.dataSurface->ExtVentedCavity(CavNum).HrPlen;
9575 8124 : }
9576 :
9577 783283 : void GatherComponentLoadsSurfAbsFact(EnergyPlusData &state)
9578 : {
9579 : // SUBROUTINE INFORMATION:
9580 : // AUTHOR Jason Glazer
9581 : // DATE WRITTEN September 2012
9582 :
9583 : // PURPOSE OF THIS SUBROUTINE:
9584 : // Gather values during sizing used for surface absorption factors
9585 :
9586 : // METHODOLOGY EMPLOYED:
9587 : // Save sequence of values for report during sizing.
9588 :
9589 783283 : auto &Surface(state.dataSurface->Surface);
9590 :
9591 783283 : if (state.dataGlobal->CompLoadReportIsReq && !state.dataGlobal->isPulseZoneSizing) {
9592 31050 : int TimeStepInDay = (state.dataGlobal->HourOfDay - 1) * state.dataGlobal->NumOfTimeStepInHour + state.dataGlobal->TimeStep;
9593 213300 : for (int enclosureNum = 1; enclosureNum <= state.dataViewFactor->NumOfRadiantEnclosures; ++enclosureNum) {
9594 182250 : state.dataOutRptTab->TMULTseq(state.dataSize->CurOverallSimDay, TimeStepInDay, enclosureNum) =
9595 182250 : state.dataViewFactor->EnclRadInfo(enclosureNum).radThermAbsMult;
9596 : }
9597 1603800 : for (int jSurf = 1; jSurf <= state.dataSurface->TotSurfaces; ++jSurf) {
9598 1572750 : if (!Surface(jSurf).HeatTransSurf || Surface(jSurf).Zone == 0) continue; // Skip non-heat transfer surfaces
9599 1429650 : if (Surface(jSurf).Class == SurfaceClass::TDD_Dome) continue; // Skip tubular daylighting device domes
9600 1429650 : state.dataOutRptTab->ITABSFseq(state.dataSize->CurOverallSimDay, TimeStepInDay, jSurf) = state.dataHeatBalSurf->SurfAbsThermalInt(jSurf);
9601 : }
9602 : }
9603 783283 : }
9604 :
9605 52039635 : Real64 GetSurfIncidentSolarMultiplier(EnergyPlusData &state, int SurfNum)
9606 : {
9607 52039635 : if (state.dataSurface->Surface(SurfNum).hasIncSolMultiplier) {
9608 2408 : if (state.dataSurface->SurfIncSolMultiplier(SurfNum).SchedPtr > 0) {
9609 2408 : return GetCurrentScheduleValue(state, state.dataSurface->SurfIncSolMultiplier(SurfNum).SchedPtr) *
9610 2408 : state.dataSurface->SurfIncSolMultiplier(SurfNum).Scaler;
9611 : } else {
9612 0 : return state.dataSurface->SurfIncSolMultiplier(SurfNum).Scaler;
9613 : }
9614 : } else {
9615 52037227 : return 1.0;
9616 : }
9617 : }
9618 :
9619 771 : void InitSurfacePropertyViewFactors(EnergyPlusData &state)
9620 : {
9621 :
9622 : // purpuse:
9623 : // Initializes sky and ground surfaces view factors of exterior surfaces
9624 : // used by SurfaceProperty:LocalEnvironment
9625 : // view factors are constant hence should be set only once
9626 :
9627 771 : if (!state.dataGlobal->AnyLocalEnvironmentsInModel) {
9628 767 : return;
9629 : }
9630 4 : if (!state.dataHeatBalSurfMgr->InitSurfaceHeatBalancefirstTime) {
9631 0 : return;
9632 : }
9633 :
9634 414 : for (int SurfNum = 1; SurfNum <= state.dataSurface->TotSurfaces; ++SurfNum) {
9635 410 : auto &Surface = state.dataSurface->Surface(SurfNum);
9636 410 : if (Surface.SurfHasSurroundingSurfProperty || Surface.IsSurfPropertyGndSurfacesDefined) {
9637 :
9638 18 : int GndSurfsNum = 0;
9639 18 : int SrdSurfsNum = 0;
9640 18 : Real64 SrdSurfsViewFactor = 0.0;
9641 18 : Real64 SurfsSkyViewFactor = 0.0;
9642 18 : Real64 GroundSurfsViewFactor = 0.0;
9643 18 : bool IsSkyViewFactorSet = false;
9644 18 : bool IsGroundViewFactorSet = false;
9645 18 : bool SetGroundViewFactorObject = false;
9646 18 : if (Surface.SurfHasSurroundingSurfProperty) {
9647 6 : SrdSurfsNum = Surface.SurfSurroundingSurfacesNum;
9648 6 : auto &SrdSurfsProperty = state.dataSurface->SurroundingSurfsProperty(SrdSurfsNum);
9649 6 : SurfsSkyViewFactor = SrdSurfsProperty.SkyViewFactor;
9650 6 : IsSkyViewFactorSet = SrdSurfsProperty.IsSkyViewFactorSet;
9651 6 : if (SurfsSkyViewFactor > 0.0) {
9652 4 : SrdSurfsViewFactor += SurfsSkyViewFactor;
9653 : }
9654 6 : if (!Surface.IsSurfPropertyGndSurfacesDefined) {
9655 5 : SrdSurfsViewFactor += SrdSurfsProperty.GroundViewFactor;
9656 5 : IsGroundViewFactorSet = SrdSurfsProperty.IsGroundViewFactorSet;
9657 5 : GroundSurfsViewFactor = SrdSurfsProperty.GroundViewFactor;
9658 : }
9659 20 : for (int SrdSurfNum = 1; SrdSurfNum <= SrdSurfsProperty.TotSurroundingSurface; SrdSurfNum++) {
9660 14 : SrdSurfsViewFactor += SrdSurfsProperty.SurroundingSurfs(SrdSurfNum).ViewFactor;
9661 : }
9662 : }
9663 18 : if (Surface.IsSurfPropertyGndSurfacesDefined) {
9664 13 : GndSurfsNum = Surface.SurfPropertyGndSurfIndex;
9665 13 : IsGroundViewFactorSet = state.dataSurface->GroundSurfsProperty(GndSurfsNum).IsGroundViewFactorSet;
9666 13 : GroundSurfsViewFactor = state.dataSurface->GroundSurfsProperty(GndSurfsNum).SurfsViewFactorSum;
9667 13 : SrdSurfsViewFactor += GroundSurfsViewFactor;
9668 : }
9669 :
9670 : // Check if the sum of all defined view factors > 1.0
9671 18 : if (SrdSurfsViewFactor > 1.0) {
9672 0 : ShowSevereError(state, "Illegal surrounding surfaces view factors for " + Surface.Name + ".");
9673 0 : ShowContinueError(state, " The sum of sky, ground, and all surrounding surfaces view factors should be less than or equal to 1.0.");
9674 : }
9675 18 : if (IsSkyViewFactorSet && IsGroundViewFactorSet) {
9676 : // If both surface sky and ground view factor defined, overwrite with the defined value
9677 4 : Surface.ViewFactorSkyIR = SurfsSkyViewFactor;
9678 4 : Surface.ViewFactorGroundIR = GroundSurfsViewFactor;
9679 14 : } else if (IsSkyViewFactorSet && !IsGroundViewFactorSet) {
9680 : // If only sky view factor defined, ground view factor = 1 - all other defined view factors.
9681 2 : Surface.ViewFactorSkyIR = SurfsSkyViewFactor;
9682 2 : Surface.ViewFactorGroundIR = 1 - SrdSurfsViewFactor;
9683 4 : if (GndSurfsNum > 0) {
9684 0 : SetGroundViewFactorObject = true;
9685 0 : state.dataSurface->GroundSurfsProperty(GndSurfsNum).IsGroundViewFactorSet = true;
9686 : } else {
9687 2 : state.dataSurface->SurroundingSurfsProperty(SrdSurfsNum).GroundViewFactor = Surface.ViewFactorGroundIR;
9688 : }
9689 12 : } else if (!IsSkyViewFactorSet && IsGroundViewFactorSet) {
9690 : // If only ground view factor defined, sky view factor = 1 - all other defined view factors.
9691 12 : Surface.ViewFactorGroundIR = GroundSurfsViewFactor;
9692 12 : Surface.ViewFactorSkyIR = 1 - SrdSurfsViewFactor;
9693 24 : if (SrdSurfsNum > 0) {
9694 0 : state.dataSurface->SurroundingSurfsProperty(SrdSurfsNum).IsSkyViewFactorSet = true;
9695 0 : state.dataSurface->SurroundingSurfsProperty(SrdSurfsNum).SkyViewFactor = Surface.ViewFactorSkyIR;
9696 : }
9697 : } else {
9698 : // If neither ground nor sky view factor specified, continue to use the original proportion.
9699 0 : Surface.ViewFactorSkyIR *= 1 - SrdSurfsViewFactor;
9700 0 : Surface.ViewFactorGroundIR *= 1 - SrdSurfsViewFactor;
9701 0 : if (SrdSurfsNum > 0) {
9702 0 : state.dataSurface->SurroundingSurfsProperty(SrdSurfsNum).IsSkyViewFactorSet = true;
9703 0 : state.dataSurface->SurroundingSurfsProperty(SrdSurfsNum).SkyViewFactor = Surface.ViewFactorSkyIR;
9704 0 : if (GndSurfsNum == 0) {
9705 0 : state.dataSurface->SurroundingSurfsProperty(SrdSurfsNum).GroundViewFactor = Surface.ViewFactorGroundIR;
9706 0 : state.dataSurface->SurroundingSurfsProperty(SrdSurfsNum).IsGroundViewFactorSet = true;
9707 : }
9708 : }
9709 0 : if (GndSurfsNum > 0) {
9710 0 : SetGroundViewFactorObject = true;
9711 0 : state.dataSurface->GroundSurfsProperty(GndSurfsNum).IsGroundViewFactorSet = true;
9712 : }
9713 : }
9714 18 : if (SetGroundViewFactorObject) {
9715 0 : ReSetGroundSurfacesViewFactor(state, SurfNum);
9716 : }
9717 : }
9718 : }
9719 : }
9720 :
9721 3482238 : void GetGroundSurfacesTemperatureAverage(EnergyPlusData &state)
9722 : {
9723 : // returns ground surfaces average temperature (deg C)
9724 : // ground surfaces viewed by a building exterior surface
9725 : // ground surfaces temperature weighed using view factors
9726 :
9727 : // local vars
9728 : Real64 GndSurfaceTemp;
9729 : Real64 GndSurfViewFactor;
9730 : Real64 GndSurfaceTempSum;
9731 :
9732 3482238 : if (!state.dataGlobal->AnyLocalEnvironmentsInModel) {
9733 3474802 : return;
9734 : }
9735 :
9736 620862 : for (int SurfNum = 1; SurfNum <= state.dataSurface->TotSurfaces; ++SurfNum) {
9737 613426 : if (!state.dataSurface->Surface(SurfNum).IsSurfPropertyGndSurfacesDefined) continue;
9738 17589 : auto &GndSurfsProperty = state.dataSurface->GroundSurfsProperty(state.dataSurface->Surface(SurfNum).SurfPropertyGndSurfIndex);
9739 17589 : if (GndSurfsProperty.SurfsViewFactorSum == 0.0) {
9740 0 : state.dataSurface->Surface(SurfNum).UseSurfPropertyGndSurfTemp = false;
9741 0 : continue;
9742 : }
9743 17589 : GndSurfaceTemp = 0.0;
9744 17589 : GndSurfViewFactor = 0.0;
9745 17589 : GndSurfaceTempSum = 0.0;
9746 59532 : for (int gSurfNum = 1; gSurfNum <= GndSurfsProperty.NumGndSurfs; gSurfNum++) {
9747 41943 : GndSurfViewFactor = GndSurfsProperty.GndSurfs(gSurfNum).ViewFactor;
9748 41943 : if (GndSurfViewFactor == 0.0) continue;
9749 41943 : if (GndSurfsProperty.GndSurfs(gSurfNum).TempSchPtr == 0) continue;
9750 40590 : GndSurfaceTemp = ScheduleManager::GetCurrentScheduleValue(state, GndSurfsProperty.GndSurfs(gSurfNum).TempSchPtr);
9751 40590 : GndSurfaceTempSum += GndSurfViewFactor * pow_4(GndSurfaceTemp + DataGlobalConstants::KelvinConv);
9752 : }
9753 18942 : if (GndSurfaceTempSum == 0.0) {
9754 1353 : GndSurfsProperty.SurfsTempAvg = 0.0;
9755 1353 : state.dataSurface->Surface(SurfNum).UseSurfPropertyGndSurfTemp = false;
9756 1353 : continue;
9757 : }
9758 16236 : GndSurfsProperty.SurfsTempAvg = root_4(GndSurfaceTempSum / GndSurfsProperty.SurfsViewFactorSum) - DataGlobalConstants::KelvinConv;
9759 : }
9760 : }
9761 :
9762 2568509 : void GetGroundSurfacesReflectanceAverage(EnergyPlusData &state)
9763 : {
9764 : // returns ground surfaces average reflectance (dimenssionless)
9765 : // ground reflectance viewed by a building exterior surface
9766 : // ground surfaces reflectance weighed using view factors
9767 :
9768 : // local vars
9769 : Real64 GndSurfRefl;
9770 : Real64 GndSurfsReflSum;
9771 :
9772 2568509 : if (!state.dataGlobal->AnyLocalEnvironmentsInModel) {
9773 2561073 : return;
9774 : }
9775 620862 : for (int SurfNum = 1; SurfNum <= state.dataSurface->TotSurfaces; ++SurfNum) {
9776 :
9777 613426 : if (!state.dataSurface->Surface(SurfNum).IsSurfPropertyGndSurfacesDefined) continue;
9778 17589 : auto &GndSurfsProperty = state.dataSurface->GroundSurfsProperty(state.dataSurface->Surface(SurfNum).SurfPropertyGndSurfIndex);
9779 17589 : if (GndSurfsProperty.SurfsViewFactorSum == 0.0) {
9780 0 : state.dataSurface->Surface(SurfNum).UseSurfPropertyGndSurfRefl = false;
9781 0 : continue;
9782 : }
9783 17589 : GndSurfRefl = 0.0;
9784 17589 : GndSurfsReflSum = 0.0;
9785 59532 : for (int gSurfNum = 1; gSurfNum <= GndSurfsProperty.NumGndSurfs; gSurfNum++) {
9786 41943 : if (GndSurfsProperty.GndSurfs(gSurfNum).ReflSchPtr == 0) continue;
9787 40590 : GndSurfRefl = ScheduleManager::GetCurrentScheduleValue(state, GndSurfsProperty.GndSurfs(gSurfNum).ReflSchPtr);
9788 40590 : GndSurfsReflSum += GndSurfsProperty.GndSurfs(gSurfNum).ViewFactor * GndSurfRefl;
9789 : }
9790 18942 : if (GndSurfsReflSum == 0.0) {
9791 1353 : GndSurfsProperty.SurfsReflAvg = 0.0;
9792 1353 : state.dataSurface->Surface(SurfNum).UseSurfPropertyGndSurfRefl = false;
9793 1353 : continue;
9794 : }
9795 16236 : GndSurfsProperty.SurfsReflAvg = GndSurfsReflSum / GndSurfsProperty.SurfsViewFactorSum;
9796 : }
9797 : }
9798 :
9799 0 : void ReSetGroundSurfacesViewFactor(EnergyPlusData &state, int const SurfNum)
9800 : {
9801 : // resets ground veiew factors based on view factors identity
9802 : // the ground view factor value is set to the first element
9803 : // when the ground view factor input field is blank
9804 :
9805 0 : if (!state.dataSurface->Surface(SurfNum).IsSurfPropertyGndSurfacesDefined) return;
9806 0 : auto &GndSurfsProperty = state.dataSurface->GroundSurfsProperty(state.dataSurface->Surface(SurfNum).SurfPropertyGndSurfIndex);
9807 0 : GndSurfsProperty.SurfsViewFactorSum = state.dataSurface->Surface(SurfNum).ViewFactorGroundIR;
9808 :
9809 0 : if (GndSurfsProperty.SurfsViewFactorSum == 0.0) {
9810 0 : state.dataSurface->Surface(SurfNum).UseSurfPropertyGndSurfRefl = false;
9811 0 : state.dataSurface->Surface(SurfNum).UseSurfPropertyGndSurfTemp = false;
9812 0 : return;
9813 : }
9814 0 : GndSurfsProperty.GndSurfs(1).ViewFactor = GndSurfsProperty.SurfsViewFactorSum;
9815 : }
9816 :
9817 2313 : } // namespace EnergyPlus::HeatBalanceSurfaceManager
|
