From c0c5465ccf478c8d5c345f307da3b8a13aee0555 Mon Sep 17 00:00:00 2001 From: amirroth Date: Thu, 28 Dec 2023 13:25:29 -0500 Subject: [PATCH] Additional cleanup, continue unifying RefPt structures --- src/EnergyPlus/AirflowNetwork/src/Solver.cpp | 78 +- src/EnergyPlus/DataSurfaces.hh | 37 +- src/EnergyPlus/DaylightingDevices.cc | 236 +++--- src/EnergyPlus/DaylightingManager.cc | 138 ++-- src/EnergyPlus/HeatBalanceIntRadExchange.cc | 15 +- src/EnergyPlus/HeatBalanceSurfaceManager.cc | 28 +- src/EnergyPlus/OutputReports.cc | 16 +- src/EnergyPlus/SolarShading.cc | 672 +++++++++--------- src/EnergyPlus/SurfaceGeometry.cc | 355 ++++----- .../unit/AirflowNetworkComponents.unit.cc | 24 +- .../unit/AirflowNetworkConditions.unit.cc | 12 +- .../unit/AirflowNetworkHVAC.unit.cc | 36 +- 12 files changed, 827 insertions(+), 820 deletions(-) diff --git a/src/EnergyPlus/AirflowNetwork/src/Solver.cpp b/src/EnergyPlus/AirflowNetwork/src/Solver.cpp index 78ea4d05d6a..b4d6e37ef7f 100644 --- a/src/EnergyPlus/AirflowNetwork/src/Solver.cpp +++ b/src/EnergyPlus/AirflowNetwork/src/Solver.cpp @@ -3582,9 +3582,8 @@ namespace AirflowNetwork { // Assign occupant ventilation control number from zone to surface for (int i = 1; i <= AirflowNetworkNumOfSurfaces; ++i) { int j = MultizoneSurfaceData(i).SurfNum; - if (m_state.dataSurface->SurfWinOriginalClass(j) == SurfaceClass::Window || - m_state.dataSurface->SurfWinOriginalClass(j) == SurfaceClass::Door || - m_state.dataSurface->SurfWinOriginalClass(j) == SurfaceClass::GlassDoor) { + auto const &surf = m_state.dataSurface->Surface(j); + if (surf.OriginalClass == SurfaceClass::Window || surf.OriginalClass == SurfaceClass::Door || surf.OriginalClass == SurfaceClass::GlassDoor) { for (n = 1; n <= AirflowNetworkNumOfZones; ++n) { if (MultizoneZoneData(n).ZoneNum == m_state.dataSurface->Surface(j).Zone) { if (MultizoneZoneData(n).OccupantVentilationControlNum > 0 && MultizoneSurfaceData(i).OccupantVentilationControlNum == 0) { @@ -4621,6 +4620,8 @@ namespace AirflowNetwork { int compnum = compnum_iter->second; AirflowNetworkLinkageData(count).CompNum = compnum; + auto &surf = m_state.dataSurface->Surface(MultizoneSurfaceData(count).SurfNum); + switch (AirflowNetworkLinkageData(count).element->type()) { case ComponentType::DOP: { // if (AirflowNetworkLinkageData(count).CompName == @@ -4630,26 +4631,25 @@ namespace AirflowNetwork { // if (AirflowNetworkCompData(i).CompTypeNum == iComponentTypeNum::DOP) { ++j; AirflowNetworkLinkageData(count).DetOpenNum = j; - MultizoneSurfaceData(count).Multiplier = m_state.dataSurface->Surface(MultizoneSurfaceData(count).SurfNum).Multiplier; - if (m_state.dataSurface->Surface(MultizoneSurfaceData(count).SurfNum).Tilt < 10.0 || - m_state.dataSurface->Surface(MultizoneSurfaceData(count).SurfNum).Tilt > 170.0) { + MultizoneSurfaceData(count).Multiplier = surf.Multiplier; + if (surf.Tilt < 10.0 || surf.Tilt > 170.0) { ShowWarningError(m_state, "An AirflowNetwork:Multizone:Surface object has an air-flow opening corresponding to"); ShowContinueError(m_state, "window or door = " + MultizoneSurfaceData(count).SurfName + ", which is within "); ShowContinueError(m_state, "10 deg of being horizontal. Airflows through large horizontal openings are poorly"); ShowContinueError(m_state, "modeled in the AirflowNetwork model resulting in only one-way airflow."); } - if (!(m_state.dataSurface->SurfWinOriginalClass(MultizoneSurfaceData(count).SurfNum) == SurfaceClass::Window || - m_state.dataSurface->SurfWinOriginalClass(MultizoneSurfaceData(count).SurfNum) == SurfaceClass::GlassDoor || - m_state.dataSurface->SurfWinOriginalClass(MultizoneSurfaceData(count).SurfNum) == SurfaceClass::Door || - m_state.dataSurface->Surface(MultizoneSurfaceData(count).SurfNum).IsAirBoundarySurf)) { + if (!(surf.OriginalClass == SurfaceClass::Window || + surf.OriginalClass == SurfaceClass::GlassDoor || + surf.OriginalClass == SurfaceClass::Door || + surf.IsAirBoundarySurf)) { ShowSevereError(m_state, format(RoutineName) + "AirflowNetworkComponent: The opening must be assigned to a window, door, glassdoor or air boundary at " + AirflowNetworkLinkageData(count).Name); ErrorsFound = true; } - if (m_state.dataSurface->SurfWinOriginalClass(MultizoneSurfaceData(count).SurfNum) == SurfaceClass::Door || - m_state.dataSurface->SurfWinOriginalClass(MultizoneSurfaceData(count).SurfNum) == SurfaceClass::GlassDoor) { + + if (surf.OriginalClass == SurfaceClass::Door || surf.OriginalClass == SurfaceClass::GlassDoor) { if (MultizoneCompDetOpeningData(AirflowNetworkCompData(compnum).TypeNum).LVOType == 2) { ShowSevereError(m_state, format(RoutineName) + @@ -4662,9 +4662,8 @@ namespace AirflowNetwork { } break; case ComponentType::SOP: { // if (AirflowNetworkCompData(i).CompTypeNum == iComponentTypeNum::SOP) { - MultizoneSurfaceData(count).Multiplier = m_state.dataSurface->Surface(MultizoneSurfaceData(count).SurfNum).Multiplier; - if (m_state.dataSurface->Surface(MultizoneSurfaceData(count).SurfNum).Tilt < 10.0 || - m_state.dataSurface->Surface(MultizoneSurfaceData(count).SurfNum).Tilt > 170.0) { + MultizoneSurfaceData(count).Multiplier = surf.Multiplier; + if (surf.Tilt < 10.0 || surf.Tilt > 170.0) { ShowSevereError(m_state, "An AirflowNetwork:Multizone:Surface object has an air-flow opening corresponding to"); ShowContinueError(m_state, "window or door = " + MultizoneSurfaceData(count).SurfName + ", which is within"); ShowContinueError(m_state, "10 deg of being horizontal. Airflows through horizontal openings are not allowed."); @@ -4672,10 +4671,10 @@ namespace AirflowNetwork { ErrorsFound = true; } - if (!(m_state.dataSurface->SurfWinOriginalClass(MultizoneSurfaceData(count).SurfNum) == SurfaceClass::Window || - m_state.dataSurface->SurfWinOriginalClass(MultizoneSurfaceData(count).SurfNum) == SurfaceClass::GlassDoor || - m_state.dataSurface->SurfWinOriginalClass(MultizoneSurfaceData(count).SurfNum) == SurfaceClass::Door || - m_state.dataSurface->Surface(MultizoneSurfaceData(count).SurfNum).IsAirBoundarySurf)) { + if (!(surf.OriginalClass == SurfaceClass::Window || + surf.OriginalClass == SurfaceClass::GlassDoor || + surf.OriginalClass == SurfaceClass::Door || + surf.IsAirBoundarySurf)) { ShowSevereError(m_state, format(RoutineName) + "AirflowNetworkComponent: The opening must be assigned to a window, door, glassdoor or air boundary at " + @@ -4685,7 +4684,7 @@ namespace AirflowNetwork { } break; case ComponentType::HOP: { // if (AirflowNetworkCompData(i).CompTypeNum == iComponentTypeNum::HOP) { - MultizoneSurfaceData(count).Multiplier = m_state.dataSurface->Surface(MultizoneSurfaceData(count).SurfNum).Multiplier; + MultizoneSurfaceData(count).Multiplier = surf.Multiplier; // Get linkage height from upper and lower zones if (MultizoneZoneData(AirflowNetworkLinkageData(count).NodeNums[0]).ZoneNum > 0) { AirflowNetworkLinkageData(count).NodeHeights[0] = @@ -4714,10 +4713,7 @@ namespace AirflowNetwork { ErrorsFound = true; } } - if (!(m_state.dataSurface->Surface(MultizoneSurfaceData(count).SurfNum).Tilt > 170.0 && - m_state.dataSurface->Surface(MultizoneSurfaceData(count).SurfNum).Tilt < 190.0) && - !(m_state.dataSurface->Surface(MultizoneSurfaceData(count).SurfNum).Tilt > -10.0 && - m_state.dataSurface->Surface(MultizoneSurfaceData(count).SurfNum).Tilt < 10.0)) { + if (!(surf.Tilt > 170.0 && surf.Tilt < 190.0) && !(surf.Tilt > -10.0 && surf.Tilt < 10.0)) { ShowWarningError(m_state, "An AirflowNetwork:Multizone:Surface object has an air-flow opening corresponding to"); ShowContinueError(m_state, "window or door = " + MultizoneSurfaceData(count).SurfName + ", which is above"); ShowContinueError(m_state, "10 deg of being horizontal. Airflows through non-horizontal openings are not modeled"); @@ -4725,10 +4721,10 @@ namespace AirflowNetwork { "with the object of AirflowNetwork:Multizone:Component:HorizontalOpening = " + AirflowNetworkCompData(compnum).Name); } - if (!(m_state.dataSurface->SurfWinOriginalClass(MultizoneSurfaceData(count).SurfNum) == SurfaceClass::Window || - m_state.dataSurface->SurfWinOriginalClass(MultizoneSurfaceData(count).SurfNum) == SurfaceClass::GlassDoor || - m_state.dataSurface->SurfWinOriginalClass(MultizoneSurfaceData(count).SurfNum) == SurfaceClass::Door || - m_state.dataSurface->Surface(MultizoneSurfaceData(count).SurfNum).IsAirBoundarySurf)) { + if (!(surf.OriginalClass == SurfaceClass::Window || + surf.OriginalClass == SurfaceClass::GlassDoor || + surf.OriginalClass == SurfaceClass::Door || + surf.IsAirBoundarySurf)) { ShowSevereError(m_state, format(RoutineName) + "AirflowNetworkComponent: The opening must be assigned to a window, door, glassdoor or air boundary at " + @@ -6432,9 +6428,10 @@ namespace AirflowNetwork { } if (MultizoneSurfaceData(i).OccupantVentilationControlNum == 0) MultizoneSurfaceData(i).OpenFactor = 0.0; j = MultizoneSurfaceData(i).SurfNum; - if (m_state.dataSurface->SurfWinOriginalClass(j) == SurfaceClass::Window || - m_state.dataSurface->SurfWinOriginalClass(j) == SurfaceClass::Door || - m_state.dataSurface->SurfWinOriginalClass(j) == SurfaceClass::GlassDoor || m_state.dataSurface->Surface(j).IsAirBoundarySurf) { + auto const &surf = m_state.dataSurface->Surface(j); + if (surf.OriginalClass == SurfaceClass::Window || + surf.OriginalClass == SurfaceClass::Door || + surf.OriginalClass == SurfaceClass::GlassDoor || surf.IsAirBoundarySurf) { if (MultizoneSurfaceData(i).OccupantVentilationControlNum > 0) { if (MultizoneSurfaceData(i).OpeningStatus == OpenStatus::FreeOperation) { if (MultizoneSurfaceData(i).OpeningProbStatus == ProbabilityCheck::ForceChange) { @@ -6513,9 +6510,10 @@ namespace AirflowNetwork { for (i = 1; i <= AirflowNetworkNumOfSurfaces; ++i) { if (i > AirflowNetworkNumOfSurfaces - NumOfLinksIntraZone) continue; j = MultizoneSurfaceData(i).SurfNum; - if (m_state.dataSurface->SurfWinOriginalClass(j) == SurfaceClass::Window || - m_state.dataSurface->SurfWinOriginalClass(j) == SurfaceClass::Door || - m_state.dataSurface->SurfWinOriginalClass(j) == SurfaceClass::GlassDoor) { + auto const &surf = m_state.dataSurface->Surface(j); + if (surf.OriginalClass == SurfaceClass::Window || + surf.OriginalClass == SurfaceClass::Door || + surf.OriginalClass == SurfaceClass::GlassDoor) { if (MultizoneSurfaceData(i).HybridCtrlGlobal) { MultizoneSurfaceData(i).OpenFactor = GlobalOpenFactor; } @@ -11302,7 +11300,9 @@ namespace AirflowNetwork { if (ActualZoneNum > 0) { for (ANSurfaceNum = 1; ANSurfaceNum <= AirflowNetworkNumOfSurfaces; ++ANSurfaceNum) { SurfNum = MultizoneSurfaceData(ANSurfaceNum).SurfNum; - if (m_state.dataSurface->Surface(SurfNum).Zone == ActualZoneNum) { + auto const &surf = m_state.dataSurface->Surface(SurfNum); + + if (surf.Zone == ActualZoneNum) { if (VentilationCtrl == HybridVentCtrl_Close) { MultizoneSurfaceData(ANSurfaceNum).HybridVentClose = true; } else { @@ -11312,10 +11312,10 @@ namespace AirflowNetwork { if (ControlType == GlobalCtrlType) { MultizoneSurfaceData(ANSurfaceNum).HybridCtrlGlobal = true; if (HybridVentSysAvailMaster(SysAvailNum) == ActualZoneNum) { - if ((m_state.dataSurface->SurfWinOriginalClass(SurfNum) == SurfaceClass::Window || - m_state.dataSurface->SurfWinOriginalClass(SurfNum) == SurfaceClass::Door || - m_state.dataSurface->SurfWinOriginalClass(SurfNum) == SurfaceClass::GlassDoor) && - m_state.dataSurface->Surface(SurfNum).ExtBoundCond == ExternalEnvironment) { + if ((surf.OriginalClass == SurfaceClass::Window || + surf.OriginalClass == SurfaceClass::Door || + surf.OriginalClass == SurfaceClass::GlassDoor) && + surf.ExtBoundCond == ExternalEnvironment) { MultizoneSurfaceData(ANSurfaceNum).HybridCtrlMaster = true; Found = true; } diff --git a/src/EnergyPlus/DataSurfaces.hh b/src/EnergyPlus/DataSurfaces.hh index 1e4f78e4388..3a133ba73d4 100644 --- a/src/EnergyPlus/DataSurfaces.hh +++ b/src/EnergyPlus/DataSurfaces.hh @@ -688,6 +688,7 @@ namespace DataSurfaces { std::vector ConstituentSurfaceNums; // A vector of surface numbers which reference this surface for representative calculations int ConstructionStoredInputValue; // holds the original value for Construction per surface input SurfaceClass Class; + SurfaceClass OriginalClass; // Geometry related parameters SurfaceShape Shape; // Surface shape (Triangle=1,Quadrilateral=2,Rectangle=3, @@ -716,13 +717,13 @@ namespace DataSurfaces { // Vertices Array1D NewVertex; Vertices Vertex; // Surface Vertices are represented by Number of Sides and Vector (type) - Vector Centroid; // computed centroid (also known as center of mass or surface balance point) - Vector lcsx; - Vector lcsy; - Vector lcsz; - Vector NewellAreaVector; - Vector NewellSurfaceNormalVector; // same as OutNormVec in vector notation - Array1D OutNormVec; // Direction cosines (outward normal vector) for surface + Vector3 Centroid; // computed centroid (also known as center of mass or surface balance point) + Vector3 lcsx; + Vector3 lcsy; + Vector3 lcsz; + Vector3 NewellAreaVector; + Vector3 NewellSurfaceNormalVector; // same as OutNormVec in vector notation + Vector3 OutNormVec; // Direction cosines (outward normal vector) for surface Real64 SinAzim; // Sine of surface azimuth angle Real64 CosAzim; // Cosine of surface azimuth angle Real64 SinTilt; // Sine of surface tilt angle @@ -818,7 +819,7 @@ namespace DataSurfaces { : Construction(0), RepresentativeCalcSurfNum(-1), ConstructionStoredInputValue(0), Class(SurfaceClass::None), Shape(SurfaceShape::None), Sides(0), Area(0.0), GrossArea(0.0), NetAreaShadowCalc(0.0), Perimeter(0.0), Azimuth(0.0), Height(0.0), Reveal(0.0), Tilt(0.0), Width(0.0), shapeCat(ShapeCat::Invalid), plane(0.0, 0.0, 0.0, 0.0), Centroid(0.0, 0.0, 0.0), lcsx(0.0, 0.0, 0.0), lcsy(0.0, 0.0, 0.0), - lcsz(0.0, 0.0, 0.0), NewellAreaVector(0.0, 0.0, 0.0), NewellSurfaceNormalVector(0.0, 0.0, 0.0), OutNormVec(3, 0.0), SinAzim(0.0), + lcsz(0.0, 0.0, 0.0), NewellAreaVector(0.0, 0.0, 0.0), NewellSurfaceNormalVector(0.0, 0.0, 0.0), OutNormVec(0.0,0.0,0.0), SinAzim(0.0), CosAzim(0.0), SinTilt(0.0), CosTilt(0.0), IsConvex(true), IsDegenerate(false), VerticesProcessed(false), XShift(0.0), YShift(0.0), HeatTransSurf(false), OutsideHeatSourceTermSchedule(0), InsideHeatSourceTermSchedule(0), HeatTransferAlgorithm(HeatTransferModel::Invalid), BaseSurf(0), NumSubSurfaces(0), Zone(0), spaceNum(0), ExtBoundCond(0), @@ -864,16 +865,19 @@ namespace DataSurfaces { Surface2D computed_surface2d() const; }; + struct SurfaceWindowRefPt { + Real64 solidAng = 0.0; // Solid angle subtended by window from daylit ref points 1 and 2 + Real64 solidAngWtd = 0.0; // Solid angle subtended by window from ref pts weighted by glare pos factor + std::array, (int)Lum::Num> lums = {{0.0, 0.0}}; + Real64 illumFromWinRep = 0.0; // Illuminance from window at reference point N [lux] + Real64 lumWinRep = 0.0; // Window luminance as viewed from reference point N [cd/m2] + }; + struct SurfaceWindowCalc // Calculated window-related values { // Members - Array1D SolidAngAtRefPt; // Solid angle subtended by window from daylit ref points 1 and 2 - Array1D SolidAngAtRefPtWtd; // Solid angle subtended by window from ref pts weighted by glare pos factor - EPVector, (int)Lum::Num>> - DaylFromWinAtRefPt; // Illuminance from window at ref pts for window with and w/o shade (lux) - // EPVector> - // BackLumFromWinAtRefPt; // Window background luminance from window wrt ref pts (cd/m2) with and w/o shade (cd/m2) - // EPVector> SourceLumFromWinAtRefPt; // Window luminance at ref pts for window with and w/o shade (cd/m2) + Array1D refPts; + Vector3 WinCenter = {0.0, 0.0, 0.0}; // X,Y,Z coordinates of window center point in building coord system // What is 10 here? std::array ThetaFace = {296.15}; // Face temperatures of window layers (K) @@ -886,8 +890,6 @@ namespace DataSurfaces { std::array EffShBlindEmiss = {0.0}; // Effective emissivity of interior blind or shade std::array EffGlassEmiss = {0.0}; // Effective emissivity of glass adjacent to interior blind or shade - Array1D IllumFromWinAtRefPtRep; // Illuminance from window at reference point N [lux] - Array1D LumWinFromRefPtRep; // Window luminance as viewed from reference point N [cd/m2] // for shadowing of ground by building and obstructions [W/m2] std::array EnclAreaMinusThisSurf = { 0.0, 0.0, 0.0}; // Enclosure inside surface area minus this surface and its subsurfaces @@ -1699,7 +1701,6 @@ struct SurfacesData : BaseGlobalStruct Array1D SurfWinCenterGlArea; // Center of glass area (m2); area of glass where 1-D conduction dominates Array1D SurfWinEdgeGlCorrFac; // Correction factor to center-of-glass conductance to account for 2-D glass conduction thermal bridging // effects near frame and divider - EPVector SurfWinOriginalClass; // 0 or if entered originally as: Array1D SurfWinShadeAbsFacFace1; // Fraction of short-wave radiation incident that is absorbed by face 1 when total absorbed radiation is // apportioned to the two faces Array1D SurfWinShadeAbsFacFace2; // Fraction of short-wave radiation incident that is absorbed by face 2 when total absorbed radiation is diff --git a/src/EnergyPlus/DaylightingDevices.cc b/src/EnergyPlus/DaylightingDevices.cc index 9bf1cdbcf18..074d408f840 100644 --- a/src/EnergyPlus/DaylightingDevices.cc +++ b/src/EnergyPlus/DaylightingDevices.cc @@ -434,7 +434,8 @@ namespace Dayltg { // METHODOLOGY EMPLOYED: // Standard EnergyPlus methodology. - auto &cCurrentModuleObject = state.dataIPShortCut->cCurrentModuleObject; + auto &ipsc = state.dataIPShortCut; + auto &cCurrentModuleObject = ipsc->cCurrentModuleObject; cCurrentModuleObject = "DaylightingDevice:Tubular"; int NumOfTDDPipes = state.dataInputProcessing->inputProcessor->getNumObjectsFound(state, cCurrentModuleObject); @@ -449,35 +450,35 @@ namespace Dayltg { state.dataInputProcessing->inputProcessor->getObjectItem(state, cCurrentModuleObject, PipeNum, - state.dataIPShortCut->cAlphaArgs, + ipsc->cAlphaArgs, NumAlphas, - state.dataIPShortCut->rNumericArgs, + ipsc->rNumericArgs, NumNumbers, IOStatus, - state.dataIPShortCut->lNumericFieldBlanks, - state.dataIPShortCut->lAlphaFieldBlanks, - state.dataIPShortCut->cAlphaFieldNames, - state.dataIPShortCut->cNumericFieldNames); + ipsc->lNumericFieldBlanks, + ipsc->lAlphaFieldBlanks, + ipsc->cAlphaFieldNames, + ipsc->cNumericFieldNames); // Pipe name - state.dataDaylightingDevicesData->TDDPipe(PipeNum).Name = state.dataIPShortCut->cAlphaArgs(1); + state.dataDaylightingDevicesData->TDDPipe(PipeNum).Name = ipsc->cAlphaArgs(1); // Get TDD:DOME object - int SurfNum = Util::FindItemInList(state.dataIPShortCut->cAlphaArgs(2), state.dataSurface->Surface); + int SurfNum = Util::FindItemInList(ipsc->cAlphaArgs(2), state.dataSurface->Surface); if (SurfNum == 0) { ShowSevereError(state, format("{} = {}: Dome {} not found.", cCurrentModuleObject, - state.dataIPShortCut->cAlphaArgs(1), - state.dataIPShortCut->cAlphaArgs(2))); + ipsc->cAlphaArgs(1), + ipsc->cAlphaArgs(2))); state.dataDaylightingDevices->GetTDDInputErrorsFound = true; } else { if (FindTDDPipe(state, SurfNum) > 0) { ShowSevereError(state, format("{} = {}: Dome {} is referenced by more than one TDD.", cCurrentModuleObject, - state.dataIPShortCut->cAlphaArgs(1), - state.dataIPShortCut->cAlphaArgs(2))); + ipsc->cAlphaArgs(1), + ipsc->cAlphaArgs(2))); state.dataDaylightingDevices->GetTDDInputErrorsFound = true; } @@ -485,8 +486,8 @@ namespace Dayltg { ShowSevereError(state, format("{} = {}: Dome {} is not of surface type TubularDaylightDome.", cCurrentModuleObject, - state.dataIPShortCut->cAlphaArgs(1), - state.dataIPShortCut->cAlphaArgs(2))); + ipsc->cAlphaArgs(1), + ipsc->cAlphaArgs(2))); state.dataDaylightingDevices->GetTDDInputErrorsFound = true; } @@ -494,8 +495,8 @@ namespace Dayltg { ShowSevereError(state, format("{} = {}: Dome {} construction ({}) must have only 1 glass layer.", cCurrentModuleObject, - state.dataIPShortCut->cAlphaArgs(1), - state.dataIPShortCut->cAlphaArgs(2), + ipsc->cAlphaArgs(1), + ipsc->cAlphaArgs(2), state.dataConstruction->Construct(state.dataSurface->Surface(SurfNum).Construction).Name)); state.dataDaylightingDevices->GetTDDInputErrorsFound = true; } @@ -504,8 +505,8 @@ namespace Dayltg { ShowSevereError(state, format("{} = {}: Dome {} must not have a shading control.", cCurrentModuleObject, - state.dataIPShortCut->cAlphaArgs(1), - state.dataIPShortCut->cAlphaArgs(2))); + ipsc->cAlphaArgs(1), + ipsc->cAlphaArgs(2))); state.dataDaylightingDevices->GetTDDInputErrorsFound = true; } @@ -513,8 +514,8 @@ namespace Dayltg { ShowSevereError(state, format("{} = {}: Dome {} must not have a frame/divider.", cCurrentModuleObject, - state.dataIPShortCut->cAlphaArgs(1), - state.dataIPShortCut->cAlphaArgs(2))); + ipsc->cAlphaArgs(1), + ipsc->cAlphaArgs(2))); state.dataDaylightingDevices->GetTDDInputErrorsFound = true; } @@ -522,8 +523,8 @@ namespace Dayltg { ShowSevereError(state, format("{} = {}: Dome {} Equivalent Layer Window is not supported.", cCurrentModuleObject, - state.dataIPShortCut->cAlphaArgs(1), - state.dataIPShortCut->cAlphaArgs(2))); + ipsc->cAlphaArgs(1), + ipsc->cAlphaArgs(2))); state.dataDaylightingDevices->GetTDDInputErrorsFound = true; } // Window multiplier is already handled in SurfaceGeometry.cc @@ -532,8 +533,8 @@ namespace Dayltg { ShowWarningError(state, format("{} = {}: Dome {} is not exposed to exterior radiation.", cCurrentModuleObject, - state.dataIPShortCut->cAlphaArgs(1), - state.dataIPShortCut->cAlphaArgs(2))); + ipsc->cAlphaArgs(1), + ipsc->cAlphaArgs(2))); } state.dataDaylightingDevicesData->TDDPipe(PipeNum).Dome = SurfNum; @@ -541,31 +542,31 @@ namespace Dayltg { } // Get TDD:DIFFUSER object - SurfNum = Util::FindItemInList(state.dataIPShortCut->cAlphaArgs(3), state.dataSurface->Surface); + SurfNum = Util::FindItemInList(ipsc->cAlphaArgs(3), state.dataSurface->Surface); if (SurfNum == 0) { ShowSevereError(state, format("{} = {}: Diffuser {} not found.", cCurrentModuleObject, - state.dataIPShortCut->cAlphaArgs(1), - state.dataIPShortCut->cAlphaArgs(3))); + ipsc->cAlphaArgs(1), + ipsc->cAlphaArgs(3))); state.dataDaylightingDevices->GetTDDInputErrorsFound = true; } else { if (FindTDDPipe(state, SurfNum) > 0) { ShowSevereError(state, format("{} = {}: Diffuser {} is referenced by more than one TDD.", cCurrentModuleObject, - state.dataIPShortCut->cAlphaArgs(1), - state.dataIPShortCut->cAlphaArgs(3))); + ipsc->cAlphaArgs(1), + ipsc->cAlphaArgs(3))); state.dataDaylightingDevices->GetTDDInputErrorsFound = true; } - if (state.dataSurface->SurfWinOriginalClass(SurfNum) != SurfaceClass::TDD_Diffuser) { + if (state.dataSurface->Surface(SurfNum).OriginalClass != SurfaceClass::TDD_Diffuser) { ShowSevereError(state, format("{} = {}: Diffuser {} is not of surface type TubularDaylightDiffuser.", cCurrentModuleObject, - state.dataIPShortCut->cAlphaArgs(1), - state.dataIPShortCut->cAlphaArgs(3))); + ipsc->cAlphaArgs(1), + ipsc->cAlphaArgs(3))); state.dataDaylightingDevices->GetTDDInputErrorsFound = true; } @@ -573,8 +574,8 @@ namespace Dayltg { ShowSevereError(state, format("{} = {}: Diffuser {} construction ({}) must have only 1 glass layer.", cCurrentModuleObject, - state.dataIPShortCut->cAlphaArgs(1), - state.dataIPShortCut->cAlphaArgs(3), + ipsc->cAlphaArgs(1), + ipsc->cAlphaArgs(3), state.dataConstruction->Construct(state.dataSurface->Surface(SurfNum).Construction).Name)); state.dataDaylightingDevices->GetTDDInputErrorsFound = true; } @@ -583,8 +584,8 @@ namespace Dayltg { ShowSevereError(state, format("{} = {}: Diffuser {} construction ({}) invalid value.", cCurrentModuleObject, - state.dataIPShortCut->cAlphaArgs(1), - state.dataIPShortCut->cAlphaArgs(3), + ipsc->cAlphaArgs(1), + ipsc->cAlphaArgs(3), state.dataConstruction->Construct(state.dataSurface->Surface(SurfNum).Construction).Name)); ShowContinueError(state, format("Diffuse solar transmittance of construction [{:.4R}] too small for calculations.", @@ -602,7 +603,7 @@ namespace Dayltg { ShowSevereError(state, format("{} = {}: Dome and diffuser areas are significantly different (>10%).", cCurrentModuleObject, - state.dataIPShortCut->cAlphaArgs(1))); + ipsc->cAlphaArgs(1))); ShowContinueError(state, format("...Diffuser Area=[{:.4R}]; Dome Area=[{:.4R}].", state.dataSurface->Surface(SurfNum).Area, @@ -612,7 +613,7 @@ namespace Dayltg { ShowWarningError(state, format("{} = {}: Dome and diffuser areas differ by > .1 m2.", cCurrentModuleObject, - state.dataIPShortCut->cAlphaArgs(1))); + ipsc->cAlphaArgs(1))); ShowContinueError(state, format("...Diffuser Area=[{:.4R}]; Dome Area=[{:.4R}].", state.dataSurface->Surface(SurfNum).Area, @@ -624,8 +625,8 @@ namespace Dayltg { ShowSevereError(state, format("{} = {}: Diffuser {} must not have a shading control.", cCurrentModuleObject, - state.dataIPShortCut->cAlphaArgs(1), - state.dataIPShortCut->cAlphaArgs(3))); + ipsc->cAlphaArgs(1), + ipsc->cAlphaArgs(3))); state.dataDaylightingDevices->GetTDDInputErrorsFound = true; } @@ -633,8 +634,8 @@ namespace Dayltg { ShowSevereError(state, format("{} = {}: Diffuser {} must not have a frame/divider.", cCurrentModuleObject, - state.dataIPShortCut->cAlphaArgs(1), - state.dataIPShortCut->cAlphaArgs(3))); + ipsc->cAlphaArgs(1), + ipsc->cAlphaArgs(3))); state.dataDaylightingDevices->GetTDDInputErrorsFound = true; } @@ -642,8 +643,8 @@ namespace Dayltg { ShowSevereError(state, format("{} = {}: Diffuser {} Equivalent Layer Window is not supported.", cCurrentModuleObject, - state.dataIPShortCut->cAlphaArgs(1), - state.dataIPShortCut->cAlphaArgs(2))); + ipsc->cAlphaArgs(1), + ipsc->cAlphaArgs(2))); state.dataDaylightingDevices->GetTDDInputErrorsFound = true; } @@ -655,25 +656,25 @@ namespace Dayltg { // Construction state.dataDaylightingDevicesData->TDDPipe(PipeNum).Construction = - Util::FindItemInList(state.dataIPShortCut->cAlphaArgs(4), state.dataConstruction->Construct); + Util::FindItemInList(ipsc->cAlphaArgs(4), state.dataConstruction->Construct); if (state.dataDaylightingDevicesData->TDDPipe(PipeNum).Construction == 0) { ShowSevereError(state, format("{} = {}: Pipe construction {} not found.", cCurrentModuleObject, - state.dataIPShortCut->cAlphaArgs(1), - state.dataIPShortCut->cAlphaArgs(4))); + ipsc->cAlphaArgs(1), + ipsc->cAlphaArgs(4))); state.dataDaylightingDevices->GetTDDInputErrorsFound = true; } else { state.dataConstruction->Construct(state.dataDaylightingDevicesData->TDDPipe(PipeNum).Construction).IsUsed = true; } - if (state.dataIPShortCut->rNumericArgs(1) > 0) { - state.dataDaylightingDevicesData->TDDPipe(PipeNum).Diameter = state.dataIPShortCut->rNumericArgs(1); + if (ipsc->rNumericArgs(1) > 0) { + state.dataDaylightingDevicesData->TDDPipe(PipeNum).Diameter = ipsc->rNumericArgs(1); } else { ShowSevereError( state, - format("{} = {}: Pipe diameter must be greater than zero.", cCurrentModuleObject, state.dataIPShortCut->cAlphaArgs(1))); + format("{} = {}: Pipe diameter must be greater than zero.", cCurrentModuleObject, ipsc->cAlphaArgs(1))); state.dataDaylightingDevices->GetTDDInputErrorsFound = true; } @@ -686,7 +687,7 @@ namespace Dayltg { ShowSevereError(state, format("{} = {}: Pipe and dome/diffuser areas are significantly different (>10%).", cCurrentModuleObject, - state.dataIPShortCut->cAlphaArgs(1))); + ipsc->cAlphaArgs(1))); ShowContinueError(state, format("...Pipe Area=[{:.4R}]; Dome/Diffuser Area=[{:.4R}].", PipeArea, @@ -696,7 +697,7 @@ namespace Dayltg { ShowWarningError(state, format("{} = {}: Pipe and dome/diffuser areas differ by > .1 m2.", cCurrentModuleObject, - state.dataIPShortCut->cAlphaArgs(1))); + ipsc->cAlphaArgs(1))); ShowContinueError(state, format("...Pipe Area=[{:.4R}]; Dome/Diffuser Area=[{:.4R}].", PipeArea, @@ -704,21 +705,21 @@ namespace Dayltg { } } - if (state.dataIPShortCut->rNumericArgs(2) > 0) { - state.dataDaylightingDevicesData->TDDPipe(PipeNum).TotLength = state.dataIPShortCut->rNumericArgs(2); + if (ipsc->rNumericArgs(2) > 0) { + state.dataDaylightingDevicesData->TDDPipe(PipeNum).TotLength = ipsc->rNumericArgs(2); } else { ShowSevereError( - state, format("{} = {}: Pipe length must be greater than zero.", cCurrentModuleObject, state.dataIPShortCut->cAlphaArgs(1))); + state, format("{} = {}: Pipe length must be greater than zero.", cCurrentModuleObject, ipsc->cAlphaArgs(1))); state.dataDaylightingDevices->GetTDDInputErrorsFound = true; } - if (state.dataIPShortCut->rNumericArgs(3) > 0) { - state.dataDaylightingDevicesData->TDDPipe(PipeNum).Reff = state.dataIPShortCut->rNumericArgs(3); + if (ipsc->rNumericArgs(3) > 0) { + state.dataDaylightingDevicesData->TDDPipe(PipeNum).Reff = ipsc->rNumericArgs(3); } else { ShowSevereError(state, format("{} = {}: Effective thermal resistance (R value) must be greater than zero.", cCurrentModuleObject, - state.dataIPShortCut->cAlphaArgs(1))); + ipsc->cAlphaArgs(1))); state.dataDaylightingDevices->GetTDDInputErrorsFound = true; } @@ -729,11 +730,11 @@ namespace Dayltg { ShowWarningError(state, format("{} = {}: No transition zones specified. All pipe absorbed solar goes to exterior.", cCurrentModuleObject, - state.dataIPShortCut->cAlphaArgs(1))); + ipsc->cAlphaArgs(1))); } else if (state.dataDaylightingDevicesData->TDDPipe(PipeNum).NumOfTZones > MaxTZones) { ShowSevereError( state, - format("{} = {}: Maximum number of transition zones exceeded.", cCurrentModuleObject, state.dataIPShortCut->cAlphaArgs(1))); + format("{} = {}: Maximum number of transition zones exceeded.", cCurrentModuleObject, ipsc->cAlphaArgs(1))); state.dataDaylightingDevices->GetTDDInputErrorsFound = true; } else { state.dataDaylightingDevicesData->TDDPipe(PipeNum).TZone.allocate(state.dataDaylightingDevicesData->TDDPipe(PipeNum).NumOfTZones); @@ -747,22 +748,22 @@ namespace Dayltg { state.dataDaylightingDevicesData->TDDPipe(PipeNum).TZoneHeatGain = 0.0; for (int TZoneNum = 1; TZoneNum <= state.dataDaylightingDevicesData->TDDPipe(PipeNum).NumOfTZones; ++TZoneNum) { - std::string const TZoneName = state.dataIPShortCut->cAlphaArgs(TZoneNum + 4); + std::string const TZoneName = ipsc->cAlphaArgs(TZoneNum + 4); state.dataDaylightingDevicesData->TDDPipe(PipeNum).TZone(TZoneNum) = Util::FindItemInList(TZoneName, state.dataHeatBal->Zone); if (state.dataDaylightingDevicesData->TDDPipe(PipeNum).TZone(TZoneNum) == 0) { ShowSevereError( state, format( - "{} = {}: Transition zone {} not found.", cCurrentModuleObject, state.dataIPShortCut->cAlphaArgs(1), TZoneName)); + "{} = {}: Transition zone {} not found.", cCurrentModuleObject, ipsc->cAlphaArgs(1), TZoneName)); state.dataDaylightingDevices->GetTDDInputErrorsFound = true; } - state.dataDaylightingDevicesData->TDDPipe(PipeNum).TZoneLength(TZoneNum) = state.dataIPShortCut->rNumericArgs(TZoneNum + 3); + state.dataDaylightingDevicesData->TDDPipe(PipeNum).TZoneLength(TZoneNum) = ipsc->rNumericArgs(TZoneNum + 3); if (state.dataDaylightingDevicesData->TDDPipe(PipeNum).TZoneLength(TZoneNum) < 0) { ShowSevereError(state, format("{} = {}: Transition zone length for {} must be zero or greater.", cCurrentModuleObject, - state.dataIPShortCut->cAlphaArgs(1), + ipsc->cAlphaArgs(1), TZoneName)); state.dataDaylightingDevices->GetTDDInputErrorsFound = true; } @@ -798,7 +799,8 @@ namespace Dayltg { // METHODOLOGY EMPLOYED: // Standard EnergyPlus methodology. - auto &cCurrentModuleObject = state.dataIPShortCut->cCurrentModuleObject; + auto &ipsc = state.dataIPShortCut; + auto &cCurrentModuleObject = ipsc->cCurrentModuleObject; cCurrentModuleObject = "DaylightingDevice:Shelf"; int NumOfShelf = state.dataInputProcessing->inputProcessor->getNumObjectsFound(state, cCurrentModuleObject); @@ -813,35 +815,35 @@ namespace Dayltg { state.dataInputProcessing->inputProcessor->getObjectItem(state, cCurrentModuleObject, ShelfNum, - state.dataIPShortCut->cAlphaArgs, + ipsc->cAlphaArgs, NumAlphas, - state.dataIPShortCut->rNumericArgs, + ipsc->rNumericArgs, NumNumbers, IOStatus, - state.dataIPShortCut->lNumericFieldBlanks, - state.dataIPShortCut->lAlphaFieldBlanks, - state.dataIPShortCut->cAlphaFieldNames, - state.dataIPShortCut->cNumericFieldNames); + ipsc->lNumericFieldBlanks, + ipsc->lAlphaFieldBlanks, + ipsc->cAlphaFieldNames, + ipsc->cNumericFieldNames); // Shelf name - state.dataDaylightingDevicesData->Shelf(ShelfNum).Name = state.dataIPShortCut->cAlphaArgs(1); + state.dataDaylightingDevicesData->Shelf(ShelfNum).Name = ipsc->cAlphaArgs(1); // Get window object - int SurfNum = Util::FindItemInList(state.dataIPShortCut->cAlphaArgs(2), state.dataSurface->Surface); + int SurfNum = Util::FindItemInList(ipsc->cAlphaArgs(2), state.dataSurface->Surface); if (SurfNum == 0) { ShowSevereError(state, format("{} = {}: Window {} not found.", cCurrentModuleObject, - state.dataIPShortCut->cAlphaArgs(1), - state.dataIPShortCut->cAlphaArgs(2))); + ipsc->cAlphaArgs(1), + ipsc->cAlphaArgs(2))); state.dataDaylightingDevices->GetShelfInputErrorsFound = true; } else { if (state.dataSurface->Surface(SurfNum).Class != SurfaceClass::Window) { ShowSevereError(state, format("{} = {}: Window {} is not of surface type WINDOW.", cCurrentModuleObject, - state.dataIPShortCut->cAlphaArgs(1), - state.dataIPShortCut->cAlphaArgs(2))); + ipsc->cAlphaArgs(1), + ipsc->cAlphaArgs(2))); state.dataDaylightingDevices->GetShelfInputErrorsFound = true; } @@ -849,8 +851,8 @@ namespace Dayltg { ShowSevereError(state, format("{} = {}: Window {} is referenced by more than one shelf.", cCurrentModuleObject, - state.dataIPShortCut->cAlphaArgs(1), - state.dataIPShortCut->cAlphaArgs(2))); + ipsc->cAlphaArgs(1), + ipsc->cAlphaArgs(2))); state.dataDaylightingDevices->GetShelfInputErrorsFound = true; } @@ -858,8 +860,8 @@ namespace Dayltg { ShowSevereError(state, format("{} = {}: Window {} must not have a shading control.", cCurrentModuleObject, - state.dataIPShortCut->cAlphaArgs(1), - state.dataIPShortCut->cAlphaArgs(2))); + ipsc->cAlphaArgs(1), + ipsc->cAlphaArgs(2))); state.dataDaylightingDevices->GetShelfInputErrorsFound = true; } @@ -867,8 +869,8 @@ namespace Dayltg { ShowSevereError(state, format("{} = {}: Window {} must not have a frame/divider.", cCurrentModuleObject, - state.dataIPShortCut->cAlphaArgs(1), - state.dataIPShortCut->cAlphaArgs(2))); + ipsc->cAlphaArgs(1), + ipsc->cAlphaArgs(2))); state.dataDaylightingDevices->GetShelfInputErrorsFound = true; } @@ -876,16 +878,16 @@ namespace Dayltg { ShowSevereError(state, format("{} = {}: Window {} must have 4 sides.", cCurrentModuleObject, - state.dataIPShortCut->cAlphaArgs(1), - state.dataIPShortCut->cAlphaArgs(2))); + ipsc->cAlphaArgs(1), + ipsc->cAlphaArgs(2))); state.dataDaylightingDevices->GetShelfInputErrorsFound = true; } if (state.dataConstruction->Construct(state.dataSurface->Surface(SurfNum).Construction).WindowTypeEQL) { ShowSevereError(state, format("{} = {}: Window {} Equivalent Layer Window is not supported.", cCurrentModuleObject, - state.dataIPShortCut->cAlphaArgs(1), - state.dataIPShortCut->cAlphaArgs(2))); + ipsc->cAlphaArgs(1), + ipsc->cAlphaArgs(2))); state.dataDaylightingDevices->GetShelfInputErrorsFound = true; } @@ -894,15 +896,15 @@ namespace Dayltg { } // Get inside shelf heat transfer surface (optional) - if (state.dataIPShortCut->cAlphaArgs(3) != "") { - SurfNum = Util::FindItemInList(state.dataIPShortCut->cAlphaArgs(3), state.dataSurface->Surface); + if (ipsc->cAlphaArgs(3) != "") { + SurfNum = Util::FindItemInList(ipsc->cAlphaArgs(3), state.dataSurface->Surface); if (SurfNum == 0) { ShowSevereError(state, format("{} = {}: Inside shelf {} not found.", cCurrentModuleObject, - state.dataIPShortCut->cAlphaArgs(1), - state.dataIPShortCut->cAlphaArgs(3))); + ipsc->cAlphaArgs(1), + ipsc->cAlphaArgs(3))); state.dataDaylightingDevices->GetShelfInputErrorsFound = true; } else { // No error if shelf belongs to more than one window, e.g. concave corners @@ -911,8 +913,8 @@ namespace Dayltg { ShowSevereError(state, format("{} = {}: Inside shelf {} must be its own Outside Boundary Condition Object.", cCurrentModuleObject, - state.dataIPShortCut->cAlphaArgs(1), - state.dataIPShortCut->cAlphaArgs(3))); + ipsc->cAlphaArgs(1), + ipsc->cAlphaArgs(3))); state.dataDaylightingDevices->GetShelfInputErrorsFound = true; } @@ -920,8 +922,8 @@ namespace Dayltg { ShowSevereError(state, format("{} = {}: Inside shelf {} must have 4 sides.", cCurrentModuleObject, - state.dataIPShortCut->cAlphaArgs(1), - state.dataIPShortCut->cAlphaArgs(3))); + ipsc->cAlphaArgs(1), + ipsc->cAlphaArgs(3))); state.dataDaylightingDevices->GetShelfInputErrorsFound = true; } @@ -930,15 +932,15 @@ namespace Dayltg { } // Get outside shelf attached shading surface (optional) - if (state.dataIPShortCut->cAlphaArgs(4) != "") { - SurfNum = Util::FindItemInList(state.dataIPShortCut->cAlphaArgs(4), state.dataSurface->Surface); + if (ipsc->cAlphaArgs(4) != "") { + SurfNum = Util::FindItemInList(ipsc->cAlphaArgs(4), state.dataSurface->Surface); if (SurfNum == 0) { ShowSevereError(state, format("{} = {}: Outside shelf {} not found.", cCurrentModuleObject, - state.dataIPShortCut->cAlphaArgs(1), - state.dataIPShortCut->cAlphaArgs(4))); + ipsc->cAlphaArgs(1), + ipsc->cAlphaArgs(4))); state.dataDaylightingDevices->GetShelfInputErrorsFound = true; } else { // No error if shelf belongs to more than one window, e.g. concave corners @@ -947,8 +949,8 @@ namespace Dayltg { ShowSevereError(state, format("{} = {}: Outside shelf {} is not a Shading:Zone:Detailed object.", cCurrentModuleObject, - state.dataIPShortCut->cAlphaArgs(1), - state.dataIPShortCut->cAlphaArgs(4))); + ipsc->cAlphaArgs(1), + ipsc->cAlphaArgs(4))); state.dataDaylightingDevices->GetShelfInputErrorsFound = true; } @@ -956,8 +958,8 @@ namespace Dayltg { ShowSevereError(state, format("{} = {}: Outside shelf {} must not have a transmittance schedule.", cCurrentModuleObject, - state.dataIPShortCut->cAlphaArgs(1), - state.dataIPShortCut->cAlphaArgs(4))); + ipsc->cAlphaArgs(1), + ipsc->cAlphaArgs(4))); state.dataDaylightingDevices->GetShelfInputErrorsFound = true; } @@ -965,29 +967,29 @@ namespace Dayltg { ShowSevereError(state, format("{} = {}: Outside shelf {} must have 4 sides.", cCurrentModuleObject, - state.dataIPShortCut->cAlphaArgs(1), - state.dataIPShortCut->cAlphaArgs(4))); + ipsc->cAlphaArgs(1), + ipsc->cAlphaArgs(4))); state.dataDaylightingDevices->GetShelfInputErrorsFound = true; } int ConstrNum = 0; // Get outside shelf construction (required if outside shelf is specified) - if (state.dataIPShortCut->cAlphaArgs(5) != "") { - ConstrNum = Util::FindItemInList(state.dataIPShortCut->cAlphaArgs(5), state.dataConstruction->Construct); + if (ipsc->cAlphaArgs(5) != "") { + ConstrNum = Util::FindItemInList(ipsc->cAlphaArgs(5), state.dataConstruction->Construct); if (ConstrNum == 0) { ShowSevereError(state, format("{} = {}: Outside shelf construction {} not found.", cCurrentModuleObject, - state.dataIPShortCut->cAlphaArgs(1), - state.dataIPShortCut->cAlphaArgs(5))); + ipsc->cAlphaArgs(1), + ipsc->cAlphaArgs(5))); state.dataDaylightingDevices->GetShelfInputErrorsFound = true; } else if (state.dataConstruction->Construct(ConstrNum).TypeIsWindow) { ShowSevereError(state, format("{} = {}: Outside shelf construction {} must not have WindowMaterial:Glazing.", cCurrentModuleObject, - state.dataIPShortCut->cAlphaArgs(1), - state.dataIPShortCut->cAlphaArgs(5))); + ipsc->cAlphaArgs(1), + ipsc->cAlphaArgs(5))); state.dataDaylightingDevices->GetShelfInputErrorsFound = true; } else { state.dataDaylightingDevicesData->Shelf(ShelfNum).Construction = ConstrNum; @@ -997,19 +999,19 @@ namespace Dayltg { ShowSevereError(state, format("{} = {}: Outside shelf requires an outside shelf construction to be specified.", cCurrentModuleObject, - state.dataIPShortCut->cAlphaArgs(1))); + ipsc->cAlphaArgs(1))); state.dataDaylightingDevices->GetShelfInputErrorsFound = true; } // Get view factor to outside shelf (optional) if (NumNumbers > 0) { - state.dataDaylightingDevicesData->Shelf(ShelfNum).ViewFactor = state.dataIPShortCut->rNumericArgs(1); + state.dataDaylightingDevicesData->Shelf(ShelfNum).ViewFactor = ipsc->rNumericArgs(1); - if (state.dataIPShortCut->rNumericArgs(1) == 0.0) { + if (ipsc->rNumericArgs(1) == 0.0) { ShowWarningError(state, format("{} = {}: View factor to outside shelf is zero. Shelf does not reflect on window.", cCurrentModuleObject, - state.dataIPShortCut->cAlphaArgs(1))); + ipsc->cAlphaArgs(1))); } } else { state.dataDaylightingDevicesData->Shelf(ShelfNum).ViewFactor = @@ -1034,7 +1036,7 @@ namespace Dayltg { ShowWarningError(state, format("{} = {}: No inside shelf or outside shelf was specified.", cCurrentModuleObject, - state.dataIPShortCut->cAlphaArgs(1))); + ipsc->cAlphaArgs(1))); } // ShelfNum diff --git a/src/EnergyPlus/DaylightingManager.cc b/src/EnergyPlus/DaylightingManager.cc index dcfd228fbf7..fdae98705fa 100644 --- a/src/EnergyPlus/DaylightingManager.cc +++ b/src/EnergyPlus/DaylightingManager.cc @@ -212,9 +212,9 @@ void DayltgAveInteriorReflectance(EnergyPlusData &state, int const enclNum) // E state.dataSurface->SurfWinDividerArea(ISurf) * (1.0 + state.dataSurface->SurfWinProjCorrDivIn(ISurf)) * (1.0 - state.dataSurface->SurfWinDividerSolAbsorp(ISurf)); - FWC fwc = FWC::Ceiling; // Ceiling + FWC fwc = FWC::Ceiling; // Ceiling if (surf.Tilt > 10.0 && surf.Tilt < 170.0) fwc = FWC::Wall; // Wall - if (surf.Tilt >= 170.0) fwc = FWC::Floor; // Floor + if (surf.Tilt >= 170.0) fwc = FWC::Floor; // Floor AR[(int)fwc] += AREA + state.dataSurface->SurfWinFrameArea(ISurf) * (1.0 + 0.5 * state.dataSurface->SurfWinProjCorrFrIn(ISurf)) + state.dataSurface->SurfWinDividerArea(ISurf) * (1.0 + state.dataSurface->SurfWinProjCorrDivIn(ISurf)); ARH[(int)fwc] += AREA * state.dataConstruction->Construct(surf.Construction).ReflectVisDiffBack + @@ -677,7 +677,7 @@ void CalcDayltgCoeffsRefMapPoints(EnergyPlusData &state) for (int enclNum = 1; enclNum <= state.dataViewFactor->NumOfSolarEnclosures; ++enclNum) { for (int loopwin = 1; loopwin <= dl->enclDaylight(enclNum).NumOfDayltgExtWins; ++loopwin) { int IWin = dl->enclDaylight(enclNum).DayltgExtWinSurfNums(loopwin); - if (state.dataSurface->SurfWinOriginalClass(IWin) != SurfaceClass::TDD_Diffuser) continue; + if (state.dataSurface->Surface(IWin).OriginalClass != SurfaceClass::TDD_Diffuser) continue; // Look up the TDD:DOME object int PipeNum = state.dataSurface->SurfWinTDDPipeNum(IWin); if (PipeNum == 0) { @@ -1689,7 +1689,7 @@ void FigureDayltgCoeffsAtPointsSetupForWindow(EnergyPlusData &state, } // Recalculation of values for TDD:DOME - if (state.dataSurface->SurfWinOriginalClass(IWin) == SurfaceClass::TDD_Diffuser) { + if (state.dataSurface->Surface(IWin).OriginalClass == SurfaceClass::TDD_Diffuser) { // Look up the TDD:DOME object int PipeNum = state.dataSurface->SurfWinTDDPipeNum(IWin); @@ -1812,8 +1812,8 @@ void FigureDayltgCoeffsAtPointsSetupForWindow(EnergyPlusData &state, if (CalledFrom == CalledFor::RefPoint) { // Initialize solid angle subtended by window wrt ref pt // and solid angle weighted by glare position factor - state.dataSurface->SurfaceWindow(IWin).SolidAngAtRefPt(iRefPoint) = 0.0; - state.dataSurface->SurfaceWindow(IWin).SolidAngAtRefPtWtd(iRefPoint) = 0.0; + state.dataSurface->SurfaceWindow(IWin).refPts(iRefPoint).solidAng = 0.0; + state.dataSurface->SurfaceWindow(IWin).refPts(iRefPoint).solidAngWtd = 0.0; } // Area of window element if (is_Rectangle) { @@ -1957,7 +1957,7 @@ void FigureDayltgCoeffsAtPointsForWindowElements( Vector3 HitPtIntWin = {0.0, 0.0, 0.0}; - if (state.dataSurface->SurfWinOriginalClass(IWin) == SurfaceClass::TDD_Diffuser) { + if (state.dataSurface->Surface(IWin).OriginalClass == SurfaceClass::TDD_Diffuser) { // Look up the TDD:DOME object int PipeNum = state.dataSurface->SurfWinTDDPipeNum(IWin); // Unshaded visible transmittance of TDD for a single ray from sky/ground element @@ -2041,10 +2041,10 @@ void FigureDayltgCoeffsAtPointsForWindowElements( if (!hitIntObs) { if (extWinType == ExtWinType::InZone || (extWinType == ExtWinType::AdjZone && hitIntWin)) { // Increment solid angle subtended by portion of window above ref pt - state.dataSurface->SurfaceWindow(IWin).SolidAngAtRefPt(iRefPoint) += DOMEGA; + state.dataSurface->SurfaceWindow(IWin).refPts(iRefPoint).solidAng += DOMEGA; dl->daylightControl(daylightCtrlNum).SolidAngAtRefPt(loopwin, iRefPoint) += DOMEGA; // Increment position-factor-modified solid angle - state.dataSurface->SurfaceWindow(IWin).SolidAngAtRefPtWtd(iRefPoint) += DOMEGA * POSFAC; + state.dataSurface->SurfaceWindow(IWin).refPts(iRefPoint).solidAngWtd += DOMEGA * POSFAC; dl->daylightControl(daylightCtrlNum).SolidAngAtRefPtWtd(loopwin, iRefPoint) += DOMEGA * POSFAC; } } @@ -3018,7 +3018,7 @@ void FigureDayltgCoeffsAtPointsForSunPosition( if (ObTrans > 1.e-6) { // Ray did not hit an obstruction or the transmittance product of hit obstructions is non-zero. // Contribution of sky or ground luminance in cd/m2 - if (state.dataSurface->SurfWinOriginalClass(IWin) == SurfaceClass::TDD_Diffuser) { + if (state.dataSurface->Surface(IWin).OriginalClass == SurfaceClass::TDD_Diffuser) { // Make all transmitted light diffuse for a TDD with a bare diffuser assert(equal_dimensions(dl->avgWinLum, dl->winLum)); assert(equal_dimensions(dl->avgWinLum, dl->dirIllum)); @@ -3218,7 +3218,7 @@ void FigureDayltgCoeffsAtPointsForSunPosition( // Sun reaches reference point; increment illuminance. // Direct normal illuminance is normalized to 1.0 - if (state.dataSurface->SurfWinOriginalClass(IWin) == SurfaceClass::TDD_Diffuser) { + if (state.dataSurface->Surface(IWin).OriginalClass == SurfaceClass::TDD_Diffuser) { // No beam is transmitted. Takes care of TDD with a bare diffuser and all types of blinds. TVISS = 0.0; } else { @@ -3274,7 +3274,7 @@ void FigureDayltgCoeffsAtPointsForSunPosition( Real64 YR = std::tan(dl->sunAngles.phi + 0.001); Real64 POSFAC = DayltgGlarePositionFactor(XR, YR); // Position factor for a window element / ref point / view vector combination - WindowSolidAngleDaylightPoint = state.dataSurface->SurfaceWindow(IWin).SolidAngAtRefPtWtd(iRefPoint); + WindowSolidAngleDaylightPoint = state.dataSurface->SurfaceWindow(IWin).refPts(iRefPoint).solidAngWtd; if (POSFAC != 0.0 && WindowSolidAngleDaylightPoint > 0.000001) { // Increment window luminance. Luminance of solar disk (cd/m2) @@ -3455,9 +3455,9 @@ void FigureDayltgCoeffsAtPointsForSunPosition( Real64 XR = std::tan(std::abs(Constant::PiOvr2 - AZVIEW - THSUNrefl) + 0.001); Real64 YR = std::tan(PHSUNrefl + 0.001); Real64 POSFAC = DayltgGlarePositionFactor(XR, YR); - if (POSFAC != 0.0 && state.dataSurface->SurfaceWindow(IWin).SolidAngAtRefPtWtd(iRefPoint) > 0.000001) { + if (POSFAC != 0.0 && state.dataSurface->SurfaceWindow(IWin).refPts(iRefPoint).solidAngWtd > 0.000001) { XAVWL = 14700.0 * std::sqrt(0.000068 * POSFAC) * double(NWX * NWY) / - std::pow(state.dataSurface->SurfaceWindow(IWin).SolidAngAtRefPtWtd(iRefPoint), 0.8); + std::pow(state.dataSurface->SurfaceWindow(IWin).refPts(iRefPoint).solidAngWtd, 0.8); dl->avgWinLum(iHour, 1).sunDisk += XAVWL * TVisRefl * SpecReflectance; // Bare window if (ANY_BLIND(ShType)) { for (int JB = 1; JB <= Material::MaxSlatAngs; ++JB) { @@ -3763,20 +3763,11 @@ void GetDaylightingParametersInput(EnergyPlusData &state) auto &surfWin = state.dataSurface->SurfaceWindow(SurfNum); if (numEnclRefPoints > 0) { if (!state.dataSurface->SurfWinSurfDayLightInit(SurfNum)) { - surfWin.SolidAngAtRefPt.allocate(numEnclRefPoints); - surfWin.SolidAngAtRefPt = 0.0; - surfWin.SolidAngAtRefPtWtd.allocate(numEnclRefPoints); - surfWin.SolidAngAtRefPtWtd = 0.0; - surfWin.DaylFromWinAtRefPt.allocate(numEnclRefPoints); - for (int i = 1; i <= numEnclRefPoints; ++i) { - auto &dayl = surfWin.DaylFromWinAtRefPt(i); - dayl[(int)Lum::Illum] = dayl[(int)Lum::Back] = dayl[(int)Lum::Source] = {0.0, 0.0}; + surfWin.refPts.allocate(numEnclRefPoints); + for (auto &refPt : surfWin.refPts) { + new (&refPt) SurfaceWindowRefPt(); } - surfWin.IllumFromWinAtRefPtRep.allocate(numEnclRefPoints); - surfWin.IllumFromWinAtRefPtRep = 0.0; - surfWin.LumWinFromRefPtRep.allocate(numEnclRefPoints); - surfWin.LumWinFromRefPtRep = 0.0; state.dataSurface->SurfWinSurfDayLightInit(SurfNum) = true; } } else { @@ -3786,19 +3777,10 @@ void GetDaylightingParametersInput(EnergyPlusData &state) int const numAdjEnclRefPoints = state.dataViewFactor->EnclSolInfo(adjSurfEnclNum).TotalEnclosureDaylRefPoints; if (numAdjEnclRefPoints > 0) { if (!state.dataSurface->SurfWinSurfDayLightInit(SurfNum)) { - surfWin.SolidAngAtRefPt.allocate(numAdjEnclRefPoints); - surfWin.SolidAngAtRefPt = 0.0; - surfWin.SolidAngAtRefPtWtd.allocate(numAdjEnclRefPoints); - surfWin.SolidAngAtRefPtWtd = 0.0; - surfWin.DaylFromWinAtRefPt.allocate(numEnclRefPoints); - for (int i = 1; i <= numEnclRefPoints; ++i) { - auto &dayl = surfWin.DaylFromWinAtRefPt(i); - dayl[(int)Lum::Illum] = dayl[(int)Lum::Back] = dayl[(int)Lum::Source] = {0.0, 0.0}; + surfWin.refPts.allocate(numAdjEnclRefPoints); + for (auto &refPt : surfWin.refPts) { + new (&refPt) SurfaceWindowRefPt(); } - surfWin.IllumFromWinAtRefPtRep.allocate(numAdjEnclRefPoints); - surfWin.IllumFromWinAtRefPtRep = 0.0; - surfWin.LumWinFromRefPtRep.allocate(numAdjEnclRefPoints); - surfWin.LumWinFromRefPtRep = 0.0; state.dataSurface->SurfWinSurfDayLightInit(SurfNum) = true; } } @@ -3882,19 +3864,21 @@ void GetDaylightingParametersInput(EnergyPlusData &state) auto const &enclSol = state.dataViewFactor->EnclSolInfo(enclOfSurf); if (enclSol.TotalEnclosureDaylRefPoints == 0 || enclSol.HasInterZoneWindow || !dl->enclDaylight(enclOfSurf).hasSplitFluxDaylighting) continue; - + + auto &surfWin = state.dataSurface->SurfaceWindow(SurfLoop); for (int refPtNum = 1; refPtNum <= enclSol.TotalEnclosureDaylRefPoints; ++refPtNum) { + auto &refPt = surfWin.refPts(refPtNum); SetupOutputVariable(state, format("Daylighting Window Reference Point {} Illuminance", refPtNum), OutputProcessor::Unit::lux, - state.dataSurface->SurfaceWindow(SurfLoop).IllumFromWinAtRefPtRep(refPtNum), + refPt.illumFromWinRep, OutputProcessor::SOVTimeStepType::Zone, OutputProcessor::SOVStoreType::Average, surf.Name); SetupOutputVariable(state, format("Daylighting Window Reference Point {} View Luminance", refPtNum), OutputProcessor::Unit::cd_m2, - state.dataSurface->SurfaceWindow(SurfLoop).LumWinFromRefPtRep(refPtNum), + refPt.lumWinRep, OutputProcessor::SOVTimeStepType::Zone, OutputProcessor::SOVStoreType::Average, surf.Name); @@ -3922,18 +3906,19 @@ void GetDaylightingParametersInput(EnergyPlusData &state) auto const &control = dl->daylightControl(controlNum); for (int refPtNum = 1; refPtNum <= control.TotalDaylRefPoints; ++refPtNum) { ++refPtCount; // Count reference points across each daylighting control in the same enclosure + auto &refPt = surfWindow.refPts(refPtCount); std::string varKey = format("{} to {}", surf.Name, state.dataDayltg->DaylRefPt(control.refPts(refPtNum).num).Name); SetupOutputVariable(state, "Daylighting Window Reference Point Illuminance", OutputProcessor::Unit::lux, - surfWindow.IllumFromWinAtRefPtRep(refPtCount), + refPt.illumFromWinRep, OutputProcessor::SOVTimeStepType::Zone, OutputProcessor::SOVStoreType::Average, varKey); SetupOutputVariable(state, "Daylighting Window Reference Point View Luminance", OutputProcessor::Unit::cd_m2, - surfWindow.LumWinFromRefPtRep(refPtCount), + refPt.lumWinRep, OutputProcessor::SOVTimeStepType::Zone, OutputProcessor::SOVStoreType::Average, varKey); @@ -5498,8 +5483,9 @@ void initDaylighting(EnergyPlusData &state, bool const initSurfaceHeatBalancefir auto &dl = state.dataDayltg; for (int SurfNum : state.dataSurface->AllExtSolWindowSurfaceList) { - state.dataSurface->SurfaceWindow(SurfNum).IllumFromWinAtRefPtRep = 0.0; - state.dataSurface->SurfaceWindow(SurfNum).LumWinFromRefPtRep = 0.0; + for (auto &refPt : state.dataSurface->SurfaceWindow(SurfNum).refPts) { + refPt.illumFromWinRep = refPt.lumWinRep = 0.0; + } } // Reset space power reduction factors @@ -5550,10 +5536,9 @@ void initDaylighting(EnergyPlusData &state, bool const initSurfaceHeatBalancefir for (int refPtNum = 1; refPtNum <= thisControl.TotalDaylRefPoints; ++refPtNum) { ++refPtCount; // Count reference points across each daylighting control in the same enclosure - state.dataSurface->SurfaceWindow(IWin).IllumFromWinAtRefPtRep(refPtCount) = - thisControl.DaylFromWinAtRefPt(extWinNum, refPtNum)[(int)Lum::Illum][(int)winCover]; - state.dataSurface->SurfaceWindow(IWin).LumWinFromRefPtRep(refPtCount) = - thisControl.DaylFromWinAtRefPt(extWinNum, refPtNum)[(int)Lum::Source][(int)winCover]; + auto &refPt = state.dataSurface->SurfaceWindow(IWin).refPts(refPtCount); + refPt.illumFromWinRep = thisControl.DaylFromWinAtRefPt(extWinNum, refPtNum)[(int)Lum::Illum][(int)winCover]; + refPt.lumWinRep = thisControl.DaylFromWinAtRefPt(extWinNum, refPtNum)[(int)Lum::Source][(int)winCover]; } } // for (controlNum) } // for (extWinNum) @@ -7182,7 +7167,7 @@ void DayltgInterReflectedIllum(EnergyPlusData &state, ShadeOn = false; ScreenOn = false; - if (state.dataSurface->SurfWinOriginalClass(IWin) == SurfaceClass::TDD_Dome) { + if (state.dataSurface->Surface(IWin).OriginalClass == SurfaceClass::TDD_Dome) { PipeNum = state.dataSurface->SurfWinTDDPipeNum(IWin); } @@ -7388,7 +7373,7 @@ void DayltgInterReflectedIllum(EnergyPlusData &state, // FLCW--(I,J) = part of incoming flux (in lumens) that goes up to ceiling and upper part of walls. // FLFW--(I,J) = part that goes down to floor and lower part of walls - if (state.dataSurface->SurfWinOriginalClass(IWin) == SurfaceClass::TDD_Dome) { + if (state.dataSurface->Surface(IWin).OriginalClass == SurfaceClass::TDD_Dome) { // Unshaded visible transmittance of TDD for a single ray from sky/ground element TVISBR = TransTDD(state, PipeNum, COSB, RadType::VisibleBeam) * state.dataSurface->SurfWinGlazedFrac(IWin); @@ -7520,7 +7505,7 @@ void DayltgInterReflectedIllum(EnergyPlusData &state, std::fill(transMult.begin(), transMult.end(), 0.0); if (ShadeOn) { // Shade - if (state.dataSurface->SurfWinOriginalClass(IWin) == SurfaceClass::TDD_Dome) { + if (state.dataSurface->Surface(IWin).OriginalClass == SurfaceClass::TDD_Dome) { // Shaded visible transmittance of TDD for a single ray from sky/ground element transMult[1] = TransTDD(state, PipeNum, COSB, RadType::VisibleBeam) * state.dataSurface->SurfWinGlazedFrac(IWin); } else { // Shade only, no TDD @@ -7606,7 +7591,7 @@ void DayltgInterReflectedIllum(EnergyPlusData &state, state.dataSurface->SurfWinGlazedFrac(IWin) * state.dataSurface->SurfWinLightWellEff(IWin); } // End of check if shade, blind or diffusing glass - if (state.dataSurface->SurfWinOriginalClass(IWin) == SurfaceClass::TDD_Dome) { + if (state.dataSurface->Surface(IWin).OriginalClass == SurfaceClass::TDD_Dome) { // No beam is transmitted. This takes care of all types of screens and blinds. std::fill(transBmBmMult.begin(), transBmBmMult.end(), 0.0); } @@ -7724,7 +7709,7 @@ void DayltgInterReflectedIllum(EnergyPlusData &state, // -- Bare window - if (state.dataSurface->SurfWinOriginalClass(IWin) == SurfaceClass::TDD_Dome) { + if (state.dataSurface->Surface(IWin).OriginalClass == SurfaceClass::TDD_Dome) { // Unshaded visible transmittance of TDD for collimated beam from the sun TVISBSun = TransTDD(state, PipeNum, COSBSun, RadType::VisibleBeam) * state.dataSurface->SurfWinGlazedFrac(IWin); dl->TDDTransVisBeam(IHR, PipeNum) = TVISBSun; @@ -7768,7 +7753,7 @@ void DayltgInterReflectedIllum(EnergyPlusData &state, if (!state.dataSurface->SurfWinMovableSlats(IWin) && JB > 1) break; if (ShadeOn || ScreenOn || state.dataSurface->SurfWinSolarDiffusing(IWin)) { // Shade or screen on or diffusing glass - if (state.dataSurface->SurfWinOriginalClass(IWin) == SurfaceClass::TDD_Dome) { + if (state.dataSurface->Surface(IWin).OriginalClass == SurfaceClass::TDD_Dome) { // Shaded visible transmittance of TDD for collimated beam from the sun transMult[1] = TransTDD(state, PipeNum, COSBSun, RadType::VisibleBeam) * state.dataSurface->SurfWinGlazedFrac(IWin); } else { @@ -7830,7 +7815,7 @@ void DayltgInterReflectedIllum(EnergyPlusData &state, transBmBmMult[JB] = TVISBSun * WindowManager::BlindBeamBeamTrans(ProfAng, SlatAng, blind.SlatWidth, blind.SlatSeparation, blind.SlatThickness); } // ShadeOn/ScreenOn/BlindOn/Diffusing glass - if (state.dataSurface->SurfWinOriginalClass(IWin) == SurfaceClass::TDD_Dome) { + if (state.dataSurface->Surface(IWin).OriginalClass == SurfaceClass::TDD_Dome) { std::fill(transBmBmMult.begin(), transBmBmMult.end(), 0.0); // No beam, diffuse only } @@ -7855,7 +7840,7 @@ void DayltgInterReflectedIllum(EnergyPlusData &state, // In the following, Beam normal illuminance times ZSU1refl = illuminance on window due to // specular reflection from exterior surfaces - if (state.dataSurface->CalcSolRefl && state.dataSurface->SurfWinOriginalClass(IWin) != SurfaceClass::TDD_Dome) { + if (state.dataSurface->CalcSolRefl && state.dataSurface->Surface(IWin).OriginalClass != SurfaceClass::TDD_Dome) { ZSU1refl = state.dataSurface->SurfReflFacBmToBmSolObs(IHR, IWin); @@ -8379,7 +8364,7 @@ void DayltgDirectSunDiskComplexFenestration(EnergyPlusData &state, auto const &complexWindowDayltgGeom = complexWindow.DaylghtGeom(CurCplxFenState); int SolBmIndex = complexWindowGeom.SolBmIndex(iHour, state.dataGlobal->TimeStep); - Real64 WindowSolidAngleDaylightPoint = (CalledFrom == CalledFor::RefPoint) ? window.SolidAngAtRefPtWtd(iRefPoint) : 0.0; + Real64 WindowSolidAngleDaylightPoint = (CalledFrom == CalledFor::RefPoint) ? window.refPts(iRefPoint).solidAngWtd : 0.0; if (WindowSolidAngleDaylightPoint < 1e-6) return; Illums WinLum; @@ -9274,9 +9259,8 @@ void DayltgSetupAdjZoneListsAndPointers(EnergyPlusData &state) // Count exterior windows in this solar enclosure for (int const surfNum : state.dataViewFactor->EnclSolInfo(enclNum).SurfacePtr) { - if ((state.dataSurface->Surface(surfNum).Class == SurfaceClass::Window && - state.dataSurface->Surface(surfNum).ExtBoundCond == ExternalEnvironment) || - state.dataSurface->SurfWinOriginalClass(surfNum) == SurfaceClass::TDD_Diffuser) { + auto const &surf = state.dataSurface->Surface(surfNum); + if ((surf.Class == SurfaceClass::Window && surf.ExtBoundCond == ExternalEnvironment) || surf.OriginalClass == SurfaceClass::TDD_Diffuser) { ++thisEnclDaylight.TotalExtWindows; } } @@ -9430,9 +9414,8 @@ void DayltgSetupAdjZoneListsAndPointers(EnergyPlusData &state) // Get exterior windows in this solar enclosure for (int const surfNum : state.dataViewFactor->EnclSolInfo(enclNum).SurfacePtr) { - auto &surf = state.dataSurface->Surface(surfNum); - if ((surf.Class == SurfaceClass::Window && surf.ExtBoundCond == ExternalEnvironment) || - state.dataSurface->SurfWinOriginalClass(surfNum) == SurfaceClass::TDD_Diffuser) { + auto const &surf = state.dataSurface->Surface(surfNum); + if ((surf.Class == SurfaceClass::Window && surf.ExtBoundCond == ExternalEnvironment) || surf.OriginalClass == SurfaceClass::TDD_Diffuser) { ++enclExtWin(enclNum); } } @@ -9446,8 +9429,7 @@ void DayltgSetupAdjZoneListsAndPointers(EnergyPlusData &state) // it would not be an "AdjIntWinEncl" for (int SurfNumAdj : state.dataViewFactor->EnclSolInfo(adjEnclNum).SurfacePtr) { auto const &surfAdj = state.dataSurface->Surface(SurfNumAdj); - if ((surfAdj.Class == SurfaceClass::Window && surfAdj.ExtBoundCond == ExternalEnvironment) || - state.dataSurface->SurfWinOriginalClass(SurfNumAdj) == SurfaceClass::TDD_Diffuser) { + if ((surfAdj.Class == SurfaceClass::Window && surfAdj.ExtBoundCond == ExternalEnvironment) || surfAdj.OriginalClass == SurfaceClass::TDD_Diffuser) { ++enclExtWin(enclNum); } } @@ -9490,9 +9472,8 @@ void DayltgSetupAdjZoneListsAndPointers(EnergyPlusData &state) int enclExtWinCtr = 0; for (int const surfNum : state.dataViewFactor->EnclSolInfo(enclNum).SurfacePtr) { - if ((state.dataSurface->Surface(surfNum).Class == SurfaceClass::Window && - state.dataSurface->Surface(surfNum).ExtBoundCond == ExternalEnvironment) || - state.dataSurface->SurfWinOriginalClass(surfNum) == SurfaceClass::TDD_Diffuser) { + auto const &surf = state.dataSurface->Surface(surfNum); + if ((surf.Class == SurfaceClass::Window && surf.ExtBoundCond == ExternalEnvironment) || surf.OriginalClass == SurfaceClass::TDD_Diffuser) { ++enclExtWinCtr; thisEnclDaylight.DayltgExtWinSurfNums(enclExtWinCtr) = surfNum; } @@ -9504,24 +9485,19 @@ void DayltgSetupAdjZoneListsAndPointers(EnergyPlusData &state) // Get exterior windows in EnclNumAdj -- there must be at least one, otherwise // it would not be an "AdjIntWinEncl" for (int SurfNumAdj : state.dataViewFactor->EnclSolInfo(adjEnclNum).SurfacePtr) { - if ((state.dataSurface->Surface(SurfNumAdj).Class == SurfaceClass::Window && - state.dataSurface->Surface(SurfNumAdj).ExtBoundCond == ExternalEnvironment) || - state.dataSurface->SurfWinOriginalClass(SurfNumAdj) == SurfaceClass::TDD_Diffuser) { + auto &surfAdj = state.dataSurface->Surface(SurfNumAdj); + if ((surfAdj.Class == SurfaceClass::Window && surfAdj.ExtBoundCond == ExternalEnvironment) || + surfAdj.OriginalClass == SurfaceClass::TDD_Diffuser) { ++enclExtWinCtr; thisEnclDaylight.DayltgExtWinSurfNums(enclExtWinCtr) = SurfNumAdj; + auto &surfWinAdj = state.dataSurface->SurfaceWindow(SurfNumAdj); // If no daylighting in the adjacent enclosure, set up variables anyway: if (state.dataViewFactor->EnclSolInfo(adjEnclNum).TotalEnclosureDaylRefPoints == 0 && !state.dataSurface->SurfWinSurfDayLightInit(SurfNumAdj)) { - auto &surfWinAdj = state.dataSurface->SurfaceWindow(SurfNumAdj); - surfWinAdj.SolidAngAtRefPt.allocate(thisEnclNumRefPoints); - surfWinAdj.SolidAngAtRefPt = 0.0; - surfWinAdj.SolidAngAtRefPtWtd.allocate(thisEnclNumRefPoints); - surfWinAdj.SolidAngAtRefPtWtd = 0.0; - surfWinAdj.DaylFromWinAtRefPt.allocate(thisEnclNumRefPoints); - for (int iRefPt = 1; iRefPt < thisEnclNumRefPoints; ++iRefPt) { - auto &dayl = surfWinAdj.DaylFromWinAtRefPt(iRefPt); - dayl[(int)Lum::Illum] = dayl[(int)Lum::Back] = dayl[(int)Lum::Source] = {0.0, 0.0}; + surfWinAdj.refPts.allocate(thisEnclNumRefPoints); + for (auto &refPt : surfWinAdj.refPts) { + new (&refPt) SurfaceWindowRefPt(); } state.dataSurface->SurfWinSurfDayLightInit(SurfNumAdj) = true; } diff --git a/src/EnergyPlus/HeatBalanceIntRadExchange.cc b/src/EnergyPlus/HeatBalanceIntRadExchange.cc index 2865a4c2199..56a18470ab5 100644 --- a/src/EnergyPlus/HeatBalanceIntRadExchange.cc +++ b/src/EnergyPlus/HeatBalanceIntRadExchange.cc @@ -271,24 +271,25 @@ namespace HeatBalanceIntRadExchange { Real64 CarrollMRTInKTo4th; // Carroll MRT for (size_type ZoneSurfNum = 0; ZoneSurfNum < s_zone_Surfaces; ++ZoneSurfNum) { int const SurfNum = zone_info.SurfacePtr[ZoneSurfNum]; - auto const &surface_window = state.dataSurface->SurfaceWindow(SurfNum); - int const ConstrNum = state.dataSurface->Surface(SurfNum).Construction; - auto const &construct = state.dataConstruction->Construct(ConstrNum); + auto const &surf = state.dataSurface->Surface(SurfNum); + auto const &surfWindow = state.dataSurface->SurfaceWindow(SurfNum); + int const constrNum = surf.Construction; + auto const &construct = state.dataConstruction->Construct(constrNum); if (construct.WindowTypeEQL) { SurfaceTempRad[ZoneSurfNum] = state.dataSurface->SurfWinEffInsSurfTemp(SurfNum); - SurfaceEmiss[ZoneSurfNum] = WindowEquivalentLayer::EQLWindowInsideEffectiveEmiss(state, ConstrNum); + SurfaceEmiss[ZoneSurfNum] = WindowEquivalentLayer::EQLWindowInsideEffectiveEmiss(state, constrNum); } else if (construct.WindowTypeBSDF && state.dataSurface->SurfWinShadingFlag(SurfNum) == DataSurfaces::WinShadingType::IntShade) { SurfaceTempRad[ZoneSurfNum] = state.dataSurface->SurfWinEffInsSurfTemp(SurfNum); - SurfaceEmiss[ZoneSurfNum] = surface_window.EffShBlindEmiss[0] + surface_window.EffGlassEmiss[0]; + SurfaceEmiss[ZoneSurfNum] = surfWindow.EffShBlindEmiss[0] + surfWindow.EffGlassEmiss[0]; } else if (construct.WindowTypeBSDF) { SurfaceTempRad[ZoneSurfNum] = state.dataSurface->SurfWinEffInsSurfTemp(SurfNum); SurfaceEmiss[ZoneSurfNum] = construct.InsideAbsorpThermal; - } else if (construct.TypeIsWindow && state.dataSurface->SurfWinOriginalClass(SurfNum) != DataSurfaces::SurfaceClass::TDD_Diffuser) { + } else if (construct.TypeIsWindow && surf.OriginalClass != DataSurfaces::SurfaceClass::TDD_Diffuser) { if (SurfIterations == 0 && NOT_SHADED(state.dataSurface->SurfWinShadingFlag(SurfNum))) { // If the window is bare this TS and it is the first time through we use the previous TS glass // temperature whether or not the window was shaded in the previous TS. If the window was shaded // the previous time step this temperature is a better starting value than the shade temperature. - SurfaceTempRad[ZoneSurfNum] = surface_window.ThetaFace[2 * construct.TotGlassLayers] - Constant::Kelvin; + SurfaceTempRad[ZoneSurfNum] = surfWindow.ThetaFace[2 * construct.TotGlassLayers] - Constant::Kelvin; SurfaceEmiss[ZoneSurfNum] = construct.InsideAbsorpThermal; // For windows with an interior shade or blind an effective inside surface temp // and emiss is used here that is a weighted combination of shade/blind and glass temp and emiss. diff --git a/src/EnergyPlus/HeatBalanceSurfaceManager.cc b/src/EnergyPlus/HeatBalanceSurfaceManager.cc index cf66f84d198..cd2238cfb1b 100644 --- a/src/EnergyPlus/HeatBalanceSurfaceManager.cc +++ b/src/EnergyPlus/HeatBalanceSurfaceManager.cc @@ -1123,12 +1123,11 @@ void GatherForPredefinedReport(EnergyPlusData &state) ++numExtSurfaces(currSurfaceClass); } if (surface.Class == DataSurfaces::SurfaceClass::Window) { - if (state.dataSurface->SurfWinOriginalClass(iSurf) == DataSurfaces::SurfaceClass::GlassDoor || - state.dataSurface->SurfWinOriginalClass(iSurf) == DataSurfaces::SurfaceClass::TDD_Diffuser) { - int currOriginalSurfaceClass = int(state.dataSurface->SurfWinOriginalClass(iSurf)); - ++numSurfaces(currOriginalSurfaceClass); + if (surface.OriginalClass == DataSurfaces::SurfaceClass::GlassDoor || + surface.OriginalClass == DataSurfaces::SurfaceClass::TDD_Diffuser) { + ++numSurfaces((int)surface.OriginalClass); if (isExterior) { - ++numExtSurfaces(currOriginalSurfaceClass); + ++numExtSurfaces((int)surface.OriginalClass); } } } @@ -3039,7 +3038,8 @@ void InitSolarHeatGains(EnergyPlusData &state) int const firstSurfWin = thisSpace.WindowSurfaceFirst; int const lastSurfWin = thisSpace.WindowSurfaceLast; for (int SurfNum = firstSurfWin; SurfNum <= lastSurfWin; ++SurfNum) { - if (Surface(SurfNum).ExtSolar || state.dataSurface->SurfWinOriginalClass(SurfNum) == DataSurfaces::SurfaceClass::TDD_Diffuser) { + auto &surf = state.dataSurface->Surface(SurfNum); + if (surf.ExtSolar || surf.OriginalClass == DataSurfaces::SurfaceClass::TDD_Diffuser) { // Exclude special shading surfaces which required SurfOpaqQRadSWOut calculations above int const ConstrNum = state.dataSurface->SurfActiveConstruction(SurfNum); auto const &thisConstruct = state.dataConstruction->Construct(ConstrNum); @@ -3275,7 +3275,7 @@ void InitSolarHeatGains(EnergyPlusData &state) state.dataHeatBal->SurfWinQRadSWwinAbsTot(SurfNum) * state.dataGlobal->TimeStepZoneSec; } else if (state.dataWindowManager->inExtWindowModel->isExternalLibraryModel()) { int SurfNum2 = SurfNum; - if (state.dataSurface->SurfWinOriginalClass(SurfNum) == DataSurfaces::SurfaceClass::TDD_Diffuser) { + if (state.dataSurface->Surface(SurfNum).OriginalClass == DataSurfaces::SurfaceClass::TDD_Diffuser) { SurfNum2 = state.dataDaylightingDevicesData->TDDPipe(state.dataSurface->SurfWinTDDPipeNum(SurfNum)).Dome; } @@ -6559,7 +6559,7 @@ void ReportSurfaceHeatBalance(EnergyPlusData &state) } state.dataSurface->SurfWinHeatTransferRepEnergy(surfNum) = state.dataSurface->SurfWinHeatGain(surfNum) * state.dataGlobal->TimeStepZoneSec; - if (state.dataSurface->SurfWinOriginalClass(surfNum) == DataSurfaces::SurfaceClass::TDD_Diffuser) { // Tubular daylighting device + if (state.dataSurface->Surface(surfNum).OriginalClass == DataSurfaces::SurfaceClass::TDD_Diffuser) { // Tubular daylighting device int pipeNum = state.dataSurface->SurfWinTDDPipeNum(surfNum); state.dataDaylightingDevicesData->TDDPipe(pipeNum).HeatGain = state.dataSurface->SurfWinHeatGainRep(surfNum); state.dataDaylightingDevicesData->TDDPipe(pipeNum).HeatLoss = state.dataSurface->SurfWinHeatLossRep(surfNum); @@ -8098,7 +8098,7 @@ void CalcHeatBalanceInsideSurf2(EnergyPlusData &state, Real64 &TH11 = state.dataHeatBalSurf->SurfOutsideTempHist(1)(SurfNum); int const ConstrNum = state.dataSurface->SurfActiveConstruction(SurfNum); // Not const, because storm window may change this auto const &construct = state.dataConstruction->Construct(ConstrNum); - if (state.dataSurface->SurfWinOriginalClass(SurfNum) == DataSurfaces::SurfaceClass::TDD_Diffuser) { // Tubular daylighting device + if (surface.OriginalClass == DataSurfaces::SurfaceClass::TDD_Diffuser) { // Tubular daylighting device // Lookup up the TDD:DOME object int const pipeNum = state.dataSurface->SurfWinTDDPipeNum(SurfNum); int const domeNum = state.dataDaylightingDevicesData->TDDPipe(pipeNum).Dome; @@ -8242,8 +8242,8 @@ void CalcHeatBalanceInsideSurf2(EnergyPlusData &state, Real64 &TH12 = state.dataHeatBalSurf->SurfInsideTempHist(1)(SurfNum); TH12 = state.dataHeatBalSurf->SurfTempIn(SurfNum); state.dataHeatBalSurf->SurfTempOut(SurfNum) = TH11; // For reporting - if (state.dataSurface->SurfWinOriginalClass(SurfNum) == DataSurfaces::SurfaceClass::TDD_Dome) continue; - if (state.dataSurface->SurfWinOriginalClass(SurfNum) == DataSurfaces::SurfaceClass::TDD_Diffuser) { // Tubular daylighting device + if (state.dataSurface->Surface(SurfNum).OriginalClass == DataSurfaces::SurfaceClass::TDD_Dome) continue; + if (state.dataSurface->Surface(SurfNum).OriginalClass == DataSurfaces::SurfaceClass::TDD_Diffuser) { // Tubular daylighting device // Tubular daylighting devices are treated as one big object with an effective R value. // The outside face temperature of the TDD:DOME and the inside face temperature of the // TDD:DIFFUSER are calculated with the outside and inside heat balances respectively. @@ -8785,7 +8785,7 @@ void CalcHeatBalanceInsideSurf2CTFOnly(EnergyPlusData &state, int const firstWindowSurf = thisSpace.WindowSurfaceFirst; int const lastWindowSurf = thisSpace.WindowSurfaceLast; for (int surfNum = firstWindowSurf; surfNum <= lastWindowSurf; ++surfNum) { - auto &surface = Surface(surfNum); + auto &surface = state.dataSurface->Surface(surfNum); if (state.dataSurface->UseRepresentativeSurfaceCalculations) { int repSurfNum = surface.RepresentativeCalcSurfNum; if (surfNum != repSurfNum) continue; @@ -8793,7 +8793,7 @@ void CalcHeatBalanceInsideSurf2CTFOnly(EnergyPlusData &state, Real64 &TH11(state.dataHeatBalSurf->SurfOutsideTempHist(1)(surfNum)); int const ConstrNum = state.dataSurface->SurfActiveConstruction(surfNum); auto const &construct = state.dataConstruction->Construct(ConstrNum); - if (state.dataSurface->SurfWinOriginalClass(surfNum) == DataSurfaces::SurfaceClass::TDD_Diffuser) { // Tubular daylighting device + if (surface.OriginalClass == DataSurfaces::SurfaceClass::TDD_Diffuser) { // Tubular daylighting device // Lookup up the TDD:DOME object int const pipeNum = state.dataSurface->SurfWinTDDPipeNum(surfNum); int const domeNum = state.dataDaylightingDevicesData->TDDPipe(pipeNum).Dome; @@ -8945,7 +8945,7 @@ void CalcHeatBalanceInsideSurf2CTFOnly(EnergyPlusData &state, Real64 &TH12 = state.dataHeatBalSurf->SurfInsideTempHist(1)(surfNum); TH12 = state.dataHeatBalSurf->SurfTempIn(surfNum); state.dataHeatBalSurf->SurfTempOut(surfNum) = TH11; // For reporting - if (state.dataSurface->SurfWinOriginalClass(surfNum) == DataSurfaces::SurfaceClass::TDD_Diffuser) { // Tubular daylighting device + if (state.dataSurface->Surface(surfNum).OriginalClass == DataSurfaces::SurfaceClass::TDD_Diffuser) { // Tubular daylighting device // Tubular daylighting devices are treated as one big object with an effective R value. // The outside face temperature of the TDD:DOME and the inside face temperature of the // TDD:DIFFUSER are calculated with the outside and inside heat balances respectively. diff --git a/src/EnergyPlus/OutputReports.cc b/src/EnergyPlus/OutputReports.cc index 74a23e0b12a..001b94665c4 100644 --- a/src/EnergyPlus/OutputReports.cc +++ b/src/EnergyPlus/OutputReports.cc @@ -626,13 +626,13 @@ void DXFOut(EnergyPlusData &state, if (thisSurface.Class == DataSurfaces::SurfaceClass::Floor) colorindex = DataSurfaceColors::ColorNo::Floor; if (thisSurface.Class == DataSurfaces::SurfaceClass::Door) colorindex = DataSurfaceColors::ColorNo::Door; if (thisSurface.Class == DataSurfaces::SurfaceClass::Window) { - if (state.dataSurface->SurfWinOriginalClass(surf) == DataSurfaces::SurfaceClass::Window) + if (thisSurface.OriginalClass == DataSurfaces::SurfaceClass::Window) colorindex = DataSurfaceColors::ColorNo::Window; - if (state.dataSurface->SurfWinOriginalClass(surf) == DataSurfaces::SurfaceClass::GlassDoor) + if (thisSurface.OriginalClass == DataSurfaces::SurfaceClass::GlassDoor) colorindex = DataSurfaceColors::ColorNo::GlassDoor; - if (state.dataSurface->SurfWinOriginalClass(surf) == DataSurfaces::SurfaceClass::TDD_Dome) + if (thisSurface.OriginalClass == DataSurfaces::SurfaceClass::TDD_Dome) colorindex = DataSurfaceColors::ColorNo::TDDDome; - if (state.dataSurface->SurfWinOriginalClass(surf) == DataSurfaces::SurfaceClass::TDD_Diffuser) + if (thisSurface.OriginalClass == DataSurfaces::SurfaceClass::TDD_Diffuser) colorindex = DataSurfaceColors::ColorNo::TDDDiffuser; } if (state.dataSurface->SurfIsPV(surf)) colorindex = DataSurfaceColors::ColorNo::PV; @@ -887,13 +887,13 @@ void DXFOutWireFrame(EnergyPlusData &state, std::string const &ColorScheme) if (thisSurface.Class == DataSurfaces::SurfaceClass::Floor) colorindex = DataSurfaceColors::ColorNo::Floor; if (thisSurface.Class == DataSurfaces::SurfaceClass::Door) colorindex = DataSurfaceColors::ColorNo::Door; if (thisSurface.Class == DataSurfaces::SurfaceClass::Window) { - if (state.dataSurface->SurfWinOriginalClass(surf) == DataSurfaces::SurfaceClass::Window) + if (thisSurface.OriginalClass == DataSurfaces::SurfaceClass::Window) colorindex = DataSurfaceColors::ColorNo::Window; - if (state.dataSurface->SurfWinOriginalClass(surf) == DataSurfaces::SurfaceClass::GlassDoor) + if (thisSurface.OriginalClass == DataSurfaces::SurfaceClass::GlassDoor) colorindex = DataSurfaceColors::ColorNo::GlassDoor; - if (state.dataSurface->SurfWinOriginalClass(surf) == DataSurfaces::SurfaceClass::TDD_Dome) + if (thisSurface.OriginalClass == DataSurfaces::SurfaceClass::TDD_Dome) colorindex = DataSurfaceColors::ColorNo::TDDDome; - if (state.dataSurface->SurfWinOriginalClass(surf) == DataSurfaces::SurfaceClass::TDD_Diffuser) + if (thisSurface.OriginalClass == DataSurfaces::SurfaceClass::TDD_Diffuser) colorindex = DataSurfaceColors::ColorNo::TDDDiffuser; } if (state.dataSurface->SurfIsPV(surf)) colorindex = DataSurfaceColors::ColorNo::PV; diff --git a/src/EnergyPlus/SolarShading.cc b/src/EnergyPlus/SolarShading.cc index d331fa8d728..9767dcd955f 100644 --- a/src/EnergyPlus/SolarShading.cc +++ b/src/EnergyPlus/SolarShading.cc @@ -843,7 +843,6 @@ void AllocateModuleArrays(EnergyPlusData &state) // METHODOLOGY EMPLOYED: // Allocation is dependent on the user input file. - int SurfLoop; int I; int NumOfLayers; int constexpr HoursInDay(24); @@ -1191,180 +1190,181 @@ void AllocateModuleArrays(EnergyPlusData &state) DisplayString(state, "Initializing Surface (Shading) Report Variables"); // CurrentModuleObject='Surfaces' - for (SurfLoop = 1; SurfLoop <= state.dataSurface->TotSurfaces; ++SurfLoop) { + for (int SurfLoop = 1; SurfLoop <= state.dataSurface->TotSurfaces; ++SurfLoop) { + auto &surf = state.dataSurface->Surface(SurfLoop); SetupOutputVariable(state, "Surface Outside Normal Azimuth Angle", OutputProcessor::Unit::deg, - state.dataSurface->Surface(SurfLoop).Azimuth, + surf.Azimuth, OutputProcessor::SOVTimeStepType::Zone, OutputProcessor::SOVStoreType::Average, - state.dataSurface->Surface(SurfLoop).Name); - if (state.dataSurface->Surface(SurfLoop).ExtSolar) { + surf.Name); + if (surf.ExtSolar) { SetupOutputVariable(state, "Surface Outside Face Sunlit Area", OutputProcessor::Unit::m2, state.dataSurface->SurfSunlitArea(SurfLoop), OutputProcessor::SOVTimeStepType::Zone, OutputProcessor::SOVStoreType::State, - state.dataSurface->Surface(SurfLoop).Name); + surf.Name); SetupOutputVariable(state, "Surface Outside Face Sunlit Fraction", OutputProcessor::Unit::None, state.dataSurface->SurfSunlitFrac(SurfLoop), OutputProcessor::SOVTimeStepType::Zone, OutputProcessor::SOVStoreType::State, - state.dataSurface->Surface(SurfLoop).Name); + surf.Name); SetupOutputVariable(state, "Surface Outside Face Incident Solar Radiation Rate per Area", OutputProcessor::Unit::W_m2, state.dataHeatBal->SurfQRadSWOutIncident(SurfLoop), OutputProcessor::SOVTimeStepType::Zone, OutputProcessor::SOVStoreType::Average, - state.dataSurface->Surface(SurfLoop).Name); + surf.Name); SetupOutputVariable(state, "Surface Outside Face Incident Beam Solar Radiation Rate per Area", OutputProcessor::Unit::W_m2, state.dataHeatBal->SurfQRadSWOutIncidentBeam(SurfLoop), OutputProcessor::SOVTimeStepType::Zone, OutputProcessor::SOVStoreType::Average, - state.dataSurface->Surface(SurfLoop).Name); + surf.Name); SetupOutputVariable(state, "Surface Outside Face Incident Sky Diffuse Solar Radiation Rate per Area", OutputProcessor::Unit::W_m2, state.dataHeatBal->SurfQRadSWOutIncidentSkyDiffuse(SurfLoop), OutputProcessor::SOVTimeStepType::Zone, OutputProcessor::SOVStoreType::Average, - state.dataSurface->Surface(SurfLoop).Name); + surf.Name); SetupOutputVariable(state, "Surface Outside Face Incident Ground Diffuse Solar Radiation Rate per Area", OutputProcessor::Unit::W_m2, state.dataHeatBal->SurfQRadSWOutIncidentGndDiffuse(SurfLoop), OutputProcessor::SOVTimeStepType::Zone, OutputProcessor::SOVStoreType::Average, - state.dataSurface->Surface(SurfLoop).Name); + surf.Name); SetupOutputVariable(state, "Surface Outside Face Beam Solar Incident Angle Cosine Value", OutputProcessor::Unit::None, state.dataHeatBal->SurfCosIncidenceAngle(SurfLoop), OutputProcessor::SOVTimeStepType::Zone, OutputProcessor::SOVStoreType::Average, - state.dataSurface->Surface(SurfLoop).Name); + surf.Name); SetupOutputVariable(state, "Surface Outside Face Incident Sky Diffuse Ground Reflected Solar Radiation Rate per Area", OutputProcessor::Unit::W_m2, state.dataHeatBal->SurfQRadSWOutIncSkyDiffReflGnd(SurfLoop), OutputProcessor::SOVTimeStepType::Zone, OutputProcessor::SOVStoreType::Average, - state.dataSurface->Surface(SurfLoop).Name); + surf.Name); SetupOutputVariable(state, "Surface Outside Face Incident Sky Diffuse Surface Reflected Solar Radiation Rate per Area", OutputProcessor::Unit::W_m2, state.dataHeatBal->SurfQRadSWOutIncSkyDiffReflObs(SurfLoop), OutputProcessor::SOVTimeStepType::Zone, OutputProcessor::SOVStoreType::Average, - state.dataSurface->Surface(SurfLoop).Name); + surf.Name); SetupOutputVariable(state, "Surface Outside Face Incident Beam To Beam Surface Reflected Solar Radiation Rate per Area", OutputProcessor::Unit::W_m2, state.dataHeatBal->SurfQRadSWOutIncBmToBmReflObs(SurfLoop), OutputProcessor::SOVTimeStepType::Zone, OutputProcessor::SOVStoreType::Average, - state.dataSurface->Surface(SurfLoop).Name); + surf.Name); SetupOutputVariable(state, "Surface Outside Face Incident Beam To Diffuse Surface Reflected Solar Radiation Rate per Area", OutputProcessor::Unit::W_m2, state.dataHeatBal->SurfQRadSWOutIncBmToDiffReflObs(SurfLoop), OutputProcessor::SOVTimeStepType::Zone, OutputProcessor::SOVStoreType::Average, - state.dataSurface->Surface(SurfLoop).Name); + surf.Name); SetupOutputVariable(state, "Surface Outside Face Incident Beam To Diffuse Ground Reflected Solar Radiation Rate per Area", OutputProcessor::Unit::W_m2, state.dataHeatBal->SurfQRadSWOutIncBmToDiffReflGnd(SurfLoop), OutputProcessor::SOVTimeStepType::Zone, OutputProcessor::SOVStoreType::Average, - state.dataSurface->Surface(SurfLoop).Name); + surf.Name); SetupOutputVariable(state, "Surface Anisotropic Sky Multiplier", OutputProcessor::Unit::None, state.dataSolarShading->SurfAnisoSkyMult(SurfLoop), OutputProcessor::SOVTimeStepType::Zone, OutputProcessor::SOVStoreType::Average, - state.dataSurface->Surface(SurfLoop).Name); + surf.Name); SetupOutputVariable(state, "Surface Window BSDF Beam Direction Number", OutputProcessor::Unit::None, state.dataHeatBal->SurfWinBSDFBeamDirectionRep(SurfLoop), OutputProcessor::SOVTimeStepType::Zone, OutputProcessor::SOVStoreType::Average, - state.dataSurface->Surface(SurfLoop).Name); + surf.Name); SetupOutputVariable(state, "Surface Window BSDF Beam Theta Angle", OutputProcessor::Unit::rad, state.dataHeatBal->SurfWinBSDFBeamThetaRep(SurfLoop), OutputProcessor::SOVTimeStepType::Zone, OutputProcessor::SOVStoreType::Average, - state.dataSurface->Surface(SurfLoop).Name); + surf.Name); SetupOutputVariable(state, "Surface Window BSDF Beam Phi Angle", OutputProcessor::Unit::rad, state.dataHeatBal->SurfWinBSDFBeamPhiRep(SurfLoop), OutputProcessor::SOVTimeStepType::Zone, OutputProcessor::SOVStoreType::Average, - state.dataSurface->Surface(SurfLoop).Name); + surf.Name); } - if (!state.dataSurface->Surface(SurfLoop).HeatTransSurf) continue; + if (!surf.HeatTransSurf) continue; - if (state.dataSurface->Surface(SurfLoop).Class == SurfaceClass::Window) { + if (surf.Class == SurfaceClass::Window) { // CurrentModuleObject='Windows/GlassDoors' - if (state.dataSurface->Surface(SurfLoop).ExtSolar) { + if (surf.ExtSolar) { SetupOutputVariable(state, "Surface Window Total Glazing Layers Absorbed Solar Radiation Rate", OutputProcessor::Unit::W, state.dataHeatBal->SurfWinQRadSWwinAbsTot(SurfLoop), OutputProcessor::SOVTimeStepType::Zone, OutputProcessor::SOVStoreType::Average, - state.dataSurface->Surface(SurfLoop).Name); + surf.Name); SetupOutputVariable(state, "Surface Window Total Glazing Layers Absorbed Shortwave Radiation Rate", OutputProcessor::Unit::W, state.dataHeatBal->SurfWinSWwinAbsTotalReport(SurfLoop), OutputProcessor::SOVTimeStepType::Zone, OutputProcessor::SOVStoreType::Average, - state.dataSurface->Surface(SurfLoop).Name); + surf.Name); - if (state.dataConstruction->Construct(state.dataSurface->Surface(SurfLoop).Construction).WindowTypeBSDF) { - NumOfLayers = state.dataConstruction->Construct(state.dataSurface->Surface(SurfLoop).Construction).TotSolidLayers; + if (state.dataConstruction->Construct(surf.Construction).WindowTypeBSDF) { + NumOfLayers = state.dataConstruction->Construct(surf.Construction).TotSolidLayers; } else { - NumOfLayers = state.dataConstruction->Construct(state.dataSurface->Surface(SurfLoop).Construction).TotLayers; + NumOfLayers = state.dataConstruction->Construct(surf.Construction).TotLayers; } for (I = 1; I <= NumOfLayers; ++I) { - if (state.dataConstruction->Construct(state.dataSurface->Surface(SurfLoop).Construction).WindowTypeBSDF) { + if (state.dataConstruction->Construct(surf.Construction).WindowTypeBSDF) { SetupOutputVariable(state, format("Surface Window Total Absorbed Shortwave Radiation Rate Layer {}", I), OutputProcessor::Unit::W, state.dataHeatBal->SurfWinQRadSWwinAbsLayer(SurfLoop, I), OutputProcessor::SOVTimeStepType::Zone, OutputProcessor::SOVStoreType::Average, - state.dataSurface->Surface(SurfLoop).Name); + surf.Name); } - if (state.dataConstruction->Construct(state.dataSurface->Surface(SurfLoop).Construction).WindowTypeBSDF || (I == 1)) { + if (state.dataConstruction->Construct(surf.Construction).WindowTypeBSDF || (I == 1)) { SetupOutputVariable(state, format("Surface Window Front Face Temperature Layer {}", I), OutputProcessor::Unit::C, state.dataHeatBal->SurfWinFenLaySurfTempFront(SurfLoop, I), OutputProcessor::SOVTimeStepType::Zone, OutputProcessor::SOVStoreType::Average, - state.dataSurface->Surface(SurfLoop).Name); + surf.Name); } - if (state.dataConstruction->Construct(state.dataSurface->Surface(SurfLoop).Construction).WindowTypeBSDF || (I == NumOfLayers)) { + if (state.dataConstruction->Construct(surf.Construction).WindowTypeBSDF || (I == NumOfLayers)) { SetupOutputVariable(state, format("Surface Window Back Face Temperature Layer {}", I), OutputProcessor::Unit::C, state.dataHeatBal->SurfWinFenLaySurfTempBack(SurfLoop, I), OutputProcessor::SOVTimeStepType::Zone, OutputProcessor::SOVStoreType::Average, - state.dataSurface->Surface(SurfLoop).Name); + surf.Name); } } @@ -1374,14 +1374,14 @@ void AllocateModuleArrays(EnergyPlusData &state) state.dataSurface->SurfWinTransSolar(SurfLoop), OutputProcessor::SOVTimeStepType::Zone, OutputProcessor::SOVStoreType::Average, - state.dataSurface->Surface(SurfLoop).Name); + surf.Name); SetupOutputVariable(state, "Surface Window Transmitted Beam Solar Radiation Rate", OutputProcessor::Unit::W, state.dataSurface->SurfWinBmSolar(SurfLoop), OutputProcessor::SOVTimeStepType::Zone, OutputProcessor::SOVStoreType::Average, - state.dataSurface->Surface(SurfLoop).Name); + surf.Name); // added TH 12/9/2009 SetupOutputVariable(state, @@ -1390,14 +1390,14 @@ void AllocateModuleArrays(EnergyPlusData &state) state.dataSurface->SurfWinBmBmSolar(SurfLoop), OutputProcessor::SOVTimeStepType::Zone, OutputProcessor::SOVStoreType::Average, - state.dataSurface->Surface(SurfLoop).Name); + surf.Name); SetupOutputVariable(state, "Surface Window Transmitted Beam To Diffuse Solar Radiation Rate", OutputProcessor::Unit::W, state.dataSurface->SurfWinBmDifSolar(SurfLoop), OutputProcessor::SOVTimeStepType::Zone, OutputProcessor::SOVStoreType::Average, - state.dataSurface->Surface(SurfLoop).Name); + surf.Name); SetupOutputVariable(state, "Surface Window Transmitted Diffuse Solar Radiation Rate", @@ -1405,42 +1405,42 @@ void AllocateModuleArrays(EnergyPlusData &state) state.dataSurface->SurfWinDifSolar(SurfLoop), OutputProcessor::SOVTimeStepType::Zone, OutputProcessor::SOVStoreType::Average, - state.dataSurface->Surface(SurfLoop).Name); + surf.Name); SetupOutputVariable(state, "Surface Window Heat Gain Rate", OutputProcessor::Unit::W, state.dataSurface->SurfWinHeatGainRep(SurfLoop), OutputProcessor::SOVTimeStepType::Zone, OutputProcessor::SOVStoreType::Average, - state.dataSurface->Surface(SurfLoop).Name); + surf.Name); SetupOutputVariable(state, "Surface Window Heat Loss Rate", OutputProcessor::Unit::W, state.dataSurface->SurfWinHeatLossRep(SurfLoop), OutputProcessor::SOVTimeStepType::Zone, OutputProcessor::SOVStoreType::Average, - state.dataSurface->Surface(SurfLoop).Name); + surf.Name); SetupOutputVariable(state, "Surface Window Gap Convective Heat Transfer Rate", OutputProcessor::Unit::W, state.dataSurface->SurfWinGapConvHtFlowRep(SurfLoop), OutputProcessor::SOVTimeStepType::Zone, OutputProcessor::SOVStoreType::Average, - state.dataSurface->Surface(SurfLoop).Name); + surf.Name); SetupOutputVariable(state, "Surface Window Shading Device Absorbed Solar Radiation Rate", OutputProcessor::Unit::W, state.dataSurface->SurfWinShadingAbsorbedSolar(SurfLoop), OutputProcessor::SOVTimeStepType::Zone, OutputProcessor::SOVStoreType::Average, - state.dataSurface->Surface(SurfLoop).Name); + surf.Name); SetupOutputVariable(state, "Surface Window Net Heat Transfer Rate", OutputProcessor::Unit::W, state.dataSurface->SurfWinHeatGain(SurfLoop), OutputProcessor::SOVTimeStepType::Zone, OutputProcessor::SOVStoreType::Average, - state.dataSurface->Surface(SurfLoop).Name); + surf.Name); if (state.dataGlobal->DisplayAdvancedReportVariables) { // CurrentModuleObject='Windows/GlassDoors(Advanced)' @@ -1450,83 +1450,83 @@ void AllocateModuleArrays(EnergyPlusData &state) state.dataSurface->SurfWinGainConvGlazToZoneRep(SurfLoop), OutputProcessor::SOVTimeStepType::Zone, OutputProcessor::SOVStoreType::Average, - state.dataSurface->Surface(SurfLoop).Name); + surf.Name); SetupOutputVariable(state, "Surface Window Inside Face Glazing Net Infrared Heat Transfer Rate", OutputProcessor::Unit::W, state.dataSurface->SurfWinGainIRGlazToZoneRep(SurfLoop), OutputProcessor::SOVTimeStepType::Zone, OutputProcessor::SOVStoreType::Average, - state.dataSurface->Surface(SurfLoop).Name); + surf.Name); SetupOutputVariable(state, "Surface Window Shortwave from Zone Back Out Window Heat Transfer Rate", OutputProcessor::Unit::W, state.dataSurface->SurfWinLossSWZoneToOutWinRep(SurfLoop), OutputProcessor::SOVTimeStepType::Zone, OutputProcessor::SOVStoreType::Average, - state.dataSurface->Surface(SurfLoop).Name); + surf.Name); SetupOutputVariable(state, "Surface Window Inside Face Frame and Divider Zone Heat Gain Rate", OutputProcessor::Unit::W, state.dataSurface->SurfWinGainFrameDividerToZoneRep(SurfLoop), OutputProcessor::SOVTimeStepType::Zone, OutputProcessor::SOVStoreType::Average, - state.dataSurface->Surface(SurfLoop).Name); + surf.Name); SetupOutputVariable(state, "Surface Window Inside Face Gap between Shade and Glazing Zone Convection Heat Gain Rate", OutputProcessor::Unit::W, state.dataSurface->SurfWinConvHeatFlowNatural(SurfLoop), OutputProcessor::SOVTimeStepType::Zone, OutputProcessor::SOVStoreType::Average, - state.dataSurface->Surface(SurfLoop).Name); + surf.Name); SetupOutputVariable(state, "Surface Window Inside Face Shade Zone Convection Heat Gain Rate", OutputProcessor::Unit::W, state.dataSurface->SurfWinGainConvShadeToZoneRep(SurfLoop), OutputProcessor::SOVTimeStepType::Zone, OutputProcessor::SOVStoreType::Average, - state.dataSurface->Surface(SurfLoop).Name); + surf.Name); SetupOutputVariable(state, "Surface Window Inside Face Shade Net Infrared Heat Transfer Rate", OutputProcessor::Unit::W, state.dataSurface->SurfWinGainIRShadeToZoneRep(SurfLoop), OutputProcessor::SOVTimeStepType::Zone, OutputProcessor::SOVStoreType::Average, - state.dataSurface->Surface(SurfLoop).Name); - if (state.dataConstruction->Construct(state.dataSurface->Surface(SurfLoop).Construction).WindowTypeEQL) { + surf.Name); + if (state.dataConstruction->Construct(surf.Construction).WindowTypeEQL) { SetupOutputVariable(state, "Surface Window Inside Face Other Convection Heat Gain Rate", OutputProcessor::Unit::W, state.dataSurface->SurfWinOtherConvHeatGain(SurfLoop), OutputProcessor::SOVTimeStepType::Zone, OutputProcessor::SOVStoreType::Average, - state.dataSurface->Surface(SurfLoop).Name); + surf.Name); } } // Added TH 12/23/2008 for thermochromic windows // CurrentModuleObject='Thermochromic Windows' - if (state.dataConstruction->Construct(state.dataSurface->Surface(SurfLoop).Construction).TCFlag == 1) { + if (state.dataConstruction->Construct(surf.Construction).TCFlag == 1) { SetupOutputVariable(state, "Surface Window Thermochromic Layer Temperature", OutputProcessor::Unit::C, state.dataSurface->SurfWinTCLayerTemp(SurfLoop), OutputProcessor::SOVTimeStepType::Zone, OutputProcessor::SOVStoreType::Average, - state.dataSurface->Surface(SurfLoop).Name); + surf.Name); SetupOutputVariable(state, "Surface Window Thermochromic Layer Property Specification Temperature", OutputProcessor::Unit::C, state.dataSurface->SurfWinSpecTemp(SurfLoop), OutputProcessor::SOVTimeStepType::Zone, OutputProcessor::SOVStoreType::Average, - state.dataSurface->Surface(SurfLoop).Name); + surf.Name); } // Added TH 5/26/2009 for switchable windows to report switching factor (tinted level) // CurrentModuleObject='Switchable Windows' - if (state.dataSurface->Surface(SurfLoop).HasShadeControl) { - if (state.dataSurface->WindowShadingControl(state.dataSurface->Surface(SurfLoop).activeWindowShadingControl).ShadingType == + if (surf.HasShadeControl) { + if (state.dataSurface->WindowShadingControl(surf.activeWindowShadingControl).ShadingType == WinShadingType::SwitchableGlazing) { // IF (SurfaceWindow(SurfLoop)%ShadingFlag == WinShadingType::SwitchableGlazing) THEN !ShadingFlag is not set to // WinShadingType::SwitchableGlazing yet! @@ -1536,14 +1536,14 @@ void AllocateModuleArrays(EnergyPlusData &state) state.dataSurface->SurfWinSwitchingFactor(SurfLoop), OutputProcessor::SOVTimeStepType::Zone, OutputProcessor::SOVStoreType::Average, - state.dataSurface->Surface(SurfLoop).Name); + surf.Name); SetupOutputVariable(state, "Surface Window Switchable Glazing Visible Transmittance", OutputProcessor::Unit::None, state.dataSurface->SurfWinVisTransSelected(SurfLoop), OutputProcessor::SOVTimeStepType::Zone, OutputProcessor::SOVStoreType::Average, - state.dataSurface->Surface(SurfLoop).Name); + surf.Name); } } @@ -1555,28 +1555,28 @@ void AllocateModuleArrays(EnergyPlusData &state) state.dataSurface->SurfWinFrameHeatGain(SurfLoop), OutputProcessor::SOVTimeStepType::Zone, OutputProcessor::SOVStoreType::Average, - state.dataSurface->Surface(SurfLoop).Name); + surf.Name); SetupOutputVariable(state, "Surface Window Frame Heat Loss Rate", OutputProcessor::Unit::W, state.dataSurface->SurfWinFrameHeatLoss(SurfLoop), OutputProcessor::SOVTimeStepType::Zone, OutputProcessor::SOVStoreType::Average, - state.dataSurface->Surface(SurfLoop).Name); + surf.Name); SetupOutputVariable(state, "Surface Window Frame Inside Temperature", OutputProcessor::Unit::C, state.dataSurface->SurfWinFrameTempIn(SurfLoop), OutputProcessor::SOVTimeStepType::Zone, OutputProcessor::SOVStoreType::Average, - state.dataSurface->Surface(SurfLoop).Name); + surf.Name); SetupOutputVariable(state, "Surface Window Frame Outside Temperature", OutputProcessor::Unit::C, state.dataSurface->SurfWinFrameTempSurfOut(SurfLoop), OutputProcessor::SOVTimeStepType::Zone, OutputProcessor::SOVStoreType::Average, - state.dataSurface->Surface(SurfLoop).Name); + surf.Name); } if (state.dataSurface->SurfWinDividerArea(SurfLoop) > 0.0) { // CurrentModuleObject='Window Dividers' @@ -1586,28 +1586,28 @@ void AllocateModuleArrays(EnergyPlusData &state) state.dataSurface->SurfWinDividerHeatGain(SurfLoop), OutputProcessor::SOVTimeStepType::Zone, OutputProcessor::SOVStoreType::Average, - state.dataSurface->Surface(SurfLoop).Name); + surf.Name); SetupOutputVariable(state, "Surface Window Divider Heat Loss Rate", OutputProcessor::Unit::W, state.dataSurface->SurfWinDividerHeatLoss(SurfLoop), OutputProcessor::SOVTimeStepType::Zone, OutputProcessor::SOVStoreType::Average, - state.dataSurface->Surface(SurfLoop).Name); + surf.Name); SetupOutputVariable(state, "Surface Window Divider Inside Temperature", OutputProcessor::Unit::C, state.dataSurface->SurfWinDividerTempIn(SurfLoop), OutputProcessor::SOVTimeStepType::Zone, OutputProcessor::SOVStoreType::Average, - state.dataSurface->Surface(SurfLoop).Name); + surf.Name); SetupOutputVariable(state, "Surface Window Divider Outside Temperature", OutputProcessor::Unit::C, state.dataSurface->SurfWinDividerTempSurfOut(SurfLoop), OutputProcessor::SOVTimeStepType::Zone, OutputProcessor::SOVStoreType::Average, - state.dataSurface->Surface(SurfLoop).Name); + surf.Name); } // CurrentModuleObject='Windows' @@ -1618,21 +1618,21 @@ void AllocateModuleArrays(EnergyPlusData &state) state.dataHeatBal->SurfWinQRadSWwinAbsTotEnergy(SurfLoop), OutputProcessor::SOVTimeStepType::Zone, OutputProcessor::SOVStoreType::Summed, - state.dataSurface->Surface(SurfLoop).Name); + surf.Name); SetupOutputVariable(state, "Surface Window Transmitted Solar Radiation Energy", OutputProcessor::Unit::J, state.dataSurface->SurfWinTransSolarEnergy(SurfLoop), OutputProcessor::SOVTimeStepType::Zone, OutputProcessor::SOVStoreType::Summed, - state.dataSurface->Surface(SurfLoop).Name); + surf.Name); SetupOutputVariable(state, "Surface Window Transmitted Beam Solar Radiation Energy", OutputProcessor::Unit::J, state.dataSurface->SurfWinBmSolarEnergy(SurfLoop), OutputProcessor::SOVTimeStepType::Zone, OutputProcessor::SOVStoreType::Summed, - state.dataSurface->Surface(SurfLoop).Name); + surf.Name); // added TH 12/9/2009 SetupOutputVariable(state, @@ -1641,14 +1641,14 @@ void AllocateModuleArrays(EnergyPlusData &state) state.dataSurface->SurfWinBmBmSolarEnergy(SurfLoop), OutputProcessor::SOVTimeStepType::Zone, OutputProcessor::SOVStoreType::Summed, - state.dataSurface->Surface(SurfLoop).Name); + surf.Name); SetupOutputVariable(state, "Surface Window Transmitted Beam To Diffuse Solar Radiation Energy", OutputProcessor::Unit::J, state.dataSurface->SurfWinBmDifSolarEnergy(SurfLoop), OutputProcessor::SOVTimeStepType::Zone, OutputProcessor::SOVStoreType::Summed, - state.dataSurface->Surface(SurfLoop).Name); + surf.Name); SetupOutputVariable(state, "Surface Window Transmitted Diffuse Solar Radiation Energy", @@ -1656,42 +1656,42 @@ void AllocateModuleArrays(EnergyPlusData &state) state.dataSurface->SurfWinDifSolarEnergy(SurfLoop), OutputProcessor::SOVTimeStepType::Zone, OutputProcessor::SOVStoreType::Summed, - state.dataSurface->Surface(SurfLoop).Name); + surf.Name); SetupOutputVariable(state, "Surface Window Heat Gain Energy", OutputProcessor::Unit::J, state.dataSurface->SurfWinHeatGainRepEnergy(SurfLoop), OutputProcessor::SOVTimeStepType::Zone, OutputProcessor::SOVStoreType::Summed, - state.dataSurface->Surface(SurfLoop).Name); + surf.Name); SetupOutputVariable(state, "Surface Window Heat Loss Energy", OutputProcessor::Unit::J, state.dataSurface->SurfWinHeatLossRepEnergy(SurfLoop), OutputProcessor::SOVTimeStepType::Zone, OutputProcessor::SOVStoreType::Summed, - state.dataSurface->Surface(SurfLoop).Name); + surf.Name); SetupOutputVariable(state, "Surface Window Gap Convective Heat Transfer Energy", OutputProcessor::Unit::J, state.dataSurface->SurfWinGapConvHtFlowRepEnergy(SurfLoop), OutputProcessor::SOVTimeStepType::Zone, OutputProcessor::SOVStoreType::Summed, - state.dataSurface->Surface(SurfLoop).Name); + surf.Name); SetupOutputVariable(state, "Surface Window Shading Device Absorbed Solar Radiation Energy", OutputProcessor::Unit::J, state.dataSurface->SurfWinShadingAbsorbedSolarEnergy(SurfLoop), OutputProcessor::SOVTimeStepType::Zone, OutputProcessor::SOVStoreType::Summed, - state.dataSurface->Surface(SurfLoop).Name); + surf.Name); SetupOutputVariable(state, "Surface Window Net Heat Transfer Energy", OutputProcessor::Unit::J, state.dataSurface->SurfWinHeatTransferRepEnergy(SurfLoop), OutputProcessor::SOVTimeStepType::Zone, OutputProcessor::SOVStoreType::Summed, - state.dataSurface->Surface(SurfLoop).Name); + surf.Name); SetupOutputVariable(state, "Surface Window System Solar Transmittance", @@ -1699,42 +1699,42 @@ void AllocateModuleArrays(EnergyPlusData &state) state.dataSurface->SurfWinSysSolTransmittance(SurfLoop), OutputProcessor::SOVTimeStepType::Zone, OutputProcessor::SOVStoreType::Average, - state.dataSurface->Surface(SurfLoop).Name); + surf.Name); SetupOutputVariable(state, "Surface Window System Solar Reflectance", OutputProcessor::Unit::None, state.dataSurface->SurfWinSysSolReflectance(SurfLoop), OutputProcessor::SOVTimeStepType::Zone, OutputProcessor::SOVStoreType::Average, - state.dataSurface->Surface(SurfLoop).Name); + surf.Name); SetupOutputVariable(state, "Surface Window System Solar Absorptance", OutputProcessor::Unit::None, state.dataSurface->SurfWinSysSolAbsorptance(SurfLoop), OutputProcessor::SOVTimeStepType::Zone, OutputProcessor::SOVStoreType::Average, - state.dataSurface->Surface(SurfLoop).Name); + surf.Name); SetupOutputVariable(state, "Surface Window Inside Face Glazing Condensation Status", OutputProcessor::Unit::None, state.dataSurface->SurfWinInsideGlassCondensationFlag(SurfLoop), OutputProcessor::SOVTimeStepType::Zone, OutputProcessor::SOVStoreType::State, - state.dataSurface->Surface(SurfLoop).Name); + surf.Name); SetupOutputVariable(state, "Surface Window Inside Face Frame Condensation Status", OutputProcessor::Unit::None, state.dataSurface->SurfWinInsideFrameCondensationFlag(SurfLoop), OutputProcessor::SOVTimeStepType::Zone, OutputProcessor::SOVStoreType::State, - state.dataSurface->Surface(SurfLoop).Name); + surf.Name); SetupOutputVariable(state, "Surface Window Inside Face Divider Condensation Status", OutputProcessor::Unit::None, state.dataSurface->SurfWinInsideDividerCondensationFlag(SurfLoop), OutputProcessor::SOVTimeStepType::Zone, OutputProcessor::SOVStoreType::State, - state.dataSurface->Surface(SurfLoop).Name); + surf.Name); // Outside reveal report variables // IF (Surface(SurfLoop)%Reveal > 0.0) THEN @@ -1744,7 +1744,7 @@ void AllocateModuleArrays(EnergyPlusData &state) state.dataSurface->SurfWinBmSolRefldOutsRevealReport(SurfLoop), OutputProcessor::SOVTimeStepType::Zone, OutputProcessor::SOVStoreType::State, - state.dataSurface->Surface(SurfLoop).Name); + surf.Name); // Energy SetupOutputVariable(state, "Surface Window Outside Reveal Reflected Beam Solar Radiation Energy", @@ -1752,7 +1752,7 @@ void AllocateModuleArrays(EnergyPlusData &state) state.dataSurface->SurfWinBmSolRefldOutsRevealRepEnergy(SurfLoop), OutputProcessor::SOVTimeStepType::Zone, OutputProcessor::SOVStoreType::Summed, - state.dataSurface->Surface(SurfLoop).Name); + surf.Name); // ENDIF // Inside reveal report variables @@ -1763,7 +1763,7 @@ void AllocateModuleArrays(EnergyPlusData &state) state.dataSurface->SurfWinBmSolRefldInsRevealReport(SurfLoop), OutputProcessor::SOVTimeStepType::Zone, OutputProcessor::SOVStoreType::State, - state.dataSurface->Surface(SurfLoop).Name); + surf.Name); // Energy SetupOutputVariable(state, "Surface Window Inside Reveal Reflected Beam Solar Radiation Energy", @@ -1771,7 +1771,7 @@ void AllocateModuleArrays(EnergyPlusData &state) state.dataSurface->SurfWinBmSolRefldInsRevealRepEnergy(SurfLoop), OutputProcessor::SOVTimeStepType::Zone, OutputProcessor::SOVStoreType::Summed, - state.dataSurface->Surface(SurfLoop).Name); + surf.Name); // Added report variables for inside reveal to debug CR 7596. TH 5/26/2009 // All reflected solar by the inside reveal is turned into diffuse @@ -1781,28 +1781,28 @@ void AllocateModuleArrays(EnergyPlusData &state) state.dataSurface->SurfWinBmSolAbsdInsRevealReport(SurfLoop), OutputProcessor::SOVTimeStepType::Zone, OutputProcessor::SOVStoreType::State, - state.dataSurface->Surface(SurfLoop).Name); + surf.Name); SetupOutputVariable(state, "Surface Window Inside Reveal Reflected Diffuse Zone Solar Radiation Rate", OutputProcessor::Unit::W, state.dataSurface->SurfWinInsRevealDiffIntoZoneReport(SurfLoop), OutputProcessor::SOVTimeStepType::Zone, OutputProcessor::SOVStoreType::State, - state.dataSurface->Surface(SurfLoop).Name); + surf.Name); SetupOutputVariable(state, "Surface Window Inside Reveal Reflected Diffuse Frame Solar Radiation Rate", OutputProcessor::Unit::W, state.dataSurface->SurfWinInsRevealDiffOntoFrameReport(SurfLoop), OutputProcessor::SOVTimeStepType::Zone, OutputProcessor::SOVStoreType::State, - state.dataSurface->Surface(SurfLoop).Name); + surf.Name); SetupOutputVariable(state, "Surface Window Inside Reveal Reflected Diffuse Glazing Solar Radiation Rate", OutputProcessor::Unit::W, state.dataSurface->SurfWinInsRevealDiffOntoGlazingReport(SurfLoop), OutputProcessor::SOVTimeStepType::Zone, OutputProcessor::SOVStoreType::State, - state.dataSurface->Surface(SurfLoop).Name); + surf.Name); } // Output blind report variables only when blinds are used @@ -1814,35 +1814,35 @@ void AllocateModuleArrays(EnergyPlusData &state) state.dataSurface->SurfWinBlTsolBmBm(SurfLoop), OutputProcessor::SOVTimeStepType::Zone, OutputProcessor::SOVStoreType::State, - state.dataSurface->Surface(SurfLoop).Name); + surf.Name); SetupOutputVariable(state, "Surface Window Blind Beam to Diffuse Solar Transmittance", OutputProcessor::Unit::None, state.dataSurface->SurfWinBlTsolBmDif(SurfLoop), OutputProcessor::SOVTimeStepType::Zone, OutputProcessor::SOVStoreType::State, - state.dataSurface->Surface(SurfLoop).Name); + surf.Name); SetupOutputVariable(state, "Surface Window Blind Diffuse to Diffuse Solar Transmittance", OutputProcessor::Unit::None, state.dataSurface->SurfWinBlTsolDifDif(SurfLoop), OutputProcessor::SOVTimeStepType::Zone, OutputProcessor::SOVStoreType::State, - state.dataSurface->Surface(SurfLoop).Name); + surf.Name); SetupOutputVariable(state, "Surface Window Blind and Glazing System Beam Solar Transmittance", OutputProcessor::Unit::None, state.dataSurface->SurfWinBlGlSysTsolBmBm(SurfLoop), OutputProcessor::SOVTimeStepType::Zone, OutputProcessor::SOVStoreType::State, - state.dataSurface->Surface(SurfLoop).Name); + surf.Name); SetupOutputVariable(state, "Surface Window Blind and Glazing System Diffuse Solar Transmittance", OutputProcessor::Unit::None, state.dataSurface->SurfWinBlGlSysTsolDifDif(SurfLoop), OutputProcessor::SOVTimeStepType::Zone, OutputProcessor::SOVStoreType::State, - state.dataSurface->Surface(SurfLoop).Name); + surf.Name); } // Output screen report variables only when screens are used @@ -1854,35 +1854,35 @@ void AllocateModuleArrays(EnergyPlusData &state) state.dataSurface->SurfWinScTsolBmBm(SurfLoop), OutputProcessor::SOVTimeStepType::Zone, OutputProcessor::SOVStoreType::State, - state.dataSurface->Surface(SurfLoop).Name); + surf.Name); SetupOutputVariable(state, "Surface Window Screen Beam to Diffuse Solar Transmittance", OutputProcessor::Unit::None, state.dataSurface->SurfWinScTsolBmDif(SurfLoop), OutputProcessor::SOVTimeStepType::Zone, OutputProcessor::SOVStoreType::State, - state.dataSurface->Surface(SurfLoop).Name); + surf.Name); SetupOutputVariable(state, "Surface Window Screen Diffuse to Diffuse Solar Transmittance", OutputProcessor::Unit::None, state.dataSurface->SurfWinScTsolDifDif(SurfLoop), OutputProcessor::SOVTimeStepType::Zone, OutputProcessor::SOVStoreType::State, - state.dataSurface->Surface(SurfLoop).Name); + surf.Name); SetupOutputVariable(state, "Surface Window Screen and Glazing System Beam Solar Transmittance", OutputProcessor::Unit::None, state.dataSurface->SurfWinScGlSysTsolBmBm(SurfLoop), OutputProcessor::SOVTimeStepType::Zone, OutputProcessor::SOVStoreType::State, - state.dataSurface->Surface(SurfLoop).Name); + surf.Name); SetupOutputVariable(state, "Surface Window Screen and Glazing System Diffuse Solar Transmittance", OutputProcessor::Unit::None, state.dataSurface->SurfWinScGlSysTsolDifDif(SurfLoop), OutputProcessor::SOVTimeStepType::Zone, OutputProcessor::SOVStoreType::State, - state.dataSurface->Surface(SurfLoop).Name); + surf.Name); } // CurrentModuleObject='Windows' @@ -1892,53 +1892,53 @@ void AllocateModuleArrays(EnergyPlusData &state) state.dataSurface->SurfWinProfileAngHor(SurfLoop), OutputProcessor::SOVTimeStepType::Zone, OutputProcessor::SOVStoreType::State, - state.dataSurface->Surface(SurfLoop).Name); + surf.Name); SetupOutputVariable(state, "Surface Window Solar Vertical Profile Angle", OutputProcessor::Unit::deg, state.dataSurface->SurfWinProfileAngVert(SurfLoop), OutputProcessor::SOVTimeStepType::Zone, OutputProcessor::SOVStoreType::State, - state.dataSurface->Surface(SurfLoop).Name); + surf.Name); SetupOutputVariable(state, "Surface Window Glazing Beam to Beam Solar Transmittance", OutputProcessor::Unit::None, state.dataSurface->SurfWinGlTsolBmBm(SurfLoop), OutputProcessor::SOVTimeStepType::Zone, OutputProcessor::SOVStoreType::State, - state.dataSurface->Surface(SurfLoop).Name); + surf.Name); SetupOutputVariable(state, "Surface Window Glazing Beam to Diffuse Solar Transmittance", OutputProcessor::Unit::None, state.dataSurface->SurfWinGlTsolBmDif(SurfLoop), OutputProcessor::SOVTimeStepType::Zone, OutputProcessor::SOVStoreType::State, - state.dataSurface->Surface(SurfLoop).Name); + surf.Name); SetupOutputVariable(state, "Surface Window Glazing Diffuse to Diffuse Solar Transmittance", OutputProcessor::Unit::None, state.dataSurface->SurfWinGlTsolDifDif(SurfLoop), OutputProcessor::SOVTimeStepType::Zone, OutputProcessor::SOVStoreType::State, - state.dataSurface->Surface(SurfLoop).Name); + surf.Name); SetupOutputVariable(state, "Surface Window Model Solver Iteration Count", OutputProcessor::Unit::None, state.dataSurface->SurfWinWindowCalcIterationsRep(SurfLoop), OutputProcessor::SOVTimeStepType::Zone, OutputProcessor::SOVStoreType::State, - state.dataSurface->Surface(SurfLoop).Name); + surf.Name); } else { // Not ExtSolar if (state.dataGlobal->DisplayAdvancedReportVariables) { // CurrentModuleObject='InteriorWindows(Advanced)' - if (state.dataSurface->SurfWinOriginalClass(SurfLoop) != SurfaceClass::TDD_Diffuser) { + if (surf.OriginalClass != SurfaceClass::TDD_Diffuser) { SetupOutputVariable(state, "Surface Window Total Glazing Layers Absorbed Solar Radiation Rate", OutputProcessor::Unit::W, state.dataHeatBal->SurfWinQRadSWwinAbsTot(SurfLoop), OutputProcessor::SOVTimeStepType::Zone, OutputProcessor::SOVStoreType::Average, - state.dataSurface->Surface(SurfLoop).Name); + surf.Name); } SetupOutputVariable(state, "Surface Window Total Glazing Layers Absorbed Shortwave Radiation Rate", @@ -1946,16 +1946,16 @@ void AllocateModuleArrays(EnergyPlusData &state) state.dataHeatBal->SurfWinSWwinAbsTotalReport(SurfLoop), OutputProcessor::SOVTimeStepType::Zone, OutputProcessor::SOVStoreType::Average, - state.dataSurface->Surface(SurfLoop).Name); + surf.Name); - if (state.dataSurface->SurfWinOriginalClass(SurfLoop) != SurfaceClass::TDD_Diffuser) { + if (surf.OriginalClass != SurfaceClass::TDD_Diffuser) { SetupOutputVariable(state, "Surface Window Transmitted Solar Radiation Rate", OutputProcessor::Unit::W, state.dataSurface->SurfWinTransSolar(SurfLoop), OutputProcessor::SOVTimeStepType::Zone, OutputProcessor::SOVStoreType::Average, - state.dataSurface->Surface(SurfLoop).Name); + surf.Name); } SetupOutputVariable(state, "Surface Window Transmitted Beam Solar Radiation Rate", @@ -1963,7 +1963,7 @@ void AllocateModuleArrays(EnergyPlusData &state) state.dataSurface->SurfWinBmSolar(SurfLoop), OutputProcessor::SOVTimeStepType::Zone, OutputProcessor::SOVStoreType::Average, - state.dataSurface->Surface(SurfLoop).Name); + surf.Name); // added TH 12/9/2009 SetupOutputVariable(state, @@ -1972,14 +1972,14 @@ void AllocateModuleArrays(EnergyPlusData &state) state.dataSurface->SurfWinBmBmSolar(SurfLoop), OutputProcessor::SOVTimeStepType::Zone, OutputProcessor::SOVStoreType::Average, - state.dataSurface->Surface(SurfLoop).Name); + surf.Name); SetupOutputVariable(state, "Surface Window Transmitted Beam To Diffuse Solar Radiation Rate", OutputProcessor::Unit::W, state.dataSurface->SurfWinBmDifSolar(SurfLoop), OutputProcessor::SOVTimeStepType::Zone, OutputProcessor::SOVStoreType::Average, - state.dataSurface->Surface(SurfLoop).Name); + surf.Name); SetupOutputVariable(state, "Surface Window Transmitted Diffuse Solar Radiation Rate", @@ -1987,35 +1987,35 @@ void AllocateModuleArrays(EnergyPlusData &state) state.dataSurface->SurfWinDifSolar(SurfLoop), OutputProcessor::SOVTimeStepType::Zone, OutputProcessor::SOVStoreType::Average, - state.dataSurface->Surface(SurfLoop).Name); + surf.Name); SetupOutputVariable(state, "Surface Window Heat Gain Rate", OutputProcessor::Unit::W, state.dataSurface->SurfWinHeatGainRep(SurfLoop), OutputProcessor::SOVTimeStepType::Zone, OutputProcessor::SOVStoreType::Average, - state.dataSurface->Surface(SurfLoop).Name); + surf.Name); SetupOutputVariable(state, "Surface Window Heat Loss Rate", OutputProcessor::Unit::W, state.dataSurface->SurfWinHeatLossRep(SurfLoop), OutputProcessor::SOVTimeStepType::Zone, OutputProcessor::SOVStoreType::Average, - state.dataSurface->Surface(SurfLoop).Name); + surf.Name); SetupOutputVariable(state, "Surface Window Gap Convective Heat Transfer Rate", OutputProcessor::Unit::W, state.dataSurface->SurfWinGapConvHtFlowRep(SurfLoop), OutputProcessor::SOVTimeStepType::Zone, OutputProcessor::SOVStoreType::Average, - state.dataSurface->Surface(SurfLoop).Name); + surf.Name); SetupOutputVariable(state, "Surface Window Shading Device Absorbed Solar Radiation Rate", OutputProcessor::Unit::W, state.dataSurface->SurfWinShadingAbsorbedSolar(SurfLoop), OutputProcessor::SOVTimeStepType::Zone, OutputProcessor::SOVStoreType::Average, - state.dataSurface->Surface(SurfLoop).Name); + surf.Name); if (state.dataSurface->SurfWinFrameArea(SurfLoop) > 0.0) { SetupOutputVariable(state, "Surface Window Frame Heat Gain Rate", @@ -2023,28 +2023,28 @@ void AllocateModuleArrays(EnergyPlusData &state) state.dataSurface->SurfWinFrameHeatGain(SurfLoop), OutputProcessor::SOVTimeStepType::Zone, OutputProcessor::SOVStoreType::Average, - state.dataSurface->Surface(SurfLoop).Name); + surf.Name); SetupOutputVariable(state, "Surface Window Frame Heat Loss Rate", OutputProcessor::Unit::W, state.dataSurface->SurfWinFrameHeatLoss(SurfLoop), OutputProcessor::SOVTimeStepType::Zone, OutputProcessor::SOVStoreType::Average, - state.dataSurface->Surface(SurfLoop).Name); + surf.Name); SetupOutputVariable(state, "Surface Window Frame Inside Temperature", OutputProcessor::Unit::C, state.dataSurface->SurfWinFrameTempIn(SurfLoop), OutputProcessor::SOVTimeStepType::Zone, OutputProcessor::SOVStoreType::Average, - state.dataSurface->Surface(SurfLoop).Name); + surf.Name); SetupOutputVariable(state, "Surface Window Frame Outside Temperature", OutputProcessor::Unit::C, state.dataSurface->SurfWinFrameTempSurfOut(SurfLoop), OutputProcessor::SOVTimeStepType::Zone, OutputProcessor::SOVStoreType::Average, - state.dataSurface->Surface(SurfLoop).Name); + surf.Name); } if (state.dataSurface->SurfWinDividerArea(SurfLoop) > 0.0) { SetupOutputVariable(state, @@ -2053,49 +2053,49 @@ void AllocateModuleArrays(EnergyPlusData &state) state.dataSurface->SurfWinDividerHeatGain(SurfLoop), OutputProcessor::SOVTimeStepType::Zone, OutputProcessor::SOVStoreType::Average, - state.dataSurface->Surface(SurfLoop).Name); + surf.Name); SetupOutputVariable(state, "Surface Window Divider Heat Loss Rate", OutputProcessor::Unit::W, state.dataSurface->SurfWinDividerHeatLoss(SurfLoop), OutputProcessor::SOVTimeStepType::Zone, OutputProcessor::SOVStoreType::Average, - state.dataSurface->Surface(SurfLoop).Name); + surf.Name); SetupOutputVariable(state, "Surface Window Divider Inside Temperature", OutputProcessor::Unit::C, state.dataSurface->SurfWinDividerTempIn(SurfLoop), OutputProcessor::SOVTimeStepType::Zone, OutputProcessor::SOVStoreType::Average, - state.dataSurface->Surface(SurfLoop).Name); + surf.Name); SetupOutputVariable(state, "Surface Window Divider Outside Temperature", OutputProcessor::Unit::C, state.dataSurface->SurfWinDividerTempSurfOut(SurfLoop), OutputProcessor::SOVTimeStepType::Zone, OutputProcessor::SOVStoreType::Average, - state.dataSurface->Surface(SurfLoop).Name); + surf.Name); } // Energy - if (state.dataSurface->SurfWinOriginalClass(SurfLoop) != SurfaceClass::TDD_Diffuser) { + if (surf.OriginalClass != SurfaceClass::TDD_Diffuser) { SetupOutputVariable(state, "Surface Window Total Glazing Layers Absorbed Solar Radiation Energy", OutputProcessor::Unit::J, state.dataHeatBal->SurfWinQRadSWwinAbsTotEnergy(SurfLoop), OutputProcessor::SOVTimeStepType::Zone, OutputProcessor::SOVStoreType::Summed, - state.dataSurface->Surface(SurfLoop).Name); + surf.Name); } - if (state.dataSurface->SurfWinOriginalClass(SurfLoop) != SurfaceClass::TDD_Diffuser) { + if (surf.OriginalClass != SurfaceClass::TDD_Diffuser) { SetupOutputVariable(state, "Surface Window Transmitted Solar Radiation Energy", OutputProcessor::Unit::J, state.dataSurface->SurfWinTransSolarEnergy(SurfLoop), OutputProcessor::SOVTimeStepType::Zone, OutputProcessor::SOVStoreType::Summed, - state.dataSurface->Surface(SurfLoop).Name); + surf.Name); } SetupOutputVariable(state, "Surface Window Transmitted Beam Solar Radiation Energy", @@ -2103,7 +2103,7 @@ void AllocateModuleArrays(EnergyPlusData &state) state.dataSurface->SurfWinBmSolarEnergy(SurfLoop), OutputProcessor::SOVTimeStepType::Zone, OutputProcessor::SOVStoreType::Summed, - state.dataSurface->Surface(SurfLoop).Name); + surf.Name); SetupOutputVariable(state, "Surface Window Transmitted Beam To Beam Solar Radiation Energy", @@ -2111,14 +2111,14 @@ void AllocateModuleArrays(EnergyPlusData &state) state.dataSurface->SurfWinBmBmSolarEnergy(SurfLoop), OutputProcessor::SOVTimeStepType::Zone, OutputProcessor::SOVStoreType::Summed, - state.dataSurface->Surface(SurfLoop).Name); + surf.Name); SetupOutputVariable(state, "Surface Window Transmitted Beam To Diffuse Solar Radiation Energy", OutputProcessor::Unit::J, state.dataSurface->SurfWinBmDifSolarEnergy(SurfLoop), OutputProcessor::SOVTimeStepType::Zone, OutputProcessor::SOVStoreType::Summed, - state.dataSurface->Surface(SurfLoop).Name); + surf.Name); SetupOutputVariable(state, "Surface Window Transmitted Diffuse Solar Radiation Energy", @@ -2126,35 +2126,35 @@ void AllocateModuleArrays(EnergyPlusData &state) state.dataSurface->SurfWinDifSolarEnergy(SurfLoop), OutputProcessor::SOVTimeStepType::Zone, OutputProcessor::SOVStoreType::Summed, - state.dataSurface->Surface(SurfLoop).Name); + surf.Name); SetupOutputVariable(state, "Surface Window Heat Gain Energy", OutputProcessor::Unit::J, state.dataSurface->SurfWinHeatGainRepEnergy(SurfLoop), OutputProcessor::SOVTimeStepType::Zone, OutputProcessor::SOVStoreType::Summed, - state.dataSurface->Surface(SurfLoop).Name); + surf.Name); SetupOutputVariable(state, "Surface Window Heat Loss Energy", OutputProcessor::Unit::J, state.dataSurface->SurfWinHeatLossRepEnergy(SurfLoop), OutputProcessor::SOVTimeStepType::Zone, OutputProcessor::SOVStoreType::Summed, - state.dataSurface->Surface(SurfLoop).Name); + surf.Name); SetupOutputVariable(state, "Surface Window Gap Convective Heat Transfer Energy", OutputProcessor::Unit::J, state.dataSurface->SurfWinGapConvHtFlowRepEnergy(SurfLoop), OutputProcessor::SOVTimeStepType::Zone, OutputProcessor::SOVStoreType::Summed, - state.dataSurface->Surface(SurfLoop).Name); + surf.Name); SetupOutputVariable(state, "Surface Window Shading Device Absorbed Solar Radiation Energy", OutputProcessor::Unit::J, state.dataSurface->SurfWinShadingAbsorbedSolarEnergy(SurfLoop), OutputProcessor::SOVTimeStepType::Zone, OutputProcessor::SOVStoreType::Summed, - state.dataSurface->Surface(SurfLoop).Name); + surf.Name); SetupOutputVariable(state, "Surface Window System Solar Transmittance", @@ -2162,56 +2162,56 @@ void AllocateModuleArrays(EnergyPlusData &state) state.dataSurface->SurfWinSysSolTransmittance(SurfLoop), OutputProcessor::SOVTimeStepType::Zone, OutputProcessor::SOVStoreType::Average, - state.dataSurface->Surface(SurfLoop).Name); + surf.Name); SetupOutputVariable(state, "Surface Window System Solar Reflectance", OutputProcessor::Unit::None, state.dataSurface->SurfWinSysSolReflectance(SurfLoop), OutputProcessor::SOVTimeStepType::Zone, OutputProcessor::SOVStoreType::Average, - state.dataSurface->Surface(SurfLoop).Name); + surf.Name); SetupOutputVariable(state, "Surface Window System Solar Absorptance", OutputProcessor::Unit::None, state.dataSurface->SurfWinSysSolAbsorptance(SurfLoop), OutputProcessor::SOVTimeStepType::Zone, OutputProcessor::SOVStoreType::Average, - state.dataSurface->Surface(SurfLoop).Name); + surf.Name); SetupOutputVariable(state, "Surface Window Inside Face Glazing Condensation Status", OutputProcessor::Unit::None, state.dataSurface->SurfWinInsideGlassCondensationFlag(SurfLoop), OutputProcessor::SOVTimeStepType::Zone, OutputProcessor::SOVStoreType::State, - state.dataSurface->Surface(SurfLoop).Name); + surf.Name); SetupOutputVariable(state, "Surface Window Inside Face Frame Condensation Status", OutputProcessor::Unit::None, state.dataSurface->SurfWinInsideFrameCondensationFlag(SurfLoop), OutputProcessor::SOVTimeStepType::Zone, OutputProcessor::SOVStoreType::State, - state.dataSurface->Surface(SurfLoop).Name); + surf.Name); SetupOutputVariable(state, "Surface Window Inside Face Divider Condensation Status", OutputProcessor::Unit::None, state.dataSurface->SurfWinInsideDividerCondensationFlag(SurfLoop), OutputProcessor::SOVTimeStepType::Zone, OutputProcessor::SOVStoreType::State, - state.dataSurface->Surface(SurfLoop).Name); + surf.Name); SetupOutputVariable(state, "Surface Window Outside Reveal Reflected Beam Solar Radiation Rate", OutputProcessor::Unit::W, state.dataSurface->SurfWinBmSolRefldOutsRevealReport(SurfLoop), OutputProcessor::SOVTimeStepType::Zone, OutputProcessor::SOVStoreType::State, - state.dataSurface->Surface(SurfLoop).Name); + surf.Name); SetupOutputVariable(state, "Surface Window Inside Reveal Reflected Beam Solar Radiation Rate", OutputProcessor::Unit::W, state.dataSurface->SurfWinBmSolRefldInsRevealReport(SurfLoop), OutputProcessor::SOVTimeStepType::Zone, OutputProcessor::SOVStoreType::State, - state.dataSurface->Surface(SurfLoop).Name); + surf.Name); // Energy SetupOutputVariable(state, "Surface Window Outside Reveal Reflected Beam Solar Radiation Energy", @@ -2219,14 +2219,14 @@ void AllocateModuleArrays(EnergyPlusData &state) state.dataSurface->SurfWinBmSolRefldOutsRevealRepEnergy(SurfLoop), OutputProcessor::SOVTimeStepType::Zone, OutputProcessor::SOVStoreType::Summed, - state.dataSurface->Surface(SurfLoop).Name); + surf.Name); SetupOutputVariable(state, "Surface Window Inside Reveal Reflected Beam Solar Radiation Energy", OutputProcessor::Unit::J, state.dataSurface->SurfWinBmSolRefldInsRevealRepEnergy(SurfLoop), OutputProcessor::SOVTimeStepType::Zone, OutputProcessor::SOVStoreType::Summed, - state.dataSurface->Surface(SurfLoop).Name); + surf.Name); // Output blind report variables only when blinds are used if (state.dataSurface->SurfWinBlindNumber(SurfLoop) > 0) { @@ -2236,35 +2236,35 @@ void AllocateModuleArrays(EnergyPlusData &state) state.dataSurface->SurfWinBlTsolBmBm(SurfLoop), OutputProcessor::SOVTimeStepType::Zone, OutputProcessor::SOVStoreType::State, - state.dataSurface->Surface(SurfLoop).Name); + surf.Name); SetupOutputVariable(state, "Surface Window Blind Beam to Diffuse Solar Transmittance", OutputProcessor::Unit::None, state.dataSurface->SurfWinBlTsolBmDif(SurfLoop), OutputProcessor::SOVTimeStepType::Zone, OutputProcessor::SOVStoreType::State, - state.dataSurface->Surface(SurfLoop).Name); + surf.Name); SetupOutputVariable(state, "Surface Window Blind Diffuse to Diffuse Solar Transmittance", OutputProcessor::Unit::None, state.dataSurface->SurfWinBlTsolDifDif(SurfLoop), OutputProcessor::SOVTimeStepType::Zone, OutputProcessor::SOVStoreType::State, - state.dataSurface->Surface(SurfLoop).Name); + surf.Name); SetupOutputVariable(state, "Surface Window Blind and Glazing System Beam Solar Transmittance", OutputProcessor::Unit::None, state.dataSurface->SurfWinBlGlSysTsolBmBm(SurfLoop), OutputProcessor::SOVTimeStepType::Zone, OutputProcessor::SOVStoreType::State, - state.dataSurface->Surface(SurfLoop).Name); + surf.Name); SetupOutputVariable(state, "Surface Window Blind and Glazing System Diffuse Solar Transmittance", OutputProcessor::Unit::None, state.dataSurface->SurfWinBlGlSysTsolDifDif(SurfLoop), OutputProcessor::SOVTimeStepType::Zone, OutputProcessor::SOVStoreType::State, - state.dataSurface->Surface(SurfLoop).Name); + surf.Name); } // Output screen report variables only when screens are used @@ -2275,35 +2275,35 @@ void AllocateModuleArrays(EnergyPlusData &state) state.dataSurface->SurfWinScTsolBmBm(SurfLoop), OutputProcessor::SOVTimeStepType::Zone, OutputProcessor::SOVStoreType::State, - state.dataSurface->Surface(SurfLoop).Name); + surf.Name); SetupOutputVariable(state, "Surface Window Screen Beam to Diffuse Solar Transmittance", OutputProcessor::Unit::None, state.dataSurface->SurfWinScTsolBmDif(SurfLoop), OutputProcessor::SOVTimeStepType::Zone, OutputProcessor::SOVStoreType::State, - state.dataSurface->Surface(SurfLoop).Name); + surf.Name); SetupOutputVariable(state, "Surface Window Screen Diffuse to Diffuse Solar Transmittance", OutputProcessor::Unit::None, state.dataSurface->SurfWinScTsolDifDif(SurfLoop), OutputProcessor::SOVTimeStepType::Zone, OutputProcessor::SOVStoreType::State, - state.dataSurface->Surface(SurfLoop).Name); + surf.Name); SetupOutputVariable(state, "Surface Window Screen and Glazing System Beam Solar Transmittance", OutputProcessor::Unit::None, state.dataSurface->SurfWinScGlSysTsolBmBm(SurfLoop), OutputProcessor::SOVTimeStepType::Zone, OutputProcessor::SOVStoreType::State, - state.dataSurface->Surface(SurfLoop).Name); + surf.Name); SetupOutputVariable(state, "Surface Window Screen and Glazing System Diffuse Solar Transmittance", OutputProcessor::Unit::None, state.dataSurface->SurfWinScGlSysTsolDifDif(SurfLoop), OutputProcessor::SOVTimeStepType::Zone, OutputProcessor::SOVStoreType::State, - state.dataSurface->Surface(SurfLoop).Name); + surf.Name); } SetupOutputVariable(state, @@ -2312,47 +2312,46 @@ void AllocateModuleArrays(EnergyPlusData &state) state.dataSurface->SurfWinProfileAngHor(SurfLoop), OutputProcessor::SOVTimeStepType::Zone, OutputProcessor::SOVStoreType::State, - state.dataSurface->Surface(SurfLoop).Name); + surf.Name); SetupOutputVariable(state, "Surface Window Solar Vertical Profile Angle", OutputProcessor::Unit::deg, state.dataSurface->SurfWinProfileAngVert(SurfLoop), OutputProcessor::SOVTimeStepType::Zone, OutputProcessor::SOVStoreType::State, - state.dataSurface->Surface(SurfLoop).Name); + surf.Name); SetupOutputVariable(state, "Surface Window Glazing Beam to Beam Solar Transmittance", OutputProcessor::Unit::None, state.dataSurface->SurfWinGlTsolBmBm(SurfLoop), OutputProcessor::SOVTimeStepType::Zone, OutputProcessor::SOVStoreType::State, - state.dataSurface->Surface(SurfLoop).Name); + surf.Name); SetupOutputVariable(state, "Surface Window Glazing Beam to Diffuse Solar Transmittance", OutputProcessor::Unit::None, state.dataSurface->SurfWinGlTsolBmDif(SurfLoop), OutputProcessor::SOVTimeStepType::Zone, OutputProcessor::SOVStoreType::State, - state.dataSurface->Surface(SurfLoop).Name); + surf.Name); SetupOutputVariable(state, "Surface Window Glazing Diffuse to Diffuse Solar Transmittance", OutputProcessor::Unit::None, state.dataSurface->SurfWinGlTsolDifDif(SurfLoop), OutputProcessor::SOVTimeStepType::Zone, OutputProcessor::SOVStoreType::State, - state.dataSurface->Surface(SurfLoop).Name); + surf.Name); SetupOutputVariable(state, "Surface Window Model Solver Iteration Count", OutputProcessor::Unit::None, state.dataSurface->SurfWinWindowCalcIterationsRep(SurfLoop), OutputProcessor::SOVTimeStepType::Zone, OutputProcessor::SOVStoreType::State, - state.dataSurface->Surface(SurfLoop).Name); + surf.Name); } } // end non extsolar reporting as advanced variables } // Window Reporting - if (state.dataSurface->Surface(SurfLoop).Class == SurfaceClass::Window && state.dataSurface->Surface(SurfLoop).ExtBoundCond > 0 && - state.dataSurface->Surface(SurfLoop).ExtBoundCond != SurfLoop) { // Interzone window + if (surf.Class == SurfaceClass::Window && surf.ExtBoundCond > 0 && surf.ExtBoundCond != SurfLoop) { // Interzone window // CurrentModuleObject='InterzoneWindows' SetupOutputVariable(state, "Surface Window Transmitted Beam Solar Radiation Rate", @@ -2360,7 +2359,7 @@ void AllocateModuleArrays(EnergyPlusData &state) state.dataSurface->SurfWinBmSolTransThruIntWinRep(SurfLoop), OutputProcessor::SOVTimeStepType::Zone, OutputProcessor::SOVStoreType::State, - state.dataSurface->Surface(SurfLoop).Name); + surf.Name); // energy SetupOutputVariable(state, "Surface Window Transmitted Beam Solar Radiation Energy", @@ -2368,9 +2367,9 @@ void AllocateModuleArrays(EnergyPlusData &state) state.dataSurface->SurfWinBmSolTransThruIntWinRepEnergy(SurfLoop), OutputProcessor::SOVTimeStepType::Zone, OutputProcessor::SOVStoreType::Summed, - state.dataSurface->Surface(SurfLoop).Name); + surf.Name); } - if (state.dataSurface->Surface(SurfLoop).Class == SurfaceClass::TDD_Dome && state.dataSurface->Surface(SurfLoop).ExtSolar) { + if (surf.Class == SurfaceClass::TDD_Dome && surf.ExtSolar) { // CurrentModuleObject='TDD Domes' SetupOutputVariable(state, "Surface Window Total Glazing Layers Absorbed Solar Radiation Rate", @@ -2378,14 +2377,14 @@ void AllocateModuleArrays(EnergyPlusData &state) state.dataHeatBal->SurfWinQRadSWwinAbsTot(SurfLoop), OutputProcessor::SOVTimeStepType::Zone, OutputProcessor::SOVStoreType::Average, - state.dataSurface->Surface(SurfLoop).Name); + surf.Name); SetupOutputVariable(state, "Surface Window Transmitted Solar Radiation Rate", OutputProcessor::Unit::W, state.dataSurface->SurfWinTransSolar(SurfLoop), OutputProcessor::SOVTimeStepType::Zone, OutputProcessor::SOVStoreType::Average, - state.dataSurface->Surface(SurfLoop).Name); + surf.Name); // energy SetupOutputVariable(state, "Surface Window Total Glazing Layers Absorbed Solar Radiation Energy", @@ -2393,16 +2392,16 @@ void AllocateModuleArrays(EnergyPlusData &state) state.dataHeatBal->SurfWinQRadSWwinAbsTotEnergy(SurfLoop), OutputProcessor::SOVTimeStepType::Zone, OutputProcessor::SOVStoreType::Summed, - state.dataSurface->Surface(SurfLoop).Name); + surf.Name); SetupOutputVariable(state, "Surface Window Transmitted Solar Radiation Energy", OutputProcessor::Unit::J, state.dataSurface->SurfWinTransSolarEnergy(SurfLoop), OutputProcessor::SOVTimeStepType::Zone, OutputProcessor::SOVStoreType::Summed, - state.dataSurface->Surface(SurfLoop).Name); + surf.Name); } - if (state.dataSurface->SurfWinOriginalClass(SurfLoop) == SurfaceClass::TDD_Diffuser) { + if (surf.OriginalClass == SurfaceClass::TDD_Diffuser) { // CurrentModuleObject='TDD Diffusers' SetupOutputVariable(state, "Surface Outside Face Incident Solar Radiation Rate per Area", @@ -2410,21 +2409,21 @@ void AllocateModuleArrays(EnergyPlusData &state) state.dataHeatBal->SurfQRadSWOutIncident(SurfLoop), OutputProcessor::SOVTimeStepType::Zone, OutputProcessor::SOVStoreType::Average, - state.dataSurface->Surface(SurfLoop).Name); + surf.Name); SetupOutputVariable(state, "Surface Window Total Glazing Layers Absorbed Solar Radiation Rate", OutputProcessor::Unit::W, state.dataHeatBal->SurfWinQRadSWwinAbsTot(SurfLoop), OutputProcessor::SOVTimeStepType::Zone, OutputProcessor::SOVStoreType::Average, - state.dataSurface->Surface(SurfLoop).Name); + surf.Name); SetupOutputVariable(state, "Surface Window Transmitted Solar Radiation Rate", OutputProcessor::Unit::W, state.dataSurface->SurfWinTransSolar(SurfLoop), OutputProcessor::SOVTimeStepType::Zone, OutputProcessor::SOVStoreType::Average, - state.dataSurface->Surface(SurfLoop).Name); + surf.Name); // energy SetupOutputVariable(state, "Surface Window Total Glazing Layers Absorbed Solar Radiation Energy", @@ -2432,19 +2431,20 @@ void AllocateModuleArrays(EnergyPlusData &state) state.dataHeatBal->SurfWinQRadSWwinAbsTotEnergy(SurfLoop), OutputProcessor::SOVTimeStepType::Zone, OutputProcessor::SOVStoreType::Summed, - state.dataSurface->Surface(SurfLoop).Name); + surf.Name); SetupOutputVariable(state, "Surface Window Transmitted Solar Radiation Energy", OutputProcessor::Unit::J, state.dataSurface->SurfWinTransSolarEnergy(SurfLoop), OutputProcessor::SOVTimeStepType::Zone, OutputProcessor::SOVStoreType::Summed, - state.dataSurface->Surface(SurfLoop).Name); + surf.Name); } } - for (SurfLoop = 1; SurfLoop <= state.dataSurface->TotSurfaces; ++SurfLoop) { - if (!state.dataSurface->Surface(SurfLoop).HeatTransSurf) continue; + for (int SurfLoop = 1; SurfLoop <= state.dataSurface->TotSurfaces; ++SurfLoop) { + auto &surf = state.dataSurface->Surface(SurfLoop); + if (!surf.HeatTransSurf) continue; // CurrentModuleObject='Surfaces' SetupOutputVariable(state, "Surface Inside Face Exterior Windows Incident Beam Solar Radiation Rate per Area", @@ -2452,49 +2452,49 @@ void AllocateModuleArrays(EnergyPlusData &state) state.dataHeatBal->SurfBmIncInsSurfIntensRep(SurfLoop), OutputProcessor::SOVTimeStepType::Zone, OutputProcessor::SOVStoreType::Average, - state.dataSurface->Surface(SurfLoop).Name); + surf.Name); SetupOutputVariable(state, "Surface Inside Face Exterior Windows Incident Beam Solar Radiation Rate", OutputProcessor::Unit::W, state.dataHeatBal->SurfBmIncInsSurfAmountRep(SurfLoop), OutputProcessor::SOVTimeStepType::Zone, OutputProcessor::SOVStoreType::Average, - state.dataSurface->Surface(SurfLoop).Name); + surf.Name); SetupOutputVariable(state, "Surface Inside Face Interior Windows Incident Beam Solar Radiation Rate per Area", OutputProcessor::Unit::W_m2, state.dataHeatBal->SurfIntBmIncInsSurfIntensRep(SurfLoop), OutputProcessor::SOVTimeStepType::Zone, OutputProcessor::SOVStoreType::Average, - state.dataSurface->Surface(SurfLoop).Name); + surf.Name); SetupOutputVariable(state, "Surface Inside Face Interior Windows Incident Beam Solar Radiation Rate", OutputProcessor::Unit::W, state.dataHeatBal->SurfIntBmIncInsSurfAmountRep(SurfLoop), OutputProcessor::SOVTimeStepType::Zone, OutputProcessor::SOVStoreType::Average, - state.dataSurface->Surface(SurfLoop).Name); + surf.Name); SetupOutputVariable(state, "Surface Inside Face Initial Transmitted Diffuse Absorbed Solar Radiation Rate", OutputProcessor::Unit::W, state.dataHeatBal->SurfInitialDifSolInAbsReport(SurfLoop), OutputProcessor::SOVTimeStepType::Zone, OutputProcessor::SOVStoreType::Average, - state.dataSurface->Surface(SurfLoop).Name); + surf.Name); SetupOutputVariable(state, "Surface Inside Face Initial Transmitted Diffuse Transmitted Out Window Solar Radiation Rate", OutputProcessor::Unit::W, state.dataHeatBal->SurfWinInitialDifSolInTransReport(SurfLoop), OutputProcessor::SOVTimeStepType::Zone, OutputProcessor::SOVStoreType::Average, - state.dataSurface->Surface(SurfLoop).Name); + surf.Name); SetupOutputVariable(state, "Surface Inside Face Absorbed Shortwave Radiation Rate", OutputProcessor::Unit::W, state.dataHeatBal->SurfSWInAbsTotalReport(SurfLoop), OutputProcessor::SOVTimeStepType::Zone, OutputProcessor::SOVStoreType::Average, - state.dataSurface->Surface(SurfLoop).Name); + surf.Name); // energy SetupOutputVariable(state, "Surface Inside Face Exterior Windows Incident Beam Solar Radiation Energy", @@ -2502,14 +2502,14 @@ void AllocateModuleArrays(EnergyPlusData &state) state.dataHeatBal->SurfBmIncInsSurfAmountRepEnergy(SurfLoop), OutputProcessor::SOVTimeStepType::Zone, OutputProcessor::SOVStoreType::Summed, - state.dataSurface->Surface(SurfLoop).Name); + surf.Name); SetupOutputVariable(state, "Surface Inside Face Interior Windows Incident Beam Solar Radiation Energy", OutputProcessor::Unit::J, state.dataHeatBal->SurfIntBmIncInsSurfAmountRepEnergy(SurfLoop), OutputProcessor::SOVTimeStepType::Zone, OutputProcessor::SOVStoreType::Summed, - state.dataSurface->Surface(SurfLoop).Name); + surf.Name); } } @@ -6454,10 +6454,11 @@ void CalcInteriorSolarDistribution(EnergyPlusData &state) // EXTERIOR WINDOWS OR TDD DOMES //-------------------------------------------------------------------------------------------------------- for (int const SurfNum : thisEnclosure.SurfacePtr) { - if (state.dataSurface->Surface(SurfNum).Class != SurfaceClass::Window && - state.dataSurface->Surface(SurfNum).Class != SurfaceClass::TDD_Dome) + auto &surf = state.dataSurface->Surface(SurfNum); + if (surf.Class != SurfaceClass::Window && + surf.Class != SurfaceClass::TDD_Dome) continue; - if (!state.dataSurface->Surface(SurfNum).ExtSolar && state.dataSurface->SurfWinOriginalClass(SurfNum) != SurfaceClass::TDD_Diffuser) + if (!surf.ExtSolar && surf.OriginalClass != SurfaceClass::TDD_Diffuser) continue; int const ConstrNum = state.dataSurface->SurfActiveConstruction(SurfNum); int const ConstrNumSh = state.dataSurface->SurfWinActiveShadedConstruction(SurfNum); @@ -6472,7 +6473,7 @@ void CalcInteriorSolarDistribution(EnergyPlusData &state) Real64 VarSlats = state.dataSurface->SurfWinMovableSlats(SurfNum); int PipeNum = state.dataSurface->SurfWinTDDPipeNum(SurfNum); int SurfNum2 = SurfNum; - if (state.dataSurface->SurfWinOriginalClass(SurfNum) == SurfaceClass::TDD_Diffuser) { + if (surf.OriginalClass == SurfaceClass::TDD_Diffuser) { SurfNum2 = state.dataDaylightingDevicesData->TDDPipe(PipeNum).Dome; } Real64 CosInc = state.dataHeatBal->SurfCosIncAng(state.dataGlobal->HourOfDay, state.dataGlobal->TimeStep, SurfNum2); @@ -6484,8 +6485,7 @@ void CalcInteriorSolarDistribution(EnergyPlusData &state) // EXTERIOR BEAM ABSORBED BY SHADING DEVICE (SurfWinExtBeamAbsByShadFac) //----------------------------------------- // Somewhat of a kludge - if (state.dataSurface->Surface(SurfNum).Class == SurfaceClass::TDD_Dome || - state.dataSurface->SurfWinOriginalClass(SurfNum) == SurfaceClass::TDD_Diffuser) + if (surf.Class == SurfaceClass::TDD_Dome || surf.OriginalClass == SurfaceClass::TDD_Diffuser) state.dataHeatBal->SurfSunlitFracWithoutReveal(state.dataGlobal->HourOfDay, state.dataGlobal->TimeStep, SurfNum) = SunLitFract; // Frames/dividers not allow int FenSolAbsPtr = 0; @@ -6918,7 +6918,7 @@ void CalcInteriorSolarDistribution(EnergyPlusData &state) auto &CFS = state.dataWindowEquivLayer->CFS; // recalcuate the diffuse absorptance and transmittance of the // the equivalent layer window model if there is shade control - int EQLNum = state.dataConstruction->Construct(state.dataSurface->Surface(SurfNum).Construction) + int EQLNum = state.dataConstruction->Construct(surf.Construction) .EQLConsPtr; // equivalent layer fenestration index if (CFS(EQLNum).ISControlled) { WindowEquivalentLayer::CalcEQLOpticalProperty( @@ -6997,7 +6997,7 @@ void CalcInteriorSolarDistribution(EnergyPlusData &state) // surface incorrectly assuming wall heat transfer routines for windows. // Construct( Surface( SurfNum ).Construction ).TransDiff = NomDiffTrans; } - } else if (state.dataSurface->SurfWinOriginalClass(SurfNum) == SurfaceClass::TDD_Diffuser) { + } else if (surf.OriginalClass == SurfaceClass::TDD_Diffuser) { DiffTrans = TransTDD(state, PipeNum, CosInc, Dayltg::RadType::SolarAniso); } else { DiffTrans = thisConstruct.TransDiff; @@ -7078,7 +7078,7 @@ void CalcInteriorSolarDistribution(EnergyPlusData &state) Real64 TDifBare; // Bare diffuse transmittance of exterior window // Beam-beam transmittance for bare exterior window if (SunLitFract > 0.0) { - if (state.dataSurface->SurfWinOriginalClass(SurfNum) == SurfaceClass::TDD_Diffuser) { + if (surf.OriginalClass == SurfaceClass::TDD_Diffuser) { TBmDif = TransTDD(state, PipeNum, CosInc, Dayltg::RadType::SolarBeam); state.dataDaylightingDevicesData->TDDPipe(PipeNum).TransSolBeam = TBmDif; // Report variable } else if (state.dataSurface->SurfWinWindowModelType(SurfNum) == WindowModel::Detailed) { // Regular window @@ -7098,7 +7098,7 @@ void CalcInteriorSolarDistribution(EnergyPlusData &state) TBmBm; } else if (state.dataSurface->SurfWinWindowModelType(SurfNum) == WindowModel::EQL) { // get ASHWAT fenestration model beam-beam and beam-diffuse properties - int EQLNum = state.dataConstruction->Construct(state.dataSurface->Surface(SurfNum).Construction) + int EQLNum = state.dataConstruction->Construct(surf.Construction) .EQLConsPtr; // equivalent layer fenestration index Real64 TBmBmEQL = state.dataSolarShading->SurfWinAbsSolBeamEQL(1, state.dataWindowEquivLayer->CFS(EQLNum).NL + 1); // Beam-diffuse transmittance @@ -7110,7 +7110,7 @@ void CalcInteriorSolarDistribution(EnergyPlusData &state) } } // Diffuse-diffuse transmittance for bare exterior window - if (state.dataSurface->SurfWinOriginalClass(SurfNum) == SurfaceClass::TDD_Diffuser) { + if (surf.OriginalClass == SurfaceClass::TDD_Diffuser) { TDifBare = TransTDD(state, PipeNum, CosInc, Dayltg::RadType::SolarAniso); } else { if (state.dataSurface->SurfWinWindowModelType(SurfNum) == WindowModel::BSDF) { @@ -7264,21 +7264,21 @@ void CalcInteriorSolarDistribution(EnergyPlusData &state) Real64 InOutProjSLFracMult = state.dataSurface->SurfaceWindow(SurfNum).InOutProjSLFracMult[state.dataGlobal->HourOfDay]; if (state.dataSurface->SurfWinWindowModelType(SurfNum) != WindowModel::EQL) { - state.dataSolarShading->SurfWinTransDifSolar(SurfNum) = DiffTrans * state.dataSurface->Surface(SurfNum).Area; + state.dataSolarShading->SurfWinTransDifSolar(SurfNum) = DiffTrans * surf.Area; if (ANY_BLIND(ShadeFlag)) { if (state.dataMaterial->Blind(state.dataSurface->SurfWinBlindNumber(SurfNum)).SlatOrientation == DataWindowEquivalentLayer::Orientation::Horizontal) { - state.dataSolarShading->SurfWinTransDifSolarGnd(SurfNum) = DiffTransGnd * state.dataSurface->Surface(SurfNum).Area; - state.dataSolarShading->SurfWinTransDifSolarSky(SurfNum) = DiffTransSky * state.dataSurface->Surface(SurfNum).Area; + state.dataSolarShading->SurfWinTransDifSolarGnd(SurfNum) = DiffTransGnd * surf.Area; + state.dataSolarShading->SurfWinTransDifSolarSky(SurfNum) = DiffTransSky * surf.Area; } } } else { // In equivalent layer window model system diffuse transmittance is based on unit // diffuse radiation flux, and hence doesn't distinguish between sky and // ground reflected diffuse radiations - state.dataSolarShading->SurfWinTransDifSolar(SurfNum) = DiffTrans * state.dataSurface->Surface(SurfNum).Area; - state.dataSolarShading->SurfWinTransDifSolarGnd(SurfNum) = DiffTrans * state.dataSurface->Surface(SurfNum).Area; - state.dataSolarShading->SurfWinTransDifSolarSky(SurfNum) = DiffTrans * state.dataSurface->Surface(SurfNum).Area; + state.dataSolarShading->SurfWinTransDifSolar(SurfNum) = DiffTrans * surf.Area; + state.dataSolarShading->SurfWinTransDifSolarGnd(SurfNum) = DiffTrans * surf.Area; + state.dataSolarShading->SurfWinTransDifSolarSky(SurfNum) = DiffTrans * surf.Area; } if (!IS_SHADED_NO_GLARE_CTRL(ShadeFlag) || ShadeFlag == WinShadingType::SwitchableGlazing) { @@ -7286,34 +7286,34 @@ void CalcInteriorSolarDistribution(EnergyPlusData &state) // Note: with previous defs of TBmBm & TBmDif, these come out right for Complex Fenestration // SurfWinTransBmSolar uses the directional-hemispherical transmittance state.dataSolarShading->SurfWinTransBmSolar(SurfNum) = - (TBmBm + TBmDif) * SunLitFract * CosInc * state.dataSurface->Surface(SurfNum).Area * InOutProjSLFracMult; + (TBmBm + TBmDif) * SunLitFract * CosInc * surf.Area * InOutProjSLFracMult; state.dataSolarShading->SurfWinTransBmBmSolar(SurfNum) = - TBmBm * SunLitFract * CosInc * state.dataSurface->Surface(SurfNum).Area * InOutProjSLFracMult; // m2 + TBmBm * SunLitFract * CosInc * surf.Area * InOutProjSLFracMult; // m2 state.dataSolarShading->SurfWinTransBmDifSolar(SurfNum) = - TBmDif * SunLitFract * CosInc * state.dataSurface->Surface(SurfNum).Area * InOutProjSLFracMult; // m2 + TBmDif * SunLitFract * CosInc * surf.Area * InOutProjSLFracMult; // m2 } else { state.dataSolarShading->SurfWinTransBmSolar(SurfNum) = - TBmAllShBlSc * SunLitFract * CosInc * state.dataSurface->Surface(SurfNum).Area * InOutProjSLFracMult; + TBmAllShBlSc * SunLitFract * CosInc * surf.Area * InOutProjSLFracMult; state.dataSolarShading->SurfWinTransBmBmSolar(SurfNum) = - TBmBmShBlSc * SunLitFract * CosInc * state.dataSurface->Surface(SurfNum).Area * InOutProjSLFracMult; + TBmBmShBlSc * SunLitFract * CosInc * surf.Area * InOutProjSLFracMult; state.dataSolarShading->SurfWinTransBmDifSolar(SurfNum) = - TBmDifShBlSc * SunLitFract * CosInc * state.dataSurface->Surface(SurfNum).Area * InOutProjSLFracMult; + TBmDifShBlSc * SunLitFract * CosInc * surf.Area * InOutProjSLFracMult; } // Add diffuse transmitted by window from beam reflected from outside reveal if (state.dataSurface->SurfWinWindowModelType(SurfNum) == WindowModel::BSDF) { // Complex Fenestration if (FenSolAbsPtr == 0) { state.dataSolarShading->SurfWinTransBmSolar(SurfNum) = - (TBmBm + TBmDif) * SunLitFract * CosInc * state.dataSurface->Surface(SurfNum).Area * InOutProjSLFracMult; + (TBmBm + TBmDif) * SunLitFract * CosInc * surf.Area * InOutProjSLFracMult; state.dataSolarShading->SurfWinTransBmBmSolar(SurfNum) = - TBmBm * SunLitFract * CosInc * state.dataSurface->Surface(SurfNum).Area * InOutProjSLFracMult; // m2 + TBmBm * SunLitFract * CosInc * surf.Area * InOutProjSLFracMult; // m2 state.dataSolarShading->SurfWinTransBmDifSolar(SurfNum) = - TBmDif * SunLitFract * CosInc * state.dataSurface->Surface(SurfNum).Area * InOutProjSLFracMult; // m2 + TBmDif * SunLitFract * CosInc * surf.Area * InOutProjSLFracMult; // m2 state.dataSolarShading->SurfWinTransBmSolar(SurfNum) += - state.dataSurface->SurfWinOutsRevealDiffOntoGlazing(SurfNum) * NomDiffTrans * state.dataSurface->Surface(SurfNum).Area; + state.dataSurface->SurfWinOutsRevealDiffOntoGlazing(SurfNum) * NomDiffTrans * surf.Area; state.dataSolarShading->SurfWinTransBmDifSolar(SurfNum) += - state.dataSurface->SurfWinOutsRevealDiffOntoGlazing(SurfNum) * NomDiffTrans * state.dataSurface->Surface(SurfNum).Area; + state.dataSurface->SurfWinOutsRevealDiffOntoGlazing(SurfNum) * NomDiffTrans * surf.Area; } else { state.dataSolarShading->SurfWinTransBmSolar(SurfNum) = 0.0; state.dataSolarShading->SurfWinTransBmDifSolar(SurfNum) = 0.0; @@ -7321,16 +7321,16 @@ void CalcInteriorSolarDistribution(EnergyPlusData &state) } else { // Regular window // this is also valid for equivalent layer window state.dataSolarShading->SurfWinTransBmSolar(SurfNum) += - state.dataSurface->SurfWinOutsRevealDiffOntoGlazing(SurfNum) * DiffTrans * state.dataSurface->Surface(SurfNum).Area; + state.dataSurface->SurfWinOutsRevealDiffOntoGlazing(SurfNum) * DiffTrans * surf.Area; state.dataSolarShading->SurfWinTransBmDifSolar(SurfNum) += - state.dataSurface->SurfWinOutsRevealDiffOntoGlazing(SurfNum) * DiffTrans * state.dataSurface->Surface(SurfNum).Area; + state.dataSurface->SurfWinOutsRevealDiffOntoGlazing(SurfNum) * DiffTrans * surf.Area; } //----------------------------------------------------------------- // BLOCK 5 - UPDATE SOLAR ENTERING A ZONE AS BEAM OR DIFFUSE RADIATION //----------------------------------------------------------------- // Increment factor for total exterior beam solar entering zone through window as beam or diffuse - if (SunLitFract > 0.0 && state.dataSurface->Surface(SurfNum).Class != SurfaceClass::TDD_Dome) { + if (SunLitFract > 0.0 && surf.Class != SurfaceClass::TDD_Dome) { // Window is schedule surface gained. Do not make addition to what enters into zone since that information is not available if (FenSolAbsPtr == 0) { Real64 TBmAll; // Window beam-to-(beam+diffuse) transmittance @@ -7340,8 +7340,8 @@ void CalcInteriorSolarDistribution(EnergyPlusData &state) } else { TBmAll = TBmBm + TBmDif; } - BTOTZone += state.dataSurface->Surface(SurfNum).IncSolMultiplier * TBmAll * SunLitFract * CosInc * - state.dataSurface->Surface(SurfNum).Area * InOutProjSLFracMult; // [m2] + BTOTZone += surf.IncSolMultiplier * TBmAll * SunLitFract * CosInc * + surf.Area * InOutProjSLFracMult; // [m2] } } @@ -7357,16 +7357,16 @@ void CalcInteriorSolarDistribution(EnergyPlusData &state) BTOTZone = BTOTZone - state.dataSurface->SurfWinBmSolRefldInsReveal(SurfNum) - state.dataSurface->SurfWinBmSolAbsdInsReveal(SurfNum) + state.dataSurface->SurfWinInsRevealDiffIntoZone(SurfNum) + - state.dataSurface->SurfWinOutsRevealDiffOntoGlazing(SurfNum) * NomDiffTrans * state.dataSurface->Surface(SurfNum).Area; + state.dataSurface->SurfWinOutsRevealDiffOntoGlazing(SurfNum) * NomDiffTrans * surf.Area; } } else { // Regular window BTOTZone = BTOTZone - state.dataSurface->SurfWinBmSolRefldInsReveal(SurfNum) - state.dataSurface->SurfWinBmSolAbsdInsReveal(SurfNum) + state.dataSurface->SurfWinInsRevealDiffIntoZone(SurfNum) + - state.dataSurface->SurfWinOutsRevealDiffOntoGlazing(SurfNum) * DiffTrans * state.dataSurface->Surface(SurfNum).Area; + state.dataSurface->SurfWinOutsRevealDiffOntoGlazing(SurfNum) * DiffTrans * surf.Area; } // Add beam solar absorbed by outside reveal to outside of window's base surface. Add beam solar absorbed by inside reveal to inside // of window's base surface. This ignores 2-D heat transfer effects. - int BaseSurfNum = state.dataSurface->Surface(SurfNum).BaseSurf; + int BaseSurfNum = surf.BaseSurf; state.dataSurface->SurfOpaqAI(BaseSurfNum) += state.dataSurface->SurfWinBmSolAbsdInsReveal(SurfNum) / state.dataSurface->Surface(BaseSurfNum).Area; state.dataSurface->SurfOpaqAO(BaseSurfNum) += @@ -7384,8 +7384,7 @@ void CalcInteriorSolarDistribution(EnergyPlusData &state) if (SunLitFract > 0.0) { if (state.dataSurface->SurfWinWindowModelType(SurfNum) != WindowModel::BSDF) if (ANY_SHADE(ShadeFlag) || state.dataSurface->SurfWinSolarDiffusing(SurfNum) || - state.dataSurface->SurfWinOriginalClass(SurfNum) == SurfaceClass::TDD_Diffuser || - state.dataSurface->Surface(SurfNum).Class == SurfaceClass::TDD_Dome) + surf.OriginalClass == SurfaceClass::TDD_Diffuser || surf.Class == SurfaceClass::TDD_Dome) continue; // Find interior beam radiation that is: @@ -7414,13 +7413,13 @@ void CalcInteriorSolarDistribution(EnergyPlusData &state) } else { TBm = TBmBm; // Bare glass or switchable glazing // Correction for beam absorbed by inside reveal - TBmDenom = (SunLitFract * CosInc * state.dataSurface->Surface(SurfNum).Area * InOutProjSLFracMult); + TBmDenom = (SunLitFract * CosInc * surf.Area * InOutProjSLFracMult); if (TBmDenom != 0.0) { // when =0.0, no correction TBm -= state.dataSurface->SurfWinBmSolAbsdInsReveal(SurfNum) / TBmDenom; } TBm = max(0.0, TBm); // this multiplier doesn't work with other shading, so no need to apply in other branches - TBm *= state.dataSurface->Surface(SurfNum).IncSolMultiplier; + TBm *= surf.IncSolMultiplier; } if (TBm == 0.0) continue; @@ -7428,7 +7427,7 @@ void CalcInteriorSolarDistribution(EnergyPlusData &state) // Inside daylighting shelves assume that no beam will pass the end of the shelf. // Since all beam is absorbed on the shelf, this might cause them to get unrealistically hot at times. // BTOTWinZone - Transmitted beam solar factor for a window [m2] - Real64 BTOTWinZone = TBm * SunLitFract * state.dataSurface->Surface(SurfNum).Area * CosInc * InOutProjSLFracMult; + Real64 BTOTWinZone = TBm * SunLitFract * surf.Area * CosInc * InOutProjSLFracMult; // Shelf surface area is divided by 2 because only one side sees beam (Area was multiplied by 2 during init) state.dataSurface->SurfOpaqAI(InShelfSurf) += BTOTWinZone / (0.5 * state.dataSurface->Surface(InShelfSurf).Area); //[-] BABSZone += BTOTWinZone; //[m2] @@ -8020,7 +8019,7 @@ void CalcInteriorSolarDistribution(EnergyPlusData &state) .Geom(CurCplxFenState) .PhiBm(state.dataGlobal->HourOfDay, state.dataGlobal->TimeStep); - int BaseSurf = state.dataSurface->Surface(SurfNum).BaseSurf; // Base surface number for current complex window + int BaseSurf = surf.BaseSurf; // Base surface number for current complex window // Get total number of back surfaces for current window (surface) // Note that it is organized by base surface int NBkSurf = state.dataShadowComb->ShadowComb(BaseSurf).NumBackSurf; @@ -8278,7 +8277,7 @@ void CalcInteriorSolarDistribution(EnergyPlusData &state) if (state.dataSolarShading->SurfIntAbsFac(FloorNum) <= 0.0 || FloorNum == SurfNum) continue; // Keep only floor surfaces int const FlConstrNum = state.dataSurface->SurfActiveConstruction(FloorNum); - Real64 BTOTWinZone = TBm * SunLitFract * state.dataSurface->Surface(SurfNum).Area * CosInc * InOutProjSLFracMult; //[m2] + Real64 BTOTWinZone = TBm * SunLitFract * surf.Area * CosInc * InOutProjSLFracMult; //[m2] Real64 AbsBeamTotWin = 0.0; if (state.dataConstruction->Construct(FlConstrNum).TransDiff <= 0.0) { @@ -8339,16 +8338,17 @@ void CalcInteriorSolarDistribution(EnergyPlusData &state) Real64 BTOTZoneSSG = 0.0; // Solar entering a zone in case of scheduled surface gains for (int iSSG = 1; iSSG <= state.dataSurface->TotSurfIncSolSSG; ++iSSG) { int SurfNum = state.dataSurface->SurfIncSolSSG(iSSG).SurfPtr; + auto &surf = state.dataSurface->Surface(SurfNum); // do calculation only if construction number match. - if (state.dataSurface->SurfIncSolSSG(iSSG).ConstrPtr == state.dataSurface->Surface(SurfNum).Construction) { - if (state.dataSurface->Surface(SurfNum).SolarEnclIndex == enclosureNum) { - Real64 AbsIntSurf = state.dataConstruction->Construct(state.dataSurface->Surface(SurfNum).Construction).InsideAbsorpSolar; + if (state.dataSurface->SurfIncSolSSG(iSSG).ConstrPtr == surf.Construction) { + if (surf.SolarEnclIndex == enclosureNum) { + Real64 AbsIntSurf = state.dataConstruction->Construct(surf.Construction).InsideAbsorpSolar; // SolarIntoZone = GetCurrentScheduleValue(SurfIncSolSSG(iSSG)%SchedPtr) * Surface(SurfNum)%Area Real64 SolarIntoZone = GetCurrentScheduleValue( state, state.dataSurface->SurfIncSolSSG(iSSG).SchedPtr); // Solar radiation into zone to current surface state.dataSurface->SurfOpaqAI(SurfNum) = SolarIntoZone * AbsIntSurf; - BABSZoneSSG += state.dataSurface->SurfOpaqAI(SurfNum) * state.dataSurface->Surface(SurfNum).Area; - BTOTZoneSSG += SolarIntoZone * state.dataSurface->Surface(SurfNum).Area; + BABSZoneSSG += state.dataSurface->SurfOpaqAI(SurfNum) * surf.Area; + BTOTZoneSSG += SolarIntoZone * surf.Area; } } } @@ -8361,7 +8361,8 @@ void CalcInteriorSolarDistribution(EnergyPlusData &state) // Variables for reporting for (int const SurfNum : thisEnclosure.SurfacePtr) { - Real64 SurfIncSolarMultiplier = state.dataSurface->Surface(SurfNum).IncSolMultiplier; + auto &surf = state.dataSurface->Surface(SurfNum); + Real64 SurfIncSolarMultiplier = surf.IncSolMultiplier; Real64 currBeamSolarRad = state.dataEnvrn->BeamSolarRad * SurfIncSolarMultiplier; Real64 currDifSolarRad = state.dataEnvrn->DifSolarRad * SurfIncSolarMultiplier; Real64 currGndSolarRad = state.dataEnvrn->GndSolarRad * SurfIncSolarMultiplier; @@ -8371,9 +8372,9 @@ void CalcInteriorSolarDistribution(EnergyPlusData &state) state.dataHeatBal->SurfBmIncInsSurfAmountRep(SurfNum) * state.dataGlobal->TimeStepZoneSec; state.dataHeatBal->SurfBmIncInsSurfIntensRep(SurfNum) = state.dataHeatBal->SurfBmIncInsSurfAmountRep(SurfNum) / - (state.dataSurface->Surface(SurfNum).Area + state.dataSurface->SurfWinDividerArea(SurfNum)); + (surf.Area + state.dataSurface->SurfWinDividerArea(SurfNum)); } else { // Simple interior solar distribution. All beam falls on floor. - if (state.dataSolarShading->SurfIntAbsFac(SurfNum) > 0.0 && state.dataSurface->Surface(SurfNum).HeatTransSurf) { + if (state.dataSolarShading->SurfIntAbsFac(SurfNum) > 0.0 && surf.HeatTransSurf) { if (thisEnclosure.FloorArea > 0.0) { // spread onto all floor surfaces, these may or may not be called "floor" state.dataHeatBal->SurfBmIncInsSurfIntensRep(SurfNum) = currBeamSolarRad * BTOTZone / thisEnclosure.FloorArea; @@ -8385,18 +8386,18 @@ void CalcInteriorSolarDistribution(EnergyPlusData &state) } } state.dataHeatBal->SurfBmIncInsSurfAmountRep(SurfNum) = - state.dataSurface->Surface(SurfNum).Area * state.dataHeatBal->SurfBmIncInsSurfIntensRep(SurfNum); + surf.Area * state.dataHeatBal->SurfBmIncInsSurfIntensRep(SurfNum); state.dataHeatBal->SurfBmIncInsSurfAmountRepEnergy(SurfNum) = state.dataHeatBal->SurfBmIncInsSurfAmountRep(SurfNum) * state.dataGlobal->TimeStepZoneSec; } - if (state.dataSurface->Surface(SurfNum).Class == SurfaceClass::Window || - state.dataSurface->Surface(SurfNum).Class == SurfaceClass::TDD_Dome) { + if (surf.Class == SurfaceClass::Window || + surf.Class == SurfaceClass::TDD_Dome) { state.dataSurface->SurfWinIntBeamAbsByShade(SurfNum) = state.dataSolarShading->SurfWinIntBeamAbsByShadFac(SurfNum); state.dataSurface->SurfWinExtBeamAbsByShade(SurfNum) = currBeamSolarRad * state.dataSolarShading->SurfWinExtBeamAbsByShadFac(SurfNum); - if ((state.dataSurface->Surface(SurfNum).ExtBoundCond == ExternalEnvironment) || - (state.dataSurface->Surface(SurfNum).ExtBoundCond == OtherSideCondModeledExt)) { + if ((surf.ExtBoundCond == ExternalEnvironment) || + (surf.ExtBoundCond == OtherSideCondModeledExt)) { WinShadingType ShadeFlag = state.dataSurface->SurfWinShadingFlag(SurfNum); int ShelfNum = state.dataSurface->SurfDaylightingShelfInd(SurfNum); @@ -8406,7 +8407,7 @@ void CalcInteriorSolarDistribution(EnergyPlusData &state) } // This lookup may be avoid if this 2nd surf loop can be combined with the 1st - if (state.dataSurface->SurfWinOriginalClass(SurfNum) == SurfaceClass::TDD_Diffuser) { + if (surf.OriginalClass == SurfaceClass::TDD_Diffuser) { int PipeNum = state.dataSurface->SurfWinTDDPipeNum(SurfNum); int SurfNum2 = state.dataDaylightingDevicesData->TDDPipe(PipeNum).Dome; Real64 CosInc = state.dataHeatBal->SurfCosIncAng(state.dataGlobal->HourOfDay, state.dataGlobal->TimeStep, SurfNum2); @@ -8422,7 +8423,7 @@ void CalcInteriorSolarDistribution(EnergyPlusData &state) state.dataSurface->SurfWinBmSolar(SurfNum) = currBeamSolarRad * state.dataSolarShading->SurfWinTransBmSolar(SurfNum); state.dataSurface->SurfWinDifSolar(SurfNum) = - SkySolarTrans * state.dataSurface->Surface(SurfNum).Area + GndSolarTrans * state.dataSurface->Surface(SurfNum).Area; + SkySolarTrans * surf.Area + GndSolarTrans * surf.Area; state.dataSurface->SurfWinBmSolarEnergy(SurfNum) = state.dataSurface->SurfWinBmSolar(SurfNum) * state.dataGlobal->TimeStepZoneSec; state.dataSurface->SurfWinDifSolarEnergy(SurfNum) = @@ -8450,7 +8451,7 @@ void CalcInteriorSolarDistribution(EnergyPlusData &state) state.dataDaylightingDevicesData->Shelf(ShelfNum).OutReflectSol; Real64 DifSolarInc = currDifSolarRad * state.dataSolarShading->SurfAnisoSkyMult(SurfNum) + - currGndSolarRad * state.dataSurface->Surface(SurfNum).ViewFactorGround + + currGndSolarRad * surf.ViewFactorGround + ShelfSolarRad * state.dataDaylightingDevicesData->Shelf(ShelfNum).ViewFactor; state.dataSurface->SurfWinBmSolar(SurfNum) = currBeamSolarRad * state.dataSolarShading->SurfWinTransBmSolar(SurfNum); @@ -8504,7 +8505,7 @@ void CalcInteriorSolarDistribution(EnergyPlusData &state) state.dataSurface->SurfWinBmDifSolar(SurfNum) * state.dataGlobal->TimeStepZoneSec; // Solar not added by TDD:DOME; added to zone via TDD:DIFFUSER - if (state.dataSurface->Surface(SurfNum).Class != SurfaceClass::TDD_Dome) { + if (surf.Class != SurfaceClass::TDD_Dome) { state.dataHeatBal->ZoneTransSolar(enclosureNum) += state.dataSurface->SurfWinTransSolar(SurfNum); //[W] state.dataHeatBal->ZoneTransSolarEnergy(enclosureNum) = state.dataHeatBal->ZoneTransSolar(enclosureNum) * state.dataGlobal->TimeStepZoneSec; //[J] @@ -8550,12 +8551,13 @@ void CalcAbsorbedOnExteriorOpaqueSurfaces(EnergyPlusData &state) for (int spaceNum : state.dataHeatBal->Zone(ZoneNum).spaceIndexes) { auto &thisSpace = state.dataHeatBal->space(spaceNum); for (int SurfNum = thisSpace.HTSurfaceFirst; SurfNum <= thisSpace.HTSurfaceLast; ++SurfNum) { + auto &surf = state.dataSurface->Surface(SurfNum); // TH added 3/24/2010 while debugging CR 7872 - if (!state.dataSurface->Surface(SurfNum).ExtSolar && state.dataSurface->SurfWinOriginalClass(SurfNum) != SurfaceClass::TDD_Diffuser) + if (!surf.ExtSolar && surf.OriginalClass != SurfaceClass::TDD_Diffuser) continue; int const ConstrNum = state.dataSurface->SurfActiveConstruction(SurfNum); int SurfNum2 = SurfNum; - if (state.dataSurface->SurfWinOriginalClass(SurfNum) == SurfaceClass::TDD_Diffuser) { + if (surf.OriginalClass == SurfaceClass::TDD_Diffuser) { int PipeNum = state.dataSurface->SurfWinTDDPipeNum(SurfNum); SurfNum2 = state.dataDaylightingDevicesData->TDDPipe(PipeNum).Dome; } @@ -8619,9 +8621,10 @@ void CalcInteriorSolarDistributionWCESimple(EnergyPlusData &state) auto &thisEnclosure = state.dataViewFactor->EnclSolInfo(enclosureNum); for (int const SurfNum : thisEnclosure.SurfacePtr) { - if (state.dataSurface->Surface(SurfNum).Class != SurfaceClass::Window) continue; + auto &surf = state.dataSurface->Surface(SurfNum); + if (surf.Class != SurfaceClass::Window) continue; int SurfNum2 = 0; - if (state.dataSurface->SurfWinOriginalClass(SurfNum) == SurfaceClass::TDD_Diffuser) { + if (surf.OriginalClass == SurfaceClass::TDD_Diffuser) { int PipeNum = state.dataSurface->SurfWinTDDPipeNum(SurfNum); SurfNum2 = state.dataDaylightingDevicesData->TDDPipe(PipeNum).Dome; } else { @@ -8660,7 +8663,7 @@ void CalcInteriorSolarDistributionWCESimple(EnergyPlusData &state) state.dataSurface->SurfWinA(SurfNum, Lay) * state.dataEnvrn->BeamSolarRad + state.dataSurface->SurfWinACFOverlap(SurfNum, Lay) * state.dataEnvrn->BeamSolarRad; state.dataHeatBal->SurfWinQRadSWwinAbsLayer(SurfNum, Lay) = - state.dataHeatBal->SurfWinQRadSWwinAbs(SurfNum, Lay) * state.dataSurface->Surface(SurfNum).Area; + state.dataHeatBal->SurfWinQRadSWwinAbs(SurfNum, Lay) * surf.Area; state.dataSurface->SurfWinADiffFront(SurfNum, Lay) = cplxState.WinSkyGndAbs(Lay); } } else { @@ -8685,7 +8688,7 @@ void CalcInteriorSolarDistributionWCESimple(EnergyPlusData &state) (state.dataSurface->SurfSkySolarInc(SurfNum2) + state.dataSurface->SurfGndSolarInc(SurfNum2)); state.dataHeatBal->SurfWinQRadSWwinAbs(SurfNum, Lay) = (absBeam + absDiff); state.dataHeatBal->SurfWinQRadSWwinAbsLayer(SurfNum, Lay) = - state.dataHeatBal->SurfWinQRadSWwinAbs(SurfNum, Lay) * state.dataSurface->Surface(SurfNum).Area; + state.dataHeatBal->SurfWinQRadSWwinAbs(SurfNum, Lay) * surf.Area; } } } @@ -8714,15 +8717,15 @@ void CalcInteriorSolarDistributionWCESimple(EnergyPlusData &state) Real64 TBmBm = aLayer->getPropertySimple(minLambda, maxLambda, PropertySimple::T, Side::Front, Scattering::DirectDirect, Theta, Phi); Real64 TBmDif = aLayer->getPropertySimple(minLambda, maxLambda, PropertySimple::T, Side::Front, Scattering::DirectDiffuse, Theta, Phi); Real64 SurfWinTransBmBmSolar = - TBmBm * SunLitFract * CosInc * state.dataSurface->Surface(SurfNum).Area * window.InOutProjSLFracMult[state.dataGlobal->HourOfDay]; + TBmBm * SunLitFract * CosInc * surf.Area * window.InOutProjSLFracMult[state.dataGlobal->HourOfDay]; Real64 SurfWinTransBmDifSolar = - TBmDif * SunLitFract * CosInc * state.dataSurface->Surface(SurfNum).Area * window.InOutProjSLFracMult[state.dataGlobal->HourOfDay]; + TBmDif * SunLitFract * CosInc * surf.Area * window.InOutProjSLFracMult[state.dataGlobal->HourOfDay]; BTOTZone += SurfWinTransBmBmSolar + SurfWinTransBmDifSolar; Real64 DifSolarRadiation = state.dataSurface->SurfSkySolarInc(SurfNum2) + state.dataSurface->SurfGndSolarInc(SurfNum2); state.dataSurface->SurfWinBmSolar(SurfNum) = - state.dataEnvrn->BeamSolarRad * (TBmBm + TBmDif) * state.dataSurface->Surface(SurfNum).Area * CosInc; - state.dataSurface->SurfWinDifSolar(SurfNum) = DifSolarRadiation * Tdiff * state.dataSurface->Surface(SurfNum).Area; + state.dataEnvrn->BeamSolarRad * (TBmBm + TBmDif) * surf.Area * CosInc; + state.dataSurface->SurfWinDifSolar(SurfNum) = DifSolarRadiation * Tdiff * surf.Area; state.dataSurface->SurfWinBmSolarEnergy(SurfNum) = state.dataSurface->SurfWinBmSolar(SurfNum) * state.dataGlobal->TimeStepZoneSec; state.dataSurface->SurfWinDifSolarEnergy(SurfNum) = state.dataSurface->SurfWinDifSolar(SurfNum) * state.dataGlobal->TimeStepZoneSec; state.dataSurface->SurfWinTransSolar(SurfNum) = state.dataSurface->SurfWinBmSolar(SurfNum) + state.dataSurface->SurfWinDifSolar(SurfNum); @@ -8731,7 +8734,7 @@ void CalcInteriorSolarDistributionWCESimple(EnergyPlusData &state) // Add beam solar absorbed by outside reveal to outside of window's base surface. // Add beam solar absorbed by inside reveal to inside of window's base surface. // This ignores 2-D heat transfer effects. - int BaseSurfNum = state.dataSurface->Surface(SurfNum).BaseSurf; + int BaseSurfNum = surf.BaseSurf; state.dataSurface->SurfOpaqAI(BaseSurfNum) = state.dataSurface->SurfWinBmSolAbsdInsReveal(SurfNum2) / state.dataSurface->Surface(BaseSurfNum).Area; state.dataSurface->SurfOpaqAO(BaseSurfNum) = @@ -8743,13 +8746,13 @@ void CalcInteriorSolarDistributionWCESimple(EnergyPlusData &state) Real64 TBm = TBmBm; // Correction for beam absorbed by inside reveal Real64 TBmDenom = - SunLitFract * CosInc * state.dataSurface->Surface(SurfNum).Area * window.InOutProjSLFracMult[state.dataGlobal->HourOfDay]; + SunLitFract * CosInc * surf.Area * window.InOutProjSLFracMult[state.dataGlobal->HourOfDay]; if (TBmDenom != 0.0) { // when =0.0, no correction TBm -= state.dataSurface->SurfWinBmSolAbsdInsReveal(SurfNum) / TBmDenom; } TBm = max(0.0, TBm); - TBm *= state.dataSurface->Surface(SurfNum).IncSolMultiplier; + TBm *= surf.IncSolMultiplier; int NumOfBackSurf = state.dataShadowComb->ShadowComb(BaseSurfNum).NumBackSurf; @@ -8781,7 +8784,7 @@ void CalcInteriorSolarDistributionWCESimple(EnergyPlusData &state) if (!state.dataSurface->Surface(FloorNum).HeatTransSurf) continue; if (state.dataSolarShading->SurfIntAbsFac(FloorNum) <= 0.0 || FloorNum == SurfNum) continue; // Keep only floor surfaces - Real64 BTOTWinZone = TBm * SunLitFract * state.dataSurface->Surface(SurfNum).Area * CosInc * + Real64 BTOTWinZone = TBm * SunLitFract * surf.Area * CosInc * window.InOutProjSLFracMult[state.dataGlobal->HourOfDay]; //[m2] if (state.dataConstruction->Construct(state.dataSurface->Surface(FloorNum).Construction).TransDiff <= 0.0) { @@ -10141,8 +10144,9 @@ void CheckGlazingShadingStatusChange(EnergyPlusData &state) for (int spaceNum : state.dataHeatBal->Zone(ZoneNum).spaceIndexes) { auto &thisSpace = state.dataHeatBal->space(spaceNum); for (int SurfNum = thisSpace.HTSurfaceFirst; SurfNum <= thisSpace.HTSurfaceLast; ++SurfNum) { - if (state.dataConstruction->Construct(state.dataSurface->Surface(SurfNum).Construction).TCFlag == 1 || - state.dataConstruction->Construct(state.dataSurface->Surface(SurfNum).Construction).WindowTypeEQL) { + auto &surf = state.dataSurface->Surface(SurfNum); + if (state.dataConstruction->Construct(surf.Construction).TCFlag == 1 || + state.dataConstruction->Construct(surf.Construction).WindowTypeEQL) { state.dataHeatBal->EnclRadAlwaysReCalc = true; break; } @@ -10179,9 +10183,10 @@ void CheckGlazingShadingStatusChange(EnergyPlusData &state) if (!state.dataGlobal->AndShadingControlInModel) return; for (int enclosureNum = 1; enclosureNum <= state.dataViewFactor->NumOfSolarEnclosures; ++enclosureNum) { for (int const SurfNum : state.dataViewFactor->EnclRadInfo(enclosureNum).SurfacePtr) { + auto &surf = state.dataSurface->Surface(SurfNum); bool surfShadingStatusChange = state.dataSurface->SurfWinExtIntShadePrevTS(SurfNum) != state.dataSurface->SurfWinShadingFlag(SurfNum) || - state.dataSurface->Surface(SurfNum).activeShadedConstruction != state.dataSurface->Surface(SurfNum).activeShadedConstructionPrev || + surf.activeShadedConstruction != surf.activeShadedConstructionPrev || state.dataSurface->SurfWinMovableSlats(SurfNum); if (surfShadingStatusChange) { state.dataViewFactor->EnclSolInfo(enclosureNum).radReCalc = true; @@ -10401,6 +10406,7 @@ void SkyDifSolarShading(EnergyPlusData &state) } for (int SurfNum : state.dataSurface->AllExtSolarSurfaceList) { + auto &surf = state.dataSurface->Surface(SurfNum); // CurrentModuleObject='Surfaces' if (detailedShading) { @@ -10410,7 +10416,7 @@ void SkyDifSolarShading(EnergyPlusData &state) state.dataSolarShading->SurfCurDifShdgRatioIsoSky(SurfNum), OutputProcessor::SOVTimeStepType::Zone, OutputProcessor::SOVStoreType::Average, - state.dataSurface->Surface(SurfNum).Name); + surf.Name); } else { SetupOutputVariable(state, "Debug Surface Solar Shading Model DifShdgRatioIsoSky", @@ -10418,7 +10424,7 @@ void SkyDifSolarShading(EnergyPlusData &state) state.dataSolarShading->SurfDifShdgRatioIsoSky(SurfNum), OutputProcessor::SOVTimeStepType::Zone, OutputProcessor::SOVStoreType::Average, - state.dataSurface->Surface(SurfNum).Name); + surf.Name); } SetupOutputVariable(state, "Debug Surface Solar Shading Model DifShdgRatioHoriz", @@ -10426,21 +10432,21 @@ void SkyDifSolarShading(EnergyPlusData &state) state.dataSolarShading->SurfDifShdgRatioHoriz(SurfNum), OutputProcessor::SOVTimeStepType::Zone, OutputProcessor::SOVStoreType::Average, - state.dataSurface->Surface(SurfNum).Name); + surf.Name); SetupOutputVariable(state, "Debug Surface Solar Shading Model WithShdgIsoSky", OutputProcessor::Unit::None, state.dataSolarShading->SurfWithShdgIsoSky(SurfNum), OutputProcessor::SOVTimeStepType::Zone, OutputProcessor::SOVStoreType::Average, - state.dataSurface->Surface(SurfNum).Name); + surf.Name); SetupOutputVariable(state, "Debug Surface Solar Shading Model WoShdgIsoSky", OutputProcessor::Unit::None, state.dataSolarShading->SurfWoShdgIsoSky(SurfNum), OutputProcessor::SOVTimeStepType::Zone, OutputProcessor::SOVStoreType::Average, - state.dataSurface->Surface(SurfNum).Name); + surf.Name); } for (int IPhi = 0; IPhi < NPhi; ++IPhi) { // Loop over patch altitude values @@ -10451,21 +10457,24 @@ void SkyDifSolarShading(EnergyPlusData &state) state.dataSolarShading->SUNCOS(2) = state.dataSolarShading->cos_Phi[IPhi] * state.dataSolarShading->sin_Theta[ITheta]; for (int SurfNum : state.dataSurface->AllExtSolAndShadingSurfaceList) { + auto &surf = state.dataSurface->Surface(SurfNum); + // Cosine of angle of incidence on surface of solar radiation from patch state.dataSolarShading->SurfSunCosTheta(SurfNum) = - state.dataSolarShading->SUNCOS(1) * state.dataSurface->Surface(SurfNum).OutNormVec(1) + - state.dataSolarShading->SUNCOS(2) * state.dataSurface->Surface(SurfNum).OutNormVec(2) + - state.dataSolarShading->SUNCOS(3) * state.dataSurface->Surface(SurfNum).OutNormVec(3); + state.dataSolarShading->SUNCOS.x * surf.OutNormVec.x + + state.dataSolarShading->SUNCOS.y * surf.OutNormVec.y + + state.dataSolarShading->SUNCOS.z * surf.OutNormVec.z; } SHADOW(state, 24, 0); for (int SurfNum : state.dataSurface->AllExtSolAndShadingSurfaceList) { + auto &surf = state.dataSurface->Surface(SurfNum); if (state.dataSolarShading->SurfSunCosTheta(SurfNum) < 0.0) continue; Fac1WoShdg = state.dataSolarShading->cos_Phi[IPhi] * DThetaDPhi * state.dataSolarShading->SurfSunCosTheta(SurfNum); - SurfArea = state.dataSurface->Surface(SurfNum).NetAreaShadowCalc; + SurfArea = surf.NetAreaShadowCalc; if (SurfArea > Eps) { FracIlluminated = state.dataSolarShading->SurfSunlitArea(SurfNum) / SurfArea; } else { @@ -10590,17 +10599,16 @@ void CalcWindowProfileAngles(EnergyPlusData &state) int const firstSurfWin = thisSpace.WindowSurfaceFirst; int const lastSurfWin = thisSpace.WindowSurfaceLast; for (int SurfNum = firstSurfWin; SurfNum <= lastSurfWin; ++SurfNum) { - - if (state.dataSurface->Surface(SurfNum).ExtBoundCond != ExternalEnvironment && - state.dataSurface->Surface(SurfNum).ExtBoundCond != OtherSideCondModeledExt) + auto &surf = state.dataSurface->Surface(SurfNum); + if (surf.ExtBoundCond != ExternalEnvironment && surf.ExtBoundCond != OtherSideCondModeledExt) continue; state.dataSurface->SurfWinProfileAngHor(SurfNum) = 0.0; state.dataSurface->SurfWinProfileAngVert(SurfNum) = 0.0; if (state.dataHeatBal->SurfCosIncAng(state.dataGlobal->HourOfDay, state.dataGlobal->TimeStep, SurfNum) <= 0.0) continue; - ElevWin = Constant::PiOvr2 - state.dataSurface->Surface(SurfNum).Tilt * Constant::DegToRadians; - AzimWin = state.dataSurface->Surface(SurfNum).Azimuth * Constant::DegToRadians; + ElevWin = Constant::PiOvr2 - surf.Tilt * Constant::DegToRadians; + AzimWin = surf.Azimuth * Constant::DegToRadians; ProfileAngHor = std::atan(sin_ElevSun / std::abs(cos_ElevSun * std::cos(AzimWin - AzimSun))) - ElevWin; @@ -10609,7 +10617,7 @@ void CalcWindowProfileAngles(EnergyPlusData &state) // IF(ABS(ElevWin) < 0.1d0) THEN ! Near-vertical window // ProfileAngVert = ABS(AzimWin-AzimSun) // ELSE - WinNorm = state.dataSurface->Surface(SurfNum).OutNormVec; + WinNorm = surf.OutNormVec; ThWin = AzimWin - Constant::PiOvr2; Real64 const sin_Elevwin(std::sin(ElevWin)); WinNormCrossBase.x = -(sin_Elevwin * std::cos(ThWin)); @@ -10737,17 +10745,18 @@ void CalcFrameDividerShadow(EnergyPlusData &state, DivProjOut = state.dataSurface->FrameDivider(FrDivNum).DividerProjectionOut; DivProjIn = state.dataSurface->FrameDivider(FrDivNum).DividerProjectionIn; - GlArea = state.dataSurface->Surface(SurfNum).Area; - ElevWin = Constant::PiOvr2 - state.dataSurface->Surface(SurfNum).Tilt * Constant::DegToRadians; + auto &surf = state.dataSurface->Surface(SurfNum); + GlArea = surf.Area; + ElevWin = Constant::PiOvr2 - surf.Tilt * Constant::DegToRadians; ElevSun = Constant::PiOvr2 - std::acos(state.dataSolarShading->SUNCOS(3)); - AzimWin = state.dataSurface->Surface(SurfNum).Azimuth * Constant::DegToRadians; + AzimWin = surf.Azimuth * Constant::DegToRadians; AzimSun = std::atan2(state.dataSolarShading->SUNCOS(1), state.dataSolarShading->SUNCOS(2)); ProfileAngHor = std::atan(std::sin(ElevSun) / std::abs(std::cos(ElevSun) * std::cos(AzimWin - AzimSun))) - ElevWin; if (std::abs(ElevWin) < 0.1) { // Near-vertical window ProfileAngVert = std::abs(AzimWin - AzimSun); } else { - WinNorm = state.dataSurface->Surface(SurfNum).OutNormVec; + WinNorm = surf.OutNormVec; ThWin = AzimWin - Constant::PiOvr2; WinNormCrossBase(1) = -std::sin(ElevWin) * std::cos(ThWin); WinNormCrossBase(2) = std::sin(ElevWin) * std::sin(ThWin); @@ -10765,8 +10774,8 @@ void CalcFrameDividerShadow(EnergyPlusData &state, FrWidth = state.dataSurface->FrameDivider(FrDivNum).FrameWidth; DivWidth = state.dataSurface->FrameDivider(FrDivNum).DividerWidth; - Arealite = (state.dataSurface->Surface(SurfNum).Height / (NHorDiv + 1.0) - DivWidth / 2.0) * - (state.dataSurface->Surface(SurfNum).Width / (NVertDiv + 1.0) - DivWidth / 2.0); + Arealite = (surf.Height / (NHorDiv + 1.0) - DivWidth / 2.0) * + (surf.Width / (NVertDiv + 1.0) - DivWidth / 2.0); if (DivProjOut > 0.0 || DivProjIn > 0.0) { ArealiteCol = (NHorDiv + 1) * Arealite; ArealiteRow = (NVertDiv + 1) * Arealite; @@ -10790,12 +10799,12 @@ void CalcFrameDividerShadow(EnergyPlusData &state, if (DivProjOut > 0.0 || DivProjIn > 0.0) { // Shaded area from all vertical dividers - AshVDout = NVertDiv * min((state.dataSurface->Surface(SurfNum).Height - NHorDiv * DivWidth) * DivProjOut * TanProfileAngVert, ArealiteCol); - AshVDin = NVertDiv * min((state.dataSurface->Surface(SurfNum).Height - NHorDiv * DivWidth) * DivProjIn * TanProfileAngVert, ArealiteCol); + AshVDout = NVertDiv * min((surf.Height - NHorDiv * DivWidth) * DivProjOut * TanProfileAngVert, ArealiteCol); + AshVDin = NVertDiv * min((surf.Height - NHorDiv * DivWidth) * DivProjIn * TanProfileAngVert, ArealiteCol); // Shaded area from all horizontal dividers - AshHDout = NHorDiv * min((state.dataSurface->Surface(SurfNum).Width - NVertDiv * DivWidth) * DivProjOut * TanProfileAngHor, ArealiteRow); - AshHDin = NHorDiv * min((state.dataSurface->Surface(SurfNum).Width - NVertDiv * DivWidth) * DivProjIn * TanProfileAngHor, ArealiteRow); + AshHDout = NHorDiv * min((surf.Width - NVertDiv * DivWidth) * DivProjOut * TanProfileAngHor, ArealiteRow); + AshHDin = NHorDiv * min((surf.Width - NVertDiv * DivWidth) * DivProjIn * TanProfileAngHor, ArealiteRow); // Horizontal divider/vertical divider shadow overlap AshDDover = min(DivProjOut * TanProfileAngHor * DivProjOut * TanProfileAngVert, Arealite) * NHorDiv * NVertDiv; @@ -10806,14 +10815,14 @@ void CalcFrameDividerShadow(EnergyPlusData &state, // Shaded area from sides of frame; to avoid complications from possible overlaps between // shadow from side of frame and shadow from vertical divider the shaded area from side of // frame is restricted to the area of one column of lites. - AshVFout = min((state.dataSurface->Surface(SurfNum).Height - NHorDiv * DivWidth) * FrProjOut * TanProfileAngVert, ArealiteCol); - AshVFin = min((state.dataSurface->Surface(SurfNum).Height - NHorDiv * DivWidth) * FrProjIn * TanProfileAngVert, ArealiteCol); + AshVFout = min((surf.Height - NHorDiv * DivWidth) * FrProjOut * TanProfileAngVert, ArealiteCol); + AshVFin = min((surf.Height - NHorDiv * DivWidth) * FrProjIn * TanProfileAngVert, ArealiteCol); // Shaded area from top or bottom of frame; to avoid complications from possible overlaps // between shadow from top or bottom of frame and shadow from horizontal divider, the shaded // area from the top or bottom of frame is restricted to the area of one row of lites. - AshHFout = min((state.dataSurface->Surface(SurfNum).Width - NVertDiv * DivWidth) * FrProjOut * TanProfileAngHor, ArealiteRow); - AshHFin = min((state.dataSurface->Surface(SurfNum).Width - NVertDiv * DivWidth) * FrProjIn * TanProfileAngHor, ArealiteRow); + AshHFout = min((surf.Width - NVertDiv * DivWidth) * FrProjOut * TanProfileAngHor, ArealiteRow); + AshHFin = min((surf.Width - NVertDiv * DivWidth) * FrProjIn * TanProfileAngHor, ArealiteRow); // Top/bottom of frame/side of frame shadow overlap AshFFover = min(FrProjOut * TanProfileAngHor * FrProjOut * TanProfileAngVert, Arealite); @@ -11000,13 +11009,14 @@ void CalcBeamSolarOnWinRevealSurface(EnergyPlusData &state) state.dataSurface->SurfWinInsRevealDiffIntoZone(SurfNum) = 0.0; state.dataSurface->SurfWinInsRevealDiffIntoZoneReport(SurfNum) = 0.0; - if ((state.dataSurface->Surface(SurfNum).ExtBoundCond != ExternalEnvironment && - state.dataSurface->Surface(SurfNum).ExtBoundCond != OtherSideCondModeledExt)) + auto &surf = state.dataSurface->Surface(SurfNum); + if ((surf.ExtBoundCond != ExternalEnvironment && + surf.ExtBoundCond != OtherSideCondModeledExt)) continue; - if (state.dataSurface->Surface(SurfNum).Reveal == 0.0 && state.dataSurface->SurfWinInsideReveal(SurfNum) == 0.0 && + if (surf.Reveal == 0.0 && state.dataSurface->SurfWinInsideReveal(SurfNum) == 0.0 && state.dataSurface->SurfWinInsideSillDepth(SurfNum) == 0.0) continue; - if (state.dataSurface->Surface(SurfNum).Sides != 4) continue; + if (surf.Sides != 4) continue; if (state.dataSurface->SurfWinInsideSillDepth(SurfNum) < state.dataSurface->SurfWinInsideReveal(SurfNum)) continue; ShadeFlag = state.dataSurface->SurfWinShadingFlag(SurfNum); @@ -11021,21 +11031,21 @@ void CalcBeamSolarOnWinRevealSurface(EnergyPlusData &state) // assumed to be perpendicular to window plane CosBetaBottom = - -state.dataEnvrn->SOLCOS(1) * state.dataSurface->Surface(SurfNum).SinAzim * state.dataSurface->Surface(SurfNum).CosTilt - - state.dataEnvrn->SOLCOS(2) * state.dataSurface->Surface(SurfNum).CosAzim * state.dataSurface->Surface(SurfNum).CosTilt + - state.dataEnvrn->SOLCOS(3) * state.dataSurface->Surface(SurfNum).SinTilt; + -state.dataEnvrn->SOLCOS(1) * surf.SinAzim * surf.CosTilt - + state.dataEnvrn->SOLCOS(2) * surf.CosAzim * surf.CosTilt + + state.dataEnvrn->SOLCOS(3) * surf.SinTilt; - CosBetaLeft = -state.dataEnvrn->SOLCOS(1) * state.dataSurface->Surface(SurfNum).CosAzim - - state.dataEnvrn->SOLCOS(2) * state.dataSurface->Surface(SurfNum).SinAzim; + CosBetaLeft = -state.dataEnvrn->SOLCOS(1) * surf.CosAzim - + state.dataEnvrn->SOLCOS(2) * surf.SinAzim; // Note: CosBetaTop = -CosBetaBottom, CosBetaRight = -CosBetaLeft - OutsReveal = state.dataSurface->Surface(SurfNum).Reveal; + OutsReveal = surf.Reveal; InsReveal = state.dataSurface->SurfWinInsideReveal(SurfNum); InsideRevealSolAbs = 0.0; GlazingThickness = state.dataSurface->SurfWinTotGlazingThickness(SurfNum); - H = state.dataSurface->Surface(SurfNum).Height; - W = state.dataSurface->Surface(SurfNum).Width; + H = surf.Height; + W = surf.Width; d1 = OutsReveal + 0.5 * GlazingThickness; ConstrNum = state.dataSurface->SurfActiveConstruction(SurfNum); ConstrNumSh = state.dataSurface->SurfWinActiveShadedConstruction(SurfNum); @@ -11045,7 +11055,7 @@ void CalcBeamSolarOnWinRevealSurface(EnergyPlusData &state) thisConstruct.TransSolBeamCoef); TanProfileAngVert = state.dataSurface->SurfWinTanProfileAngVert(SurfNum); TanProfileAngHor = state.dataSurface->SurfWinTanProfileAngHor(SurfNum); - FrameDivNum = state.dataSurface->Surface(SurfNum).FrameDivider; + FrameDivNum = surf.FrameDivider; FrameWidth = 0.0; if (FrameDivNum != 0) { FrameWidth = state.dataSurface->FrameDivider(FrameDivNum).FrameWidth; @@ -11073,7 +11083,7 @@ void CalcBeamSolarOnWinRevealSurface(EnergyPlusData &state) TanAlpha = TanProfileAngHor; TanGamma = TanProfileAngVert; CosBeta = std::abs(CosBetaLeft); - L = state.dataSurface->Surface(SurfNum).Height; + L = surf.Height; d2 = InsReveal + 0.5 * GlazingThickness; d2prime = d1 + d2 - W / TanGamma; InsideRevealSolAbs = state.dataSurface->SurfWinInsideRevealSolAbs(SurfNum); @@ -11082,7 +11092,7 @@ void CalcBeamSolarOnWinRevealSurface(EnergyPlusData &state) TanAlpha = TanProfileAngVert; TanGamma = TanProfileAngHor; CosBeta = std::abs(CosBetaBottom); - L = state.dataSurface->Surface(SurfNum).Width; + L = surf.Width; if (CosBetaBottom > 0.0) { // Bottom reveal surfaces may be illuminated d2 = InsSillDepth + 0.5 * GlazingThickness; InsideRevealSolAbs = state.dataSurface->SurfWinInsideSillSolAbs(SurfNum); @@ -11252,7 +11262,7 @@ void CalcBeamSolarOnWinRevealSurface(EnergyPlusData &state) // Reflected solar from outside horizontal and vertical reveal incident on glazing state.dataSurface->SurfWinOutsRevealDiffOntoGlazing(SurfNum) += - FracToGlassOuts * BmSolRefldOutsReveal / state.dataSurface->Surface(SurfNum).Area; + FracToGlassOuts * BmSolRefldOutsReveal / surf.Area; if (FrameWidth > 0.0) { // Reflected solar from outside horizontal and vertical reveal incident on frame @@ -11301,7 +11311,7 @@ void CalcBeamSolarOnWinRevealSurface(EnergyPlusData &state) // Reflected solar from inside horizontal and vertical reveal incident on glazing state.dataSurface->SurfWinInsRevealDiffOntoGlazing(SurfNum) += - FracToGlassIns * BmSolRefldInsReveal / state.dataSurface->Surface(SurfNum).Area; + FracToGlassIns * BmSolRefldInsReveal / surf.Area; // Added TH 5/26/2009 for reporting purpose - diffuse on window glass from inside // reveal (W) @@ -11383,11 +11393,13 @@ void ReportSurfaceShading(EnergyPlusData &state) int RepCol; // the column of the predefined report for (SurfNum = 1; SurfNum <= state.dataSurface->TotSurfaces; ++SurfNum) { + auto &surf = state.dataSurface->Surface(SurfNum); + state.dataSurface->SurfSunlitFrac(SurfNum) = state.dataHeatBal->SurfSunlitFrac(state.dataGlobal->HourOfDay, state.dataGlobal->TimeStep, SurfNum); state.dataSurface->SurfSunlitArea(SurfNum) = state.dataHeatBal->SurfSunlitFrac(state.dataGlobal->HourOfDay, state.dataGlobal->TimeStep, SurfNum) * - state.dataSurface->Surface(SurfNum).Area; + surf.Area; } // added for predefined reporting RepCol = 0; @@ -11418,8 +11430,9 @@ void ReportSurfaceShading(EnergyPlusData &state) } if (RepCol != 0) { for (SurfNum = 1; SurfNum <= state.dataSurface->TotSurfaces; ++SurfNum) { - if (state.dataSurface->Surface(SurfNum).Class == SurfaceClass::Window) { - PreDefTableEntry(state, RepCol, state.dataSurface->Surface(SurfNum).Name, state.dataSurface->SurfSunlitFrac(SurfNum)); + auto &surf = state.dataSurface->Surface(SurfNum); + if (surf.Class == SurfaceClass::Window) { + PreDefTableEntry(state, RepCol, surf.Name, state.dataSurface->SurfSunlitFrac(SurfNum)); } } } @@ -11627,15 +11640,16 @@ void ComputeWinShadeAbsorpFactors(EnergyPlusData &state) int const firstSurfWin = thisSpace.WindowSurfaceFirst; int const lastSurfWin = thisSpace.WindowSurfaceLast; for (int SurfNum = firstSurfWin; SurfNum <= lastSurfWin; ++SurfNum) { - if (state.dataSurface->Surface(SurfNum).Class == SurfaceClass::Window && state.dataSurface->Surface(SurfNum).HasShadeControl) { - int WinShadeCtrlNum = state.dataSurface->Surface(SurfNum).activeWindowShadingControl; // Window shading control number + auto &surf = state.dataSurface->Surface(SurfNum); + if (surf.Class == SurfaceClass::Window && surf.HasShadeControl) { + int WinShadeCtrlNum = surf.activeWindowShadingControl; // Window shading control number int MatNumSh = 0; // Shade layer material number Real64 AbsorpEff = 0.0; // Effective absorptance of isolated shade layer (fraction of // of incident radiation remaining after reflected portion is // removed that is absorbed if (ANY_SHADE(state.dataSurface->WindowShadingControl(WinShadeCtrlNum).ShadingType)) { - int const ConstrNumSh = state.dataSurface->Surface(SurfNum).activeShadedConstruction; // Window construction number with shade + int const ConstrNumSh = surf.activeShadedConstruction; // Window construction number with shade int TotLay = state.dataConstruction->Construct(ConstrNumSh).TotLayers; // Total layers in a construction if (state.dataSurface->WindowShadingControl(WinShadeCtrlNum).ShadingType == WinShadingType::IntShade) { @@ -11763,9 +11777,10 @@ void CalcWinTransDifSolInitialDistribution(EnergyPlusData &state) // Loop over all diffuse solar transmitting surfaces (i.e., exterior windows and TDDs) in the current zone for (int const DifTransSurfNum : thisEnclosure.SurfacePtr) { // Skip surfaces that are not exterior, except for TDD_Diffusers - if (((state.dataSurface->Surface(DifTransSurfNum).ExtBoundCond != ExternalEnvironment) && - (state.dataSurface->Surface(DifTransSurfNum).ExtBoundCond != OtherSideCondModeledExt)) && - state.dataSurface->SurfWinOriginalClass(DifTransSurfNum) != SurfaceClass::TDD_Diffuser) + auto &difTransSurf = state.dataSurface->Surface(DifTransSurfNum); + if ((difTransSurf.ExtBoundCond != ExternalEnvironment) && + (difTransSurf.ExtBoundCond != OtherSideCondModeledExt) && + (difTransSurf.OriginalClass != SurfaceClass::TDD_Diffuser)) continue; // Do I need to do anything special for TDDs? @@ -11774,8 +11789,7 @@ void CalcWinTransDifSolInitialDistribution(EnergyPlusData &state) // } // Skip surfaces that are not exterior windows or TDD diffusers - if (state.dataSurface->Surface(DifTransSurfNum).Class != SurfaceClass::Window && - state.dataSurface->SurfWinOriginalClass(DifTransSurfNum) != SurfaceClass::TDD_Diffuser) + if (difTransSurf.Class != SurfaceClass::Window && difTransSurf.OriginalClass != SurfaceClass::TDD_Diffuser) continue; //---------------------------------------------------------------------------------------------------------- diff --git a/src/EnergyPlus/SurfaceGeometry.cc b/src/EnergyPlus/SurfaceGeometry.cc index a44115564f3..ab14b64db4b 100644 --- a/src/EnergyPlus/SurfaceGeometry.cc +++ b/src/EnergyPlus/SurfaceGeometry.cc @@ -218,7 +218,6 @@ namespace SurfaceGeometry { state.dataSurface->SurfWinGlazedFrac.dimension(NumSurfaces, 1); state.dataSurface->SurfWinCenterGlArea.dimension(NumSurfaces, 0); state.dataSurface->SurfWinEdgeGlCorrFac.dimension(NumSurfaces, 1); - state.dataSurface->SurfWinOriginalClass.dimension(NumSurfaces, SurfaceClass::None); state.dataSurface->SurfWinShadeAbsFacFace1.dimension(NumSurfaces, 0.5); state.dataSurface->SurfWinShadeAbsFacFace2.dimension(NumSurfaces, 0.5); state.dataSurface->SurfWinConvCoeffWithShade.dimension(NumSurfaces, 0); @@ -2431,35 +2430,36 @@ namespace SurfaceGeometry { } for (int SurfNum = 1; SurfNum <= MovedSurfs; ++SurfNum) { // TotSurfaces + auto &surf = state.dataSurface->Surface(SurfNum); // GLASSDOORs and TDD:DIFFUSERs will be treated as windows in the subsequent heat transfer and daylighting // calculations. Reset class to 'Window' after saving the original designation in SurfaceWindow. - state.dataSurface->SurfWinOriginalClass(SurfNum) = state.dataSurface->Surface(SurfNum).Class; + surf.OriginalClass = surf.Class; - if (state.dataSurface->Surface(SurfNum).Class == SurfaceClass::GlassDoor || - state.dataSurface->Surface(SurfNum).Class == SurfaceClass::TDD_Diffuser) - state.dataSurface->Surface(SurfNum).Class = SurfaceClass::Window; + if (surf.Class == SurfaceClass::GlassDoor || + surf.Class == SurfaceClass::TDD_Diffuser) + surf.Class = SurfaceClass::Window; - if (state.dataSurface->Surface(SurfNum).Class == SurfaceClass::TDD_Dome) { + if (surf.Class == SurfaceClass::TDD_Dome) { // Reset the TDD:DOME subsurface to act as a base surface that can shade and be shaded // NOTE: This must be set early so that subsequent shading calculations are done correctly - state.dataSurface->Surface(SurfNum).BaseSurf = SurfNum; + surf.BaseSurf = SurfNum; } } errFlag = false; if (!SurfError) { for (int SurfNum = 1; SurfNum <= MovedSurfs; ++SurfNum) { // TotSurfaces - if (state.dataSurface->Surface(SurfNum).HasShadeControl) { - WinShadingControlPtr = - state.dataSurface->Surface(SurfNum).activeWindowShadingControl; // use first item since others should be identical + auto &surf = state.dataSurface->Surface(SurfNum); + if (surf.HasShadeControl) { + WinShadingControlPtr = surf.activeWindowShadingControl; // use first item since others should be identical if (state.dataSurface->WindowShadingControl(WinShadingControlPtr).slatAngleControl != SlatAngleControl::Fixed) { state.dataSurface->SurfWinMovableSlats(SurfNum) = true; state.dataSurface->AnyMovableSlat = true; state.dataHeatBalSurf->SurfMovSlatsIndexList.push_back(SurfNum); } - ConstrNumSh = state.dataSurface->Surface(SurfNum).activeShadedConstruction; + ConstrNumSh = surf.activeShadedConstruction; if (ConstrNumSh <= 0) continue; WinShadingType ShadingType = state.dataSurface->WindowShadingControl(WinShadingControlPtr).ShadingType; @@ -2551,24 +2551,24 @@ namespace SurfaceGeometry { LayNumOutside = 0; for (int SurfNum = 1; SurfNum <= state.dataSurface->TotSurfaces; ++SurfNum) { + auto &surf = state.dataSurface->Surface(SurfNum); // Check for EcoRoof and only 1 allowed to be used. - if (state.dataSurface->Surface(SurfNum).Construction > 0) - state.dataSurface->SurfExtEcoRoof(SurfNum) = - state.dataConstruction->Construct(state.dataSurface->Surface(SurfNum).Construction).TypeIsEcoRoof; + if (surf.Construction > 0) + state.dataSurface->SurfExtEcoRoof(SurfNum) = state.dataConstruction->Construct(surf.Construction).TypeIsEcoRoof; if (!state.dataSurface->SurfExtEcoRoof(SurfNum)) continue; if (LayNumOutside == 0) { - LayNumOutside = state.dataConstruction->Construct(state.dataSurface->Surface(SurfNum).Construction).LayerPoint(1); + LayNumOutside = state.dataConstruction->Construct(surf.Construction).LayerPoint(1); continue; } - if (LayNumOutside != state.dataConstruction->Construct(state.dataSurface->Surface(SurfNum).Construction).LayerPoint(1)) { + if (LayNumOutside != state.dataConstruction->Construct(surf.Construction).LayerPoint(1)) { ShowSevereError(state, format("{}Only one EcoRoof Material is currently allowed for all constructions.", RoutineName)); ShowContinueError(state, format("... first material={}", state.dataMaterial->Material(LayNumOutside)->Name)); ShowContinueError( state, format("... conflicting Construction={} uses material={}", - state.dataConstruction->Construct(state.dataSurface->Surface(SurfNum).Construction).Name, + state.dataConstruction->Construct(surf.Construction).Name, state.dataMaterial - ->Material(state.dataConstruction->Construct(state.dataSurface->Surface(SurfNum).Construction).LayerPoint(1)) + ->Material(state.dataConstruction->Construct(surf.Construction).LayerPoint(1)) ->Name)); ErrorsFound = true; } @@ -2588,24 +2588,25 @@ namespace SurfaceGeometry { // Set flag that determines whether a surface can be an exterior obstruction // Also set associated surfaces for Kiva foundations and build heat transfer surface lists for (int SurfNum = 1; SurfNum <= state.dataSurface->TotSurfaces; ++SurfNum) { - state.dataSurface->Surface(SurfNum).IsShadowPossibleObstruction = false; - if (state.dataSurface->Surface(SurfNum).ExtSolar) { + auto &surf = state.dataSurface->Surface(SurfNum); + surf.IsShadowPossibleObstruction = false; + if (surf.ExtSolar) { // This may include some attached shading surfaces state.dataSurface->AllExtSolarSurfaceList.push_back(SurfNum); } - if (state.dataSurface->Surface(SurfNum).HeatTransSurf) { + if (surf.HeatTransSurf) { // Outside light shelves get tagged later as HeatTransSurf=true but they haven't been processed yet state.dataSurface->AllHTSurfaceList.push_back(SurfNum); - int const zoneNum(state.dataSurface->Surface(SurfNum).Zone); + int const zoneNum(surf.Zone); auto &surfZone(state.dataHeatBal->Zone(zoneNum)); surfZone.ZoneHTSurfaceList.push_back(SurfNum); // Sort window vs non-window surfaces - if (state.dataSurface->Surface(SurfNum).Class == DataSurfaces::SurfaceClass::Window) { + if (surf.Class == DataSurfaces::SurfaceClass::Window) { state.dataSurface->AllHTWindowSurfaceList.push_back(SurfNum); surfZone.ZoneHTWindowSurfaceList.push_back(SurfNum); - if (state.dataSurface->Surface(SurfNum).ExtSolar) { + if (surf.ExtSolar) { state.dataSurface->AllExtSolWindowSurfaceList.push_back(SurfNum); - if (state.dataSurface->Surface(SurfNum).FrameDivider > 0) { + if (surf.FrameDivider > 0) { state.dataSurface->AllExtSolWinWithFrameSurfaceList.push_back(SurfNum); } } @@ -2613,7 +2614,7 @@ namespace SurfaceGeometry { state.dataSurface->AllHTNonWindowSurfaceList.push_back(SurfNum); surfZone.ZoneHTNonWindowSurfaceList.push_back(SurfNum); } - int const surfExtBoundCond(state.dataSurface->Surface(SurfNum).ExtBoundCond); + int const surfExtBoundCond(surf.ExtBoundCond); // Build zone and interzone surface lists if ((surfExtBoundCond > 0) && (surfExtBoundCond != SurfNum)) { state.dataSurface->AllIZSurfaceList.push_back(SurfNum); @@ -2622,7 +2623,7 @@ namespace SurfaceGeometry { adjZone.ZoneHTSurfaceList.push_back(SurfNum); adjZone.ZoneIZSurfaceList.push_back(SurfNum); // Sort window vs non-window surfaces - if (state.dataSurface->Surface(SurfNum).Class == DataSurfaces::SurfaceClass::Window) { + if (surf.Class == DataSurfaces::SurfaceClass::Window) { adjZone.ZoneHTWindowSurfaceList.push_back(SurfNum); } else { adjZone.ZoneHTNonWindowSurfaceList.push_back(SurfNum); @@ -2631,29 +2632,29 @@ namespace SurfaceGeometry { } // Exclude non-exterior heat transfer surfaces (but not OtherSideCondModeledExt = -4 CR7640) - if (state.dataSurface->Surface(SurfNum).HeatTransSurf && state.dataSurface->Surface(SurfNum).ExtBoundCond > 0) continue; - if (state.dataSurface->Surface(SurfNum).HeatTransSurf && state.dataSurface->Surface(SurfNum).ExtBoundCond == Ground) continue; - if (state.dataSurface->Surface(SurfNum).HeatTransSurf && state.dataSurface->Surface(SurfNum).ExtBoundCond == KivaFoundation) { + if (surf.HeatTransSurf && surf.ExtBoundCond > 0) continue; + if (surf.HeatTransSurf && surf.ExtBoundCond == Ground) continue; + if (surf.HeatTransSurf && surf.ExtBoundCond == KivaFoundation) { state.dataSurface->AllHTKivaSurfaceList.push_back(SurfNum); if (!ErrorsFound) - state.dataSurfaceGeometry->kivaManager.foundationInputs[state.dataSurface->Surface(SurfNum).OSCPtr].surfaces.push_back( + state.dataSurfaceGeometry->kivaManager.foundationInputs[surf.OSCPtr].surfaces.push_back( SurfNum); continue; } - if (state.dataSurface->Surface(SurfNum).HeatTransSurf && state.dataSurface->Surface(SurfNum).ExtBoundCond == OtherSideCoefNoCalcExt) + if (surf.HeatTransSurf && surf.ExtBoundCond == OtherSideCoefNoCalcExt) continue; - if (state.dataSurface->Surface(SurfNum).HeatTransSurf && state.dataSurface->Surface(SurfNum).ExtBoundCond == OtherSideCoefCalcExt) + if (surf.HeatTransSurf && surf.ExtBoundCond == OtherSideCoefCalcExt) continue; // Exclude windows and doors, i.e., consider only their base surfaces as possible obstructions - if (state.dataSurface->Surface(SurfNum).Class == SurfaceClass::Window || - state.dataSurface->Surface(SurfNum).Class == SurfaceClass::Door) + if (surf.Class == SurfaceClass::Window || + surf.Class == SurfaceClass::Door) continue; // Exclude duplicate shading surfaces - if (state.dataSurface->Surface(SurfNum).MirroredSurf) continue; + if (surf.MirroredSurf) continue; // Exclude air boundary surfaces - if (state.dataSurface->Surface(SurfNum).IsAirBoundarySurf) continue; + if (surf.IsAirBoundarySurf) continue; - state.dataSurface->Surface(SurfNum).IsShadowPossibleObstruction = true; + surf.IsShadowPossibleObstruction = true; state.dataSurface->AllShadowPossObstrSurfaceList.push_back(SurfNum); } @@ -2663,10 +2664,11 @@ namespace SurfaceGeometry { state.dataConstruction->Construct.end(), [](Construction::ConstructionProps const &e) { return e.TypeIsIRT; })) { for (int SurfNum = 1; SurfNum <= state.dataSurface->TotSurfaces; ++SurfNum) { - if (!state.dataSurface->Surface(SurfNum).HeatTransSurf) continue; // ignore shading surfaces - if (state.dataSurface->Surface(SurfNum).ExtBoundCond > 0 && state.dataSurface->Surface(SurfNum).ExtBoundCond != SurfNum) + auto &surf = state.dataSurface->Surface(SurfNum); + if (!surf.HeatTransSurf) continue; // ignore shading surfaces + if (surf.ExtBoundCond > 0 && surf.ExtBoundCond != SurfNum) continue; // interzone, not adiabatic surface - if (!state.dataConstruction->Construct(state.dataSurface->Surface(SurfNum).Construction).TypeIsIRT) { + if (!state.dataConstruction->Construct(surf.Construction).TypeIsIRT) { continue; } if (!state.dataGlobal->DisplayExtraWarnings) { @@ -2675,7 +2677,7 @@ namespace SurfaceGeometry { ShowWarningError(state, format("{}Surface=\"{}\" uses InfraredTransparent construction in a non-interzone surface. (illegal use)", RoutineName, - state.dataSurface->Surface(SurfNum).Name)); + surf.Name)); } } if (iTmp1 > 0) { @@ -2804,9 +2806,10 @@ namespace SurfaceGeometry { } for (int SurfNum = 1; SurfNum <= state.dataSurface->TotSurfaces; SurfNum++) { + auto &surf = state.dataSurface->Surface(SurfNum); // Initialize run time surface arrays - state.dataSurface->SurfActiveConstruction(SurfNum) = state.dataSurface->Surface(SurfNum).Construction; - state.dataSurface->Surface(SurfNum).RepresentativeCalcSurfNum = SurfNum; + state.dataSurface->SurfActiveConstruction(SurfNum) = surf.Construction; + surf.RepresentativeCalcSurfNum = SurfNum; } // Representative surface calculations: Assign representative heat transfer surfaces @@ -2824,7 +2827,7 @@ namespace SurfaceGeometry { state.dataConstruction->Construct(surface.Construction).SourceSinkPresent || surface.Class == SurfaceClass::TDD_Dome || (surface.Class == SurfaceClass::Window && - (state.dataSurface->SurfWinOriginalClass(surfNum) == SurfaceClass::TDD_Diffuser || + (surface.OriginalClass == SurfaceClass::TDD_Diffuser || state.dataSurface->SurfWinWindowModelType(surfNum) != WindowModel::Detailed || state.dataWindowManager->inExtWindowModel->isExternalLibraryModel() || state.dataConstruction->Construct(surface.Construction).TCFlag == 1)); @@ -2927,13 +2930,14 @@ namespace SurfaceGeometry { for (int spaceNum : state.dataHeatBal->Zone(ZoneNum).spaceIndexes) { auto &thisSpace = state.dataHeatBal->space(spaceNum); for (int SurfNum : thisSpace.surfaces) { + auto &surf = state.dataSurface->Surface(SurfNum); if (thisSpace.AllSurfaceFirst == 0) { thisSpace.AllSurfaceFirst = SurfNum; } thisSpace.AllSurfaceLast = SurfNum; - if (state.dataSurface->Surface(SurfNum).IsAirBoundarySurf) { - state.dataSurface->Surface(SurfNum).HeatTransSurf = false; + if (surf.IsAirBoundarySurf) { + surf.HeatTransSurf = false; continue; } // Non window surfaces are grouped next within each space @@ -2945,19 +2949,19 @@ namespace SurfaceGeometry { thisSpace.HTSurfaceLast = SurfNum; // Window surfaces are grouped next within each space - if ((state.dataSurface->Surface(SurfNum).Class == DataSurfaces::SurfaceClass::Window) || - (state.dataSurface->Surface(SurfNum).Class == DataSurfaces::SurfaceClass::GlassDoor) || - (state.dataSurface->Surface(SurfNum).Class == DataSurfaces::SurfaceClass::TDD_Diffuser)) { + if ((surf.Class == DataSurfaces::SurfaceClass::Window) || + (surf.Class == DataSurfaces::SurfaceClass::GlassDoor) || + (surf.Class == DataSurfaces::SurfaceClass::TDD_Diffuser)) { if (thisSpace.WindowSurfaceFirst == 0) { thisSpace.WindowSurfaceFirst = SurfNum; } thisSpace.WindowSurfaceLast = SurfNum; - } else if (state.dataSurface->Surface(SurfNum).Class != DataSurfaces::SurfaceClass::TDD_Dome) { + } else if (surf.Class != DataSurfaces::SurfaceClass::TDD_Dome) { thisSpace.OpaqOrIntMassSurfaceLast = SurfNum; } // TDDDome surfaces are grouped last within each space - if (state.dataSurface->Surface(SurfNum).Class == DataSurfaces::SurfaceClass::TDD_Dome) { + if (surf.Class == DataSurfaces::SurfaceClass::TDD_Dome) { if (thisSpace.TDDDomeFirst == 0) { thisSpace.TDDDomeFirst = SurfNum; } @@ -7457,11 +7461,12 @@ namespace SurfaceGeometry { // For shading surfaces, initialize value of reflectance values to default values. These values // may be overridden below for shading surfaces with an associated Shading Surface Reflectance object. for (SurfNum = 1; SurfNum <= state.dataSurface->TotSurfaces; ++SurfNum) { - if (!(state.dataSurface->Surface(SurfNum).Class == SurfaceClass::Shading || - state.dataSurface->Surface(SurfNum).Class == SurfaceClass::Detached_F || - state.dataSurface->Surface(SurfNum).Class == SurfaceClass::Detached_B || - state.dataSurface->Surface(SurfNum).Class == SurfaceClass::Overhang || - state.dataSurface->Surface(SurfNum).Class == SurfaceClass::Fin)) + auto const &surf = state.dataSurface->Surface(SurfNum); + if (!(surf.Class == SurfaceClass::Shading || + surf.Class == SurfaceClass::Detached_F || + surf.Class == SurfaceClass::Detached_B || + surf.Class == SurfaceClass::Overhang || + surf.Class == SurfaceClass::Fin)) continue; state.dataSurface->SurfShadowDiffuseSolRefl(SurfNum) = 0.2; state.dataSurface->SurfShadowDiffuseVisRefl(SurfNum) = 0.2; @@ -7501,17 +7506,18 @@ namespace SurfaceGeometry { // Check that associated surface is a shading surface WrongSurfaceType = false; if (SurfNum != 0) { - if (!(state.dataSurface->Surface(SurfNum).Class == SurfaceClass::Shading || - state.dataSurface->Surface(SurfNum).Class == SurfaceClass::Detached_F || - state.dataSurface->Surface(SurfNum).Class == SurfaceClass::Detached_B || - state.dataSurface->Surface(SurfNum).Class == SurfaceClass::Overhang || - state.dataSurface->Surface(SurfNum).Class == SurfaceClass::Fin)) + auto const &surf = state.dataSurface->Surface(SurfNum); + if (!(surf.Class == SurfaceClass::Shading || + surf.Class == SurfaceClass::Detached_F || + surf.Class == SurfaceClass::Detached_B || + surf.Class == SurfaceClass::Overhang || + surf.Class == SurfaceClass::Fin)) WrongSurfaceType = true; if (WrongSurfaceType) { ShowSevereError(state, format("GetShadingSurfReflectanceData: {}=\"{}\", surface is not a shading surface.", cCurrentModuleObject, - state.dataSurface->Surface(SurfNum).Name)); + surf.Name)); ErrorsFound = true; continue; } @@ -7563,19 +7569,20 @@ namespace SurfaceGeometry { "Visible Reflectance,Surface Glazing Fraction,Surface Glazing Contruction\n"); for (SurfNum = 1; SurfNum <= state.dataSurface->TotSurfaces; ++SurfNum) { - if (!(state.dataSurface->Surface(SurfNum).Class == SurfaceClass::Shading || - state.dataSurface->Surface(SurfNum).Class == SurfaceClass::Detached_F || - state.dataSurface->Surface(SurfNum).Class == SurfaceClass::Detached_B || - state.dataSurface->Surface(SurfNum).Class == SurfaceClass::Overhang || - state.dataSurface->Surface(SurfNum).Class == SurfaceClass::Fin)) + auto const &surf = state.dataSurface->Surface(SurfNum); + if (!(surf.Class == SurfaceClass::Shading || + surf.Class == SurfaceClass::Detached_F || + surf.Class == SurfaceClass::Detached_B || + surf.Class == SurfaceClass::Overhang || + surf.Class == SurfaceClass::Fin)) continue; constexpr std::string_view fmt = "ShadingProperty Reflectance,{},{},{:.2R},{:.2R},{:.2R}, {}\n"; if (state.dataSurface->SurfShadowGlazingConstruct(SurfNum) != 0) { print(state.files.eio, fmt, - state.dataSurface->Surface(SurfNum).Name, - cSurfaceClass(state.dataSurface->Surface(SurfNum).Class), + surf.Name, + cSurfaceClass(surf.Class), state.dataSurface->SurfShadowDiffuseSolRefl(SurfNum), state.dataSurface->SurfShadowDiffuseVisRefl(SurfNum), state.dataSurface->SurfShadowGlazingFrac(SurfNum), @@ -7583,8 +7590,8 @@ namespace SurfaceGeometry { } else { print(state.files.eio, fmt, - state.dataSurface->Surface(SurfNum).Name, - cSurfaceClass(state.dataSurface->Surface(SurfNum).Class), + surf.Name, + cSurfaceClass(surf.Class), state.dataSurface->SurfShadowDiffuseSolRefl(SurfNum), state.dataSurface->SurfShadowDiffuseVisRefl(SurfNum), state.dataSurface->SurfShadowGlazingFrac(SurfNum), @@ -8781,97 +8788,106 @@ namespace SurfaceGeometry { if (SELECT_CASE_var == "ALLEXTERIORSURFACES") { SurfacesOfType = false; for (SurfNum = 1; SurfNum <= state.dataSurface->TotSurfaces; ++SurfNum) { - if (!state.dataSurface->Surface(SurfNum).HeatTransSurf) continue; - if (state.dataSurface->Surface(SurfNum).ExtBoundCond > 0) continue; // Interior surfaces - if (state.dataConstruction->Construct(state.dataSurface->Surface(SurfNum).Construction).TypeIsWindow) continue; + auto &surf = state.dataSurface->Surface(SurfNum); + if (!surf.HeatTransSurf) continue; + if (surf.ExtBoundCond > 0) continue; // Interior surfaces + if (state.dataConstruction->Construct(surf.Construction).TypeIsWindow) continue; SurfacesOfType = true; - state.dataSurface->Surface(SurfNum).HeatTransferAlgorithm = tmpAlgoInput; + surf.HeatTransferAlgorithm = tmpAlgoInput; } } else if (SELECT_CASE_var == "ALLEXTERIORWALLS") { SurfacesOfType = false; for (SurfNum = 1; SurfNum <= state.dataSurface->TotSurfaces; ++SurfNum) { - if (!state.dataSurface->Surface(SurfNum).HeatTransSurf) continue; - if (state.dataSurface->Surface(SurfNum).ExtBoundCond > 0) continue; // Interior surfaces + auto &surf = state.dataSurface->Surface(SurfNum); + if (!surf.HeatTransSurf) continue; + if (surf.ExtBoundCond > 0) continue; // Interior surfaces - if (state.dataSurface->Surface(SurfNum).Class != SurfaceClass::Wall) continue; - if (state.dataConstruction->Construct(state.dataSurface->Surface(SurfNum).Construction).TypeIsWindow) continue; + if (surf.Class != SurfaceClass::Wall) continue; + if (state.dataConstruction->Construct(surf.Construction).TypeIsWindow) continue; SurfacesOfType = true; - state.dataSurface->Surface(SurfNum).HeatTransferAlgorithm = tmpAlgoInput; + surf.HeatTransferAlgorithm = tmpAlgoInput; } } else if (SELECT_CASE_var == "ALLEXTERIORROOFS") { SurfacesOfType = false; for (SurfNum = 1; SurfNum <= state.dataSurface->TotSurfaces; ++SurfNum) { - if (!state.dataSurface->Surface(SurfNum).HeatTransSurf) continue; - if (state.dataSurface->Surface(SurfNum).ExtBoundCond > 0) continue; // Interior surfaces - if (state.dataSurface->Surface(SurfNum).Class != SurfaceClass::Roof) continue; - if (state.dataConstruction->Construct(state.dataSurface->Surface(SurfNum).Construction).TypeIsWindow) continue; + auto &surf = state.dataSurface->Surface(SurfNum); + if (!surf.HeatTransSurf) continue; + if (surf.ExtBoundCond > 0) continue; // Interior surfaces + if (surf.Class != SurfaceClass::Roof) continue; + if (state.dataConstruction->Construct(surf.Construction).TypeIsWindow) continue; SurfacesOfType = true; - state.dataSurface->Surface(SurfNum).HeatTransferAlgorithm = tmpAlgoInput; + surf.HeatTransferAlgorithm = tmpAlgoInput; } } else if (SELECT_CASE_var == "ALLEXTERIORFLOORS") { SurfacesOfType = false; for (SurfNum = 1; SurfNum <= state.dataSurface->TotSurfaces; ++SurfNum) { - if (!state.dataSurface->Surface(SurfNum).HeatTransSurf) continue; - if (state.dataSurface->Surface(SurfNum).ExtBoundCond > 0) continue; // Interior surfaces - if (state.dataSurface->Surface(SurfNum).Class != SurfaceClass::Floor) continue; - if (state.dataConstruction->Construct(state.dataSurface->Surface(SurfNum).Construction).TypeIsWindow) continue; + auto &surf = state.dataSurface->Surface(SurfNum); + if (!surf.HeatTransSurf) continue; + if (surf.ExtBoundCond > 0) continue; // Interior surfaces + if (surf.Class != SurfaceClass::Floor) continue; + if (state.dataConstruction->Construct(surf.Construction).TypeIsWindow) continue; SurfacesOfType = true; - state.dataSurface->Surface(SurfNum).HeatTransferAlgorithm = tmpAlgoInput; + surf.HeatTransferAlgorithm = tmpAlgoInput; } } else if (SELECT_CASE_var == "ALLGROUNDCONTACTSURFACES") { SurfacesOfType = false; for (SurfNum = 1; SurfNum <= state.dataSurface->TotSurfaces; ++SurfNum) { - if (!state.dataSurface->Surface(SurfNum).HeatTransSurf) continue; - if (state.dataSurface->Surface(SurfNum).ExtBoundCond != Ground) continue; // ground BC - if (state.dataConstruction->Construct(state.dataSurface->Surface(SurfNum).Construction).TypeIsWindow) continue; + auto &surf = state.dataSurface->Surface(SurfNum); + if (!surf.HeatTransSurf) continue; + if (surf.ExtBoundCond != Ground) continue; // ground BC + if (state.dataConstruction->Construct(surf.Construction).TypeIsWindow) continue; SurfacesOfType = true; - state.dataSurface->Surface(SurfNum).HeatTransferAlgorithm = tmpAlgoInput; + surf.HeatTransferAlgorithm = tmpAlgoInput; } } else if (SELECT_CASE_var == "ALLINTERIORSURFACES") { SurfacesOfType = false; for (SurfNum = 1; SurfNum <= state.dataSurface->TotSurfaces; ++SurfNum) { - if (!state.dataSurface->Surface(SurfNum).HeatTransSurf) continue; - if (state.dataSurface->Surface(SurfNum).ExtBoundCond <= 0) continue; // Exterior surfaces - if (state.dataConstruction->Construct(state.dataSurface->Surface(SurfNum).Construction).TypeIsWindow) continue; + auto &surf = state.dataSurface->Surface(SurfNum); + if (!surf.HeatTransSurf) continue; + if (surf.ExtBoundCond <= 0) continue; // Exterior surfaces + if (state.dataConstruction->Construct(surf.Construction).TypeIsWindow) continue; SurfacesOfType = true; - state.dataSurface->Surface(SurfNum).HeatTransferAlgorithm = tmpAlgoInput; + surf.HeatTransferAlgorithm = tmpAlgoInput; } } else if (SELECT_CASE_var == "ALLINTERIORWALLS") { SurfacesOfType = false; for (SurfNum = 1; SurfNum <= state.dataSurface->TotSurfaces; ++SurfNum) { - if (!state.dataSurface->Surface(SurfNum).HeatTransSurf) continue; - if (state.dataSurface->Surface(SurfNum).ExtBoundCond <= 0) continue; // Exterior surfaces - if (state.dataSurface->Surface(SurfNum).Class != SurfaceClass::Wall) continue; - if (state.dataConstruction->Construct(state.dataSurface->Surface(SurfNum).Construction).TypeIsWindow) continue; + auto &surf = state.dataSurface->Surface(SurfNum); + if (!surf.HeatTransSurf) continue; + if (surf.ExtBoundCond <= 0) continue; // Exterior surfaces + if (surf.Class != SurfaceClass::Wall) continue; + if (state.dataConstruction->Construct(surf.Construction).TypeIsWindow) continue; SurfacesOfType = true; - state.dataSurface->Surface(SurfNum).HeatTransferAlgorithm = tmpAlgoInput; + surf.HeatTransferAlgorithm = tmpAlgoInput; } } else if ((SELECT_CASE_var == "ALLINTERIORROOFS") || (SELECT_CASE_var == "ALLINTERIORCEILINGS")) { SurfacesOfType = false; for (SurfNum = 1; SurfNum <= state.dataSurface->TotSurfaces; ++SurfNum) { - if (!state.dataSurface->Surface(SurfNum).HeatTransSurf) continue; - if (state.dataSurface->Surface(SurfNum).ExtBoundCond <= 0) continue; // Exterior surfaces - if (state.dataSurface->Surface(SurfNum).Class != SurfaceClass::Roof) continue; - if (state.dataConstruction->Construct(state.dataSurface->Surface(SurfNum).Construction).TypeIsWindow) continue; + auto &surf = state.dataSurface->Surface(SurfNum); + if (!surf.HeatTransSurf) continue; + if (surf.ExtBoundCond <= 0) continue; // Exterior surfaces + if (surf.Class != SurfaceClass::Roof) continue; + if (state.dataConstruction->Construct(surf.Construction).TypeIsWindow) continue; SurfacesOfType = true; - state.dataSurface->Surface(SurfNum).HeatTransferAlgorithm = tmpAlgoInput; + surf.HeatTransferAlgorithm = tmpAlgoInput; } } else if (SELECT_CASE_var == "ALLINTERIORFLOORS") { SurfacesOfType = false; for (SurfNum = 1; SurfNum <= state.dataSurface->TotSurfaces; ++SurfNum) { - if (!state.dataSurface->Surface(SurfNum).HeatTransSurf) continue; - if (state.dataSurface->Surface(SurfNum).ExtBoundCond <= 0) continue; // Exterior surfaces - if (state.dataSurface->Surface(SurfNum).Class != SurfaceClass::Floor) continue; - if (state.dataConstruction->Construct(state.dataSurface->Surface(SurfNum).Construction).TypeIsWindow) continue; + auto &surf = state.dataSurface->Surface(SurfNum); + if (!surf.HeatTransSurf) continue; + if (surf.ExtBoundCond <= 0) continue; // Exterior surfaces + if (surf.Class != SurfaceClass::Floor) continue; + if (state.dataConstruction->Construct(surf.Construction).TypeIsWindow) continue; SurfacesOfType = true; - state.dataSurface->Surface(SurfNum).HeatTransferAlgorithm = tmpAlgoInput; + surf.HeatTransferAlgorithm = tmpAlgoInput; } } else { SurfacesOfType = false; @@ -10711,9 +10727,10 @@ namespace SurfaceGeometry { ShowSevereError(state, format("{}=\"{}\" invalid.", cCurrentModuleObject, state.dataIPShortCut->cAlphaArgs(1))); ErrorsFound = true; } else { - if (state.dataSurface->Surface(SurfNum).Class != SurfaceClass::Window || state.dataSurface->Surface(SurfNum).ExtBoundCond != 0) { + auto const &surf = state.dataSurface->Surface(SurfNum); + if (surf.Class != SurfaceClass::Window || surf.ExtBoundCond != 0) { ShowSevereError(state, format("{}=\"{}\"", cCurrentModuleObject, state.dataIPShortCut->cAlphaArgs(1))); - ShowSevereError(state, format("cannot be used with surface={}", state.dataSurface->Surface(SurfNum).Name)); + ShowSevereError(state, format("cannot be used with surface={}", surf.Name)); ShowContinueError(state, "because that surface is not an exterior window."); ErrorsFound = true; } @@ -10838,13 +10855,14 @@ namespace SurfaceGeometry { // Check that associated surface is a 2- or 3-pane exterior window WrongSurfaceType = false; if (SurfNum != 0) { - if (state.dataSurface->Surface(SurfNum).Class != SurfaceClass::Window) WrongSurfaceType = true; - if (state.dataSurface->Surface(SurfNum).Class == SurfaceClass::Window) { - ConstrNum = state.dataSurface->Surface(SurfNum).Construction; + auto const &surf = state.dataSurface->Surface(SurfNum); + if (surf.Class != SurfaceClass::Window) WrongSurfaceType = true; + if (surf.Class == SurfaceClass::Window) { + ConstrNum = surf.Construction; if (state.dataConstruction->Construct(ConstrNum).TotGlassLayers != 2 && state.dataConstruction->Construct(ConstrNum).TotGlassLayers != 3) WrongSurfaceType = true; - if (state.dataSurface->Surface(SurfNum).ExtBoundCond != ExternalEnvironment) WrongSurfaceType = true; + if (surf.ExtBoundCond != ExternalEnvironment) WrongSurfaceType = true; } if (WrongSurfaceType) { ShowSevereError(state, @@ -10956,6 +10974,7 @@ namespace SurfaceGeometry { } if (SurfNum > 0) { + auto const &surf = state.dataSurface->Surface(SurfNum); state.dataSurface->AirflowWindows = true; state.dataSurface->SurfWinAirflowSource(SurfNum) = static_cast(getEnumValue(WindowAirFlowSourceNamesUC, state.dataIPShortCut->cAlphaArgs(2))); @@ -10964,9 +10983,9 @@ namespace SurfaceGeometry { static_cast(getEnumValue(WindowAirFlowDestinationNamesUC, state.dataIPShortCut->cAlphaArgs(3))); if (state.dataSurface->SurfWinAirflowDestination(SurfNum) == WindowAirFlowDestination::Return) { - int controlledZoneNum = DataZoneEquipment::GetControlledZoneIndex(state, state.dataSurface->Surface(SurfNum).ZoneName); + int controlledZoneNum = DataZoneEquipment::GetControlledZoneIndex(state, surf.ZoneName); if (controlledZoneNum > 0) { - state.dataHeatBal->Zone(state.dataSurface->Surface(SurfNum).Zone).HasAirFlowWindowReturn = true; + state.dataHeatBal->Zone(surf.Zone).HasAirFlowWindowReturn = true; } // Set return air node number @@ -10975,15 +10994,15 @@ namespace SurfaceGeometry { if (!state.dataIPShortCut->lAlphaFieldBlanks(7)) { retNodeName = state.dataIPShortCut->cAlphaArgs(7); } - std::string callDescription = cCurrentModuleObject + "=" + state.dataSurface->Surface(SurfNum).Name; + std::string callDescription = cCurrentModuleObject + "=" + surf.Name; state.dataSurface->SurfWinAirflowReturnNodePtr(SurfNum) = - DataZoneEquipment::GetReturnAirNodeForZone(state, state.dataSurface->Surface(SurfNum).Zone, retNodeName, callDescription); + DataZoneEquipment::GetReturnAirNodeForZone(state, surf.Zone, retNodeName, callDescription); if (state.dataSurface->SurfWinAirflowReturnNodePtr(SurfNum) == 0) { ShowSevereError(state, format("{}{}=\"{}\", airflow window return air node not found for {} = {}", RoutineName, cCurrentModuleObject, - state.dataSurface->Surface(SurfNum).Name, + surf.Name, state.dataIPShortCut->cAlphaFieldNames(3), state.dataIPShortCut->cAlphaArgs(3))); if (!state.dataIPShortCut->lAlphaFieldBlanks(7)) @@ -11034,7 +11053,7 @@ namespace SurfaceGeometry { } } // Warning if associated window is an interior window - if (state.dataSurface->Surface(SurfNum).ExtBoundCond != ExternalEnvironment && !ErrorsFound) + if (surf.ExtBoundCond != ExternalEnvironment && !ErrorsFound) ShowWarningError(state, format("{}=\"{}\", is an Interior window; cannot be an airflow window.", cCurrentModuleObject, @@ -11053,12 +11072,12 @@ namespace SurfaceGeometry { state.dataConstruction->Construct(ConstrNum).Name)); } // Require that gas be air in airflow gaps on either side of a between glass shade/blind - if (state.dataSurface->Surface(SurfNum).HasShadeControl) { - for (std::size_t listIndex = 0; listIndex < state.dataSurface->Surface(SurfNum).windowShadingControlList.size(); + if (surf.HasShadeControl) { + for (std::size_t listIndex = 0; listIndex < surf.windowShadingControlList.size(); ++listIndex) { - int WSCPtr = state.dataSurface->Surface(SurfNum).windowShadingControlList[listIndex]; + int WSCPtr = surf.windowShadingControlList[listIndex]; if (ANY_BETWEENGLASS_SHADE_BLIND(state.dataSurface->WindowShadingControl(WSCPtr).ShadingType)) { - ConstrNumSh = state.dataSurface->Surface(SurfNum).shadedConstructionList[listIndex]; + ConstrNumSh = surf.shadedConstructionList[listIndex]; if (state.dataConstruction->Construct(ConstrNum).TotGlassLayers == 2) { MatGapFlow1 = state.dataConstruction->Construct(ConstrNumSh).LayerPoint(2); MatGapFlow2 = state.dataConstruction->Construct(ConstrNumSh).LayerPoint(4); @@ -12413,8 +12432,7 @@ namespace SurfaceGeometry { surfacenotused.dimension(NFaces, 0); for (int SurfNum = thisZone.AllSurfaceFirst; SurfNum <= thisZone.AllSurfaceLast; ++SurfNum) { - auto &thisSurface = state.dataSurface->Surface(SurfNum); - + auto &thisSurface = state.dataSurface->Surface(SurfNum); // Only include Base Surfaces in Calc. if (thisSurface.Class != SurfaceClass::Wall && thisSurface.Class != SurfaceClass::Floor && thisSurface.Class != SurfaceClass::Roof) { @@ -13811,17 +13829,18 @@ namespace SurfaceGeometry { Vector x23; // Determine Components of the Coordinate Translation Vector. + auto const &surf = state.dataSurface->Surface(SurfNum); - x21 = state.dataSurface->Surface(SurfNum).Vertex(2) - state.dataSurface->Surface(SurfNum).Vertex(1); - x23 = state.dataSurface->Surface(SurfNum).Vertex(2) - state.dataSurface->Surface(SurfNum).Vertex(3); + x21 = surf.Vertex(2) - surf.Vertex(1); + x23 = surf.Vertex(2) - surf.Vertex(3); DotSelfX23 = magnitude_squared(x23); if (DotSelfX23 <= .1e-6) { ShowSevereError(state, - format("CalcCoordinateTransformation: Invalid dot product, surface=\"{}\":", state.dataSurface->Surface(SurfNum).Name)); - for (I = 1; I <= state.dataSurface->Surface(SurfNum).Sides; ++I) { - auto const &point = state.dataSurface->Surface(SurfNum).Vertex(I); + format("CalcCoordinateTransformation: Invalid dot product, surface=\"{}\":", surf.Name)); + for (I = 1; I <= surf.Sides; ++I) { + auto const &point = surf.Vertex(I); ShowContinueError(state, format(" ({:8.3F},{:8.3F},{:8.3F})", point.x, point.y, point.z)); } ShowFatalError( @@ -13831,8 +13850,8 @@ namespace SurfaceGeometry { Gamma = dot(x21, x23) / magnitude_squared(x23); - CompCoordTranslVector = state.dataSurface->Surface(SurfNum).Vertex(2) + - Gamma * (state.dataSurface->Surface(SurfNum).Vertex(3) - state.dataSurface->Surface(SurfNum).Vertex(2)); + CompCoordTranslVector = surf.Vertex(2) + + Gamma * (surf.Vertex(3) - surf.Vertex(2)); } void CreateShadedWindowConstruction(EnergyPlusData &state, @@ -13998,12 +14017,13 @@ namespace SurfaceGeometry { for (int StormWinNum = 1; StormWinNum <= state.dataSurface->TotStormWin; ++StormWinNum) { int SurfNum = state.dataSurface->StormWindow(StormWinNum).BaseWindowNum; // Surface number - int ConstrNum = state.dataSurface->Surface(SurfNum).Construction; // Number of unshaded construction + auto &surf = state.dataSurface->Surface(SurfNum); + int ConstrNum = surf.Construction; // Number of unshaded construction // Fatal error if base construction has more than three glass layers if (state.dataConstruction->Construct(ConstrNum).TotGlassLayers > 3) { ShowFatalError( state, - format("Window={} has more than 3 glass layers; a storm window cannot be applied.", state.dataSurface->Surface(SurfNum).Name)); + format("Window={} has more than 3 glass layers; a storm window cannot be applied.", surf.Name)); } // create unshaded construction with storm window @@ -14022,11 +14042,9 @@ namespace SurfaceGeometry { state.dataSurface->SurfWinStormWinConstr(SurfNum) = ConstrNewSt; // create shaded constructions with storm window - state.dataSurface->Surface(SurfNum).shadedStormWinConstructionList.resize( - state.dataSurface->Surface(SurfNum).shadedConstructionList.size(), - 0); // make the shaded storm window size the same size as the number of shaded constructions - for (std::size_t iConstruction = 0; iConstruction < state.dataSurface->Surface(SurfNum).shadedConstructionList.size(); ++iConstruction) { - int curConstruction = state.dataSurface->Surface(SurfNum).shadedConstructionList[iConstruction]; + surf.shadedStormWinConstructionList.resize(surf.shadedConstructionList.size(), 0); // make the shaded storm window size the same size as the number of shaded constructions + for (std::size_t iConstruction = 0; iConstruction < surf.shadedConstructionList.size(); ++iConstruction) { + int curConstruction = surf.shadedConstructionList[iConstruction]; // Set ShAndSt, which is true if the window has a shaded construction to which a storm window // can be added. (A storm window can be added if there is an interior shade or blind and up to three // glass layers, or there is a between-glass shade or blind and two glass layers.) @@ -14047,7 +14065,7 @@ namespace SurfaceGeometry { } else { ShowContinueError(state, format("Window={} has a shaded construction to which a storm window cannot be applied.", - state.dataSurface->Surface(SurfNum).Name)); + surf.Name)); ShowContinueError(state, "Storm windows can only be applied to shaded constructions that:"); ShowContinueError(state, "have an interior shade or blind and up to three glass layers, or"); ShowContinueError(state, "have a between-glass shade or blind and two glass layers."); @@ -14055,12 +14073,12 @@ namespace SurfaceGeometry { } } if (ShAndSt) { + auto &surf = state.dataSurface->Surface(SurfNum); std::string ConstrNameStSh = "SHADEDCONSTRUCTIONWITHSTORMWIN:" + state.dataConstruction->Construct(iConstruction).Name + ":" + ChrNum; // Name of shaded construction with storm window int ConstrNewStSh = createConstructionWithStorm( state, ConstrNum, ConstrNameStSh, state.dataSurface->StormWindow(StormWinNum).StormWinMaterialNum, MatNewStAir); - state.dataSurface->Surface(SurfNum).shadedStormWinConstructionList[iConstruction] = - ConstrNewStSh; // put in same index as the shaded constuction + surf.shadedStormWinConstructionList[iConstruction] = ConstrNewStSh; // put in same index as the shaded constuction } } // end of loop for shaded constructions } // end of loop over storm window objects @@ -15245,20 +15263,20 @@ namespace SurfaceGeometry { // loop through all the surfaces for (SurfNum = 1; SurfNum <= state.dataSurface->TotSurfaces; ++SurfNum) { - - Found = Util::FindItemInList(state.dataSurface->Surface(SurfNum).Name, TmpCandidateSurfaceNames, NumCandidateNames); + auto &surf = state.dataSurface->Surface(SurfNum); + Found = Util::FindItemInList(surf.Name, TmpCandidateSurfaceNames, NumCandidateNames); if (Found > 0) { - if (!state.dataSurface->Surface(SurfNum).HeatTransSurf) { // not BIPV, must be a shading surf with solar device + if (!surf.HeatTransSurf) { // not BIPV, must be a shading surf with solar device // Setup missing values to allow shading surfaces to model incident solar and wind - state.dataSurface->Surface(SurfNum).ExtSolar = true; - state.dataSurface->Surface(SurfNum).ExtWind = true; - state.dataSurface->Surface(SurfNum).ViewFactorGround = 0.5 * (1.0 - state.dataSurface->Surface(SurfNum).CosTilt); + surf.ExtSolar = true; + surf.ExtWind = true; + surf.ViewFactorGround = 0.5 * (1.0 - surf.CosTilt); } // check if this surface is used for ICS collector mounting and has OthersideCondictionsModel as its // boundary condition if (NumOfICSUnits > 0) { for (CollectorNum = 1; CollectorNum <= NumOfCollectors; ++CollectorNum) { - if (Util::SameString(state.dataSurface->Surface(SurfNum).Name, TmpCandidateICSSurfaceNames(CollectorNum)) && + if (Util::SameString(surf.Name, TmpCandidateICSSurfaceNames(CollectorNum)) && Util::SameString(TmpCandidateICSBCTypeNames(CollectorNum), "OTHERSIDECONDITIONSMODEL")) { state.dataSurface->SurfIsICS(SurfNum) = true; state.dataSurface->SurfICSPtr(SurfNum) = CollectorNum; @@ -15949,7 +15967,10 @@ namespace SurfaceGeometry { // invalid surface ErrorsFound = true; return; - } else if (state.dataSurface->Surface(SurfNum).Sides != 4) { + } + + auto &surf = state.dataSurface->Surface(SurfNum); + if (surf.Sides != 4) { // the method is designed for 4-sided surface return; } else if (isRectangle(state, SurfNum)) { @@ -15957,13 +15978,13 @@ namespace SurfaceGeometry { return; } - SurfWorldAz = state.dataSurface->Surface(SurfNum).Azimuth; - SurfTilt = state.dataSurface->Surface(SurfNum).Tilt; + SurfWorldAz = surf.Azimuth; + SurfTilt = surf.Tilt; BaseCosAzimuth = std::cos(SurfWorldAz * Constant::DegToRadians); BaseSinAzimuth = std::sin(SurfWorldAz * Constant::DegToRadians); BaseCosTilt = std::cos(SurfTilt * Constant::DegToRadians); BaseSinTilt = std::sin(SurfTilt * Constant::DegToRadians); - NumSurfSides = state.dataSurface->Surface(SurfNum).Sides; + NumSurfSides = surf.Sides; // Calculate WidthMax and HeightMax WidthMax = 0.0; @@ -15971,9 +15992,9 @@ namespace SurfaceGeometry { for (int i = 1; i < NumSurfSides; ++i) { for (int j = i + 1; j <= NumSurfSides; ++j) { - Xp = state.dataSurface->Surface(SurfNum).Vertex(j).x - state.dataSurface->Surface(SurfNum).Vertex(i).x; - Yp = state.dataSurface->Surface(SurfNum).Vertex(j).y - state.dataSurface->Surface(SurfNum).Vertex(i).y; - Zp = state.dataSurface->Surface(SurfNum).Vertex(j).z - state.dataSurface->Surface(SurfNum).Vertex(i).z; + Xp = surf.Vertex(j).x - surf.Vertex(i).x; + Yp = surf.Vertex(j).y - surf.Vertex(i).y; + Zp = surf.Vertex(j).z - surf.Vertex(i).z; XLLC = -Xp * BaseCosAzimuth + Yp * BaseSinAzimuth; YLLC = -Xp * BaseSinAzimuth * BaseCosTilt - Yp * BaseCosAzimuth * BaseCosTilt + Zp * BaseSinTilt; @@ -15990,12 +16011,12 @@ namespace SurfaceGeometry { } else { AspectRatio = 1; } - WidthEff = std::sqrt(state.dataSurface->Surface(SurfNum).Area * AspectRatio); - HeightEff = std::sqrt(state.dataSurface->Surface(SurfNum).Area / AspectRatio); + WidthEff = std::sqrt(surf.Area * AspectRatio); + HeightEff = std::sqrt(surf.Area / AspectRatio); // Assign the effective width and length to the surface - state.dataSurface->Surface(SurfNum).Width = WidthEff; - state.dataSurface->Surface(SurfNum).Height = HeightEff; + surf.Width = WidthEff; + surf.Height = HeightEff; } void CheckForReversedLayers(EnergyPlusData &state, diff --git a/tst/EnergyPlus/unit/AirflowNetworkComponents.unit.cc b/tst/EnergyPlus/unit/AirflowNetworkComponents.unit.cc index c834fa290a8..c5b282ff5fd 100644 --- a/tst/EnergyPlus/unit/AirflowNetworkComponents.unit.cc +++ b/tst/EnergyPlus/unit/AirflowNetworkComponents.unit.cc @@ -411,9 +411,9 @@ TEST_F(EnergyPlusFixture, AirflowNetwork_TestTriangularWindowWarning) state->dataSurface->Surface(3).Vertex(3).z = 1.0; SurfaceGeometry::AllocateSurfaceWindows(*state, 3); - state->dataSurface->SurfWinOriginalClass(1) = DataSurfaces::SurfaceClass::Window; - state->dataSurface->SurfWinOriginalClass(2) = DataSurfaces::SurfaceClass::Window; - state->dataSurface->SurfWinOriginalClass(3) = DataSurfaces::SurfaceClass::Window; + state->dataSurface->Surface(1).OriginalClass = DataSurfaces::SurfaceClass::Window; + state->dataSurface->Surface(2).OriginalClass = DataSurfaces::SurfaceClass::Window; + state->dataSurface->Surface(3).OriginalClass = DataSurfaces::SurfaceClass::Window; state->dataGlobal->NumOfZones = 1; std::string const idf_objects = delimited_string({ @@ -2257,15 +2257,15 @@ TEST_F(EnergyPlusFixture, AirflowNetwork_TestPolygonalWindows) state->dataSurface->Surface(11).Vertex(3).z = 2.4384; SurfaceGeometry::AllocateSurfaceWindows(*state, 14); - state->dataSurface->SurfWinOriginalClass(4) = DataSurfaces::SurfaceClass::Window; - state->dataSurface->SurfWinOriginalClass(5) = DataSurfaces::SurfaceClass::Window; - state->dataSurface->SurfWinOriginalClass(6) = DataSurfaces::SurfaceClass::Window; - state->dataSurface->SurfWinOriginalClass(9) = DataSurfaces::SurfaceClass::Window; - state->dataSurface->SurfWinOriginalClass(10) = DataSurfaces::SurfaceClass::Window; - state->dataSurface->SurfWinOriginalClass(11) = DataSurfaces::SurfaceClass::Window; - state->dataSurface->SurfWinOriginalClass(12) = DataSurfaces::SurfaceClass::Window; - state->dataSurface->SurfWinOriginalClass(13) = DataSurfaces::SurfaceClass::Window; - state->dataSurface->SurfWinOriginalClass(14) = DataSurfaces::SurfaceClass::Window; + state->dataSurface->Surface(4).OriginalClass = DataSurfaces::SurfaceClass::Window; + state->dataSurface->Surface(5).OriginalClass = DataSurfaces::SurfaceClass::Window; + state->dataSurface->Surface(6).OriginalClass = DataSurfaces::SurfaceClass::Window; + state->dataSurface->Surface(9).OriginalClass = DataSurfaces::SurfaceClass::Window; + state->dataSurface->Surface(10).OriginalClass = DataSurfaces::SurfaceClass::Window; + state->dataSurface->Surface(11).OriginalClass = DataSurfaces::SurfaceClass::Window; + state->dataSurface->Surface(12).OriginalClass = DataSurfaces::SurfaceClass::Window; + state->dataSurface->Surface(13).OriginalClass = DataSurfaces::SurfaceClass::Window; + state->dataSurface->Surface(14).OriginalClass = DataSurfaces::SurfaceClass::Window; state->dataGlobal->NumOfZones = 1; std::string const idf_objects = delimited_string({ diff --git a/tst/EnergyPlus/unit/AirflowNetworkConditions.unit.cc b/tst/EnergyPlus/unit/AirflowNetworkConditions.unit.cc index ff2ca30e7a1..6c746055ee2 100644 --- a/tst/EnergyPlus/unit/AirflowNetworkConditions.unit.cc +++ b/tst/EnergyPlus/unit/AirflowNetworkConditions.unit.cc @@ -107,8 +107,8 @@ TEST_F(EnergyPlusFixture, AirflowNetwork_TestDefaultBehaviourOfSimulationControl state->dataSurface->Surface(2).Sides = 4; SurfaceGeometry::AllocateSurfaceWindows(*state, 2); - state->dataSurface->SurfWinOriginalClass(1) = DataSurfaces::SurfaceClass::Window; - state->dataSurface->SurfWinOriginalClass(2) = DataSurfaces::SurfaceClass::Window; + state->dataSurface->Surface(1).OriginalClass = DataSurfaces::SurfaceClass::Window; + state->dataSurface->Surface(2).OriginalClass = DataSurfaces::SurfaceClass::Window; state->dataGlobal->NumOfZones = 1; std::string const idf_objects = delimited_string({ @@ -208,8 +208,8 @@ TEST_F(EnergyPlusFixture, AirflowNetworkSimulationControl_DefaultSolver) state->dataSurface->Surface(2).Sides = 4; SurfaceGeometry::AllocateSurfaceWindows(*state, 2); - state->dataSurface->SurfWinOriginalClass(1) = DataSurfaces::SurfaceClass::Window; - state->dataSurface->SurfWinOriginalClass(2) = DataSurfaces::SurfaceClass::Window; + state->dataSurface->Surface(1).OriginalClass = DataSurfaces::SurfaceClass::Window; + state->dataSurface->Surface(2).OriginalClass = DataSurfaces::SurfaceClass::Window; state->dataGlobal->NumOfZones = 1; state->dataHeatBal->TotPeople = 1; // Total number of people statements @@ -302,9 +302,9 @@ TEST_F(EnergyPlusFixture, AirflowNetworkSimulationControl_SetSolver) state->dataSurface->Surface(2).Sides = 4; SurfaceGeometry::AllocateSurfaceWindows(*state, 2); - state->dataSurface->SurfWinOriginalClass(1) = DataSurfaces::SurfaceClass::Window; + state->dataSurface->Surface(1).OriginalClass = DataSurfaces::SurfaceClass::Window; ; - state->dataSurface->SurfWinOriginalClass(2) = DataSurfaces::SurfaceClass::Window; + state->dataSurface->Surface(2).OriginalClass = DataSurfaces::SurfaceClass::Window; ; state->dataGlobal->NumOfZones = 1; diff --git a/tst/EnergyPlus/unit/AirflowNetworkHVAC.unit.cc b/tst/EnergyPlus/unit/AirflowNetworkHVAC.unit.cc index fcf8870db71..16f20a65715 100644 --- a/tst/EnergyPlus/unit/AirflowNetworkHVAC.unit.cc +++ b/tst/EnergyPlus/unit/AirflowNetworkHVAC.unit.cc @@ -127,8 +127,8 @@ TEST_F(EnergyPlusFixture, AirflowNetwork_TestZoneVentingSch) state->dataSurface->Surface(2).Sides = 4; SurfaceGeometry::AllocateSurfaceWindows(*state, 2); - state->dataSurface->SurfWinOriginalClass(1) = DataSurfaces::SurfaceClass::Window; - state->dataSurface->SurfWinOriginalClass(2) = DataSurfaces::SurfaceClass::Window; + state->dataSurface->Surface(1).OriginalClass = DataSurfaces::SurfaceClass::Window; + state->dataSurface->Surface(2).OriginalClass = DataSurfaces::SurfaceClass::Window; state->dataGlobal->NumOfZones = 1; std::string const idf_objects = delimited_string({ @@ -2314,8 +2314,8 @@ TEST_F(EnergyPlusFixture, AirflowNetwork_TestZoneVentingSchWithAdaptiveCtrl) state->dataSurface->Surface(2).Sides = 4; SurfaceGeometry::AllocateSurfaceWindows(*state, 2); - state->dataSurface->SurfWinOriginalClass(1) = DataSurfaces::SurfaceClass::Window; - state->dataSurface->SurfWinOriginalClass(2) = DataSurfaces::SurfaceClass::Window; + state->dataSurface->Surface(1).OriginalClass = DataSurfaces::SurfaceClass::Window; + state->dataSurface->Surface(2).OriginalClass = DataSurfaces::SurfaceClass::Window; state->dataGlobal->NumOfZones = 1; state->dataHeatBal->TotPeople = 1; // Total number of people statements @@ -6121,8 +6121,7 @@ TEST_F(EnergyPlusFixture, AirflowNetwork_CheckMultiZoneNodes_NoZoneNode) state->dataSurface->Surface(1).Tilt = 180.0; state->dataSurface->Surface(1).Sides = 4; - state->dataSurface->SurfWinOriginalClass.allocate(1); - state->dataSurface->SurfWinOriginalClass(1) = DataSurfaces::SurfaceClass::Window; + state->dataSurface->Surface(1).OriginalClass = DataSurfaces::SurfaceClass::Window; state->dataAirSystemsData->PrimaryAirSystems.allocate(1); state->dataAirSystemsData->PrimaryAirSystems(1).NumBranches = 1; @@ -6199,8 +6198,7 @@ TEST_F(EnergyPlusFixture, AirflowNetwork_CheckMultiZoneNodes_NoInletNode) state->dataSurface->Surface(1).Tilt = 180.0; state->dataSurface->Surface(1).Sides = 4; - state->dataSurface->SurfWinOriginalClass.allocate(1); - state->dataSurface->SurfWinOriginalClass(1) = DataSurfaces::SurfaceClass::Window; + state->dataSurface->Surface(1).OriginalClass = DataSurfaces::SurfaceClass::Window; state->dataAirSystemsData->PrimaryAirSystems.allocate(1); state->dataAirSystemsData->PrimaryAirSystems(1).NumBranches = 1; @@ -10546,8 +10544,8 @@ TEST_F(EnergyPlusFixture, AirflowNetwork_TestZoneVentingAirBoundary) state->dataSurface->Surface(3).Sides = 4; SurfaceGeometry::AllocateSurfaceWindows(*state, 2); - state->dataSurface->SurfWinOriginalClass(1) = DataSurfaces::SurfaceClass::Window; - state->dataSurface->SurfWinOriginalClass(2) = DataSurfaces::SurfaceClass::Window; + state->dataSurface->Surface(1).OriginalClass = DataSurfaces::SurfaceClass::Window; + state->dataSurface->Surface(2).OriginalClass = DataSurfaces::SurfaceClass::Window; state->dataGlobal->NumOfZones = 1; std::string const idf_objects = delimited_string({ @@ -10663,8 +10661,7 @@ TEST_F(EnergyPlusFixture, AirflowNetwork_TestNoZoneEqpSupportZoneERV) state->dataSurface->Surface(1).Tilt = 180.0; state->dataSurface->Surface(1).Sides = 4; - state->dataSurface->SurfWinOriginalClass.allocate(1); - state->dataSurface->SurfWinOriginalClass(1) = DataSurfaces::SurfaceClass::Window; + state->dataSurface->Surface(1).OriginalClass = DataSurfaces::SurfaceClass::Window; // Create air system state->dataAirSystemsData->PrimaryAirSystems.allocate(1); @@ -10844,8 +10841,7 @@ TEST_F(EnergyPlusFixture, AirflowNetwork_TestZoneEqpSupportZoneERV) state->dataSurface->Surface(1).Tilt = 180.0; state->dataSurface->Surface(1).Sides = 4; - state->dataSurface->SurfWinOriginalClass.allocate(1); - state->dataSurface->SurfWinOriginalClass(1) = DataSurfaces::SurfaceClass::Window; + state->dataSurface->Surface(1).OriginalClass = DataSurfaces::SurfaceClass::Window; // Create air system state->dataAirSystemsData->PrimaryAirSystems.allocate(1); @@ -11012,8 +11008,7 @@ TEST_F(EnergyPlusFixture, AirflowNetwork_TestZoneEqpSupportUnbalancedZoneERV) state->dataSurface->Surface(1).Tilt = 180.0; state->dataSurface->Surface(1).Sides = 4; - state->dataSurface->SurfWinOriginalClass.allocate(1); - state->dataSurface->SurfWinOriginalClass(1) = DataSurfaces::SurfaceClass::Window; + state->dataSurface->Surface(1).OriginalClass = DataSurfaces::SurfaceClass::Window; // Create air system state->dataAirSystemsData->PrimaryAirSystems.allocate(1); @@ -11193,8 +11188,7 @@ TEST_F(EnergyPlusFixture, AirflowNetwork_TestNoZoneEqpSupportHPWH) state->dataSurface->Surface(1).Tilt = 180.0; state->dataSurface->Surface(1).Sides = 4; - state->dataSurface->SurfWinOriginalClass.allocate(1); - state->dataSurface->SurfWinOriginalClass(1) = DataSurfaces::SurfaceClass::Window; + state->dataSurface->Surface(1).OriginalClass = DataSurfaces::SurfaceClass::Window; // Create air system state->dataAirSystemsData->PrimaryAirSystems.allocate(1); @@ -11331,8 +11325,7 @@ TEST_F(EnergyPlusFixture, AirflowNetwork_TestZoneEqpSupportHPWH) state->dataSurface->Surface(1).Tilt = 180.0; state->dataSurface->Surface(1).Sides = 4; - state->dataSurface->SurfWinOriginalClass.allocate(1); - state->dataSurface->SurfWinOriginalClass(1) = DataSurfaces::SurfaceClass::Window; + state->dataSurface->Surface(1).OriginalClass = DataSurfaces::SurfaceClass::Window; // Create air system state->dataAirSystemsData->PrimaryAirSystems.allocate(1); @@ -11460,8 +11453,7 @@ TEST_F(EnergyPlusFixture, AirflowNetwork_TestZoneEqpSupportHPWHZoneAndOA) state->dataSurface->Surface(1).Tilt = 180.0; state->dataSurface->Surface(1).Sides = 4; - state->dataSurface->SurfWinOriginalClass.allocate(1); - state->dataSurface->SurfWinOriginalClass(1) = DataSurfaces::SurfaceClass::Window; + state->dataSurface->Surface(1).OriginalClass = DataSurfaces::SurfaceClass::Window; // Create air system state->dataAirSystemsData->PrimaryAirSystems.allocate(1);