diff --git a/src/EnergyPlus/ChilledCeilingPanelSimple.cc b/src/EnergyPlus/ChilledCeilingPanelSimple.cc index 610c391aec8..e5376657abe 100644 --- a/src/EnergyPlus/ChilledCeilingPanelSimple.cc +++ b/src/EnergyPlus/ChilledCeilingPanelSimple.cc @@ -1708,12 +1708,10 @@ namespace EnergyPlus::CoolingPanelSimple { SumHATsurf = 0.0; - for (SurfNum = state.dataHeatBal->Zone(ZoneNum).SurfaceFirst; SurfNum <= state.dataHeatBal->Zone(ZoneNum).SurfaceLast; ++SurfNum) { + for (SurfNum = state.dataHeatBal->Zone(ZoneNum).HTSurfaceFirst; SurfNum <= state.dataHeatBal->Zone(ZoneNum).HTSurfaceLast; ++SurfNum) { auto &ThisSurf(Surface(SurfNum)); - if (!ThisSurf.HeatTransSurf) continue; // Skip non-heat transfer surfaces - Area = ThisSurf.Area; if (ThisSurf.Class == DataSurfaces::SurfaceClass::Window) { diff --git a/src/EnergyPlus/ConvectionCoefficients.cc b/src/EnergyPlus/ConvectionCoefficients.cc index 8a2273078cc..07817cee722 100644 --- a/src/EnergyPlus/ConvectionCoefficients.cc +++ b/src/EnergyPlus/ConvectionCoefficients.cc @@ -251,9 +251,7 @@ namespace ConvectionCoefficients { } for (ZoneNum = 1; ZoneNum <= state.dataGlobal->NumOfZones; ++ZoneNum) { - for (SurfNum = Zone(ZoneNum).SurfaceFirst; SurfNum <= Zone(ZoneNum).SurfaceLast; ++SurfNum) { - - if (!Surface(SurfNum).HeatTransSurf) continue; // Skip non-heat transfer surfaces + for (SurfNum = Zone(ZoneNum).HTSurfaceFirst; SurfNum <= Zone(ZoneNum).HTSurfaceLast; ++SurfNum) { if (present(ZoneToResimulate)) { if ((ZoneNum != ZoneToResimulate) && (AdjacentZoneToSurface(SurfNum) != ZoneToResimulate)) { @@ -2743,9 +2741,7 @@ namespace ConvectionCoefficients { Real64 AirHumRat = DataHeatBalFanSys::ZoneAirHumRatAvg(ZoneNum); - for (auto SurfNum = Zone(ZoneNum).SurfaceFirst; SurfNum <= Zone(ZoneNum).SurfaceLast; ++SurfNum) { - if (!Surface(SurfNum).HeatTransSurf) continue; // Skip non-heat transfer surfaces - + for (auto SurfNum = Zone(ZoneNum).HTSurfaceFirst; SurfNum <= Zone(ZoneNum).HTSurfaceLast; ++SurfNum) { if (Surface(SurfNum).ExtBoundCond == DataSurfaces::KivaFoundation) { state.dataSurfaceGeometry->kivaManager.surfaceConvMap[SurfNum].in = [=, &state](double Tsurf, double Tamb, double, double, double cosTilt) -> double { return CalcCeilingDiffuserIntConvCoeff( @@ -2830,9 +2826,7 @@ namespace ConvectionCoefficients { } } - for (SurfNum = Zone(ZoneNum).SurfaceFirst; SurfNum <= Zone(ZoneNum).SurfaceLast; ++SurfNum) { - if (!Surface(SurfNum).HeatTransSurf) continue; // Skip non-heat transfer surfaces - + for (SurfNum = Zone(ZoneNum).HTSurfaceFirst; SurfNum <= Zone(ZoneNum).HTSurfaceLast; ++SurfNum) { if (ACH <= 3.0) { // Use the other convection algorithm if (!state.dataConstruction->Construct(Surface(SurfNum).Construction).TypeIsWindow) { CalcASHRAEDetailedIntConvCoeff(state, SurfNum, SurfaceTemperatures(SurfNum), MAT(ZoneNum)); @@ -2928,7 +2922,7 @@ namespace ConvectionCoefficients { HConvNet = 0.0; // determine major width and minor width - for (SurfNum = Zone(ZoneNum).SurfaceFirst; SurfNum <= Zone(ZoneNum).SurfaceLast; ++SurfNum) { + for (SurfNum = Zone(ZoneNum).HTSurfaceFirst; SurfNum <= Zone(ZoneNum).HTSurfaceLast; ++SurfNum) { if (Surface(SurfNum).Class != SurfaceClass::Wall) continue; if (Surface(SurfNum).Width > majorW) { @@ -2941,7 +2935,7 @@ namespace ConvectionCoefficients { } // assign major surfaces - for (SurfNum = Zone(ZoneNum).SurfaceFirst; SurfNum <= Zone(ZoneNum).SurfaceLast; ++SurfNum) { + for (SurfNum = Zone(ZoneNum).HTSurfaceFirst; SurfNum <= Zone(ZoneNum).HTSurfaceLast; ++SurfNum) { if (Surface(SurfNum).Class != SurfaceClass::Wall) continue; if (Surface(SurfNum).Width == majorW) { @@ -2983,9 +2977,7 @@ namespace ConvectionCoefficients { } // Assign convection coefficients - for (SurfNum = Zone(ZoneNum).SurfaceFirst; SurfNum <= Zone(ZoneNum).SurfaceLast; ++SurfNum) { - if (!Surface(SurfNum).HeatTransSurf) continue; // Skip non-heat transfer surfaces - + for (SurfNum = Zone(ZoneNum).HTSurfaceFirst; SurfNum <= Zone(ZoneNum).HTSurfaceLast; ++SurfNum) { // Use ASHRAESimple correlation to give values for all the minor surfaces CalcASHRAESimpleIntConvCoeff(state, SurfNum, SurfaceTemperatures(SurfNum), MAT(ZoneNum)); @@ -3504,7 +3496,7 @@ namespace ConvectionCoefficients { thisWWR = -999.0; // throw error? } // first pass thru this zones surfaces to gather data - for (int SurfLoop = Zone(ZoneLoop).SurfaceFirst; SurfLoop <= Zone(ZoneLoop).SurfaceLast; ++SurfLoop) { + for (int SurfLoop = Zone(ZoneLoop).HTSurfaceFirst; SurfLoop <= Zone(ZoneLoop).HTSurfaceLast; ++SurfLoop) { // first catch exterior walls and do summations if ((Surface(SurfLoop).ExtBoundCond == ExternalEnvironment) && (Surface(SurfLoop).Class == SurfaceClass::Wall)) { PerimExtLengthSum += Surface(SurfLoop).Width; @@ -3517,7 +3509,7 @@ namespace ConvectionCoefficients { } // second pass thru zone surfs to fill data - for (int SurfLoop = Zone(ZoneLoop).SurfaceFirst; SurfLoop <= Zone(ZoneLoop).SurfaceLast; ++SurfLoop) { + for (int SurfLoop = Zone(ZoneLoop).HTSurfaceFirst; SurfLoop <= Zone(ZoneLoop).HTSurfaceLast; ++SurfLoop) { // now fill values Surface(SurfLoop).IntConvZoneWallHeight = Zone(ZoneLoop).CeilingHeight; Surface(SurfLoop).IntConvZonePerimLength = PerimExtLengthSum; @@ -3527,7 +3519,7 @@ namespace ConvectionCoefficients { // third pass for window locations if ((ExtWindowCount > 0) && (ExtWallCount > 0)) { - for (int SurfLoop = Zone(ZoneLoop).SurfaceFirst; SurfLoop <= Zone(ZoneLoop).SurfaceLast; ++SurfLoop) { + for (int SurfLoop = Zone(ZoneLoop).HTSurfaceFirst; SurfLoop <= Zone(ZoneLoop).HTSurfaceLast; ++SurfLoop) { if ((Surface(SurfLoop).ExtBoundCond == ExternalEnvironment) && ((Surface(SurfLoop).Class == SurfaceClass::Window) || (Surface(SurfLoop).Class == SurfaceClass::GlassDoor))) { if (Surface(SurfLoop).IntConvWindowWallRatio < 0.5) { @@ -4190,7 +4182,7 @@ namespace ConvectionCoefficients { state.dataConvectionCoefficient->ActiveFloorCount = 0; state.dataConvectionCoefficient->ActiveFloorArea = 0.0; - for (SurfLoop = Zone(ZoneLoop).SurfaceFirst; SurfLoop <= Zone(ZoneLoop).SurfaceLast; ++SurfLoop) { + for (SurfLoop = Zone(ZoneLoop).HTSurfaceFirst; SurfLoop <= Zone(ZoneLoop).HTSurfaceLast; ++SurfLoop) { if (!Surface(SurfLoop).IntConvSurfHasActiveInIt) continue; if (Surface(SurfLoop).Class == SurfaceClass::Wall || Surface(SurfLoop).Class == SurfaceClass::Door) { ++state.dataConvectionCoefficient->ActiveWallCount; @@ -5178,7 +5170,7 @@ namespace ConvectionCoefficients { } else if ((SELECT_CASE_var == VentilatedSlab_Num) || (SELECT_CASE_var == LoTempRadiant_Num)) { if (state.dataZoneEquip->ZoneEquipConfig(ZoneNum).InFloorActiveElement) { - for (SurfLoop = Zone(ZoneNum).SurfaceFirst; SurfLoop <= Zone(ZoneNum).SurfaceLast; ++SurfLoop) { + for (SurfLoop = Zone(ZoneNum).HTSurfaceFirst; SurfLoop <= Zone(ZoneNum).HTSurfaceLast; ++SurfLoop) { if (!Surface(SurfLoop).IntConvSurfHasActiveInIt) continue; if (Surface(SurfLoop).Class == SurfaceClass::Floor) { DeltaTemp = TH(2, 1, SurfLoop) - MAT(ZoneNum); @@ -5197,7 +5189,7 @@ namespace ConvectionCoefficients { } if (state.dataZoneEquip->ZoneEquipConfig(ZoneNum).InCeilingActiveElement) { - for (SurfLoop = Zone(ZoneNum).SurfaceFirst; SurfLoop <= Zone(ZoneNum).SurfaceLast; ++SurfLoop) { + for (SurfLoop = Zone(ZoneNum).HTSurfaceFirst; SurfLoop <= Zone(ZoneNum).HTSurfaceLast; ++SurfLoop) { if (!Surface(SurfLoop).IntConvSurfHasActiveInIt) continue; if (Surface(SurfLoop).Class == SurfaceClass::Roof) { DeltaTemp = TH(2, 1, SurfLoop) - MAT(ZoneNum); @@ -5216,7 +5208,7 @@ namespace ConvectionCoefficients { } if (state.dataZoneEquip->ZoneEquipConfig(ZoneNum).InWallActiveElement) { - for (SurfLoop = Zone(ZoneNum).SurfaceFirst; SurfLoop <= Zone(ZoneNum).SurfaceLast; ++SurfLoop) { + for (SurfLoop = Zone(ZoneNum).HTSurfaceFirst; SurfLoop <= Zone(ZoneNum).HTSurfaceLast; ++SurfLoop) { if (!Surface(SurfLoop).IntConvSurfHasActiveInIt) continue; if (Surface(SurfLoop).Class == SurfaceClass::Wall || Surface(SurfLoop).Class == SurfaceClass::Door) { DeltaTemp = TH(2, 1, SurfLoop) - MAT(ZoneNum); @@ -5275,8 +5267,8 @@ namespace ConvectionCoefficients { // Calculate Grashof, Reynolds, and Richardson numbers for the zone // Grashof for zone air based on largest delta T between surfaces and zone height - Tmin = minval(TH(2, 1, {Zone(ZoneNum).SurfaceFirst, Zone(ZoneNum).SurfaceLast})); - Tmax = maxval(TH(2, 1, {Zone(ZoneNum).SurfaceFirst, Zone(ZoneNum).SurfaceLast})); + Tmin = minval(TH(2, 1, {Zone(ZoneNum).HTSurfaceFirst, Zone(ZoneNum).HTSurfaceLast})); + Tmax = maxval(TH(2, 1, {Zone(ZoneNum).HTSurfaceFirst, Zone(ZoneNum).HTSurfaceLast})); GrH = (g * (Tmax - Tmin) * pow_3(Zone(ZoneNum).CeilingHeight)) / ((MAT(ZoneNum) + DataGlobalConstants::KelvinConv) * pow_2(v)); // Reynolds number = Vdot supply / v * cube root of zone volume (Goldstein and Noveselac 2010) diff --git a/src/EnergyPlus/DElightManagerF.cc b/src/EnergyPlus/DElightManagerF.cc index 28bae1f5003..5a6f71d4b1b 100644 --- a/src/EnergyPlus/DElightManagerF.cc +++ b/src/EnergyPlus/DElightManagerF.cc @@ -304,8 +304,8 @@ namespace DElightManagerF { // Zone Surface Data Section // Count the number of opaque surfaces bounding the current zone iNumOpaqueSurfs = 0; - iSurfaceFirst = zn.SurfaceFirst; - int const iSurfaceLast = zn.SurfaceLast; // ending loop variable for surfaces + iSurfaceFirst = zn.HTSurfaceFirst; + int const iSurfaceLast = zn.HTSurfaceLast; // ending loop variable for surfaces for (int isurf = iSurfaceFirst; isurf <= iSurfaceLast; ++isurf) { auto &surf(Surface(isurf)); diff --git a/src/EnergyPlus/DataHeatBalance.hh b/src/EnergyPlus/DataHeatBalance.hh index e45c2492c6b..9036a59267c 100644 --- a/src/EnergyPlus/DataHeatBalance.hh +++ b/src/EnergyPlus/DataHeatBalance.hh @@ -369,25 +369,30 @@ namespace DataHeatBalance { int PlenumCondNum; // Supply or return plenum conditions number, 0 if this is not a plenum zone int TempControlledZoneIndex; // this is the index number for TempControlledZone structure for lookup // Pointers to Surface Data Structure - int AllSurfaceFirst; // First surface in zone including air boundaries - int SurfaceFirst; // First Heat Transfer Surface in Zone - int SurfaceLast; // Last Heat Transfer Surface in Zone - int NonWindowSurfaceFirst; // First Non-Window Heat Transfer Surface in Zone - int NonWindowSurfaceLast; // Last Non-Window Heat Transfer Surface in Zone - int WindowSurfaceFirst; // First Window Heat Transfer Surface in Zone - int WindowSurfaceLast; // Last Window Heat Transfer Surface in Zone - int InsideConvectionAlgo; // Ref: appropriate values for Inside Convection solution - int NumSurfaces; // Number of surfaces for this zone - int NumSubSurfaces; // Number of subsurfaces for this zone (windows, doors, tdd dome and diffusers) - int NumShadingSurfaces; // Number of shading surfaces for this zone - int OutsideConvectionAlgo; // Ref: appropriate values for Outside Convection solution - Vector Centroid; // Center of the zone found by averaging wall, floor, and roof centroids - Real64 MinimumX; // Minimum X value for entire zone - Real64 MaximumX; // Maximum X value for entire zone - Real64 MinimumY; // Minimum Y value for entire zone - Real64 MaximumY; // Maximum Y value for entire zone - Real64 MinimumZ; // Minimum Z value for entire zone - Real64 MaximumZ; // Maximum Z value for entire zone + int AllSurfaceFirst; // First surface in zone including air boundaries + int AllSurfaceLast; // Last surface in zone including air boundaries + int HTSurfaceFirst; // First Heat Transfer Surface in Zone + int HTSurfaceLast; // Last Heat Transfer Surface in Zone + int OpaqOrIntMassSurfaceFirst; // First Opaque or Interior Mass Heat Transfer Surface (including opaque doors) in Zone + int OpaqOrIntMassSurfaceLast; // Last Opaque or Interior Mass Heat Transfer Surface (including opaque doors) in Zone + int WindowSurfaceFirst; // First Window Heat Transfer Surface in Zone + int WindowSurfaceLast; // Last Window Heat Transfer Surface in Zone + int OpaqOrWinSurfaceFirst; // First opaque (including IntMass) or window (non TDD Dome) Surface in Zone + int OpaqOrWinSurfaceLast; // Last opaque (including IntMass) or window (non TDD Dome) Surface in Zone + int TDDDomeFirst; // First TDD Dome Surface in Zone + int TDDDomeLast; // Last TDD Dome Surface in Zone + int InsideConvectionAlgo; // Ref: appropriate values for Inside Convection solution + int NumSurfaces; // Number of surfaces for this zone + int NumSubSurfaces; // Number of subsurfaces for this zone (windows, doors, tdd dome and diffusers) + int NumShadingSurfaces; // Number of shading surfaces for this zone + int OutsideConvectionAlgo; // Ref: appropriate values for Outside Convection solution + Vector Centroid; // Center of the zone found by averaging wall, floor, and roof centroids + Real64 MinimumX; // Minimum X value for entire zone + Real64 MaximumX; // Maximum X value for entire zone + Real64 MinimumY; // Minimum Y value for entire zone + Real64 MaximumY; // Maximum Y value for entire zone + Real64 MinimumZ; // Minimum Z value for entire zone + Real64 MaximumZ; // Maximum Z value for entire zone std::vector ZoneHTSurfaceList; // List of HT surfaces related to this zone (includes adjacent interzone surfaces) std::vector ZoneIZSurfaceList; // List of interzone surfaces in this zone std::vector ZoneHTNonWindowSurfaceList; // List of non-window HT surfaces related to this zone (includes adjacent interzone surfaces) @@ -471,17 +476,20 @@ namespace DataHeatBalance { ExtWindowArea_Multiplied(0.0), ExtGrossWallArea_Multiplied(0.0), ExtNetWallArea(0.0), TotalSurfArea(0.0), ExteriorTotalSurfArea(0.0), ExteriorTotalGroundSurfArea(0.0), ExtGrossGroundWallArea(0.0), ExtGrossGroundWallArea_Multiplied(0.0), SystemZoneNodeNumber(0), IsControlled(false), IsSupplyPlenum(false), IsReturnPlenum(false), ZoneEqNum(0), PlenumCondNum(0), TempControlledZoneIndex(0), - AllSurfaceFirst(0), SurfaceFirst(0), SurfaceLast(0), NonWindowSurfaceFirst(0), NonWindowSurfaceLast(0), WindowSurfaceFirst(0), - WindowSurfaceLast(0), InsideConvectionAlgo(ASHRAESimple), NumSurfaces(0), NumSubSurfaces(0), NumShadingSurfaces(0), - OutsideConvectionAlgo(ASHRAESimple), Centroid(0.0, 0.0, 0.0), MinimumX(0.0), MaximumX(0.0), MinimumY(0.0), MaximumY(0.0), MinimumZ(0.0), - MaximumZ(0.0), RadiantEnclosureNum(0), SolarEnclosureNum(0), OutDryBulbTemp(0.0), OutDryBulbTempEMSOverrideOn(false), - OutDryBulbTempEMSOverrideValue(0.0), OutWetBulbTemp(0.0), OutWetBulbTempEMSOverrideOn(false), OutWetBulbTempEMSOverrideValue(0.0), - WindSpeed(0.0), WindSpeedEMSOverrideOn(false), WindSpeedEMSOverrideValue(0.0), WindDir(0.0), WindDirEMSOverrideOn(false), - WindDirEMSOverrideValue(0.0), HasLinkedOutAirNode(false), LinkedOutAirNode(0.0), isPartOfTotalArea(true), isNominalOccupied(false), - isNominalControlled(false), TotOccupants(0.0), AirHBimBalanceErrIndex(0), NoHeatToReturnAir(false), RefrigCaseRA(false), - HasAdjustedReturnTempByITE(false), AdjustedReturnTempByITE(0.0), HasLtsRetAirGain(false), HasAirFlowWindowReturn(false), - InternalHeatGains(0.0), NominalInfilVent(0.0), NominalMixing(0.0), TempOutOfBoundsReported(false), EnforcedReciprocity(false), - ZoneMinCO2SchedIndex(0), ZoneMaxCO2SchedIndex(0), ZoneContamControllerSchedIndex(0), FlagCustomizedZoneCap(false), + AllSurfaceFirst(0), AllSurfaceLast(-1), HTSurfaceFirst(0), HTSurfaceLast(-1), OpaqOrIntMassSurfaceFirst(0), OpaqOrIntMassSurfaceLast(-1), + WindowSurfaceFirst(0), WindowSurfaceLast(-1), OpaqOrWinSurfaceFirst(0), OpaqOrWinSurfaceLast(-1), TDDDomeFirst(0), TDDDomeLast(-1), + InsideConvectionAlgo(ASHRAESimple), NumSurfaces(0), NumSubSurfaces(0), NumShadingSurfaces(0), OutsideConvectionAlgo(ASHRAESimple), Centroid(0.0, 0.0, 0.0), + MinimumX(0.0), MaximumX(0.0), MinimumY(0.0), MaximumY(0.0), MinimumZ(0.0), MaximumZ(0.0), RadiantEnclosureNum(0), SolarEnclosureNum(0), + + OutDryBulbTemp(0.0), OutDryBulbTempEMSOverrideOn(false), OutDryBulbTempEMSOverrideValue(0.0), OutWetBulbTemp(0.0), + OutWetBulbTempEMSOverrideOn(false), OutWetBulbTempEMSOverrideValue(0.0), WindSpeed(0.0), WindSpeedEMSOverrideOn(false), + WindSpeedEMSOverrideValue(0.0), WindDir(0.0), WindDirEMSOverrideOn(false), WindDirEMSOverrideValue(0.0), HasLinkedOutAirNode(false), + LinkedOutAirNode(0.0), isPartOfTotalArea(true), isNominalOccupied(false), isNominalControlled(false), TotOccupants(0.0), + AirHBimBalanceErrIndex(0), NoHeatToReturnAir(false), RefrigCaseRA(false), HasAdjustedReturnTempByITE(false), + AdjustedReturnTempByITE(0.0), HasLtsRetAirGain(false), HasAirFlowWindowReturn(false), InternalHeatGains(0.0), NominalInfilVent(0.0), + NominalMixing(0.0), TempOutOfBoundsReported(false), EnforcedReciprocity(false), ZoneMinCO2SchedIndex(0), ZoneMaxCO2SchedIndex(0), + ZoneContamControllerSchedIndex(0), FlagCustomizedZoneCap(false), + // Hybrid Modeling ZoneMeasuredTemperature(0.0), ZoneMeasuredHumidityRatio(0.0), ZoneMeasuredCO2Concentration(0.0), ZoneMeasuredSupplyAirTemperature(0.0), ZoneMeasuredSupplyAirFlowRate(0.0), ZoneMeasuredSupplyAirHumidityRatio(0.0), ZoneMeasuredSupplyAirCO2Concentration(0.0), ZonePeopleActivityLevel(0.0), ZonePeopleSensibleHeatFraction(0.0), ZonePeopleRadiantHeatFraction(0.0), ZoneVolCapMultpSens(1.0), diff --git a/src/EnergyPlus/DaylightingManager.cc b/src/EnergyPlus/DaylightingManager.cc index 7375825f337..30b6e722174 100644 --- a/src/EnergyPlus/DaylightingManager.cc +++ b/src/EnergyPlus/DaylightingManager.cc @@ -2142,8 +2142,8 @@ namespace EnergyPlus::DaylightingManager { } if (ExtWinType == DataDaylighting::iExtWinType::AdjZoneExtWin) { // Does ray pass through an interior window in zone (ZoneNum) containing the ref point? - for (IntWin = state.dataHeatBal->Zone(ZoneNum).SurfaceFirst; IntWin <= state.dataHeatBal->Zone(ZoneNum).SurfaceLast; ++IntWin) { - if (Surface(IntWin).Class == SurfaceClass::Window && Surface(IntWin).ExtBoundCond >= 1) { + for (IntWin = state.dataHeatBal->Zone(ZoneNum).WindowSurfaceFirst; IntWin <= state.dataHeatBal->Zone(ZoneNum).WindowSurfaceLast; ++IntWin) { + if (Surface(IntWin).ExtBoundCond >= 1) { // in develop this was Surface(IntWin).Class == SurfaceClass::Window && Surface(IntWin).ExtBoundCond >= 1 if (Surface(Surface(IntWin).ExtBoundCond).Zone == Surface(IWin).Zone) { PierceSurface(IntWin, RREF, Ray, HitPtIntWin, hitIntWin); if (hitIntWin) { @@ -3425,9 +3425,9 @@ namespace EnergyPlus::DaylightingManager { // adjacent to zones with exterior windows // Does RAYCOS pass through interior window in zone containing RP? // Loop over zone surfaces looking for interior windows between reference point and sun - for (int IntWinDisk = Zone(ZoneNum).SurfaceFirst, IntWinDisk_end = Zone(ZoneNum).SurfaceLast; IntWinDisk <= IntWinDisk_end; + for (int IntWinDisk = Zone(ZoneNum).WindowSurfaceFirst, IntWinDisk_end = Zone(ZoneNum).WindowSurfaceLast; IntWinDisk <= IntWinDisk_end; ++IntWinDisk) { - if (Surface(IntWinDisk).Class == SurfaceClass::Window && Surface(IntWinDisk).ExtBoundCond >= 1) { + if (Surface(IntWinDisk).ExtBoundCond >= 1) { if (Surface(Surface(IntWinDisk).ExtBoundCond).Zone == Surface(IWin2).Zone) { PierceSurface(IntWinDisk, RREF, RAYCOS, HitPtIntWinDisk, hitIntWinDisk); if (hitIntWinDisk) { @@ -6772,8 +6772,7 @@ namespace EnergyPlus::DaylightingManager { // Loop again over windows and reset remaining shading flags that // are 10 or higher (i.e., conditionally off) to off - for (int IWin = state.dataHeatBal->Zone(ZoneNum).SurfaceFirst; IWin <= state.dataHeatBal->Zone(ZoneNum).SurfaceLast; ++IWin) { - if (Surface(IWin).Class != SurfaceClass::Window) continue; + for (int IWin = state.dataHeatBal->Zone(ZoneNum).WindowSurfaceFirst; IWin <= state.dataHeatBal->Zone(ZoneNum).WindowSurfaceLast; ++IWin) { if (Surface(IWin).ExtBoundCond != ExternalEnvironment) continue; bool anyGlareControl = BITF_TEST_ANY(BITF(SurfWinShadingFlag(IWin)), BITF(WinShadingType::IntShadeConditionallyOff) | BITF(WinShadingType::GlassConditionallyLightened) |\ BITF(WinShadingType::ExtShadeConditionallyOff) | BITF(WinShadingType::IntBlindConditionallyOff) | BITF(WinShadingType::ExtBlindConditionallyOff)); @@ -9647,16 +9646,16 @@ namespace EnergyPlus::DaylightingManager { for (int ZoneNumAdj : DataViewFactorInformation::ZoneSolarInfo(adjEnclNum).ZoneNums) { // Require that ZoneNumAdj have a least one exterior window bool AdjZoneHasExtWins = false; - for (int SurfNumAdj = Zone(ZoneNumAdj).SurfaceFirst; SurfNumAdj <= Zone(ZoneNumAdj).SurfaceLast; ++SurfNumAdj) { - if (Surface(SurfNumAdj).Class == SurfaceClass::Window && Surface(SurfNumAdj).ExtBoundCond == ExternalEnvironment) { + for (int SurfNumAdj = Zone(ZoneNumAdj).WindowSurfaceFirst; SurfNumAdj <= Zone(ZoneNumAdj).WindowSurfaceLast; ++SurfNumAdj) { + if (Surface(SurfNumAdj).ExtBoundCond == ExternalEnvironment) { AdjZoneHasExtWins = true; break; } } if (!AdjZoneHasExtWins) continue; // Loop again through surfaces in ZoneNumAdj and see if any are interior windows adjacent to ZoneNum - for (int SurfNumAdj = Zone(ZoneNumAdj).SurfaceFirst; SurfNumAdj <= Zone(ZoneNumAdj).SurfaceLast; ++SurfNumAdj) { - if (Surface(SurfNumAdj).Class == SurfaceClass::Window && Surface(SurfNumAdj).ExtBoundCond >= 1) { + for (int SurfNumAdj = Zone(ZoneNumAdj).WindowSurfaceFirst; SurfNumAdj <= Zone(ZoneNumAdj).WindowSurfaceLast; ++SurfNumAdj) { + if (Surface(SurfNumAdj).ExtBoundCond >= 1) { // This is an interior window in ZoneNumAdj if (Surface(Surface(SurfNumAdj).ExtBoundCond).SolarEnclIndex == thisZoneEnclNum) { // This interior window is adjacent to ZoneNum @@ -9683,16 +9682,16 @@ namespace EnergyPlus::DaylightingManager { if (ZoneNumAdj == ZoneNum) continue; // Require that ZoneNumAdj have a least one exterior window bool AdjZoneHasExtWins = false; - for (int SurfNumAdj = Zone(ZoneNumAdj).SurfaceFirst; SurfNumAdj <= Zone(ZoneNumAdj).SurfaceLast; ++SurfNumAdj) { - if (Surface(SurfNumAdj).Class == SurfaceClass::Window && Surface(SurfNumAdj).ExtBoundCond == ExternalEnvironment) { + for (int SurfNumAdj = Zone(ZoneNumAdj).WindowSurfaceFirst; SurfNumAdj <= Zone(ZoneNumAdj).WindowSurfaceLast; ++SurfNumAdj) { + if (Surface(SurfNumAdj).ExtBoundCond == ExternalEnvironment) { AdjZoneHasExtWins = true; break; } } if (!AdjZoneHasExtWins) continue; // Loop again through surfaces in ZoneNumAdj and see if any are interior windows adjacent to ZoneNum - for (int SurfNumAdj = Zone(ZoneNumAdj).SurfaceFirst; SurfNumAdj <= Zone(ZoneNumAdj).SurfaceLast; ++SurfNumAdj) { - if (Surface(SurfNumAdj).Class == SurfaceClass::Window && Surface(SurfNumAdj).ExtBoundCond >= 1) { + for (int SurfNumAdj = Zone(ZoneNumAdj).WindowSurfaceFirst; SurfNumAdj <= Zone(ZoneNumAdj).WindowSurfaceLast; ++SurfNumAdj) { + if (Surface(SurfNumAdj).ExtBoundCond >= 1) { // This is an interior window in ZoneNumAdj if (Surface(Surface(SurfNumAdj).ExtBoundCond).SolarEnclIndex == thisZoneEnclNum) { // This interior window is adjacent to ZoneNum @@ -9718,8 +9717,8 @@ namespace EnergyPlus::DaylightingManager { int const thisZoneEnclNum = Zone(ZoneNum).SolarEnclosureNum; for (int ZoneAdjLoop = 1; ZoneAdjLoop <= state.dataDaylightingData->ZoneDaylight(ZoneNum).NumOfIntWinAdjZones; ++ZoneAdjLoop) { int ZoneNumAdj = state.dataDaylightingData->ZoneDaylight(ZoneNum).AdjIntWinZoneNums(ZoneAdjLoop); - for (int SurfNumAdj = Zone(ZoneNumAdj).SurfaceFirst; SurfNumAdj <= Zone(ZoneNumAdj).SurfaceLast; ++SurfNumAdj) { - if (Surface(SurfNumAdj).Class == SurfaceClass::Window && Surface(SurfNumAdj).ExtBoundCond == ExternalEnvironment) { + for (int SurfNumAdj = Zone(ZoneNumAdj).WindowSurfaceFirst; SurfNumAdj <= Zone(ZoneNumAdj).WindowSurfaceLast; ++SurfNumAdj) { + if (Surface(SurfNumAdj).ExtBoundCond == ExternalEnvironment) { ++state.dataDaylightingData->ZoneDaylight(ZoneNum).NumOfIntWinAdjZoneExtWins; } } @@ -9731,15 +9730,15 @@ namespace EnergyPlus::DaylightingManager { int ExtWinIndex = 0; for (int ZoneAdjLoop = 1; ZoneAdjLoop <= state.dataDaylightingData->ZoneDaylight(ZoneNum).NumOfIntWinAdjZones; ++ZoneAdjLoop) { int const ZoneNumAdj = state.dataDaylightingData->ZoneDaylight(ZoneNum).AdjIntWinZoneNums(ZoneAdjLoop); - for (int SurfNumAdj = Zone(ZoneNumAdj).SurfaceFirst; SurfNumAdj <= Zone(ZoneNumAdj).SurfaceLast; ++SurfNumAdj) { - if (Surface(SurfNumAdj).Class == SurfaceClass::Window && Surface(SurfNumAdj).ExtBoundCond == ExternalEnvironment) { + for (int SurfNumAdj = Zone(ZoneNumAdj).WindowSurfaceFirst; SurfNumAdj <= Zone(ZoneNumAdj).WindowSurfaceLast; ++SurfNumAdj) { + if (Surface(SurfNumAdj).ExtBoundCond == ExternalEnvironment) { ++ExtWinIndex; state.dataDaylightingData->ZoneDaylight(ZoneNum).IntWinAdjZoneExtWin(ExtWinIndex).SurfNum = SurfNumAdj; // now count interior windows shared by both zones int NumOfIntWindowsCount = 0; - for (int SurfNumAdj2 = Zone(ZoneNumAdj).SurfaceFirst; SurfNumAdj2 <= Zone(ZoneNumAdj).SurfaceLast; ++SurfNumAdj2) { - if (Surface(SurfNumAdj2).Class == SurfaceClass::Window && Surface(SurfNumAdj2).ExtBoundCond >= 1) { + for (int SurfNumAdj2 = Zone(ZoneNumAdj).WindowSurfaceFirst; SurfNumAdj2 <= Zone(ZoneNumAdj).WindowSurfaceLast; ++SurfNumAdj2) { + if (Surface(SurfNumAdj2).ExtBoundCond >= 1) { // This is an interior window in ZoneNumAdj if (Surface(Surface(SurfNumAdj2).ExtBoundCond).SolarEnclIndex == thisZoneEnclNum) { // This interior window is adjacent to ZoneNum and associated with this @@ -9751,8 +9750,8 @@ namespace EnergyPlus::DaylightingManager { state.dataDaylightingData->ZoneDaylight(ZoneNum).IntWinAdjZoneExtWin(ExtWinIndex).IntWinNum.allocate(NumOfIntWindowsCount); state.dataDaylightingData->ZoneDaylight(ZoneNum).IntWinAdjZoneExtWin(ExtWinIndex).IntWinNum = 0; int IntWinIndex = 0; - for (int SurfNumAdj2 = Zone(ZoneNumAdj).SurfaceFirst; SurfNumAdj2 <= Zone(ZoneNumAdj).SurfaceLast; ++SurfNumAdj2) { - if (Surface(SurfNumAdj2).Class == SurfaceClass::Window && Surface(SurfNumAdj2).ExtBoundCond >= 1) { + for (int SurfNumAdj2 = Zone(ZoneNumAdj).WindowSurfaceFirst; SurfNumAdj2 <= Zone(ZoneNumAdj).WindowSurfaceLast; ++SurfNumAdj2) { + if (Surface(SurfNumAdj2).ExtBoundCond >= 1) { // This is an interior window in ZoneNumAdj if (Surface(Surface(SurfNumAdj2).ExtBoundCond).SolarEnclIndex == thisZoneEnclNum) { // This interior window is adjacent to ZoneNum and associated with this @@ -9786,9 +9785,8 @@ namespace EnergyPlus::DaylightingManager { int ZoneNumAdj = state.dataDaylightingData->ZoneDaylight(ZoneNum).AdjIntWinZoneNums(loop); // Get exterior windows in ZoneNumAdj -- there must be at least one, otherwise // it would not be an "AdjIntWinZone" - for (int SurfNumAdj = Zone(ZoneNumAdj).SurfaceFirst; SurfNumAdj <= Zone(ZoneNumAdj).SurfaceLast; ++SurfNumAdj) { - if ((Surface(SurfNumAdj).Class == SurfaceClass::Window && Surface(SurfNumAdj).ExtBoundCond == ExternalEnvironment) || - SurfWinOriginalClass(SurfNumAdj) == SurfaceClass::TDD_Diffuser) { + for (int SurfNumAdj = Zone(ZoneNumAdj).WindowSurfaceFirst; SurfNumAdj <= Zone(ZoneNumAdj).WindowSurfaceLast; ++SurfNumAdj) { + if (Surface(SurfNumAdj).ExtBoundCond == ExternalEnvironment || SurfWinOriginalClass(SurfNumAdj) == SurfaceClass::TDD_Diffuser) { ++ZoneExtWin(ZoneNum); } } @@ -9855,9 +9853,8 @@ namespace EnergyPlus::DaylightingManager { int const ZoneNumAdj = state.dataDaylightingData->ZoneDaylight(ZoneNum).AdjIntWinZoneNums(loop); // Get exterior windows in ZoneNumAdj -- there must be at least one, otherwise // it would not be an "AdjIntWinZone" - for (int SurfNumAdj = Zone(ZoneNumAdj).SurfaceFirst; SurfNumAdj <= Zone(ZoneNumAdj).SurfaceLast; ++SurfNumAdj) { - if ((Surface(SurfNumAdj).Class == SurfaceClass::Window && Surface(SurfNumAdj).ExtBoundCond == ExternalEnvironment) || - SurfWinOriginalClass(SurfNumAdj) == SurfaceClass::TDD_Diffuser) { + for (int SurfNumAdj = Zone(ZoneNumAdj).WindowSurfaceFirst; SurfNumAdj <= Zone(ZoneNumAdj).WindowSurfaceLast; ++SurfNumAdj) { + if (Surface(SurfNumAdj).ExtBoundCond == ExternalEnvironment || SurfWinOriginalClass(SurfNumAdj) == SurfaceClass::TDD_Diffuser) { ++ZoneExtWinCtr; state.dataDaylightingData->ZoneDaylight(ZoneNum).DayltgExtWinSurfNums(ZoneExtWinCtr) = SurfNumAdj; @@ -10126,8 +10123,8 @@ namespace EnergyPlus::DaylightingManager { state.dataDaylightingData->ZoneDaylight(ZoneNum).MinIntWinSolidAng = 2.0 * DataGlobalConstants::Pi; if (state.dataDaylightingData->ZoneDaylight(ZoneNum).TotalDaylRefPoints == 0) continue; if (state.dataDaylightingData->ZoneDaylight(ZoneNum).NumOfIntWinAdjZones == 0) continue; - for (IWin = Zone(ZoneNum).SurfaceFirst; IWin <= Zone(ZoneNum).SurfaceLast; ++IWin) { - if (Surface(IWin).Class == SurfaceClass::Window && Surface(IWin).ExtBoundCond >= 1) { + for (IWin = Zone(ZoneNum).WindowSurfaceFirst; IWin <= Zone(ZoneNum).WindowSurfaceLast; ++IWin) { + if (Surface(IWin).ExtBoundCond >= 1) { ZoneNumAdj = Surface(Surface(IWin).ExtBoundCond).Zone; IntWinNextToIntWinAdjZone = false; for (loop = 1; loop <= state.dataDaylightingData->ZoneDaylight(ZoneNum).NumOfIntWinAdjZones; ++loop) { diff --git a/src/EnergyPlus/ElectricBaseboardRadiator.cc b/src/EnergyPlus/ElectricBaseboardRadiator.cc index d3079a7d71d..52817143672 100644 --- a/src/EnergyPlus/ElectricBaseboardRadiator.cc +++ b/src/EnergyPlus/ElectricBaseboardRadiator.cc @@ -1140,9 +1140,7 @@ namespace ElectricBaseboardRadiator { SumHATsurf = 0.0; - for (SurfNum = state.dataHeatBal->Zone(ZoneNum).SurfaceFirst; SurfNum <= state.dataHeatBal->Zone(ZoneNum).SurfaceLast; ++SurfNum) { - if (!Surface(SurfNum).HeatTransSurf) continue; // Skip non-heat transfer surfaces - + for (SurfNum = state.dataHeatBal->Zone(ZoneNum).HTSurfaceFirst; SurfNum <= state.dataHeatBal->Zone(ZoneNum).HTSurfaceLast; ++SurfNum) { Area = Surface(SurfNum).Area; if (Surface(SurfNum).Class == SurfaceClass::Window) { diff --git a/src/EnergyPlus/HVACManager.cc b/src/EnergyPlus/HVACManager.cc index 94f594d811d..2d3efbd8bdb 100644 --- a/src/EnergyPlus/HVACManager.cc +++ b/src/EnergyPlus/HVACManager.cc @@ -2752,7 +2752,7 @@ namespace EnergyPlus::HVACManager { break; } } - for (SurfNum = Zone(ZoneNum).SurfaceFirst; SurfNum <= Zone(ZoneNum).SurfaceLast; ++SurfNum) { + for (SurfNum = Zone(ZoneNum).HTSurfaceFirst; SurfNum <= Zone(ZoneNum).HTSurfaceLast; ++SurfNum) { if (DataSurfaces::SurfWinAirflowDestination(SurfNum) == AirFlowWindow_Destination_ReturnAir) { ShowWarningError(state, "For zone=" + Zone(ZoneNum).Name + " return air heat gain from air flow windows will be applied to the zone air."); diff --git a/src/EnergyPlus/HWBaseboardRadiator.cc b/src/EnergyPlus/HWBaseboardRadiator.cc index 3760c9581eb..02f8f210537 100644 --- a/src/EnergyPlus/HWBaseboardRadiator.cc +++ b/src/EnergyPlus/HWBaseboardRadiator.cc @@ -1789,9 +1789,7 @@ namespace HWBaseboardRadiator { SumHATsurf = 0.0; - for (SurfNum = state.dataHeatBal->Zone(ZoneNum).SurfaceFirst; SurfNum <= state.dataHeatBal->Zone(ZoneNum).SurfaceLast; ++SurfNum) { - if (!Surface(SurfNum).HeatTransSurf) continue; // Skip non-heat transfer surfaces - + for (SurfNum = state.dataHeatBal->Zone(ZoneNum).HTSurfaceFirst; SurfNum <= state.dataHeatBal->Zone(ZoneNum).HTSurfaceLast; ++SurfNum) { Area = Surface(SurfNum).Area; if (Surface(SurfNum).Class == SurfaceClass::Window) { diff --git a/src/EnergyPlus/HeatBalanceIntRadExchange.cc b/src/EnergyPlus/HeatBalanceIntRadExchange.cc index 8cb25fce4cf..d2176970ede 100644 --- a/src/EnergyPlus/HeatBalanceIntRadExchange.cc +++ b/src/EnergyPlus/HeatBalanceIntRadExchange.cc @@ -545,8 +545,8 @@ namespace HeatBalanceIntRadExchange { } int numEnclosureSurfaces = 0; for (int zoneNum : thisEnclosure.ZoneNums) { - for (int surfNum = state.dataHeatBal->Zone(zoneNum).SurfaceFirst, surfNum_end = state.dataHeatBal->Zone(zoneNum).SurfaceLast; surfNum <= surfNum_end; ++surfNum) { - if (Surface(surfNum).HeatTransSurf) ++numEnclosureSurfaces; + for (int surfNum = state.dataHeatBal->Zone(zoneNum).HTSurfaceFirst, surfNum_end = state.dataHeatBal->Zone(zoneNum).HTSurfaceLast; surfNum <= surfNum_end; ++surfNum) { + ++numEnclosureSurfaces; } } thisEnclosure.NumOfSurfaces = numEnclosureSurfaces; @@ -568,14 +568,12 @@ namespace HeatBalanceIntRadExchange { int enclosureSurfNum = 0; for (int const zoneNum : thisEnclosure.ZoneNums) { int priorZoneTotEnclSurfs = enclosureSurfNum; - for (int surfNum = state.dataHeatBal->Zone(zoneNum).SurfaceFirst, surfNum_end = state.dataHeatBal->Zone(zoneNum).SurfaceLast; surfNum <= surfNum_end; ++surfNum) { - if (!Surface(surfNum).HeatTransSurf) continue; + for (int surfNum = state.dataHeatBal->Zone(zoneNum).HTSurfaceFirst, surfNum_end = state.dataHeatBal->Zone(zoneNum).HTSurfaceLast; surfNum <= surfNum_end; ++surfNum) { ++enclosureSurfNum; thisEnclosure.SurfacePtr(enclosureSurfNum) = surfNum; } // Store SurfaceReportNums to maintain original reporting order - for (int allSurfNum = state.dataHeatBal->Zone(zoneNum).SurfaceFirst, surfNum_end = state.dataHeatBal->Zone(zoneNum).SurfaceLast; allSurfNum <= surfNum_end; ++allSurfNum) { - if (!Surface(DataSurfaces::AllSurfaceListReportOrder[allSurfNum - 1]).HeatTransSurf) continue; + for (int allSurfNum = state.dataHeatBal->Zone(zoneNum).HTSurfaceFirst, surfNum_end = state.dataHeatBal->Zone(zoneNum).HTSurfaceLast; allSurfNum <= surfNum_end; ++allSurfNum) { for (int enclSNum = priorZoneTotEnclSurfs+1; enclSNum <= enclosureSurfNum; ++enclSNum) { if (thisEnclosure.SurfacePtr(enclSNum) == DataSurfaces::AllSurfaceListReportOrder[allSurfNum - 1]) { thisEnclosure.SurfaceReportNums.push_back(enclSNum); @@ -847,9 +845,9 @@ namespace HeatBalanceIntRadExchange { } int numEnclosureSurfaces = 0; for (int zoneNum : thisEnclosure.ZoneNums) { - for (int surfNum = state.dataHeatBal->Zone(zoneNum).SurfaceFirst, surfNum_end = state.dataHeatBal->Zone(zoneNum).SurfaceLast; surfNum <= surfNum_end; ++surfNum) { + for (int surfNum = state.dataHeatBal->Zone(zoneNum).HTSurfaceFirst, surfNum_end = state.dataHeatBal->Zone(zoneNum).HTSurfaceLast; surfNum <= surfNum_end; ++surfNum) { // Include only heat transfer surfaces - if (Surface(surfNum).HeatTransSurf) ++numEnclosureSurfaces; + ++numEnclosureSurfaces; } } thisEnclosure.NumOfSurfaces = numEnclosureSurfaces; @@ -867,9 +865,8 @@ namespace HeatBalanceIntRadExchange { int enclosureSurfNum = 0; for (int const zoneNum : thisEnclosure.ZoneNums) { int priorZoneTotEnclSurfs = enclosureSurfNum; - for (int surfNum = state.dataHeatBal->Zone(zoneNum).SurfaceFirst, surfNum_end = state.dataHeatBal->Zone(zoneNum).SurfaceLast; surfNum <= surfNum_end; ++surfNum) { + for (int surfNum = state.dataHeatBal->Zone(zoneNum).HTSurfaceFirst, surfNum_end = state.dataHeatBal->Zone(zoneNum).HTSurfaceLast; surfNum <= surfNum_end; ++surfNum) { // Do not include non-heat transfer surfaces - if (!Surface(surfNum).HeatTransSurf) continue; ++enclosureSurfNum; thisEnclosure.SurfacePtr(enclosureSurfNum) = surfNum; // Store pointers back to here @@ -877,8 +874,7 @@ namespace HeatBalanceIntRadExchange { Surface(surfNum).SolarEnclIndex = enclosureNum; } // Store SurfaceReportNums to maintain original reporting order - for (int allSurfNum = state.dataHeatBal->Zone(zoneNum).SurfaceFirst, surfNum_end = state.dataHeatBal->Zone(zoneNum).SurfaceLast; allSurfNum <= surfNum_end; ++allSurfNum) { - if (!Surface(DataSurfaces::AllSurfaceListReportOrder[allSurfNum - 1]).HeatTransSurf) continue; + for (int allSurfNum = state.dataHeatBal->Zone(zoneNum).HTSurfaceFirst, surfNum_end = state.dataHeatBal->Zone(zoneNum).HTSurfaceLast; allSurfNum <= surfNum_end; ++allSurfNum) { for (int enclSNum = priorZoneTotEnclSurfs + 1; enclSNum <= enclosureSurfNum; ++enclSNum) { if (thisEnclosure.SurfacePtr(enclSNum) == DataSurfaces::AllSurfaceListReportOrder[allSurfNum - 1]) { thisEnclosure.SurfaceReportNums.push_back(enclSNum); diff --git a/src/EnergyPlus/HeatBalanceManager.cc b/src/EnergyPlus/HeatBalanceManager.cc index 17102e0fbfe..83d079e32dc 100644 --- a/src/EnergyPlus/HeatBalanceManager.cc +++ b/src/EnergyPlus/HeatBalanceManager.cc @@ -7933,14 +7933,14 @@ namespace HeatBalanceManager { ZoneUnscheduled = false; ZoneScheduled = false; - for (iSurf = state.dataHeatBal->Zone(ZoneNum).SurfaceFirst; iSurf <= state.dataHeatBal->Zone(ZoneNum).SurfaceLast; ++iSurf) { + for (iSurf = state.dataHeatBal->Zone(ZoneNum).HTSurfaceFirst; iSurf <= state.dataHeatBal->Zone(ZoneNum).HTSurfaceLast; ++iSurf) { iConst = Surface(iSurf).Construction; if (Surface(iSurf).Class == SurfaceClass::Window) { SchedPtr = WindowScheduledSolarAbs(iSurf, iConst); } else { SchedPtr = SurfaceScheduledSolarInc(iSurf, iConst); } - if (iSurf == state.dataHeatBal->Zone(ZoneNum).SurfaceFirst) { + if (iSurf == state.dataHeatBal->Zone(ZoneNum).HTSurfaceFirst) { if (SchedPtr != 0) { ZoneScheduled = true; ZoneUnscheduled = false; @@ -7967,7 +7967,7 @@ namespace HeatBalanceManager { } if ((!ZoneScheduled) && (!ZoneUnscheduled)) { - for (iSurf = state.dataHeatBal->Zone(ZoneNum).SurfaceFirst; iSurf <= state.dataHeatBal->Zone(ZoneNum).SurfaceLast; ++iSurf) { + for (iSurf = state.dataHeatBal->Zone(ZoneNum).HTSurfaceFirst; iSurf <= state.dataHeatBal->Zone(ZoneNum).HTSurfaceLast; ++iSurf) { iConst = Surface(iSurf).Construction; if (Surface(iSurf).Class == SurfaceClass::Window) { SchedPtr = WindowScheduledSolarAbs(iSurf, iConst); diff --git a/src/EnergyPlus/HeatBalanceSurfaceManager.cc b/src/EnergyPlus/HeatBalanceSurfaceManager.cc index e9839684399..2891dd094be 100644 --- a/src/EnergyPlus/HeatBalanceSurfaceManager.cc +++ b/src/EnergyPlus/HeatBalanceSurfaceManager.cc @@ -504,7 +504,6 @@ namespace EnergyPlus::HeatBalanceSurfaceManager { for (int zoneNum = 1; zoneNum <= state.dataGlobal->NumOfZones; ++zoneNum) { int const firstSurfWin = state.dataHeatBal->Zone(zoneNum).WindowSurfaceFirst; int const lastSurfWin = state.dataHeatBal->Zone(zoneNum).WindowSurfaceLast; - if (firstSurfWin == -1) continue; for (int SurfNum = firstSurfWin; SurfNum <= lastSurfWin; ++SurfNum) { if (Surface(SurfNum).ExtSolar) { SurfaceWindow(SurfNum).IllumFromWinAtRefPtRep = 0.0; @@ -662,7 +661,6 @@ namespace EnergyPlus::HeatBalanceSurfaceManager { for (int zoneNum = 1; zoneNum <= state.dataGlobal->NumOfZones; ++zoneNum) { int const firstSurfWin = state.dataHeatBal->Zone(zoneNum).WindowSurfaceFirst; int const lastSurfWin = state.dataHeatBal->Zone(zoneNum).WindowSurfaceLast; - if (firstSurfWin == -1) continue; for (int SurfNum = firstSurfWin; SurfNum <= lastSurfWin; ++SurfNum) { SurfWinFracTimeShadingDeviceOn(SurfNum) = 0.0; if (IS_SHADED(SurfWinShadingFlag(SurfNum))) { @@ -719,16 +717,9 @@ namespace EnergyPlus::HeatBalanceSurfaceManager { InitHeatBalFiniteDiff(state); } - CTFConstOutPart = 0.0; - CTFConstInPart = 0.0; - if (state.dataHeatBal->AnyInternalHeatSourceInInput) { - CTFTsrcConstPart = 0.0; - CTFTuserConstPart = 0.0; - } - for (int zoneNum = 1; zoneNum <= state.dataGlobal->NumOfZones; ++zoneNum) {// Loop through all surfaces... - int const firstSurfOpaque = state.dataHeatBal->Zone(zoneNum).NonWindowSurfaceFirst; - int const lastSurfOpaque = state.dataHeatBal->Zone(zoneNum).NonWindowSurfaceLast; + int const firstSurfOpaque = state.dataHeatBal->Zone(zoneNum).OpaqOrIntMassSurfaceFirst; + int const lastSurfOpaque = state.dataHeatBal->Zone(zoneNum).OpaqOrIntMassSurfaceLast; for (int SurfNum = firstSurfOpaque; SurfNum <= lastSurfOpaque; ++SurfNum) { auto const &surface(Surface(SurfNum)); if (surface.HeatTransferAlgorithm != HeatTransferModel_CTF && @@ -809,8 +800,8 @@ namespace EnergyPlus::HeatBalanceSurfaceManager { // Zero out all of the radiant system heat balance coefficient arrays for (int zoneNum = 1; zoneNum <= state.dataGlobal->NumOfZones; ++zoneNum) {// Loop through all surfaces... - int const firstSurf = state.dataHeatBal->Zone(zoneNum).SurfaceFirst; - int const lastSurf = state.dataHeatBal->Zone(zoneNum).SurfaceLast; + int const firstSurf = state.dataHeatBal->Zone(zoneNum).HTSurfaceFirst; + int const lastSurf = state.dataHeatBal->Zone(zoneNum).HTSurfaceLast; for (int SurfNum = firstSurf; SurfNum <= lastSurf; ++SurfNum) { RadSysTiHBConstCoef(SurfNum) = 0.0; RadSysTiHBToutCoef(SurfNum) = 0.0; @@ -1384,7 +1375,6 @@ namespace EnergyPlus::HeatBalanceSurfaceManager { TempSurfIn.dimension(TotSurfaces, 0.0); TempInsOld.dimension(TotSurfaces, 0.0); TempSurfInTmp.dimension(TotSurfaces, 0.0); - TempSurfInTmp.dimension(TotSurfaces, 0.0); RefAirTemp.dimension(TotSurfaces, 0.0); SurfQRadLWOutSrdSurfs.dimension(TotSurfaces, 0.0); @@ -2080,8 +2070,8 @@ namespace EnergyPlus::HeatBalanceSurfaceManager { // Loop through zones... state.dataHeatBal->TempEffBulkAir(zoneNum) = 23.0; TempTstatAir(zoneNum) = 23.0; - int const firstSurf = state.dataHeatBal->Zone(zoneNum).SurfaceFirst; - int const lastSurf = state.dataHeatBal->Zone(zoneNum).SurfaceLast; + int const firstSurf = state.dataHeatBal->Zone(zoneNum).HTSurfaceFirst; + int const lastSurf = state.dataHeatBal->Zone(zoneNum).HTSurfaceLast; for (int SurfNum = firstSurf; SurfNum <= lastSurf; ++SurfNum) { SUMH(SurfNum) = 0; // module level array TempSurfIn(SurfNum) = 23.0; // module level array @@ -2121,8 +2111,8 @@ namespace EnergyPlus::HeatBalanceSurfaceManager { QAirExtReport(SurfNum) = 0.0; QHeatEmiReport(SurfNum) = 0.0; } // end of Surf array - int const firstSurfOpaq = state.dataHeatBal->Zone(zoneNum).NonWindowSurfaceFirst; - int const lastSurfOpaq = state.dataHeatBal->Zone(zoneNum).NonWindowSurfaceLast; + int const firstSurfOpaq = state.dataHeatBal->Zone(zoneNum).OpaqOrIntMassSurfaceFirst; + int const lastSurfOpaq = state.dataHeatBal->Zone(zoneNum).OpaqOrIntMassSurfaceLast; if (firstSurfOpaq >= 0) { for (int SurfNum = firstSurfOpaq; SurfNum <= lastSurfOpaq; ++SurfNum) { SurfOpaqInsFaceConduction(SurfNum) = 0.0; @@ -2246,7 +2236,6 @@ namespace EnergyPlus::HeatBalanceSurfaceManager { // (I)BLAST legacy routine QSUN // TODO: InterpSlatAng (XL) - // TODO: TDD in Zone // Using/Aliasing using SolarShading::CalcInteriorSolarDistribution; @@ -2291,8 +2280,8 @@ namespace EnergyPlus::HeatBalanceSurfaceManager { state.dataHeatBal->ZoneOpaqSurfExtFaceCondLossRep(zoneNum) = 0.0; } for (int zoneNum = 1; zoneNum <= state.dataGlobal->NumOfZones; ++zoneNum) { - int const firstSurfOpaq = state.dataHeatBal->Zone(zoneNum).NonWindowSurfaceFirst; - int const lastSurfOpaq = state.dataHeatBal->Zone(zoneNum).NonWindowSurfaceLast; + int const firstSurfOpaq = state.dataHeatBal->Zone(zoneNum).OpaqOrIntMassSurfaceFirst; + int const lastSurfOpaq = state.dataHeatBal->Zone(zoneNum).OpaqOrIntMassSurfaceLast; for (int SurfNum = firstSurfOpaq; SurfNum <= lastSurfOpaq; ++SurfNum) { SurfOpaqInsFaceCondGainRep(SurfNum) = 0.0; SurfOpaqInsFaceCondLossRep(SurfNum) = 0.0; @@ -2300,7 +2289,6 @@ namespace EnergyPlus::HeatBalanceSurfaceManager { SurfOpaqQRadSWLightsInAbs(SurfNum) = 0.0; SurfOpaqQRadSWOutAbs(SurfNum) = 0.0; SurfOpaqInitialDifSolInAbs(SurfNum) = 0.0; - SurfOpaqInsFaceBeamSolAbsorbed(SurfNum) = 0.0; state.dataHeatBal->SurfOpaqSWOutAbsTotalReport(SurfNum) = 0.0; state.dataHeatBal->SurfOpaqSWOutAbsEnergyReport(SurfNum) = 0.0; @@ -2756,8 +2744,8 @@ namespace EnergyPlus::HeatBalanceSurfaceManager { } for (int zoneNum = 1; zoneNum <= state.dataGlobal->NumOfZones; ++zoneNum) { - int const firstSurfOpaq = state.dataHeatBal->Zone(zoneNum).NonWindowSurfaceFirst; - int const lastSurfOpaq = state.dataHeatBal->Zone(zoneNum).NonWindowSurfaceLast; + int const firstSurfOpaq = state.dataHeatBal->Zone(zoneNum).OpaqOrIntMassSurfaceFirst; + int const lastSurfOpaq = state.dataHeatBal->Zone(zoneNum).OpaqOrIntMassSurfaceLast; for (int SurfNum = firstSurfOpaq; SurfNum <= lastSurfOpaq; ++SurfNum) { int ConstrNum = Surface(SurfNum).Construction; if (SurfWinStormWinFlag(SurfNum) == 1) ConstrNum = Surface(SurfNum).StormWinConstruction; @@ -3316,8 +3304,8 @@ namespace EnergyPlus::HeatBalanceSurfaceManager { SurfWinA(Lay, SurfNum) * currBeamSolar(SurfNum); state.dataHeatBal->SurfWinQRadSWwinAbsLayer(Lay, SurfNum) = state.dataHeatBal->SurfWinQRadSWwinAbs(Lay, SurfNum) * Surface(SurfNum).Area; state.dataHeatBal->SurfWinQRadSWwinAbsTot(SurfNum) += state.dataHeatBal->SurfWinQRadSWwinAbsLayer(Lay, SurfNum); + state.dataHeatBal->SurfWinQRadSWwinAbsTotEnergy(SurfNum) = state.dataHeatBal->SurfWinQRadSWwinAbsTot(SurfNum) * state.dataGlobal->TimeStepZoneSec; } - state.dataHeatBal->SurfWinQRadSWwinAbsTotEnergy(SurfNum) = state.dataHeatBal->SurfWinQRadSWwinAbsTot(SurfNum) * state.dataGlobal->TimeStepZoneSec; } } // End of sun-up check } @@ -3439,12 +3427,11 @@ namespace EnergyPlus::HeatBalanceSurfaceManager { // COMPUTE RADIANT GAINS ON SURFACES for (int zoneNum = 1; zoneNum <= state.dataGlobal->NumOfZones; ++zoneNum) { - int const firstSurfOpaque = state.dataHeatBal->Zone(zoneNum).NonWindowSurfaceFirst; - int const lastSurfOpaque = state.dataHeatBal->Zone(zoneNum).NonWindowSurfaceLast; + int const firstSurfOpaque = state.dataHeatBal->Zone(zoneNum).OpaqOrIntMassSurfaceFirst; + int const lastSurfOpaque = state.dataHeatBal->Zone(zoneNum).OpaqOrIntMassSurfaceLast; int const radEnclosureNum = state.dataHeatBal->Zone(zoneNum).RadiantEnclosureNum; int const solEnclosureNum = state.dataHeatBal->Zone(zoneNum).SolarEnclosureNum; for (int SurfNum = firstSurfOpaque; SurfNum <= lastSurfOpaque; ++SurfNum) { - if (Surface(SurfNum).Class == DataSurfaces::SurfaceClass::TDD_Dome) continue; // Skip tubular daylighting device domes int ConstrNum = Surface(SurfNum).Construction; Real64 AbsIntSurf = state.dataConstruction->Construct(ConstrNum).InsideAbsorpSolar; // Inside opaque surface solar absorptance @@ -3487,9 +3474,7 @@ namespace EnergyPlus::HeatBalanceSurfaceManager { int const firstSurfWin = state.dataHeatBal->Zone(zoneNum).WindowSurfaceFirst; int const lastSurfWin = state.dataHeatBal->Zone(zoneNum).WindowSurfaceLast; - if (firstSurfWin == -1) continue; for (int SurfNum = firstSurfWin; SurfNum <= lastSurfWin; ++SurfNum) { // Window - if (Surface(SurfNum).Class == SurfaceClass::TDD_Dome) continue; // Skip tubular daylighting device domes int ConstrNum = Surface(SurfNum).Construction; if (SurfWinWindowModelType(SurfNum) != WindowEQLModel) { @@ -3805,9 +3790,8 @@ namespace EnergyPlus::HeatBalanceSurfaceManager { } for (int zoneNum = 1; zoneNum <= state.dataGlobal->NumOfZones; ++zoneNum) { - int const firstSurf = state.dataHeatBal->Zone(zoneNum).SurfaceFirst; - int const lastSurf = state.dataHeatBal->Zone(zoneNum).SurfaceLast; - if (firstSurf <= 0) continue; + int const firstSurf = state.dataHeatBal->Zone(zoneNum).HTSurfaceFirst; + int const lastSurf = state.dataHeatBal->Zone(zoneNum).HTSurfaceLast; for (int SurfNum = firstSurf; SurfNum <= lastSurf; ++SurfNum) { int ConstrNum = Surface(SurfNum).Construction; state.dataHeatBal->ITABSF(SurfNum) = state.dataConstruction->Construct(ConstrNum).InsideAbsorpThermal; @@ -3823,7 +3807,6 @@ namespace EnergyPlus::HeatBalanceSurfaceManager { } int const firstSurfWin = state.dataHeatBal->Zone(zoneNum).WindowSurfaceFirst; int const lastSurfWin = state.dataHeatBal->Zone(zoneNum).WindowSurfaceLast; - if (firstSurfWin == -1) continue; for (int SurfNum = firstSurfWin; SurfNum <= lastSurfWin; ++SurfNum) { // For window with an interior shade or blind, emissivity is a combination of glass and shade/blind emissivity WinShadingType ShadeFlag = SurfWinShadingFlag(SurfNum); @@ -4567,7 +4550,6 @@ namespace EnergyPlus::HeatBalanceSurfaceManager { int HistTermNum; // DO loop counter for history terms int SideNum; // DO loop counter for surfaces sides (inside, outside) - int SurfNum; // Surface number DO loop counter static Array1D QExt1; // Heat flux at the exterior surface during first time step/series static Array1D QInt1; // Heat flux at the interior surface during first time step/series @@ -4607,33 +4589,34 @@ namespace EnergyPlus::HeatBalanceSurfaceManager { auto const l111(TH.index(1, 1, 1)); auto const l211(TH.index(2, 1, 1)); - auto l11(l111); - auto l21(l211); - for (SurfNum = 1; SurfNum <= TotSurfaces; - ++SurfNum, ++l11, ++l21) { // Loop through all (heat transfer) surfaces... [ l11 ] = ( 1, 1, SurfNum ), [ l21 ] = ( 2, 1, SurfNum ) - auto const &surface(Surface(SurfNum)); - - if (surface.Class == SurfaceClass::Window || !surface.HeatTransSurf) continue; + for (int zoneNum = 1; zoneNum <= state.dataGlobal->NumOfZones; ++zoneNum) { + int const firstSurfOpaq = state.dataHeatBal->Zone(zoneNum).OpaqOrIntMassSurfaceFirst; + int const lastSurfOpaq = state.dataHeatBal->Zone(zoneNum).OpaqOrIntMassSurfaceLast; + for (int SurfNum = firstSurfOpaq; SurfNum <= lastSurfOpaq; ++SurfNum) { + // Loop through all (heat transfer) surfaces... [ l11 ] = ( 1, 1, SurfNum ), [ l21 ] = ( 2, 1, SurfNum ) + int l11 = l111 + SurfNum - 1; + int l21 = l211 + SurfNum - 1; + auto const &surface(Surface(SurfNum)); - if ((surface.HeatTransferAlgorithm != HeatTransferModel_CTF) && (surface.HeatTransferAlgorithm != HeatTransferModel_EMPD)) continue; + if ((surface.HeatTransferAlgorithm != HeatTransferModel_CTF) && (surface.HeatTransferAlgorithm != HeatTransferModel_EMPD)) continue; - int const ConstrNum(surface.Construction); - auto const &construct(state.dataConstruction->Construct(ConstrNum)); + int const ConstrNum(surface.Construction); + auto const &construct(state.dataConstruction->Construct(ConstrNum)); - if (construct.NumCTFTerms == 0) continue; // Skip surfaces with no history terms + if (construct.NumCTFTerms == 0) continue; // Skip surfaces with no history terms - // Sign convention for the various terms in the following two equations - // is based on the form of the Conduction Transfer Function equation - // given by: - // Qin,now = (Sum of)(Y Tout) - (Sum of)(Z Tin) + (Sum of)(F Qin,old) + (Sum of)(V Qsrc) - // Qout,now = (Sum of)(X Tout) - (Sum of)(Y Tin) + (Sum of)(F Qout,old) + (Sum of)(W Qsrc) - // In both equations, flux is positive from outside to inside. The V and W terms are for radiant systems only. + // Sign convention for the various terms in the following two equations + // is based on the form of the Conduction Transfer Function equation + // given by: + // Qin,now = (Sum of)(Y Tout) - (Sum of)(Z Tin) + (Sum of)(F Qin,old) + (Sum of)(V Qsrc) + // Qout,now = (Sum of)(X Tout) - (Sum of)(Y Tin) + (Sum of)(F Qout,old) + (Sum of)(W Qsrc) + // In both equations, flux is positive from outside to inside. The V and W terms are for radiant systems only. - // Set current inside flux: - Real64 const QH_12 = QH[l21] = TH[l11] * construct.CTFCross(0) - TempSurfIn(SurfNum) * construct.CTFInside(0) + - CTFConstInPart(SurfNum); // Heat source/sink term for radiant systems - if (surface.Class == SurfaceClass::Floor || surface.Class == SurfaceClass::Wall || surface.Class == SurfaceClass::IntMass || - surface.Class == SurfaceClass::Roof || surface.Class == SurfaceClass::Door) { + // Set current inside flux: + Real64 const QH_12 = QH[l21] = TH[l11] * construct.CTFCross(0) - TempSurfIn(SurfNum) * construct.CTFInside(0) + + CTFConstInPart(SurfNum); // Heat source/sink term for radiant systems + // Only HT opaq surfaces are evaluated, previous if (surface.Class == SurfaceClass::Floor || surface.Class == SurfaceClass::Wall || surface.Class == SurfaceClass::IntMass || + // surface.Class == SurfaceClass::Roof || surface.Class == SurfaceClass::Door) checks are reduncant. if (construct.SourceSinkPresent) { Real64 const QH_12s = QH[l21] = QH_12 + QsrcHist(SurfNum, 1) * construct.CTFSourceIn(0); SurfOpaqInsFaceConduction(SurfNum) = surface.Area * QH_12s; @@ -4652,52 +4635,48 @@ namespace EnergyPlus::HeatBalanceSurfaceManager { } else { SurfOpaqInsFaceCondLossRep(SurfNum) = - SurfOpaqInsFaceConduction(SurfNum); } - } - // Update the temperature at the source/sink location (if one is present) - if (construct.SourceSinkPresent) { - TempSource(SurfNum) = TsrcHist(SurfNum, 1) = TH[l11] * construct.CTFTSourceOut(0) + TempSurfIn(SurfNum) * construct.CTFTSourceIn(0) + - QsrcHist(SurfNum, 1) * construct.CTFTSourceQ(0) + CTFTsrcConstPart(SurfNum); - TempUserLoc(SurfNum) = TuserHist(SurfNum, 1) = TH[l11] * construct.CTFTUserOut(0) + TempSurfIn(SurfNum) * construct.CTFTUserIn(0) + - QsrcHist(SurfNum, 1) * construct.CTFTUserSource(0) + CTFTuserConstPart(SurfNum); - } + // Update the temperature at the source/sink location (if one is present) + if (construct.SourceSinkPresent) { + TempSource(SurfNum) = TsrcHist(SurfNum, 1) = TH[l11] * construct.CTFTSourceOut(0) + TempSurfIn(SurfNum) * construct.CTFTSourceIn(0) + + QsrcHist(SurfNum, 1) * construct.CTFTSourceQ(0) + CTFTsrcConstPart(SurfNum); + TempUserLoc(SurfNum) = TuserHist(SurfNum, 1) = TH[l11] * construct.CTFTUserOut(0) + TempSurfIn(SurfNum) * construct.CTFTUserIn(0) + + QsrcHist(SurfNum, 1) * construct.CTFTUserSource(0) + CTFTuserConstPart(SurfNum); + } - if (surface.ExtBoundCond > 0) continue; // Don't need to evaluate outside for partitions + if (surface.ExtBoundCond > 0) continue; // Don't need to evaluate outside for partitions - // Set current outside flux: - if (construct.SourceSinkPresent) { - QH[l11] = TH[l11] * construct.CTFOutside(0) - TempSurfIn(SurfNum) * construct.CTFCross(0) + - QsrcHist(SurfNum, 1) * construct.CTFSourceOut(0) + CTFConstOutPart(SurfNum); // Heat source/sink term for radiant systems - } else { - QH[l11] = TH[l11] * construct.CTFOutside(0) - TempSurfIn(SurfNum) * construct.CTFCross(0) + CTFConstOutPart(SurfNum); - } - if (surface.Class == SurfaceClass::Floor || surface.Class == SurfaceClass::Wall || surface.Class == SurfaceClass::IntMass || - surface.Class == SurfaceClass::Roof || surface.Class == SurfaceClass::Door) { + // Set current outside flux: + if (construct.SourceSinkPresent) { + QH[l11] = TH[l11] * construct.CTFOutside(0) - TempSurfIn(SurfNum) * construct.CTFCross(0) + + QsrcHist(SurfNum, 1) * construct.CTFSourceOut(0) + CTFConstOutPart(SurfNum); // Heat source/sink term for radiant systems + } else { + QH[l11] = TH[l11] * construct.CTFOutside(0) - TempSurfIn(SurfNum) * construct.CTFCross(0) + CTFConstOutPart(SurfNum); + } SurfOpaqOutsideFaceConductionFlux(SurfNum) = -QH[l11]; // switch sign for balance at outside face SurfOpaqOutsideFaceConduction(SurfNum) = surface.Area * SurfOpaqOutsideFaceConductionFlux(SurfNum); } - } // ...end of loop over all (heat transfer) surfaces... - l11 = l111; - l21 = l211; - for (SurfNum = 1; SurfNum <= TotSurfaces; - ++SurfNum, ++l11, ++l21) { // Loop through all (heat transfer) surfaces... [ l11 ] = ( 1, 1, SurfNum ), [ l21 ] = ( 2, 1, SurfNum ) - auto const &surface(Surface(SurfNum)); - - if (surface.Class == SurfaceClass::Window || !surface.HeatTransSurf) continue; - if ((surface.HeatTransferAlgorithm != HeatTransferModel_CTF) && (surface.HeatTransferAlgorithm != HeatTransferModel_EMPD) && - (surface.HeatTransferAlgorithm != HeatTransferModel_TDD)) - continue; - if (SUMH(SurfNum) == 0) { // First time step in a block for a surface, update arrays - TempExt1(SurfNum) = TH[l11]; - TempInt1(SurfNum) = TempSurfIn(SurfNum); - QExt1(SurfNum) = QH[l11]; - QInt1(SurfNum) = QH[l21]; - if (state.dataHeatBal->AnyInternalHeatSourceInInput) { - Tsrc1(SurfNum) = TsrcHist(SurfNum, 1); - Tuser1(SurfNum) = TuserHist(SurfNum, 1); - Qsrc1(SurfNum) = QsrcHist(SurfNum, 1); + for (int zoneNum = 1; zoneNum <= state.dataGlobal->NumOfZones; ++zoneNum) { + int const firstSurfOpaq = state.dataHeatBal->Zone(zoneNum).OpaqOrIntMassSurfaceFirst; + int const lastSurfOpaq = state.dataHeatBal->Zone(zoneNum).OpaqOrIntMassSurfaceLast; + for (int SurfNum = firstSurfOpaq; SurfNum <= lastSurfOpaq; ++SurfNum) { + // Loop through all (heat transfer) surfaces... [ l11 ] = ( 1, 1, SurfNum ), [ l21 ] = ( 2, 1, SurfNum ) + int l11 = l111 + SurfNum - 1; + int l21 = l211 + SurfNum - 1; + if ((Surface(SurfNum).HeatTransferAlgorithm != HeatTransferModel_CTF) && (Surface(SurfNum).HeatTransferAlgorithm != HeatTransferModel_EMPD)) + continue; + if (SUMH(SurfNum) == 0) { // First time step in a block for a surface, update arrays + TempExt1(SurfNum) = TH[l11]; + TempInt1(SurfNum) = TempSurfIn(SurfNum); + QExt1(SurfNum) = QH[l11]; + QInt1(SurfNum) = QH[l21]; + if (state.dataHeatBal->AnyInternalHeatSourceInInput) { + Tsrc1(SurfNum) = TsrcHist(SurfNum, 1); + Tuser1(SurfNum) = TuserHist(SurfNum, 1); + Qsrc1(SurfNum) = QsrcHist(SurfNum, 1); + } } } @@ -4705,149 +4684,151 @@ namespace EnergyPlus::HeatBalanceSurfaceManager { // SHIFT TEMPERATURE AND FLUX HISTORIES: // SHIFT AIR TEMP AND FLUX SHIFT VALUES WHEN AT BOTTOM OF ARRAY SPACE. - for (SurfNum = 1; SurfNum <= TotSurfaces; ++SurfNum) { // Loop through all (heat transfer) surfaces... - auto const &surface(Surface(SurfNum)); - - if (surface.Class == SurfaceClass::Window || surface.Class == SurfaceClass::TDD_Dome || !surface.HeatTransSurf) continue; - if ((surface.HeatTransferAlgorithm != HeatTransferModel_CTF) && (surface.HeatTransferAlgorithm != HeatTransferModel_EMPD) && - (surface.HeatTransferAlgorithm != HeatTransferModel_TDD)) - continue; - - int const ConstrNum(surface.Construction); - auto const &construct(state.dataConstruction->Construct(ConstrNum)); - - ++SUMH(SurfNum); - SumTime(SurfNum) = double(SUMH(SurfNum)) * state.dataGlobal->TimeStepZone; - - if (SUMH(SurfNum) == construct.NumHistories) { - - SUMH(SurfNum) = 0; - - if (construct.NumCTFTerms > 1) { - int const numCTFTerms(construct.NumCTFTerms); - for (SideNum = 1; SideNum <= 2; ++SideNum) { // Tuned Index order switched for cache friendliness - auto l(THM.index(SideNum, numCTFTerms, SurfNum)); - auto const li(THM.size3()); - auto l1(l + li); - for (HistTermNum = numCTFTerms + 1; HistTermNum >= 3; --HistTermNum, l1 = l, l -= li) { // Tuned Linear indexing - // TH( SideNum, HistTermNum, SurfNum ) = THM( SideNum, HistTermNum, SurfNum ) = THM( SideNum, HistTermNum - 1, SurfNum ); - // QH( SideNum, HistTermNum, SurfNum ) = QHM( SideNum, HistTermNum, SurfNum ) = QHM( SideNum, HistTermNum - 1, SurfNum ); - TH[l1] = THM[l1] = THM[l]; - QH[l1] = QHM[l1] = QHM[l]; + + for (int zoneNum = 1; zoneNum <= state.dataGlobal->NumOfZones; ++zoneNum) { + int const firstSurfOpaq = state.dataHeatBal->Zone(zoneNum).OpaqOrIntMassSurfaceFirst; + int const lastSurfOpaq = state.dataHeatBal->Zone(zoneNum).OpaqOrIntMassSurfaceLast; + for (int SurfNum = firstSurfOpaq; SurfNum <= lastSurfOpaq; ++SurfNum) { + auto const &surface(Surface(SurfNum)); + + if ((surface.HeatTransferAlgorithm != HeatTransferModel_CTF) && (surface.HeatTransferAlgorithm != HeatTransferModel_EMPD)) + continue; + + int const ConstrNum(surface.Construction); + auto const &construct(state.dataConstruction->Construct(ConstrNum)); + + ++SUMH(SurfNum); + SumTime(SurfNum) = double(SUMH(SurfNum)) * state.dataGlobal->TimeStepZone; + + if (SUMH(SurfNum) == construct.NumHistories) { + + SUMH(SurfNum) = 0; + + if (construct.NumCTFTerms > 1) { + int const numCTFTerms(construct.NumCTFTerms); + for (SideNum = 1; SideNum <= 2; ++SideNum) { // Tuned Index order switched for cache friendliness + auto l(THM.index(SideNum, numCTFTerms, SurfNum)); + auto const li(THM.size3()); + auto l1(l + li); + for (HistTermNum = numCTFTerms + 1; HistTermNum >= 3; --HistTermNum, l1 = l, l -= li) { // Tuned Linear indexing + // TH( SideNum, HistTermNum, SurfNum ) = THM( SideNum, HistTermNum, SurfNum ) = THM( SideNum, HistTermNum - 1, SurfNum ); + // QH( SideNum, HistTermNum, SurfNum ) = QHM( SideNum, HistTermNum, SurfNum ) = QHM( SideNum, HistTermNum - 1, SurfNum ); + TH[l1] = THM[l1] = THM[l]; + QH[l1] = QHM[l1] = QHM[l]; + } } - } - if (construct.SourceSinkPresent) { - auto m(TsrcHistM.index(SurfNum, numCTFTerms)); - auto m1(m + 1); - for (HistTermNum = numCTFTerms + 1; HistTermNum >= 3; --HistTermNum, --m, --m1) { // Tuned Linear indexing - // TsrcHist( SurfNum, HistTerm ) = TsrcHistM( SurfNum, HHistTerm ) = TsrcHistM( SurfNum, HistTermNum - 1 ); - // QsrcHist( SurfNum, HistTerm ) = QsrcHistM( SurfNum, HHistTerm ) = QsrcHistM( SurfNum, HistTermNum - 1 ); - TsrcHist[m1] = TsrcHistM[m1] = TsrcHistM[m]; - QsrcHist[m1] = QsrcHistM[m1] = QsrcHistM[m]; - TuserHist[m1] = TuserHistM[m1] = TuserHistM[m]; + if (construct.SourceSinkPresent) { + auto m(TsrcHistM.index(SurfNum, numCTFTerms)); + auto m1(m + 1); + for (HistTermNum = numCTFTerms + 1; HistTermNum >= 3; --HistTermNum, --m, --m1) { // Tuned Linear indexing + // TsrcHist( SurfNum, HistTerm ) = TsrcHistM( SurfNum, HHistTerm ) = TsrcHistM( SurfNum, HistTermNum - 1 ); + // QsrcHist( SurfNum, HistTerm ) = QsrcHistM( SurfNum, HHistTerm ) = QsrcHistM( SurfNum, HistTermNum - 1 ); + TsrcHist[m1] = TsrcHistM[m1] = TsrcHistM[m]; + QsrcHist[m1] = QsrcHistM[m1] = QsrcHistM[m]; + TuserHist[m1] = TuserHistM[m1] = TuserHistM[m]; + } } } - } - // Tuned Linear indexing - // THM( 1, 2, SurfNum ) = TempExt1( SurfNum ); - // THM( 2, 2, SurfNum ) = TempInt1( SurfNum ); - // TsrcHistM( SurfNum, 2 ) = Tsrc1( SurfNum ); - // QHM( 1, 2, SurfNum ) = QExt1( SurfNum ); - // QHM( 2, 2, SurfNum ) = QInt1( SurfNum ); - // QsrcHistM( SurfNum, 2 ) = Qsrc1( SurfNum ); - // - // TH( 1, 2, SurfNum ) = THM( 1, 2, SurfNum ); - // TH( 2, 2, SurfNum ) = THM( 2, 2, SurfNum ); - // TsrcHist( SurfNum, 2 ) = TsrcHistM( SurfNum, 2 ); - // QH( 1, 2, SurfNum ) = QHM( 1, 2, SurfNum ); - // QH( 2, 2, SurfNum ) = QHM( 2, 2, SurfNum ); - // QsrcHist( SurfNum, 2 ) = QsrcHistM( SurfNum, 2 ); - - auto const l21(TH.index(1, 2, SurfNum)); // Linear index - auto const l22(TH.index(2, 2, SurfNum)); // Linear index - THM[l21] = TempExt1(SurfNum); - THM[l22] = TempInt1(SurfNum); - QHM[l21] = QExt1(SurfNum); - QHM[l22] = QInt1(SurfNum); - - TH[l21] = THM[l21]; - TH[l22] = THM(2, 2, SurfNum); - QH[l21] = QHM[l21]; - QH[l22] = QHM(2, 2, SurfNum); + // Tuned Linear indexing + // THM( 1, 2, SurfNum ) = TempExt1( SurfNum ); + // THM( 2, 2, SurfNum ) = TempInt1( SurfNum ); + // TsrcHistM( SurfNum, 2 ) = Tsrc1( SurfNum ); + // QHM( 1, 2, SurfNum ) = QExt1( SurfNum ); + // QHM( 2, 2, SurfNum ) = QInt1( SurfNum ); + // QsrcHistM( SurfNum, 2 ) = Qsrc1( SurfNum ); + // + // TH( 1, 2, SurfNum ) = THM( 1, 2, SurfNum ); + // TH( 2, 2, SurfNum ) = THM( 2, 2, SurfNum ); + // TsrcHist( SurfNum, 2 ) = TsrcHistM( SurfNum, 2 ); + // QH( 1, 2, SurfNum ) = QHM( 1, 2, SurfNum ); + // QH( 2, 2, SurfNum ) = QHM( 2, 2, SurfNum ); + // QsrcHist( SurfNum, 2 ) = QsrcHistM( SurfNum, 2 ); + + auto const l21(TH.index(1, 2, SurfNum)); // Linear index + auto const l22(TH.index(2, 2, SurfNum)); // Linear index + THM[l21] = TempExt1(SurfNum); + THM[l22] = TempInt1(SurfNum); + QHM[l21] = QExt1(SurfNum); + QHM[l22] = QInt1(SurfNum); + + TH[l21] = THM[l21]; + TH[l22] = THM(2, 2, SurfNum); + QH[l21] = QHM[l21]; + QH[l22] = QHM(2, 2, SurfNum); - if (construct.SourceSinkPresent) { - TsrcHistM(SurfNum, 2) = Tsrc1(SurfNum); - TuserHistM(SurfNum, 2) = Tuser1(SurfNum); - QsrcHistM(SurfNum, 2) = Qsrc1(SurfNum); - TsrcHist(SurfNum, 2) = TsrcHistM(SurfNum, 2); - TuserHist(SurfNum, 2) = TuserHistM(SurfNum, 2); - QsrcHist(SurfNum, 2) = QsrcHistM(SurfNum, 2); - } + if (construct.SourceSinkPresent) { + TsrcHistM(SurfNum, 2) = Tsrc1(SurfNum); + TuserHistM(SurfNum, 2) = Tuser1(SurfNum); + QsrcHistM(SurfNum, 2) = Qsrc1(SurfNum); + TsrcHist(SurfNum, 2) = TsrcHistM(SurfNum, 2); + TuserHist(SurfNum, 2) = TuserHistM(SurfNum, 2); + QsrcHist(SurfNum, 2) = QsrcHistM(SurfNum, 2); + } - } else { + } else { - Real64 const sum_steps(SumTime(SurfNum) / construct.CTFTimeStep); - if (construct.NumCTFTerms > 1) { - int const numCTFTerms(construct.NumCTFTerms); - for (SideNum = 1; SideNum <= 2; ++SideNum) { // Tuned Index order switched for cache friendliness - auto l(THM.index(SideNum, numCTFTerms, SurfNum)); - auto const s3(THM.size3()); - auto l1(l + s3); - for (HistTermNum = numCTFTerms + 1; HistTermNum >= 3; --HistTermNum, l1 = l, l -= s3) { // Tuned Linear indexing - // Real64 const THM_l1( THM( SideNum, HistTermNum, SurfNum ) ); - // TH( SideNum, HistTermNum, SurfNum ) = THM_l1 - ( THM_l1 - THM( SideNum, HistTermNum - 1, SurfNum ) ) * sum_steps; - // Real64 const QHM_l1( QHM( SideNum, HistTermNum, SurfNum ) ); - // QH( SideNum, HistTermNum, SurfNum ) = QHM_l1 - ( QHM_l1 - QHM( SideNum, HistTermNum - 1, SurfNum ) ) * sum_steps; - Real64 const THM_l1(THM[l1]); - TH[l1] = THM_l1 - (THM_l1 - THM[l]) * sum_steps; - Real64 const QHM_l1(QHM[l1]); - QH[l1] = QHM_l1 - (QHM_l1 - QHM[l]) * sum_steps; + Real64 const sum_steps(SumTime(SurfNum) / construct.CTFTimeStep); + if (construct.NumCTFTerms > 1) { + int const numCTFTerms(construct.NumCTFTerms); + for (SideNum = 1; SideNum <= 2; ++SideNum) { // Tuned Index order switched for cache friendliness + auto l(THM.index(SideNum, numCTFTerms, SurfNum)); + auto const s3(THM.size3()); + auto l1(l + s3); + for (HistTermNum = numCTFTerms + 1; HistTermNum >= 3; --HistTermNum, l1 = l, l -= s3) { // Tuned Linear indexing + // Real64 const THM_l1( THM( SideNum, HistTermNum, SurfNum ) ); + // TH( SideNum, HistTermNum, SurfNum ) = THM_l1 - ( THM_l1 - THM( SideNum, HistTermNum - 1, SurfNum ) ) * sum_steps; + // Real64 const QHM_l1( QHM( SideNum, HistTermNum, SurfNum ) ); + // QH( SideNum, HistTermNum, SurfNum ) = QHM_l1 - ( QHM_l1 - QHM( SideNum, HistTermNum - 1, SurfNum ) ) * sum_steps; + Real64 const THM_l1(THM[l1]); + TH[l1] = THM_l1 - (THM_l1 - THM[l]) * sum_steps; + Real64 const QHM_l1(QHM[l1]); + QH[l1] = QHM_l1 - (QHM_l1 - QHM[l]) * sum_steps; + } } - } - if (construct.SourceSinkPresent) { - auto m(TsrcHistM.index(SurfNum, numCTFTerms)); - auto m1(m + 1); - for (HistTermNum = numCTFTerms + 1; HistTermNum >= 3; --HistTermNum, --m, --m1) { // Tuned Linear indexing [ l ] == () - // Real64 const TsrcHistM_elem( TsrcHistM( SurfNum, HistTermNum ) ); - // TsrcHist( SurfNum, HistTermNum ) = TsrcHistM_elem - ( TsrcHistM_elem - TsrcHistM( SurfNum, HistTermNum - 1 ) ) * - // sum_steps; Real64 const QsrcHistM_elem( QsrcHistM( SurfNum, HistTermNum ) ); QsrcHist( SurfNum, HistTermNum ) = - // QsrcHistM_elem - ( QsrcHistM_elem - QsrcHistM( SurfNum, HistTermNum - 1 ) ) * sum_steps; - Real64 const TsrcHistM_m1(TsrcHistM[m1]); - TsrcHist[m1] = TsrcHistM_m1 - (TsrcHistM_m1 - TsrcHistM[m]) * sum_steps; - Real64 const QsrcHistM_m1(QsrcHistM[m1]); - QsrcHist[m1] = QsrcHistM_m1 - (QsrcHistM_m1 - QsrcHistM[m]) * sum_steps; - Real64 const TuserHistM_m1(TuserHistM[m1]); - TuserHist[m1] = TuserHistM_m1 - (TuserHistM_m1 - TuserHistM[m]) * sum_steps; + if (construct.SourceSinkPresent) { + auto m(TsrcHistM.index(SurfNum, numCTFTerms)); + auto m1(m + 1); + for (HistTermNum = numCTFTerms + 1; HistTermNum >= 3; --HistTermNum, --m, --m1) { // Tuned Linear indexing [ l ] == () + // Real64 const TsrcHistM_elem( TsrcHistM( SurfNum, HistTermNum ) ); + // TsrcHist( SurfNum, HistTermNum ) = TsrcHistM_elem - ( TsrcHistM_elem - TsrcHistM( SurfNum, HistTermNum - 1 ) ) * + // sum_steps; Real64 const QsrcHistM_elem( QsrcHistM( SurfNum, HistTermNum ) ); QsrcHist( SurfNum, HistTermNum ) = + // QsrcHistM_elem - ( QsrcHistM_elem - QsrcHistM( SurfNum, HistTermNum - 1 ) ) * sum_steps; + Real64 const TsrcHistM_m1(TsrcHistM[m1]); + TsrcHist[m1] = TsrcHistM_m1 - (TsrcHistM_m1 - TsrcHistM[m]) * sum_steps; + Real64 const QsrcHistM_m1(QsrcHistM[m1]); + QsrcHist[m1] = QsrcHistM_m1 - (QsrcHistM_m1 - QsrcHistM[m]) * sum_steps; + Real64 const TuserHistM_m1(TuserHistM[m1]); + TuserHist[m1] = TuserHistM_m1 - (TuserHistM_m1 - TuserHistM[m]) * sum_steps; + } } } - } - // Tuned Linear indexing - // TH( 1, 2, SurfNum ) = THM( 1, 2, SurfNum ) - ( THM( 1, 2, SurfNum ) - TempExt1( SurfNum ) ) * sum_steps; - // TH( 2, 2, SurfNum ) = THM( 2, 2, SurfNum ) - ( THM( 2, 2, SurfNum ) - TempInt1( SurfNum ) ) * sum_steps; - // QH( 1, 2, SurfNum ) = QHM( 1, 2, SurfNum ) - ( QHM( 1, 2, SurfNum ) - QExt1( SurfNum ) ) * sum_steps; - // QH( 2, 2, SurfNum ) = QHM( 2, 2, SurfNum ) - ( QHM( 2, 2, SurfNum ) - QInt1( SurfNum ) ) * sum_steps; + // Tuned Linear indexing + // TH( 1, 2, SurfNum ) = THM( 1, 2, SurfNum ) - ( THM( 1, 2, SurfNum ) - TempExt1( SurfNum ) ) * sum_steps; + // TH( 2, 2, SurfNum ) = THM( 2, 2, SurfNum ) - ( THM( 2, 2, SurfNum ) - TempInt1( SurfNum ) ) * sum_steps; + // QH( 1, 2, SurfNum ) = QHM( 1, 2, SurfNum ) - ( QHM( 1, 2, SurfNum ) - QExt1( SurfNum ) ) * sum_steps; + // QH( 2, 2, SurfNum ) = QHM( 2, 2, SurfNum ) - ( QHM( 2, 2, SurfNum ) - QInt1( SurfNum ) ) * sum_steps; - auto const l21(TH.index(1, 2, SurfNum)); // Linear index - auto const l22(TH.index(2, 2, SurfNum)); // Linear index - TH[l21] = THM[l21] - (THM[l21] - TempExt1(SurfNum)) * sum_steps; - TH[l22] = THM[l22] - (THM[l22] - TempInt1(SurfNum)) * sum_steps; - QH[l21] = QHM[l21] - (QHM[l21] - QExt1(SurfNum)) * sum_steps; - QH[l22] = QHM[l22] - (QHM[l22] - QInt1(SurfNum)) * sum_steps; + auto const l21(TH.index(1, 2, SurfNum)); // Linear index + auto const l22(TH.index(2, 2, SurfNum)); // Linear index + TH[l21] = THM[l21] - (THM[l21] - TempExt1(SurfNum)) * sum_steps; + TH[l22] = THM[l22] - (THM[l22] - TempInt1(SurfNum)) * sum_steps; + QH[l21] = QHM[l21] - (QHM[l21] - QExt1(SurfNum)) * sum_steps; + QH[l22] = QHM[l22] - (QHM[l22] - QInt1(SurfNum)) * sum_steps; - // Tuned Linear indexing - // TsrcHist( SurfNum, 2 ) = TsrcHistM( SurfNum, 2 ) - ( TsrcHistM( SurfNum, 2 ) - Tsrc1( SurfNum ) ) * sum_steps; - // QsrcHist( SurfNum, 2 ) = QsrcHistM( SurfNum, 2 ) - ( QsrcHistM( SurfNum, 2 ) - Qsrc1( SurfNum ) ) * sum_steps; + // Tuned Linear indexing + // TsrcHist( SurfNum, 2 ) = TsrcHistM( SurfNum, 2 ) - ( TsrcHistM( SurfNum, 2 ) - Tsrc1( SurfNum ) ) * sum_steps; + // QsrcHist( SurfNum, 2 ) = QsrcHistM( SurfNum, 2 ) - ( QsrcHistM( SurfNum, 2 ) - Qsrc1( SurfNum ) ) * sum_steps; - if (construct.SourceSinkPresent) { - auto const l2(TsrcHist.index(SurfNum, 2)); - TsrcHist[l2] = TsrcHistM[l2] - (TsrcHistM[l2] - Tsrc1(SurfNum)) * sum_steps; - QsrcHist[l2] = QsrcHistM[l2] - (QsrcHistM[l2] - Qsrc1(SurfNum)) * sum_steps; - TuserHist[l2] = TuserHistM[l2] - (TuserHistM[l2] - Tuser1(SurfNum)) * sum_steps; + if (construct.SourceSinkPresent) { + auto const l2(TsrcHist.index(SurfNum, 2)); + TsrcHist[l2] = TsrcHistM[l2] - (TsrcHistM[l2] - Tsrc1(SurfNum)) * sum_steps; + QsrcHist[l2] = QsrcHistM[l2] - (QsrcHistM[l2] - Qsrc1(SurfNum)) * sum_steps; + TuserHist[l2] = TuserHistM[l2] - (TuserHistM[l2] - Tuser1(SurfNum)) * sum_steps; + } } } - } // ...end of loop over all (heat transfer) surfaces } @@ -4888,7 +4869,7 @@ namespace EnergyPlus::HeatBalanceSurfaceManager { for (ZoneNum = 1; ZoneNum <= state.dataGlobal->NumOfZones; ++ZoneNum) { if (present(ZoneToResimulate) && (ZoneNum != ZoneToResimulate)) continue; SumAET = 0.0; - for (SurfNum = state.dataHeatBal->Zone(ZoneNum).SurfaceFirst; SurfNum <= state.dataHeatBal->Zone(ZoneNum).SurfaceLast; ++SurfNum) { + for (SurfNum = state.dataHeatBal->Zone(ZoneNum).HTSurfaceFirst; SurfNum <= state.dataHeatBal->Zone(ZoneNum).HTSurfaceLast; ++SurfNum) { SumAET += SurfaceAE(SurfNum) * TempSurfIn(SurfNum); } if (ZoneAESum(ZoneNum) > 0.01) { @@ -5310,14 +5291,17 @@ namespace EnergyPlus::HeatBalanceSurfaceManager { QSteamBaseboardSurf(SurfNum) + QElecBaseboardSurf(SurfNum)) * surfaceArea; QRadHVACInReport(SurfNum) = QdotRadHVACInRep(SurfNum) * state.dataGlobal->TimeStepZoneSec; - - if (Surface(SurfNum).Class == SurfaceClass::Floor || Surface(SurfNum).Class == SurfaceClass::Wall || - Surface(SurfNum).Class == SurfaceClass::IntMass || Surface(SurfNum).Class == SurfaceClass::Roof || - Surface(SurfNum).Class == SurfaceClass::Door) { - + if (Surface(SurfNum).ExtBoundCond == ExternalEnvironment) { + SumSurfaceHeatEmission += QHeatEmiReport(SurfNum) * state.dataGlobal->TimeStepZoneSec; + } + } + for (int ZoneNum = 1; ZoneNum <= state.dataGlobal->NumOfZones; ++ZoneNum) { + int const firstSurfOpaq = state.dataHeatBal->Zone(ZoneNum).OpaqOrIntMassSurfaceFirst; + int const lastSurfOpaq = state.dataHeatBal->Zone(ZoneNum).OpaqOrIntMassSurfaceLast; + for (int SurfNum = firstSurfOpaq; SurfNum <= lastSurfOpaq; ++SurfNum) { // inside face conduction updates SurfOpaqInsFaceConductionEnergy(SurfNum) = SurfOpaqInsFaceConduction(SurfNum) * state.dataGlobal->TimeStepZoneSec; - state.dataHeatBal->ZoneOpaqSurfInsFaceCond(Surface(SurfNum).Zone) += SurfOpaqInsFaceConduction(SurfNum); + state.dataHeatBal->ZoneOpaqSurfInsFaceCond(ZoneNum) += SurfOpaqInsFaceConduction(SurfNum); SurfOpaqInsFaceCondGainRep(SurfNum) = 0.0; SurfOpaqInsFaceCondLossRep(SurfNum) = 0.0; if (SurfOpaqInsFaceConduction(SurfNum) >= 0.0) { @@ -5328,7 +5312,7 @@ namespace EnergyPlus::HeatBalanceSurfaceManager { // outside face conduction updates SurfOpaqOutsideFaceConductionEnergy(SurfNum) = SurfOpaqOutsideFaceConduction(SurfNum) * state.dataGlobal->TimeStepZoneSec; - state.dataHeatBal->ZoneOpaqSurfExtFaceCond(Surface(SurfNum).Zone) += SurfOpaqOutsideFaceConduction(SurfNum); + state.dataHeatBal->ZoneOpaqSurfExtFaceCond(ZoneNum) += SurfOpaqOutsideFaceConduction(SurfNum); SurfOpaqExtFaceCondGainRep(SurfNum) = 0.0; SurfOpaqExtFaceCondLossRep(SurfNum) = 0.0; if (SurfOpaqOutsideFaceConduction(SurfNum) >= 0.0) { @@ -5361,13 +5345,8 @@ namespace EnergyPlus::HeatBalanceSurfaceManager { } else { SurfOpaqStorageCondLossRep(SurfNum) = - SurfOpaqStorageConduction(SurfNum); } - } // opaque heat transfer surfaces. - if (Surface(SurfNum).ExtBoundCond == ExternalEnvironment) { - SumSurfaceHeatEmission += QHeatEmiReport(SurfNum) * state.dataGlobal->TimeStepZoneSec; - } - } // loop over surfaces - for (int ZoneNum = 1; ZoneNum <= state.dataGlobal->NumOfZones; ++ZoneNum) { + if (state.dataHeatBal->ZoneOpaqSurfInsFaceCond(ZoneNum) >= 0.0) { state.dataHeatBal->ZoneOpaqSurfInsFaceCondGainRep(ZoneNum) = state.dataHeatBal->ZoneOpaqSurfInsFaceCond(ZoneNum); state.dataHeatBal->ZnOpqSurfInsFaceCondGnRepEnrg(ZoneNum) = state.dataHeatBal->ZoneOpaqSurfInsFaceCondGainRep(ZoneNum) * state.dataGlobal->TimeStepZoneSec; @@ -5511,11 +5490,8 @@ namespace EnergyPlus::HeatBalanceSurfaceManager { } for (int zoneNum = 1; zoneNum <= state.dataGlobal->NumOfZones; ++zoneNum) {// Loop through all surfaces... - int const firstSurfOpaque = state.dataHeatBal->Zone(zoneNum).NonWindowSurfaceFirst; - int const lastSurfOpaque = state.dataHeatBal->Zone(zoneNum).NonWindowSurfaceLast; - if (firstSurfOpaque <= 0) continue; - for (int SurfNum = firstSurfOpaque; SurfNum <= lastSurfOpaque; ++SurfNum) { - + for (int SurfNum = state.dataHeatBal->Zone(zoneNum).HTSurfaceFirst; SurfNum <= state.dataHeatBal->Zone(zoneNum).HTSurfaceLast; ++SurfNum) { + if (Surface(SurfNum).Class == SurfaceClass::Window) continue; if (present(ZoneToResimulate)) { if ((zoneNum != ZoneToResimulate) && (AdjacentZoneToSurface(SurfNum) != ZoneToResimulate)) { continue; // skip surfaces that are not associated with this zone @@ -5958,7 +5934,6 @@ namespace EnergyPlus::HeatBalanceSurfaceManager { } } // Calculate LWR from surrounding surfaces if defined for an exterior surface - SurfQRadLWOutSrdSurfs(SurfNum) = 0; if (Surface(SurfNum).HasSurroundingSurfProperties) { int SrdSurfsNum = Surface(SurfNum).SurroundingSurfacesNum; // Absolute temperature of the outside surface of an exterior surface @@ -5973,8 +5948,8 @@ namespace EnergyPlus::HeatBalanceSurfaceManager { } if (Surface(SurfNum).HeatTransferAlgorithm == HeatTransferModel_CTF || - Surface(SurfNum).HeatTransferAlgorithm == HeatTransferModel_EMPD) { - + Surface(SurfNum).HeatTransferAlgorithm == HeatTransferModel_EMPD || + Surface(SurfNum).Class == SurfaceClass::TDD_Dome) { CalcOutsideSurfTemp(state, SurfNum, zoneNum, ConstrNum, HMovInsul, TempExt, MovInsulErrorFlag); if (MovInsulErrorFlag) ShowFatalError(state, "CalcOutsideSurfTemp: Program terminates due to preceding conditions."); @@ -6091,7 +6066,7 @@ namespace EnergyPlus::HeatBalanceSurfaceManager { DataHeatBalSurface::Zone_has_mixed_HT_models.resize(state.dataGlobal->NumOfZones + 1, false); for (int iZone = 1; iZone <= state.dataGlobal->NumOfZones; ++iZone) { auto const &zone(state.dataHeatBal->Zone(iZone)); - for (int iSurf = zone.SurfaceFirst, eSurf = zone.SurfaceLast; iSurf <= eSurf; ++iSurf) { + for (int iSurf = zone.HTSurfaceFirst, eSurf = zone.HTSurfaceLast; iSurf <= eSurf; ++iSurf) { auto const alg(Surface(iSurf).HeatTransferAlgorithm); if ((alg == HeatTransferModel_CondFD) || (alg == HeatTransferModel_HAMT) || (alg == HeatTransferModel_Kiva)) { DataHeatBalSurface::Zone_has_mixed_HT_models[iZone] = true; @@ -6796,7 +6771,7 @@ namespace EnergyPlus::HeatBalanceSurfaceManager { Real64 &TH12(TH(2, 1, SurfNum)); TH12 = TempSurfInRep(SurfNum) = TempSurfIn(SurfNum); SurfTempOut(SurfNum) = TH11; // For reporting - + if (SurfWinOriginalClass(SurfNum) == SurfaceClass::TDD_Dome) continue; if (SurfWinOriginalClass(SurfNum) == 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 @@ -7030,8 +7005,8 @@ namespace EnergyPlus::HeatBalanceSurfaceManager { if (calcHeatBalInsideSurfCTFOnlyFirstTime) { // Set up coefficient arrays that never change - loop over non-window HT surfaces for (int zoneNum = FirstZone; zoneNum <= LastZone; ++zoneNum) { - int const firstSurf = state.dataHeatBal->Zone(zoneNum).NonWindowSurfaceFirst; - int const lastSurf = state.dataHeatBal->Zone(zoneNum).NonWindowSurfaceLast; + int const firstSurf = state.dataHeatBal->Zone(zoneNum).OpaqOrIntMassSurfaceFirst; + int const lastSurf = state.dataHeatBal->Zone(zoneNum).OpaqOrIntMassSurfaceLast; for (int surfNum = firstSurf; surfNum <= lastSurf; ++surfNum) { int const ConstrNum = Surface(surfNum).Construction; auto const &construct(state.dataConstruction->Construct(ConstrNum)); @@ -7061,9 +7036,9 @@ namespace EnergyPlus::HeatBalanceSurfaceManager { } for (int zoneNum = FirstZone; zoneNum <= LastZone; ++zoneNum) { - int const firstSurf = state.dataHeatBal->Zone(zoneNum).SurfaceFirst; - int const lastSurf = state.dataHeatBal->Zone(zoneNum).SurfaceLast; - + // loop over all heat transfer surface except TDD Dome. + int const firstSurf = state.dataHeatBal->Zone(zoneNum).OpaqOrWinSurfaceFirst; + int const lastSurf = state.dataHeatBal->Zone(zoneNum).OpaqOrWinSurfaceLast; // determine reference air temperatures and other variable terms - loop over all surfaces for (int surfNum = firstSurf; surfNum <= lastSurf; ++surfNum) { @@ -7088,49 +7063,43 @@ namespace EnergyPlus::HeatBalanceSurfaceManager { IsNotPoolSurf(surfNum) = 1; } } - - // Skip TDD:DOME objects. Inside temp is handled by TDD:DIFFUSER. - if (Surface(surfNum).Class == SurfaceClass::TDD_Dome) continue; - - { - auto const SELECT_CASE_var(Surface(surfNum).TAirRef); - if (SELECT_CASE_var == ZoneMeanAirTemp) { - RefAirTemp(surfNum) = MAT(zoneNum); - state.dataHeatBal->TempEffBulkAir(surfNum) = MAT(zoneNum); // for reporting surf adjacent air temp - } else if (SELECT_CASE_var == AdjacentAirTemp) { - RefAirTemp(surfNum) = state.dataHeatBal->TempEffBulkAir(surfNum); - } else if (SELECT_CASE_var == ZoneSupplyAirTemp) { - // determine ZoneEquipConfigNum for this zone - int ZoneEquipConfigNum = zoneNum; - // check whether this zone is a controlled zone or not - if (!state.dataHeatBal->Zone(zoneNum).IsControlled) { - ShowFatalError(state, "Zones must be controlled for Ceiling-Diffuser Convection model. No system serves zone " + - state.dataHeatBal->Zone(zoneNum).Name); - return; - } - // determine supply air conditions - Real64 SumSysMCp = 0.0; - Real64 SumSysMCpT = 0.0; - Real64 const CpAir = Psychrometrics::PsyCpAirFnW(ZoneAirHumRat(zoneNum)); - for (int NodeNum = 1; NodeNum <= state.dataZoneEquip->ZoneEquipConfig(ZoneEquipConfigNum).NumInletNodes; ++NodeNum) { - Real64 NodeTemp = DataLoopNode::Node(state.dataZoneEquip->ZoneEquipConfig(ZoneEquipConfigNum).InletNode(NodeNum)).Temp; - Real64 MassFlowRate = - DataLoopNode::Node(state.dataZoneEquip->ZoneEquipConfig(ZoneEquipConfigNum).InletNode(NodeNum)).MassFlowRate; - SumSysMCp += MassFlowRate * CpAir; - SumSysMCpT += MassFlowRate * CpAir * NodeTemp; - } - // a weighted average of the inlet temperatures. - if (SumSysMCp > 0.0) { // protect div by zero - RefAirTemp(surfNum) = SumSysMCpT / SumSysMCp; // BG changed 02-16-2005 to add index (SurfNum) - } else { - RefAirTemp(surfNum) = MAT(zoneNum); - } - state.dataHeatBal->TempEffBulkAir(surfNum) = RefAirTemp(surfNum); // for reporting surf adjacent air temp + auto const SELECT_CASE_var(Surface(surfNum).TAirRef); + if (SELECT_CASE_var == ZoneMeanAirTemp) { + RefAirTemp(surfNum) = MAT(zoneNum); + state.dataHeatBal->TempEffBulkAir(surfNum) = MAT(zoneNum); // for reporting surf adjacent air temp + } else if (SELECT_CASE_var == AdjacentAirTemp) { + RefAirTemp(surfNum) = state.dataHeatBal->TempEffBulkAir(surfNum); + } else if (SELECT_CASE_var == ZoneSupplyAirTemp) { + // determine ZoneEquipConfigNum for this zone + int ZoneEquipConfigNum = zoneNum; + // check whether this zone is a controlled zone or not + if (!state.dataHeatBal->Zone(zoneNum).IsControlled) { + ShowFatalError(state, "Zones must be controlled for Ceiling-Diffuser Convection model. No system serves zone " + + state.dataHeatBal->Zone(zoneNum).Name); + return; + } + // determine supply air conditions + Real64 SumSysMCp = 0.0; + Real64 SumSysMCpT = 0.0; + Real64 const CpAir = Psychrometrics::PsyCpAirFnW(ZoneAirHumRat(zoneNum)); + for (int NodeNum = 1; NodeNum <= state.dataZoneEquip->ZoneEquipConfig(ZoneEquipConfigNum).NumInletNodes; ++NodeNum) { + Real64 NodeTemp = DataLoopNode::Node(state.dataZoneEquip->ZoneEquipConfig(ZoneEquipConfigNum).InletNode(NodeNum)).Temp; + Real64 MassFlowRate = + DataLoopNode::Node(state.dataZoneEquip->ZoneEquipConfig(ZoneEquipConfigNum).InletNode(NodeNum)).MassFlowRate; + SumSysMCp += MassFlowRate * CpAir; + SumSysMCpT += MassFlowRate * CpAir * NodeTemp; + } + // a weighted average of the inlet temperatures. + if (SumSysMCp > 0.0) { // protect div by zero + RefAirTemp(surfNum) = SumSysMCpT / SumSysMCp; // BG changed 02-16-2005 to add index (SurfNum) } else { - // currently set to mean air temp but should add error warning here RefAirTemp(surfNum) = MAT(zoneNum); - state.dataHeatBal->TempEffBulkAir(surfNum) = MAT(zoneNum); // for reporting surf adjacent air temp } + state.dataHeatBal->TempEffBulkAir(surfNum) = RefAirTemp(surfNum); // for reporting surf adjacent air temp + } else { + // currently set to mean air temp but should add error warning here + RefAirTemp(surfNum) = MAT(zoneNum); + state.dataHeatBal->TempEffBulkAir(surfNum) = MAT(zoneNum); // for reporting surf adjacent air temp } } @@ -7170,8 +7139,8 @@ namespace EnergyPlus::HeatBalanceSurfaceManager { } // Set up coefficient arrays prior to calculations and precalc terms that do no change during iteration - non-window surfaces - int const firstNonWinSurf = state.dataHeatBal->Zone(zoneNum).NonWindowSurfaceFirst; - int const lastNonWinSurf = state.dataHeatBal->Zone(zoneNum).NonWindowSurfaceLast; + int const firstNonWinSurf = state.dataHeatBal->Zone(zoneNum).OpaqOrIntMassSurfaceFirst; + int const lastNonWinSurf = state.dataHeatBal->Zone(zoneNum).OpaqOrIntMassSurfaceLast; Real64 const timeStepZoneSeconds = state.dataGlobal->TimeStepZoneSec; // local for vectorization Real64 const iterDampConstant = IterDampConst; // local for vectorization // this loop auto-vectorizes @@ -7207,8 +7176,8 @@ namespace EnergyPlus::HeatBalanceSurfaceManager { ConvectionCoefficients::InitInteriorConvectionCoeffs(state, TempSurfIn, ZoneToResimulate); // Since HConvIn has changed re-calculate a few terms - non-window surfaces for (int zoneNum = FirstZone; zoneNum <= LastZone; ++zoneNum) { - int const firstSurf = state.dataHeatBal->Zone(zoneNum).NonWindowSurfaceFirst; - int const lastSurf = state.dataHeatBal->Zone(zoneNum).NonWindowSurfaceLast; + int const firstSurf = state.dataHeatBal->Zone(zoneNum).OpaqOrIntMassSurfaceFirst; + int const lastSurf = state.dataHeatBal->Zone(zoneNum).OpaqOrIntMassSurfaceLast; Real64 const timeStepZoneSeconds = state.dataGlobal->TimeStepZoneSec; // local for vectorization Real64 const iterDampConstant = IterDampConst; // local for vectorization // this loop auto-vectorizes @@ -7226,8 +7195,8 @@ namespace EnergyPlus::HeatBalanceSurfaceManager { // Loop over non-window surfaces for (int zoneNum = FirstZone; zoneNum <= LastZone; ++zoneNum) { - int const firstNonWinSurf = state.dataHeatBal->Zone(zoneNum).NonWindowSurfaceFirst; - int const lastNonWinSurf = state.dataHeatBal->Zone(zoneNum).NonWindowSurfaceLast; + int const firstNonWinSurf = state.dataHeatBal->Zone(zoneNum).OpaqOrIntMassSurfaceFirst; + int const lastNonWinSurf = state.dataHeatBal->Zone(zoneNum).OpaqOrIntMassSurfaceLast; Real64 const iterDampConstant = IterDampConst; // local for vectorization // this loop auto-vectorizes for (int surfNum = firstNonWinSurf; surfNum <= lastNonWinSurf; ++surfNum) { @@ -7490,9 +7459,8 @@ namespace EnergyPlus::HeatBalanceSurfaceManager { } } - // Loop over all HT surfaces - int const firstSurf = state.dataHeatBal->Zone(zoneNum).SurfaceFirst; - int const lastSurf = state.dataHeatBal->Zone(zoneNum).SurfaceLast; + int const firstSurf = state.dataHeatBal->Zone(zoneNum).OpaqOrWinSurfaceFirst; + int const lastSurf = state.dataHeatBal->Zone(zoneNum).OpaqOrWinSurfaceLast; for (int surfNum = firstSurf; surfNum <= lastSurf; ++surfNum) { auto &surface(Surface(surfNum)); auto &zone(state.dataHeatBal->Zone(zoneNum)); @@ -7500,7 +7468,6 @@ namespace EnergyPlus::HeatBalanceSurfaceManager { Real64 &TH12(TH(2, 1, surfNum)); TH12 = TempSurfInRep(surfNum) = TempSurfIn(surfNum); SurfTempOut(surfNum) = TH11; // For reporting - if (SurfWinOriginalClass(surfNum) == 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 @@ -7545,8 +7512,8 @@ namespace EnergyPlus::HeatBalanceSurfaceManager { // Convergence check - Loop through all relevant non-window surfaces to check for convergence... Real64 MaxDelTemp = 0.0; // Maximum change in surface temperature for any opaque surface from one iteration to the next for (int zoneNum = FirstZone; zoneNum <= LastZone; ++zoneNum) { - int const firstNonWinSurf = state.dataHeatBal->Zone(zoneNum).NonWindowSurfaceFirst; - int const lastNonWinSurf = state.dataHeatBal->Zone(zoneNum).NonWindowSurfaceLast; + int const firstNonWinSurf = state.dataHeatBal->Zone(zoneNum).OpaqOrIntMassSurfaceFirst; + int const lastNonWinSurf = state.dataHeatBal->Zone(zoneNum).OpaqOrIntMassSurfaceLast; for (int surfNum = firstNonWinSurf; surfNum <= lastNonWinSurf; ++surfNum) { Real64 delta = TempSurfIn(surfNum) - TempInsOld(surfNum); Real64 absDif = std::abs(delta); @@ -7589,11 +7556,9 @@ namespace EnergyPlus::HeatBalanceSurfaceManager { // Set various surface output variables and other record keeping - after iterations are complete - all HT surfaces for (int zoneNum = FirstZone; zoneNum <= LastZone; ++zoneNum) { - int const firstSurf = state.dataHeatBal->Zone(zoneNum).SurfaceFirst; - int const lastSurf = state.dataHeatBal->Zone(zoneNum).SurfaceLast; + int const firstSurf = state.dataHeatBal->Zone(zoneNum).OpaqOrWinSurfaceFirst; + int const lastSurf = state.dataHeatBal->Zone(zoneNum).OpaqOrWinSurfaceLast; for (int surfNum = firstSurf; surfNum <= lastSurf; ++surfNum) { - if (Surface(surfNum).Class == SurfaceClass::TDD_Dome) continue; // Skip TDD:DOME objects. Inside temp is handled by TDD:DIFFUSER. - // Inside Face Convection - sign convention is positive means energy going into inside face from the air. auto const HConvInTemp_fac(-state.dataHeatBal->HConvIn(surfNum) * (TempSurfIn(surfNum) - RefAirTemp(surfNum))); QdotConvInRep(surfNum) = Surface(surfNum).Area * HConvInTemp_fac; diff --git a/src/EnergyPlus/HighTempRadiantSystem.cc b/src/EnergyPlus/HighTempRadiantSystem.cc index d70ccdce73e..6ac99d1e376 100644 --- a/src/EnergyPlus/HighTempRadiantSystem.cc +++ b/src/EnergyPlus/HighTempRadiantSystem.cc @@ -1480,8 +1480,7 @@ namespace HighTempRadiantSystem { SumHATsurf = 0.0; - for (SurfNum = state.dataHeatBal->Zone(ZoneNum).SurfaceFirst; SurfNum <= state.dataHeatBal->Zone(ZoneNum).SurfaceLast; ++SurfNum) { - if (!Surface(SurfNum).HeatTransSurf) continue; // Skip non-heat transfer surfaces + for (SurfNum = state.dataHeatBal->Zone(ZoneNum).HTSurfaceFirst; SurfNum <= state.dataHeatBal->Zone(ZoneNum).HTSurfaceLast; ++SurfNum) { Area = Surface(SurfNum).Area; diff --git a/src/EnergyPlus/InternalHeatGains.cc b/src/EnergyPlus/InternalHeatGains.cc index 196949118fb..5d82e22f859 100644 --- a/src/EnergyPlus/InternalHeatGains.cc +++ b/src/EnergyPlus/InternalHeatGains.cc @@ -5705,11 +5705,10 @@ namespace InternalHeatGains { AllocateLoadComponentArrays(state); } for (int zoneNum = 1; zoneNum <= state.dataGlobal->NumOfZones; ++zoneNum) {// Loop through all surfaces... - int const firstSurf = state.dataHeatBal->Zone(zoneNum).SurfaceFirst; - int const lastSurf = state.dataHeatBal->Zone(zoneNum).SurfaceLast; + int const firstSurf = state.dataHeatBal->Zone(zoneNum).HTSurfaceFirst; + int const lastSurf = state.dataHeatBal->Zone(zoneNum).HTSurfaceLast; if (firstSurf <= 0) continue; for (int SurfNum = firstSurf; SurfNum <= lastSurf; ++SurfNum) { - if (!Surface(SurfNum).HeatTransSurf) continue; // Skip non-heat transfer surfaces int const radEnclosureNum = state.dataHeatBal->Zone(zoneNum).RadiantEnclosureNum; if (!state.dataGlobal->doLoadComponentPulseNow) { state.dataHeatBal->SurfQRadThermInAbs(SurfNum) = state.dataHeatBal->QL(radEnclosureNum) * state.dataHeatBal->TMULT(radEnclosureNum) * state.dataHeatBal->ITABSF(SurfNum); diff --git a/src/EnergyPlus/LowTempRadiantSystem.cc b/src/EnergyPlus/LowTempRadiantSystem.cc index 84910f3b043..08a48591d2e 100644 --- a/src/EnergyPlus/LowTempRadiantSystem.cc +++ b/src/EnergyPlus/LowTempRadiantSystem.cc @@ -5740,11 +5740,7 @@ namespace LowTempRadiantSystem { // Return value Real64 sumHATsurf(0.0); - auto &Zone(state.dataHeatBal->Zone); - - for (int surfNum = Zone(ZoneNum).SurfaceFirst; surfNum <= Zone(ZoneNum).SurfaceLast; ++surfNum) { - if (!Surface(surfNum).HeatTransSurf) continue; // Skip non-heat transfer surfaces - + for (int surfNum = state.dataHeatBal->Zone(ZoneNum).HTSurfaceFirst; surfNum <= state.dataHeatBal->Zone(ZoneNum).HTSurfaceLast; ++surfNum) { Real64 Area = Surface(surfNum).Area; if (Surface(surfNum).Class == SurfaceClass::Window) { diff --git a/src/EnergyPlus/MundtSimMgr.cc b/src/EnergyPlus/MundtSimMgr.cc index 98022b2fbf5..309c4954312 100644 --- a/src/EnergyPlus/MundtSimMgr.cc +++ b/src/EnergyPlus/MundtSimMgr.cc @@ -230,8 +230,8 @@ namespace MundtSimMgr { // find number of zones using the Mundt model ++NumOfMundtZones; // find maximum number of surfaces in zones using the Mundt model - SurfFirst = Zone(ZoneIndex).SurfaceFirst; - NumOfSurfs = Zone(ZoneIndex).SurfaceLast - SurfFirst + 1; + SurfFirst = Zone(ZoneIndex).HTSurfaceFirst; + NumOfSurfs = Zone(ZoneIndex).HTSurfaceLast - SurfFirst + 1; MaxNumOfSurfs = max(MaxNumOfSurfs, NumOfSurfs); // fine maximum number of air nodes in zones using the Mundt model NumOfAirNodes = state.dataRoomAirMod->TotNumOfZoneAirNodes(ZoneIndex); diff --git a/src/EnergyPlus/OutputReportTabular.cc b/src/EnergyPlus/OutputReportTabular.cc index 2f6facdbb0e..e4fb89ffa7d 100644 --- a/src/EnergyPlus/OutputReportTabular.cc +++ b/src/EnergyPlus/OutputReportTabular.cc @@ -13689,8 +13689,7 @@ namespace EnergyPlus::OutputReportTabular { Real64 adjFeneSurfNetRadSeq = 0.0; // code from ComputeDelayedComponents starts - for (int jSurf = Zone(zoneIndex).SurfaceFirst; jSurf <= Zone(zoneIndex).SurfaceLast; ++jSurf) { - if (!Surface(jSurf).HeatTransSurf) continue; // Skip non-heat transfer surfaces + for (int jSurf = Zone(zoneIndex).HTSurfaceFirst; jSurf <= Zone(zoneIndex).HTSurfaceLast; ++jSurf) { // for each time step, step back through time and apply decay curve to radiant heat for each end use absorbed in each surface Real64 peopleConvFromSurf = 0.0; @@ -13903,8 +13902,7 @@ namespace EnergyPlus::OutputReportTabular { // opaque surfaces - must combine individual surfaces by class and other side conditions delayOpaque = 0.0; - for (int kSurf = Zone(zoneIndex).SurfaceFirst; kSurf <= Zone(zoneIndex).SurfaceLast; ++kSurf) { - if (!Surface(kSurf).HeatTransSurf) continue; // Skip non-heat transfer surfaces + for (int kSurf = Zone(zoneIndex).HTSurfaceFirst; kSurf <= Zone(zoneIndex).HTSurfaceLast; ++kSurf) { curExtBoundCond = Surface(kSurf).ExtBoundCond; // if exterior is other side coefficients using ground preprocessor terms then diff --git a/src/EnergyPlus/OutputReports.cc b/src/EnergyPlus/OutputReports.cc index 2f8cc504747..d6e75526f56 100644 --- a/src/EnergyPlus/OutputReports.cc +++ b/src/EnergyPlus/OutputReports.cc @@ -1391,7 +1391,7 @@ void DetailsForSurfaces(EnergyPlusData &state, int const RptType) // (1=Vertices } for (ZoneNum = 1; ZoneNum <= state.dataGlobal->NumOfZones; ++ZoneNum) { - *eiostream << "Zone Surfaces," << state.dataHeatBal->Zone(ZoneNum).Name << "," << (state.dataHeatBal->Zone(ZoneNum).SurfaceLast - state.dataHeatBal->Zone(ZoneNum).AllSurfaceFirst + 1) << '\n'; + *eiostream << "Zone Surfaces," << state.dataHeatBal->Zone(ZoneNum).Name << "," << (state.dataHeatBal->Zone(ZoneNum).AllSurfaceLast - state.dataHeatBal->Zone(ZoneNum).AllSurfaceFirst + 1) << '\n'; for (int surf : DataSurfaces::AllSurfaceListReportOrder) { if (Surface(surf).Zone != ZoneNum) continue; SolarDiffusing = ""; diff --git a/src/EnergyPlus/RoomAirModelAirflowNetwork.cc b/src/EnergyPlus/RoomAirModelAirflowNetwork.cc index 80fdac71068..563ef2449ea 100644 --- a/src/EnergyPlus/RoomAirModelAirflowNetwork.cc +++ b/src/EnergyPlus/RoomAirModelAirflowNetwork.cc @@ -311,7 +311,7 @@ namespace RoomAirModelAirflowNetwork { // loop over all zones with RoomAirflowNetwork model for (LoopZone = 1; LoopZone <= state.dataGlobal->NumOfZones; ++LoopZone) { if (!state.dataRoomAirMod->RoomAirflowNetworkZoneInfo(LoopZone).IsUsed) continue; - NumSurfs = state.dataHeatBal->Zone(LoopZone).SurfaceLast - state.dataHeatBal->Zone(LoopZone).SurfaceFirst + 1; + NumSurfs = state.dataHeatBal->Zone(LoopZone).HTSurfaceLast - state.dataHeatBal->Zone(LoopZone).HTSurfaceFirst + 1; for (LoopAirNode = 1; LoopAirNode <= state.dataRoomAirMod->RoomAirflowNetworkZoneInfo(LoopZone).NumOfAirNodes; ++LoopAirNode) { // loop over all the modeled room air nodes // calculate volume of air in node's control volume @@ -1024,14 +1024,13 @@ namespace RoomAirModelAirflowNetwork { // Modified by Gu to include assigned surfaces only shown in the surface lsit if (!state.dataRoomAirMod->RoomAirflowNetworkZoneInfo(ZoneNum).Node(RoomAirNodeNum).HasSurfacesAssigned) return; - for (SurfNum = state.dataHeatBal->Zone(ZoneNum).SurfaceFirst; SurfNum <= state.dataHeatBal->Zone(ZoneNum).SurfaceLast; ++SurfNum) { + for (SurfNum = state.dataHeatBal->Zone(ZoneNum).HTSurfaceFirst; SurfNum <= state.dataHeatBal->Zone(ZoneNum).HTSurfaceLast; ++SurfNum) { - if (!Surface(SurfNum).HeatTransSurf) continue; // Skip non - heat transfer surfaces if (state.dataRoomAirMod->RoomAirflowNetworkZoneInfo(ZoneNum).ControlAirNodeID == RoomAirNodeNum) { Found = false; for (Loop = 1; Loop <= state.dataRoomAirMod->RoomAirflowNetworkZoneInfo(ZoneNum).NumOfAirNodes; ++Loop) { if (Loop != RoomAirNodeNum) { - if (state.dataRoomAirMod->RoomAirflowNetworkZoneInfo(ZoneNum).Node(Loop).SurfMask(SurfNum - state.dataHeatBal->Zone(ZoneNum).SurfaceFirst + 1)) { + if (state.dataRoomAirMod->RoomAirflowNetworkZoneInfo(ZoneNum).Node(Loop).SurfMask(SurfNum - state.dataHeatBal->Zone(ZoneNum).HTSurfaceFirst + 1)) { Found = true; break; } @@ -1039,7 +1038,7 @@ namespace RoomAirModelAirflowNetwork { } if (Found) continue; } else { - if (!state.dataRoomAirMod->RoomAirflowNetworkZoneInfo(ZoneNum).Node(RoomAirNodeNum).SurfMask(SurfNum - state.dataHeatBal->Zone(ZoneNum).SurfaceFirst + 1)) continue; + if (!state.dataRoomAirMod->RoomAirflowNetworkZoneInfo(ZoneNum).Node(RoomAirNodeNum).SurfMask(SurfNum - state.dataHeatBal->Zone(ZoneNum).HTSurfaceFirst + 1)) continue; } HA = 0.0; @@ -1177,8 +1176,7 @@ namespace RoomAirModelAirflowNetwork { SumHmARa = 0.0; SumHmARaW = 0.0; - for (SurfNum = state.dataHeatBal->Zone(ZoneNum).SurfaceFirst; SurfNum <= state.dataHeatBal->Zone(ZoneNum).SurfaceLast; ++SurfNum) { - if (!Surface(SurfNum).HeatTransSurf) continue; // Skip non - heat transfer surfaces + for (SurfNum = state.dataHeatBal->Zone(ZoneNum).HTSurfaceFirst; SurfNum <= state.dataHeatBal->Zone(ZoneNum).HTSurfaceLast; ++SurfNum) { if (Surface(SurfNum).Class == SurfaceClass::Window) continue; if (state.dataRoomAirMod->RoomAirflowNetworkZoneInfo(ZoneNum).ControlAirNodeID == RoomAirNode) { @@ -1186,7 +1184,7 @@ namespace RoomAirModelAirflowNetwork { for (Loop = 1; Loop <= state.dataRoomAirMod->RoomAirflowNetworkZoneInfo(ZoneNum).NumOfAirNodes; ++Loop) { // None - assigned surfaces belong to the zone node if (Loop != RoomAirNode) { - if (state.dataRoomAirMod->RoomAirflowNetworkZoneInfo(ZoneNum).Node(Loop).SurfMask(SurfNum - state.dataHeatBal->Zone(ZoneNum).SurfaceFirst + 1)) { + if (state.dataRoomAirMod->RoomAirflowNetworkZoneInfo(ZoneNum).Node(Loop).SurfMask(SurfNum - state.dataHeatBal->Zone(ZoneNum).HTSurfaceFirst + 1)) { Found = true; break; } @@ -1194,7 +1192,7 @@ namespace RoomAirModelAirflowNetwork { } if (Found) continue; } else { - if (!state.dataRoomAirMod->RoomAirflowNetworkZoneInfo(ZoneNum).Node(RoomAirNode).SurfMask(SurfNum - state.dataHeatBal->Zone(ZoneNum).SurfaceFirst + 1)) continue; + if (!state.dataRoomAirMod->RoomAirflowNetworkZoneInfo(ZoneNum).Node(RoomAirNode).SurfMask(SurfNum - state.dataHeatBal->Zone(ZoneNum).HTSurfaceFirst + 1)) continue; } if (Surface(SurfNum).HeatTransferAlgorithm == HeatTransferModel_HAMT) { diff --git a/src/EnergyPlus/RoomAirModelManager.cc b/src/EnergyPlus/RoomAirModelManager.cc index 4900b977906..3033622eb26 100644 --- a/src/EnergyPlus/RoomAirModelManager.cc +++ b/src/EnergyPlus/RoomAirModelManager.cc @@ -346,13 +346,13 @@ namespace RoomAirModelManager { state.dataRoomAirMod->AirPatternZoneInfo(ZoneNum).ZoneID = ZoneNum; // figure number of surfaces for this zone - state.dataRoomAirMod->AirPatternZoneInfo(ZoneNum).totNumSurfs = state.dataHeatBal->Zone(ZoneNum).SurfaceLast - state.dataHeatBal->Zone(ZoneNum).SurfaceFirst + 1; + state.dataRoomAirMod->AirPatternZoneInfo(ZoneNum).totNumSurfs = state.dataHeatBal->Zone(ZoneNum).HTSurfaceLast - state.dataHeatBal->Zone(ZoneNum).HTSurfaceFirst + 1; // allocate nested derived type for surface info state.dataRoomAirMod->AirPatternZoneInfo(ZoneNum).Surf.allocate(state.dataRoomAirMod->AirPatternZoneInfo(ZoneNum).totNumSurfs); // Fill in what we know for nested structure for surfaces for (thisSurfinZone = 1; thisSurfinZone <= state.dataRoomAirMod->AirPatternZoneInfo(ZoneNum).totNumSurfs; ++thisSurfinZone) { - thisHBsurfID = state.dataHeatBal->Zone(ZoneNum).SurfaceFirst + thisSurfinZone - 1; + thisHBsurfID = state.dataHeatBal->Zone(ZoneNum).HTSurfaceFirst + thisSurfinZone - 1; if (Surface(thisHBsurfID).Class == DataSurfaces::SurfaceClass::IntMass) { state.dataRoomAirMod->AirPatternZoneInfo(ZoneNum).Surf(thisSurfinZone).SurfID = thisHBsurfID; state.dataRoomAirMod->AirPatternZoneInfo(ZoneNum).Surf(thisSurfinZone).Zeta = 0.5; @@ -663,7 +663,7 @@ namespace RoomAirModelManager { ErrorsFound = true; } else { ZoneNum = state.dataRoomAirMod->AirNode(AirNodeNum).ZonePtr; - NumOfSurfs = state.dataHeatBal->Zone(ZoneNum).SurfaceLast - state.dataHeatBal->Zone(ZoneNum).SurfaceFirst + 1; + NumOfSurfs = state.dataHeatBal->Zone(ZoneNum).HTSurfaceLast - state.dataHeatBal->Zone(ZoneNum).HTSurfaceFirst + 1; state.dataRoomAirMod->AirNode(AirNodeNum).SurfMask.allocate(NumOfSurfs); } @@ -749,8 +749,8 @@ namespace RoomAirModelManager { // this air node is in this zone; hence, first get name of all surfaces in this zone ZoneNum = state.dataRoomAirMod->AirNode(AirNodeNum).ZonePtr; - SurfFirst = state.dataHeatBal->Zone(ZoneNum).SurfaceFirst; - NumOfSurfs = state.dataHeatBal->Zone(ZoneNum).SurfaceLast - state.dataHeatBal->Zone(ZoneNum).SurfaceFirst + 1; + SurfFirst = state.dataHeatBal->Zone(ZoneNum).HTSurfaceFirst; + NumOfSurfs = state.dataHeatBal->Zone(ZoneNum).HTSurfaceLast - state.dataHeatBal->Zone(ZoneNum).HTSurfaceFirst + 1; // terminate the program due to a severe error in the specified input if ((NumSurfsInvolved) > NumOfSurfs) { @@ -1426,7 +1426,7 @@ namespace RoomAirModelManager { } else { state.dataRoomAirMod->RoomAirflowNetworkZoneInfo(ZoneNum).ControlAirNodeID = AirCntrlNodeNum; } - state.dataRoomAirMod->RoomAirflowNetworkZoneInfo(ZoneNum).totNumSurfs = state.dataHeatBal->Zone(ZoneNum).SurfaceLast - state.dataHeatBal->Zone(ZoneNum).SurfaceFirst + 1; + state.dataRoomAirMod->RoomAirflowNetworkZoneInfo(ZoneNum).totNumSurfs = state.dataHeatBal->Zone(ZoneNum).HTSurfaceLast - state.dataHeatBal->Zone(ZoneNum).HTSurfaceFirst + 1; } // loop thru NumOfRoomAirflowNetControl cCurrentModuleObject = "RoomAir:Node:AirflowNetwork"; @@ -1501,7 +1501,7 @@ namespace RoomAirModelManager { if (RAFNNodeNum > 0) { // found it foundList = true; NumSurfsThisNode = NumAlphas - 1; - NumOfSurfs = state.dataHeatBal->Zone(ZoneNum).SurfaceLast - state.dataHeatBal->Zone(ZoneNum).SurfaceFirst + 1; + NumOfSurfs = state.dataHeatBal->Zone(ZoneNum).HTSurfaceLast - state.dataHeatBal->Zone(ZoneNum).HTSurfaceFirst + 1; if (allocated(state.dataRoomAirMod->RoomAirflowNetworkZoneInfo(ZoneNum).Node(RAFNNodeNum).SurfMask)) { // throw error found twice ShowSevereError(state, "GetRoomAirflowNetworkData: Invalid " + cAlphaFieldNames(1) + " = " + cAlphaArgs(1)); @@ -1514,7 +1514,7 @@ namespace RoomAirModelManager { state.dataRoomAirMod->RoomAirflowNetworkZoneInfo(ZoneNum).Node(RAFNNodeNum).HasSurfacesAssigned = true; // relate surfaces to this air node and check to see whether surface names are specified correctly or not SurfCount = 0; - SurfFirst = state.dataHeatBal->Zone(ZoneNum).SurfaceFirst - 1; + SurfFirst = state.dataHeatBal->Zone(ZoneNum).HTSurfaceFirst - 1; for (ListSurfNum = 2; ListSurfNum <= NumAlphas; ++ListSurfNum) { for (SurfNum = 1; SurfNum <= NumOfSurfs; ++SurfNum) { // IF( cAlphaArgs( ListSurfNum ) == Surface( SurfFirst + SurfNum ).Name ) THEN @@ -1927,7 +1927,7 @@ namespace RoomAirModelManager { SetZoneAux = true; // cycle in this zone for all the surfaces - for (SurfNum = state.dataHeatBal->Zone(ZNum).SurfaceFirst; SurfNum <= state.dataHeatBal->Zone(ZNum).SurfaceLast; ++SurfNum) { + for (SurfNum = state.dataHeatBal->Zone(ZNum).HTSurfaceFirst; SurfNum <= state.dataHeatBal->Zone(ZNum).HTSurfaceLast; ++SurfNum) { if (Surface(SurfNum).Class != DataSurfaces::SurfaceClass::IntMass) { // Recalculate lowest and highest height for the zone Z1Zone = std::numeric_limits::max(); diff --git a/src/EnergyPlus/RoomAirModelUserTempPattern.cc b/src/EnergyPlus/RoomAirModelUserTempPattern.cc index 4e900112ab9..71a1326f365 100644 --- a/src/EnergyPlus/RoomAirModelUserTempPattern.cc +++ b/src/EnergyPlus/RoomAirModelUserTempPattern.cc @@ -707,7 +707,7 @@ namespace RoomAirModelUserTempPattern { ZMax = 0.0; ZMin = 0.0; Count = 0; - for (SurfNum = state.dataHeatBal->Zone(thisZone).SurfaceFirst; SurfNum <= state.dataHeatBal->Zone(thisZone).SurfaceLast; ++SurfNum) { + for (SurfNum = state.dataHeatBal->Zone(thisZone).HTSurfaceFirst; SurfNum <= state.dataHeatBal->Zone(thisZone).HTSurfaceLast; ++SurfNum) { if (Surface(SurfNum).Class == DataSurfaces::SurfaceClass::Floor) { // Use Average Z for surface, more important for roofs than floors... ++FloorCount; @@ -834,8 +834,8 @@ namespace RoomAirModelUserTempPattern { - SurfFirst = state.dataHeatBal->Zone(ZoneNum).SurfaceFirst; - SurfLast = state.dataHeatBal->Zone(ZoneNum).SurfaceLast; + SurfFirst = state.dataHeatBal->Zone(ZoneNum).HTSurfaceFirst; + SurfLast = state.dataHeatBal->Zone(ZoneNum).HTSurfaceLast; // set air system leaving node conditions // this is not so easy. THis task is normally done in CalcZoneLeavingConditions @@ -873,7 +873,7 @@ namespace RoomAirModelUserTempPattern { WinGapFlowTtoRA = 0.0; if (state.dataZoneEquip->ZoneEquipConfig(zoneEquipNum).ZoneHasAirFlowWindowReturn) { - for (SurfNum = state.dataHeatBal->Zone(ZoneNum).SurfaceFirst; SurfNum <= state.dataHeatBal->Zone(ZoneNum).SurfaceLast; ++SurfNum) { + for (SurfNum = state.dataHeatBal->Zone(ZoneNum).HTSurfaceFirst; SurfNum <= state.dataHeatBal->Zone(ZoneNum).HTSurfaceLast; ++SurfNum) { if (DataSurfaces::SurfWinAirflowThisTS(SurfNum) > 0.0 && DataSurfaces::SurfWinAirflowDestination(SurfNum) == AirFlowWindow_Destination_ReturnAir) { FlowThisTS = PsyRhoAirFnPbTdbW(state, state.dataEnvrn->OutBaroPress, DataSurfaces::SurfWinTAirflowGapOutlet(SurfNum), Node(ZoneNode).HumRat) * diff --git a/src/EnergyPlus/SolarShading.cc b/src/EnergyPlus/SolarShading.cc index 0972614bb38..94ef2a2a097 100644 --- a/src/EnergyPlus/SolarShading.cc +++ b/src/EnergyPlus/SolarShading.cc @@ -290,7 +290,6 @@ namespace EnergyPlus::SolarShading { for (int zoneNum = 1; zoneNum <= state.dataGlobal->NumOfZones; ++zoneNum) { int const firstSurfWin = state.dataHeatBal->Zone(zoneNum).WindowSurfaceFirst; int const lastSurfWin = state.dataHeatBal->Zone(zoneNum).WindowSurfaceLast; - if (firstSurfWin == -1) continue; for (int SurfNum = firstSurfWin; SurfNum <= lastSurfWin; ++SurfNum) { SurfWinTransSolar(SurfNum) = 0.0; @@ -6001,8 +6000,8 @@ namespace EnergyPlus::SolarShading { IntBeamAbsByShadFac(SurfNum) = 0.0; ExtBeamAbsByShadFac(SurfNum) = 0.0; } - int const firstSurfOpaque = state.dataHeatBal->Zone(zoneNum).NonWindowSurfaceFirst; - int const lastSurfOpaque = state.dataHeatBal->Zone(zoneNum).NonWindowSurfaceLast; + int const firstSurfOpaque = state.dataHeatBal->Zone(zoneNum).OpaqOrIntMassSurfaceFirst; + int const lastSurfOpaque = state.dataHeatBal->Zone(zoneNum).OpaqOrIntMassSurfaceLast; for (int SurfNum = firstSurfOpaque; SurfNum <= lastSurfOpaque; ++SurfNum) { SurfOpaqAI(SurfNum) = 0.0; SurfOpaqAO(SurfNum) = 0.0; @@ -7666,8 +7665,7 @@ namespace EnergyPlus::SolarShading { // Calculates solar energy absorbed on exterior opaque surfaces for (int ZoneNum = 1; ZoneNum <= state.dataGlobal->NumOfZones; ++ZoneNum) { - for (int SurfNum = state.dataHeatBal->Zone(ZoneNum).SurfaceFirst; SurfNum <= state.dataHeatBal->Zone(ZoneNum).SurfaceLast; ++SurfNum) { -// if (!Surface(SurfNum).HeatTransSurf) continue; + for (int SurfNum = state.dataHeatBal->Zone(ZoneNum).HTSurfaceFirst; SurfNum <= state.dataHeatBal->Zone(ZoneNum).HTSurfaceLast; ++SurfNum) { // TH added 3/24/2010 while debugging CR 7872 if (!Surface(SurfNum).ExtSolar && SurfWinOriginalClass(SurfNum) != SurfaceClass::TDD_Diffuser) continue; int ConstrNum = Surface(SurfNum).Construction; @@ -9230,7 +9228,6 @@ namespace EnergyPlus::SolarShading { for (int zoneNum = 1; zoneNum <= state.dataGlobal->NumOfZones; ++zoneNum) { int const firstSurfWin = state.dataHeatBal->Zone(zoneNum).WindowSurfaceFirst; int const lastSurfWin = state.dataHeatBal->Zone(zoneNum).WindowSurfaceLast; - if (firstSurfWin == -1) continue; for (int ISurf = firstSurfWin; ISurf <= lastSurfWin; ++ISurf) { SurfWinAirflowThisTS(ISurf) = 0.0; @@ -9930,7 +9927,6 @@ namespace EnergyPlus::SolarShading { for (int zoneNum = 1; zoneNum <= state.dataGlobal->NumOfZones; ++zoneNum) { int const firstSurfWin = state.dataHeatBal->Zone(zoneNum).WindowSurfaceFirst; int const lastSurfWin = state.dataHeatBal->Zone(zoneNum).WindowSurfaceLast; - if (firstSurfWin == -1) continue; for (int SurfNum = firstSurfWin; SurfNum <= lastSurfWin; ++SurfNum) { // Added TH for initialization. CR 7596 inside reveal causing high cooling loads // for outside reveals @@ -10548,7 +10544,6 @@ namespace EnergyPlus::SolarShading { for (int zoneNum = 1; zoneNum <= state.dataGlobal->NumOfZones; ++zoneNum) { int const firstSurfWin = state.dataHeatBal->Zone(zoneNum).WindowSurfaceFirst; int const lastSurfWin = state.dataHeatBal->Zone(zoneNum).WindowSurfaceLast; - if (firstSurfWin == -1) continue; for (int SurfNum = firstSurfWin; SurfNum <= lastSurfWin; ++SurfNum) { if (Surface(SurfNum).Class == SurfaceClass::Window && Surface(SurfNum).HasShadeControl) { int WinShadeCtrlNum = Surface(SurfNum).activeWindowShadingControl; // Window shading control number diff --git a/src/EnergyPlus/SteamBaseboardRadiator.cc b/src/EnergyPlus/SteamBaseboardRadiator.cc index 49327dab7da..ed3cbf84fe7 100644 --- a/src/EnergyPlus/SteamBaseboardRadiator.cc +++ b/src/EnergyPlus/SteamBaseboardRadiator.cc @@ -1436,9 +1436,7 @@ namespace SteamBaseboardRadiator { SumHATsurf = 0.0; - for (SurfNum = state.dataHeatBal->Zone(ZoneNum).SurfaceFirst; SurfNum <= state.dataHeatBal->Zone(ZoneNum).SurfaceLast; ++SurfNum) { - if (!Surface(SurfNum).HeatTransSurf) continue; // Skip non-heat transfer surfaces - + for (SurfNum = state.dataHeatBal->Zone(ZoneNum).HTSurfaceFirst; SurfNum <= state.dataHeatBal->Zone(ZoneNum).HTSurfaceLast; ++SurfNum) { Area = Surface(SurfNum).Area; if (Surface(SurfNum).Class == SurfaceClass::Window) { diff --git a/src/EnergyPlus/SurfaceGeometry.cc b/src/EnergyPlus/SurfaceGeometry.cc index c2837ddb129..a2b6960895a 100644 --- a/src/EnergyPlus/SurfaceGeometry.cc +++ b/src/EnergyPlus/SurfaceGeometry.cc @@ -481,7 +481,7 @@ namespace SurfaceGeometry { state.dataHeatBal->Zone(ZoneNum).ExtWindowArea); } // Use AllSurfaceFirst which includes air boundaries - for (SurfNum = state.dataHeatBal->Zone(ZoneNum).AllSurfaceFirst; SurfNum <= state.dataHeatBal->Zone(ZoneNum).SurfaceLast; ++SurfNum) { + for (SurfNum = state.dataHeatBal->Zone(ZoneNum).AllSurfaceFirst; SurfNum <= state.dataHeatBal->Zone(ZoneNum).HTSurfaceLast; ++SurfNum) { if (Surface(SurfNum).Class == SurfaceClass::Roof) { // Use Average Z for surface, more important for roofs than floors... ++CeilCount; @@ -558,7 +558,7 @@ namespace SurfaceGeometry { state.dataHeatBal->Zone(ZoneNum).MinimumZ = Surface(state.dataHeatBal->Zone(ZoneNum).AllSurfaceFirst).Vertex(1).z; state.dataHeatBal->Zone(ZoneNum).MaximumZ = Surface(state.dataHeatBal->Zone(ZoneNum).AllSurfaceFirst).Vertex(1).z; } - for (SurfNum = state.dataHeatBal->Zone(ZoneNum).AllSurfaceFirst; SurfNum <= state.dataHeatBal->Zone(ZoneNum).SurfaceLast; ++SurfNum) { + for (SurfNum = state.dataHeatBal->Zone(ZoneNum).AllSurfaceFirst; SurfNum <= state.dataHeatBal->Zone(ZoneNum).HTSurfaceLast; ++SurfNum) { if (Surface(SurfNum).Class == SurfaceClass::IntMass) continue; nonInternalMassSurfacesPresent = true; if (Surface(SurfNum).Class == SurfaceClass::Wall || (Surface(SurfNum).Class == SurfaceClass::Roof) || @@ -849,13 +849,16 @@ namespace SurfaceGeometry { // METHODOLOGY EMPLOYED: // The order of surfaces does not matter and the surfaces are resorted into // the hierarchical order: - // Detached Surfaces - // Base Surface for zone x - // Subsurfaces for base surface - // Base Surface for zone x - // etc - // Heat Transfer Surfaces and Shading surfaces are mixed in the list - // Pointers are set in the zones (First, Last) + // All Shading Surfaces + // Airwalls for zone x1 + // Base Surfaces for zone x1 + // Opaque Subsurfaces for zone x1 + // Window Subsurfaces for zone x1 + // TDD Dome Surfaces for zone x1 + // Airwalls for zone x2 + // Base Surfaces for zone x2 + // etc + // Pointers are set in the zones (AllSurfaceFirst/Last, HTSurfaceFirst/Last, OpaqOrIntMassSurfaceFirst/Last, WindowSurfaceFirst/Last, OpaqOrWinSurfaceFirst/Last, TDDDomeFirst/Last) // REFERENCES: // This routine manages getting the input for the following Objects: @@ -1324,8 +1327,9 @@ namespace SurfaceGeometry { // Floors // Roofs/Ceilings // Internal Mass - // Non-Window subsurfaces (doors and TubularDaylightingDomes) + // Non-Window subsurfaces (including doors) // Window subsurfaces (including TubularDaylightingDiffusers) + // TubularDaylightingDomes // After reordering, MovedSurfs should equal TotSurfaces // For reporting purposes, the legacy surface order is also saved in DataSurfaces::AllSurfaceListReportOrder: @@ -1437,16 +1441,31 @@ namespace SurfaceGeometry { DataSurfaces::AllSurfaceListReportOrder.push_back(MovedSurfs); } - // Non-window) subsurfaces are next (anything left in this zone that's not a window or a glass door) - // includes SurfaceClass::TDD_Dome which transmits light but is not a window for heat balance purposes + // Opaque door goes next for (int SubSurfNum = 1; SubSurfNum <= TotSurfaces; ++SubSurfNum) { if (SurfaceTmpClassMoved(SubSurfNum)) continue; if (state.dataSurfaceGeometry->SurfaceTmp(SubSurfNum).Zone != ZoneNum) continue; - if (state.dataSurfaceGeometry->SurfaceTmp(SubSurfNum).Class == SurfaceClass::Window) continue; - if (state.dataSurfaceGeometry->SurfaceTmp(SubSurfNum).Class == SurfaceClass::GlassDoor) continue; - if (state.dataSurfaceGeometry->SurfaceTmp(SubSurfNum).Class == SurfaceClass::TDD_Diffuser) continue; + if (state.dataSurfaceGeometry->SurfaceTmp(SubSurfNum).Class != SurfaceClass::Door) continue; + ++MovedSurfs; + Surface(MovedSurfs) = state.dataSurfaceGeometry->SurfaceTmp(SubSurfNum); + SurfaceTmpClassMoved(SubSurfNum) = true; // 'Moved' + // Reset BaseSurf to it's positive value (set to negative earlier) + Surface(MovedSurfs).BaseSurf = -Surface(MovedSurfs).BaseSurf; + state.dataSurfaceGeometry->SurfaceTmp(SubSurfNum).BaseSurf = -1; + // Find and replace negative SubSurfNum with new MovedSurfs num in surface list for reporting + std::replace(DataSurfaces::AllSurfaceListReportOrder.begin(), DataSurfaces::AllSurfaceListReportOrder.end(), -SubSurfNum, MovedSurfs); + } + + // The exterior window subsurfaces (includes SurfaceClass::Window and SurfaceClass::GlassDoor) goes next + for (int SubSurfNum = 1; SubSurfNum <= TotSurfaces; ++SubSurfNum) { + + if (SurfaceTmpClassMoved(SubSurfNum)) continue; + if (state.dataSurfaceGeometry->SurfaceTmp(SubSurfNum).Zone != ZoneNum) continue; + if (state.dataSurfaceGeometry->SurfaceTmp(SubSurfNum).ExtBoundCond > 0) continue; // Exterior window + if ((state.dataSurfaceGeometry->SurfaceTmp(SubSurfNum).Class != SurfaceClass::Window) && (state.dataSurfaceGeometry->SurfaceTmp(SubSurfNum).Class != SurfaceClass::GlassDoor)) + continue; ++MovedSurfs; Surface(MovedSurfs) = state.dataSurfaceGeometry->SurfaceTmp(SubSurfNum); @@ -1458,13 +1477,13 @@ namespace SurfaceGeometry { std::replace(DataSurfaces::AllSurfaceListReportOrder.begin(), DataSurfaces::AllSurfaceListReportOrder.end(), -SubSurfNum, MovedSurfs); } - // Last but not least, the window subsurfaces (includes SurfaceClass::TDD_Diffuser) + // The interior window subsurfaces (includes SurfaceClass::Window and SurfaceClass::GlassDoor) goes next for (int SubSurfNum = 1; SubSurfNum <= TotSurfaces; ++SubSurfNum) { if (SurfaceTmpClassMoved(SubSurfNum)) continue; if (state.dataSurfaceGeometry->SurfaceTmp(SubSurfNum).Zone != ZoneNum) continue; - if ((state.dataSurfaceGeometry->SurfaceTmp(SubSurfNum).Class != SurfaceClass::Window) && (state.dataSurfaceGeometry->SurfaceTmp(SubSurfNum).Class != SurfaceClass::GlassDoor) && - (state.dataSurfaceGeometry->SurfaceTmp(SubSurfNum).Class != SurfaceClass::TDD_Diffuser)) + if (state.dataSurfaceGeometry->SurfaceTmp(SubSurfNum).ExtBoundCond <= 0) continue; + if ((state.dataSurfaceGeometry->SurfaceTmp(SubSurfNum).Class != SurfaceClass::Window) && (state.dataSurfaceGeometry->SurfaceTmp(SubSurfNum).Class != SurfaceClass::GlassDoor)) continue; ++MovedSurfs; @@ -1476,6 +1495,41 @@ namespace SurfaceGeometry { // Find and replace negative SubSurfNum with new MovedSurfs num in surface list for reporting std::replace(DataSurfaces::AllSurfaceListReportOrder.begin(), DataSurfaces::AllSurfaceListReportOrder.end(), -SubSurfNum, MovedSurfs); } + + // The SurfaceClass::TDD_Diffuser (OriginalClass = Window) goes next + for (int SubSurfNum = 1; SubSurfNum <= TotSurfaces; ++SubSurfNum) { + + if (SurfaceTmpClassMoved(SubSurfNum)) continue; + if (state.dataSurfaceGeometry->SurfaceTmp(SubSurfNum).Zone != ZoneNum) continue; + if (state.dataSurfaceGeometry->SurfaceTmp(SubSurfNum).Class != SurfaceClass::TDD_Diffuser) + continue; + + ++MovedSurfs; + Surface(MovedSurfs) = state.dataSurfaceGeometry->SurfaceTmp(SubSurfNum); + SurfaceTmpClassMoved(SubSurfNum) = true; // 'Moved' + // Reset BaseSurf to it's positive value (set to negative earlier) + Surface(MovedSurfs).BaseSurf = -Surface(MovedSurfs).BaseSurf; + state.dataSurfaceGeometry->SurfaceTmp(SubSurfNum).BaseSurf = -1; + // Find and replace negative SubSurfNum with new MovedSurfs num in surface list for reporting + std::replace(DataSurfaces::AllSurfaceListReportOrder.begin(), DataSurfaces::AllSurfaceListReportOrder.end(), -SubSurfNum, MovedSurfs); + } + + // Last but not least, SurfaceClass::TDD_Dome + for (int SubSurfNum = 1; SubSurfNum <= TotSurfaces; ++SubSurfNum) { + + if (SurfaceTmpClassMoved(SubSurfNum)) continue; + if (state.dataSurfaceGeometry->SurfaceTmp(SubSurfNum).Zone != ZoneNum) continue; + if (state.dataSurfaceGeometry->SurfaceTmp(SubSurfNum).Class != SurfaceClass::TDD_Dome) continue; + + ++MovedSurfs; + Surface(MovedSurfs) = state.dataSurfaceGeometry->SurfaceTmp(SubSurfNum); + SurfaceTmpClassMoved(SubSurfNum) = true; // 'Moved' + // Reset BaseSurf to it's positive value (set to negative earlier) + Surface(MovedSurfs).BaseSurf = -Surface(MovedSurfs).BaseSurf; + state.dataSurfaceGeometry->SurfaceTmp(SubSurfNum).BaseSurf = -1; + // Find and replace negative SubSurfNum with new MovedSurfs num in surface list for reporting + std::replace(DataSurfaces::AllSurfaceListReportOrder.begin(), DataSurfaces::AllSurfaceListReportOrder.end(), -SubSurfNum, MovedSurfs); + } } if (MovedSurfs != TotSurfaces) { @@ -1895,17 +1949,28 @@ namespace SurfaceGeometry { state.dataHeatBal->Zone(ZoneNum).AllSurfaceFirst = SurfNum; } if (Surface(SurfNum).IsAirBoundarySurf) continue; - if (state.dataHeatBal->Zone(ZoneNum).SurfaceFirst == 0) { - state.dataHeatBal->Zone(ZoneNum).SurfaceFirst = SurfNum; + if (state.dataHeatBal->Zone(ZoneNum).HTSurfaceFirst == 0) { + state.dataHeatBal->Zone(ZoneNum).HTSurfaceFirst = SurfNum; // Non window surfaces are grouped next within each zone - state.dataHeatBal->Zone(ZoneNum).NonWindowSurfaceFirst = SurfNum; + state.dataHeatBal->Zone(ZoneNum).OpaqOrIntMassSurfaceFirst = SurfNum; } if ((state.dataHeatBal->Zone(ZoneNum).WindowSurfaceFirst == 0) && ((Surface(SurfNum).Class == DataSurfaces::SurfaceClass::Window) || (Surface(SurfNum).Class == DataSurfaces::SurfaceClass::GlassDoor) || (Surface(SurfNum).Class == DataSurfaces::SurfaceClass::TDD_Diffuser))) { // Window surfaces are grouped last within each zone state.dataHeatBal->Zone(ZoneNum).WindowSurfaceFirst = SurfNum; - state.dataHeatBal->Zone(ZoneNum).NonWindowSurfaceLast = SurfNum - 1; + state.dataHeatBal->Zone(ZoneNum).OpaqOrIntMassSurfaceLast = SurfNum - 1; + } + if ((state.dataHeatBal->Zone(ZoneNum).TDDDomeFirst == 0) && (Surface(SurfNum).Class == DataSurfaces::SurfaceClass::TDD_Dome)) { + // Window surfaces are grouped last within each zone + state.dataHeatBal->Zone(ZoneNum).TDDDomeFirst = SurfNum; + if (state.dataHeatBal->Zone(ZoneNum).WindowSurfaceFirst != 0) { + state.dataHeatBal->Zone(ZoneNum).WindowSurfaceLast = SurfNum - 1; + } else { + // No window in the zone. + state.dataHeatBal->Zone(ZoneNum).OpaqOrIntMassSurfaceLast = SurfNum - 1; + state.dataHeatBal->Zone(ZoneNum).WindowSurfaceLast = -1; + } break; } } @@ -1913,34 +1978,34 @@ namespace SurfaceGeometry { } // Surface First pointers are set, set last if (state.dataGlobal->NumOfZones > 0) { - state.dataHeatBal->Zone(state.dataGlobal->NumOfZones).SurfaceLast = TotSurfaces; - if ((Surface(TotSurfaces).Class == DataSurfaces::SurfaceClass::Window) || - (Surface(TotSurfaces).Class == DataSurfaces::SurfaceClass::GlassDoor) || - (Surface(TotSurfaces).Class == DataSurfaces::SurfaceClass::TDD_Diffuser)) { - state.dataHeatBal->Zone(state.dataGlobal->NumOfZones).WindowSurfaceLast = TotSurfaces; - } else { - // If there are no windows in the zone, then set this to -1 so any for loops on WindowSurfaceFirst to WindowSurfaceLast will not - // execute - state.dataHeatBal->Zone(state.dataGlobal->NumOfZones).WindowSurfaceLast = -1; - state.dataHeatBal->Zone(state.dataGlobal->NumOfZones).NonWindowSurfaceLast = TotSurfaces; - } + state.dataHeatBal->Zone(state.dataGlobal->NumOfZones).AllSurfaceLast = TotSurfaces; } for (int ZoneNum = 1; ZoneNum <= state.dataGlobal->NumOfZones - 1; ++ZoneNum) { - state.dataHeatBal->Zone(ZoneNum).SurfaceLast = state.dataHeatBal->Zone(ZoneNum + 1).AllSurfaceFirst - 1; - if ((Surface(state.dataHeatBal->Zone(ZoneNum).SurfaceLast).Class == DataSurfaces::SurfaceClass::Window) || - (Surface(state.dataHeatBal->Zone(ZoneNum).SurfaceLast).Class == DataSurfaces::SurfaceClass::GlassDoor) || - (Surface(state.dataHeatBal->Zone(ZoneNum).SurfaceLast).Class == DataSurfaces::SurfaceClass::TDD_Diffuser)) { - state.dataHeatBal->Zone(ZoneNum).WindowSurfaceLast = state.dataHeatBal->Zone(ZoneNum + 1).AllSurfaceFirst - 1; + state.dataHeatBal->Zone(ZoneNum).AllSurfaceLast = state.dataHeatBal->Zone(ZoneNum + 1).AllSurfaceFirst - 1; + } + for (int ZoneNum = 1; ZoneNum <= state.dataGlobal->NumOfZones; ++ZoneNum) { + if (Surface(state.dataHeatBal->Zone(ZoneNum).AllSurfaceLast).Class == DataSurfaces::SurfaceClass::TDD_Dome) { + state.dataHeatBal->Zone(ZoneNum).TDDDomeLast = state.dataHeatBal->Zone(ZoneNum).AllSurfaceLast; + } else if ((Surface(state.dataHeatBal->Zone(ZoneNum).AllSurfaceLast).Class == DataSurfaces::SurfaceClass::Window) || + (Surface(state.dataHeatBal->Zone(ZoneNum).AllSurfaceLast).Class == DataSurfaces::SurfaceClass::GlassDoor) || + (Surface(state.dataHeatBal->Zone(ZoneNum).AllSurfaceLast).Class == DataSurfaces::SurfaceClass::TDD_Diffuser)) { + state.dataHeatBal->Zone(ZoneNum).TDDDomeLast = - 1; + state.dataHeatBal->Zone(ZoneNum).WindowSurfaceLast = state.dataHeatBal->Zone(ZoneNum).AllSurfaceLast; } else { // If there are no windows in the zone, then set this to -1 so any for loops on WindowSurfaceFirst to WindowSurfaceLast will not // execute + state.dataHeatBal->Zone(ZoneNum).TDDDomeLast = - 1; state.dataHeatBal->Zone(ZoneNum).WindowSurfaceLast = -1; - state.dataHeatBal->Zone(ZoneNum).NonWindowSurfaceLast = state.dataHeatBal->Zone(ZoneNum).SurfaceLast; + state.dataHeatBal->Zone(ZoneNum).OpaqOrIntMassSurfaceLast = state.dataHeatBal->Zone(ZoneNum).AllSurfaceLast; } + state.dataHeatBal->Zone(ZoneNum).OpaqOrWinSurfaceFirst = state.dataHeatBal->Zone(ZoneNum).HTSurfaceFirst; + state.dataHeatBal->Zone(ZoneNum).OpaqOrWinSurfaceLast = std::max(state.dataHeatBal->Zone(ZoneNum).OpaqOrIntMassSurfaceLast, state.dataHeatBal->Zone(ZoneNum).WindowSurfaceLast); + state.dataHeatBal->Zone(ZoneNum).HTSurfaceLast = state.dataHeatBal->Zone(ZoneNum).AllSurfaceLast; } + for (int ZoneNum = 1; ZoneNum <= state.dataGlobal->NumOfZones; ++ZoneNum) { - if (state.dataHeatBal->Zone(ZoneNum).SurfaceFirst == 0) { + if (state.dataHeatBal->Zone(ZoneNum).HTSurfaceFirst == 0) { ShowSevereError(state, RoutineName + "Zone has no surfaces, Zone=" + state.dataHeatBal->Zone(ZoneNum).Name); SurfError = true; } @@ -1949,7 +2014,7 @@ namespace SurfaceGeometry { // Set up Floor Areas for Zones if (!SurfError) { for (int ZoneNum = 1; ZoneNum <= state.dataGlobal->NumOfZones; ++ZoneNum) { - for (int SurfNum = state.dataHeatBal->Zone(ZoneNum).SurfaceFirst; SurfNum <= state.dataHeatBal->Zone(ZoneNum).SurfaceLast; ++SurfNum) { + for (int SurfNum = state.dataHeatBal->Zone(ZoneNum).HTSurfaceFirst; SurfNum <= state.dataHeatBal->Zone(ZoneNum).HTSurfaceLast; ++SurfNum) { if (Surface(SurfNum).Class == SurfaceClass::Floor) { state.dataHeatBal->Zone(ZoneNum).FloorArea += Surface(SurfNum).Area; state.dataHeatBal->Zone(ZoneNum).HasFloor = true; @@ -2082,8 +2147,8 @@ namespace SurfaceGeometry { OpaqueHTSurfs = 0; OpaqueHTSurfsWithWin = 0; InternalMassSurfs = 0; - if (state.dataHeatBal->Zone(ZoneNum).SurfaceFirst == 0) continue; // Zone with no surfaces - for (int SurfNum = state.dataHeatBal->Zone(ZoneNum).SurfaceFirst; SurfNum <= state.dataHeatBal->Zone(ZoneNum).SurfaceLast; ++SurfNum) { + if (state.dataHeatBal->Zone(ZoneNum).HTSurfaceFirst == 0) continue; // Zone with no surfaces + for (int SurfNum = state.dataHeatBal->Zone(ZoneNum).HTSurfaceFirst; SurfNum <= state.dataHeatBal->Zone(ZoneNum).HTSurfaceLast; ++SurfNum) { if (Surface(SurfNum).Class == SurfaceClass::Floor || Surface(SurfNum).Class == SurfaceClass::Wall || Surface(SurfNum).Class == SurfaceClass::Roof) ++OpaqueHTSurfs; @@ -10287,14 +10352,14 @@ namespace SurfaceGeometry { SumAreas = 0.0; SurfCount = 0.0; // Use AllSurfaceFirst which includes air boundaries - NFaces = state.dataHeatBal->Zone(ZoneNum).SurfaceLast - state.dataHeatBal->Zone(ZoneNum).AllSurfaceFirst + 1; + NFaces = state.dataHeatBal->Zone(ZoneNum).AllSurfaceLast - state.dataHeatBal->Zone(ZoneNum).AllSurfaceFirst + 1; notused = 0; ZoneStruct.NumSurfaceFaces = NFaces; ZoneStruct.SurfaceFace.allocate(NFaces); NActFaces = 0; surfacenotused.dimension(NFaces, 0); - for (SurfNum = state.dataHeatBal->Zone(ZoneNum).AllSurfaceFirst; SurfNum <= state.dataHeatBal->Zone(ZoneNum).SurfaceLast; ++SurfNum) { + for (SurfNum = state.dataHeatBal->Zone(ZoneNum).AllSurfaceFirst; SurfNum <= state.dataHeatBal->Zone(ZoneNum).AllSurfaceLast; ++SurfNum) { // Only include Base Surfaces in Calc. diff --git a/src/EnergyPlus/SwimmingPool.cc b/src/EnergyPlus/SwimmingPool.cc index 5a34470296e..d28f8bc9f4c 100644 --- a/src/EnergyPlus/SwimmingPool.cc +++ b/src/EnergyPlus/SwimmingPool.cc @@ -1001,9 +1001,7 @@ namespace EnergyPlus::SwimmingPool { Real64 SumHATsurf = 0.0; // Return value - for (int SurfNum = state.dataHeatBal->Zone(ZoneNum).SurfaceFirst; SurfNum <= state.dataHeatBal->Zone(ZoneNum).SurfaceLast; ++SurfNum) { - if (!DataSurfaces::Surface(SurfNum).HeatTransSurf) continue; // Skip non-heat transfer surfaces - + for (int SurfNum = state.dataHeatBal->Zone(ZoneNum).HTSurfaceFirst; SurfNum <= state.dataHeatBal->Zone(ZoneNum).HTSurfaceLast; ++SurfNum) { Real64 Area = DataSurfaces::Surface(SurfNum).Area; // Effective surface area if (DataSurfaces::Surface(SurfNum).Class == DataSurfaces::SurfaceClass::Window) { diff --git a/src/EnergyPlus/ThermalChimney.cc b/src/EnergyPlus/ThermalChimney.cc index 65a149591df..4d6fe901758 100644 --- a/src/EnergyPlus/ThermalChimney.cc +++ b/src/EnergyPlus/ThermalChimney.cc @@ -643,13 +643,13 @@ namespace ThermalChimney { ZoneNum = state.dataThermalChimneys->ThermalChimneySys(Loop).RealZonePtr; // start off with first surface in zone widths - majorW = Surface(state.dataHeatBal->Zone(ZoneNum).SurfaceFirst).Width; + majorW = Surface(state.dataHeatBal->Zone(ZoneNum).HTSurfaceFirst).Width; minorW = majorW; TempmajorW = 0.0; TemporaryWallSurfTemp = -10000.0; // determine major width and minor width - for (SurfNum = state.dataHeatBal->Zone(ZoneNum).SurfaceFirst + 1; SurfNum <= state.dataHeatBal->Zone(ZoneNum).SurfaceLast; ++SurfNum) { + for (SurfNum = state.dataHeatBal->Zone(ZoneNum).HTSurfaceFirst + 1; SurfNum <= state.dataHeatBal->Zone(ZoneNum).HTSurfaceLast; ++SurfNum) { if (Surface(SurfNum).Class != SurfaceClass::Wall) continue; if (Surface(SurfNum).Width > majorW) { @@ -661,7 +661,7 @@ namespace ThermalChimney { } } - for (SurfNum = state.dataHeatBal->Zone(ZoneNum).SurfaceFirst; SurfNum <= state.dataHeatBal->Zone(ZoneNum).SurfaceLast; ++SurfNum) { + for (SurfNum = state.dataHeatBal->Zone(ZoneNum).HTSurfaceFirst; SurfNum <= state.dataHeatBal->Zone(ZoneNum).HTSurfaceLast; ++SurfNum) { if (Surface(SurfNum).Width == majorW) { if (TempSurfIn(SurfNum) > TemporaryWallSurfTemp) { TemporaryWallSurfTemp = TempSurfIn(SurfNum); @@ -671,12 +671,8 @@ namespace ThermalChimney { } } - for (SurfNum = state.dataHeatBal->Zone(ZoneNum).SurfaceFirst; SurfNum <= state.dataHeatBal->Zone(ZoneNum).SurfaceLast; ++SurfNum) { - - if (!Surface(SurfNum).HeatTransSurf) continue; // Skip non-heat transfer surfaces - + for (SurfNum = state.dataHeatBal->Zone(ZoneNum).HTSurfaceFirst; SurfNum <= state.dataHeatBal->Zone(ZoneNum).HTSurfaceLast; ++SurfNum) { if (Surface(SurfNum).Class == SurfaceClass::Window) { - if (Surface(SurfNum).Width > TempmajorW) { TempmajorW = Surface(SurfNum).Width; ConvTransCoeffGlassFluid = state.dataHeatBal->HConvIn(SurfNum); diff --git a/src/EnergyPlus/ThermalComfort.cc b/src/EnergyPlus/ThermalComfort.cc index 230faec6b7e..24354541706 100644 --- a/src/EnergyPlus/ThermalComfort.cc +++ b/src/EnergyPlus/ThermalComfort.cc @@ -1911,8 +1911,8 @@ namespace ThermalComfort { // Note that area*emissivity needs to be recalculated because of the possibility of changes to the emissivity via the EMS SumAET = 0.0; ZoneAESum(ZoneNum) = 0.0; - for (SurfNum2 = state.dataHeatBal->Zone(ZoneNum).SurfaceFirst; SurfNum2 <= state.dataHeatBal->Zone(ZoneNum).SurfaceLast; ++SurfNum2) { - if ((Surface(SurfNum2).HeatTransSurf) && (SurfNum2 != SurfNum)) { + for (SurfNum2 = state.dataHeatBal->Zone(ZoneNum).HTSurfaceFirst; SurfNum2 <= state.dataHeatBal->Zone(ZoneNum).HTSurfaceLast; ++SurfNum2) { + if (SurfNum2 != SurfNum) { SurfaceAE(SurfNum2) = Surface(SurfNum2).Area * state.dataConstruction->Construct(Surface(SurfNum2).Construction).InsideAbsorpThermal; SumAET += SurfaceAE(SurfNum2) * TH(2, 1, SurfNum2); ZoneAESum(ZoneNum) += SurfaceAE(SurfNum2); diff --git a/src/EnergyPlus/VentilatedSlab.cc b/src/EnergyPlus/VentilatedSlab.cc index d629324b228..c88c2f51e8c 100644 --- a/src/EnergyPlus/VentilatedSlab.cc +++ b/src/EnergyPlus/VentilatedSlab.cc @@ -4448,9 +4448,7 @@ namespace VentilatedSlab { SumHATsurf = 0.0; - for (SurfNum = state.dataHeatBal->Zone(ZoneNum).SurfaceFirst; SurfNum <= state.dataHeatBal->Zone(ZoneNum).SurfaceLast; ++SurfNum) { - if (!Surface(SurfNum).HeatTransSurf) continue; // Skip non-heat transfer surfaces - + for (SurfNum = state.dataHeatBal->Zone(ZoneNum).HTSurfaceFirst; SurfNum <= state.dataHeatBal->Zone(ZoneNum).HTSurfaceLast; ++SurfNum) { Area = Surface(SurfNum).Area; if (Surface(SurfNum).Class == SurfaceClass::Window) { diff --git a/src/EnergyPlus/WindowComplexManager.cc b/src/EnergyPlus/WindowComplexManager.cc index 84f7c8e6acc..3f4634dfe1e 100644 --- a/src/EnergyPlus/WindowComplexManager.cc +++ b/src/EnergyPlus/WindowComplexManager.cc @@ -920,11 +920,11 @@ namespace WindowComplexManager { for (int ZoneNum = 1; ZoneNum <= state.dataGlobal->NumOfZones; ++ZoneNum) { ComplexFenInZone = false; - for (int SurfNum = state.dataHeatBal->Zone(ZoneNum).SurfaceFirst; SurfNum <= state.dataHeatBal->Zone(ZoneNum).SurfaceLast; ++SurfNum) { + for (int SurfNum = state.dataHeatBal->Zone(ZoneNum).HTSurfaceFirst; SurfNum <= state.dataHeatBal->Zone(ZoneNum).HTSurfaceLast; ++SurfNum) { if (SurfWinWindowModelType(SurfNum) == WindowBSDFModel) ComplexFenInZone = true; } if (ComplexFenInZone) { - NumSurfInZone = state.dataHeatBal->Zone(ZoneNum).SurfaceLast - state.dataHeatBal->Zone(ZoneNum).SurfaceFirst + 1; + NumSurfInZone = state.dataHeatBal->Zone(ZoneNum).HTSurfaceLast - state.dataHeatBal->Zone(ZoneNum).HTSurfaceFirst + 1; if (state.dataBSDFWindow->MaxBkSurf < NumSurfInZone) state.dataBSDFWindow->MaxBkSurf = NumSurfInZone; } } diff --git a/src/EnergyPlus/ZoneEquipmentManager.cc b/src/EnergyPlus/ZoneEquipmentManager.cc index 0f3dc6ab2c1..86a27208313 100644 --- a/src/EnergyPlus/ZoneEquipmentManager.cc +++ b/src/EnergyPlus/ZoneEquipmentManager.cc @@ -4506,7 +4506,7 @@ namespace EnergyPlus::ZoneEquipmentManager { WinGapFlowTtoRA = 0.0; if (state.dataZoneEquip->ZoneEquipConfig(ZoneNum).ZoneHasAirFlowWindowReturn) { - for (SurfNum = state.dataHeatBal->Zone(ActualZoneNum).SurfaceFirst; SurfNum <= state.dataHeatBal->Zone(ActualZoneNum).SurfaceLast; ++SurfNum) { + for (SurfNum = state.dataHeatBal->Zone(ActualZoneNum).HTSurfaceFirst; SurfNum <= state.dataHeatBal->Zone(ActualZoneNum).HTSurfaceLast; ++SurfNum) { if (DataSurfaces::SurfWinAirflowThisTS(SurfNum) > 0.0 && DataSurfaces::SurfWinAirflowDestination(SurfNum) == AirFlowWindow_Destination_ReturnAir) { FlowThisTS = PsyRhoAirFnPbTdbW(state, state.dataEnvrn->OutBaroPress, DataSurfaces::SurfWinTAirflowGapOutlet(SurfNum), Node(ZoneNode).HumRat) * diff --git a/src/EnergyPlus/ZoneTempPredictorCorrector.cc b/src/EnergyPlus/ZoneTempPredictorCorrector.cc index cf29d9d02f1..a118609513f 100644 --- a/src/EnergyPlus/ZoneTempPredictorCorrector.cc +++ b/src/EnergyPlus/ZoneTempPredictorCorrector.cc @@ -2721,19 +2721,15 @@ namespace ZoneTempPredictorCorrector { for (Loop = 1; Loop <= state.dataGlobal->NumOfZones; ++Loop) { FirstSurfFlag = true; - if (state.dataHeatBal->Zone(Loop).SurfaceFirst > 0) { - for (SurfNum = state.dataHeatBal->Zone(Loop).SurfaceFirst; SurfNum <= state.dataHeatBal->Zone(Loop).SurfaceLast; ++SurfNum) { - if (!Surface(SurfNum).HeatTransSurf) continue; // Skip non-heat transfer surfaces - - if (FirstSurfFlag) { - TRefFlag = Surface(SurfNum).TAirRef; - FirstSurfFlag = false; - } - // for each particular zone, the reference air temperature(s) should be the same - // (either mean air, bulk air, or supply air temp). - if (Surface(SurfNum).TAirRef != TRefFlag) { - ShowWarningError(state, "Different reference air temperatures for difference surfaces encountered in zone " + state.dataHeatBal->Zone(Loop).Name); - } + for (SurfNum = state.dataHeatBal->Zone(Loop).HTSurfaceFirst; SurfNum <= state.dataHeatBal->Zone(Loop).HTSurfaceLast; ++SurfNum) { + if (FirstSurfFlag) { + TRefFlag = Surface(SurfNum).TAirRef; + FirstSurfFlag = false; + } + // for each particular zone, the reference air temperature(s) should be the same + // (either mean air, bulk air, or supply air temp). + if (Surface(SurfNum).TAirRef != TRefFlag) { + ShowWarningError(state, "Different reference air temperatures for difference surfaces encountered in zone " + state.dataHeatBal->Zone(Loop).Name); } } } @@ -4542,7 +4538,7 @@ namespace ZoneTempPredictorCorrector { // if no surface in the zone uses EMPD or HAMT then zero bool no_ht_EMPD_or_HAMT(true); - for (int i = state.dataHeatBal->Zone(ZoneNum).SurfaceFirst, e = state.dataHeatBal->Zone(ZoneNum).SurfaceLast; i <= e; ++i) { + for (int i = state.dataHeatBal->Zone(ZoneNum).HTSurfaceFirst, e = state.dataHeatBal->Zone(ZoneNum).HTSurfaceLast; i <= e; ++i) { auto const &htAlgo(Surface(i).HeatTransferAlgorithm); if ((htAlgo == HeatTransferModel_EMPD) || (htAlgo == HeatTransferModel_HAMT)) { no_ht_EMPD_or_HAMT = false; @@ -5491,7 +5487,7 @@ namespace ZoneTempPredictorCorrector { // SumHmARaW and SumHmARa will be used with the moisture balance on the building elements and // are currently set to zero to remind us where they need to be in the future bool no_ht_EMPD_or_HAMT(true); - for (int i = state.dataHeatBal->Zone(ZoneNum).SurfaceFirst, e = state.dataHeatBal->Zone(ZoneNum).SurfaceLast; i <= e; ++i) { + for (int i = state.dataHeatBal->Zone(ZoneNum).HTSurfaceFirst, e = state.dataHeatBal->Zone(ZoneNum).HTSurfaceLast; i <= e; ++i) { auto const &htAlgo(Surface(i).HeatTransferAlgorithm); if ((htAlgo == HeatTransferModel_EMPD) || (htAlgo == HeatTransferModel_HAMT)) { no_ht_EMPD_or_HAMT = false; @@ -6246,10 +6242,7 @@ namespace ZoneTempPredictorCorrector { SumSysMCpT /= ZoneMult; } // Sum all surface convection: SumHA, SumHATsurf, SumHATref (and additional contributions to SumIntGain) - for (SurfNum = state.dataHeatBal->Zone(ZoneNum).SurfaceFirst; SurfNum <= state.dataHeatBal->Zone(ZoneNum).SurfaceLast; ++SurfNum) { - - if (!Surface(SurfNum).HeatTransSurf) continue; // Skip non-heat transfer surfaces - + for (SurfNum = state.dataHeatBal->Zone(ZoneNum).HTSurfaceFirst; SurfNum <= state.dataHeatBal->Zone(ZoneNum).HTSurfaceLast; ++SurfNum) { HA = 0.0; Area = Surface(SurfNum).Area; // For windows, this is the glazing area @@ -6542,9 +6535,7 @@ namespace ZoneTempPredictorCorrector { SumNonAirSystem = NonAirSystemResponse(ZoneNum) + SumConvHTRadSys(ZoneNum) + SumConvPool(ZoneNum); // Sum all surface convection: SumHA, SumHATsurf, SumHATref (and additional contributions to SumIntGain) - for (SurfNum = state.dataHeatBal->Zone(ZoneNum).SurfaceFirst; SurfNum <= state.dataHeatBal->Zone(ZoneNum).SurfaceLast; ++SurfNum) { - - if (!Surface(SurfNum).HeatTransSurf) continue; // Skip non-heat transfer surfaces + for (SurfNum = state.dataHeatBal->Zone(ZoneNum).HTSurfaceFirst; SurfNum <= state.dataHeatBal->Zone(ZoneNum).HTSurfaceLast; ++SurfNum) { Area = Surface(SurfNum).Area; // For windows, this is the glazing area // determine reference air temperature for this surface's convective heat transfer model diff --git a/tst/EnergyPlus/unit/HeatBalanceSurfaceManager.unit.cc b/tst/EnergyPlus/unit/HeatBalanceSurfaceManager.unit.cc index 0b2b0112da0..7281044550c 100644 --- a/tst/EnergyPlus/unit/HeatBalanceSurfaceManager.unit.cc +++ b/tst/EnergyPlus/unit/HeatBalanceSurfaceManager.unit.cc @@ -266,10 +266,9 @@ TEST_F(EnergyPlusFixture, HeatBalanceSurfaceManager_ComputeIntThermalAbsorpFacto state->dataGlobal->NumOfZones = 1; state->dataHeatBal->TotMaterials = 1; state->dataHeatBal->TotConstructs = 1; - state->dataHeatBal->Zone.allocate(state->dataGlobal->NumOfZones); - state->dataHeatBal->Zone(1).SurfaceFirst = 1; - state->dataHeatBal->Zone(1).SurfaceLast = 1; + state->dataHeatBal->Zone(1).HTSurfaceFirst = 1; + state->dataHeatBal->Zone(1).HTSurfaceLast = 1; state->dataHeatBal->Zone(1).WindowSurfaceFirst = 1; state->dataHeatBal->Zone(1).WindowSurfaceLast = 1; DataSurfaces::Surface.allocate(DataSurfaces::TotSurfaces); @@ -313,6 +312,8 @@ TEST_F(EnergyPlusFixture, HeatBalanceSurfaceManager_UpdateFinalThermalHistories) DataSurfaces::Surface(1).HeatTransferAlgorithm = DataSurfaces::HeatTransferModel_CTF; DataSurfaces::Surface(1).ExtBoundCond = 1; DataSurfaces::Surface(1).Construction = 1; + state->dataHeatBal->Zone(1).OpaqOrIntMassSurfaceFirst = 1; + state->dataHeatBal->Zone(1).OpaqOrIntMassSurfaceLast = 1; state->dataConstruction->Construct(1).NumCTFTerms = 2; state->dataConstruction->Construct(1).SourceSinkPresent = true; diff --git a/tst/EnergyPlus/unit/HybridModel.unit.cc b/tst/EnergyPlus/unit/HybridModel.unit.cc index 646bb365e9b..f0706ab23ae 100644 --- a/tst/EnergyPlus/unit/HybridModel.unit.cc +++ b/tst/EnergyPlus/unit/HybridModel.unit.cc @@ -245,8 +245,8 @@ TEST_F(EnergyPlusFixture, HybridModel_CorrectZoneAirTempTest) state->dataHeatBal->Zone(1).ZoneEqNum = 1; state->dataHeatBal->Zone(1).Multiplier = 1; state->dataHeatBal->Zone(1).SystemZoneNodeNumber = 1; - state->dataHeatBal->Zone(1).SurfaceFirst = 1; - state->dataHeatBal->Zone(1).SurfaceLast = 2; + state->dataHeatBal->Zone(1).HTSurfaceFirst = 0; // No HT surface here. + state->dataHeatBal->Zone(1).HTSurfaceLast = -1; state->dataHeatBal->Zone(1).Volume = 1061.88; state->dataGlobal->TimeStepZone = 10.0 / 60.0; // Zone timestep in hours TimeStepSys = 10.0 / 60.0; @@ -735,8 +735,8 @@ TEST_F(EnergyPlusFixture, HybridModel_CorrectZoneContaminantsTest) state->dataHeatBal->Zone(1).ZoneEqNum = 1; state->dataHeatBal->Zone(1).Multiplier = 1; state->dataHeatBal->Zone(1).SystemZoneNodeNumber = 1; - state->dataHeatBal->Zone(1).SurfaceFirst = 1; - state->dataHeatBal->Zone(1).SurfaceLast = 2; + state->dataHeatBal->Zone(1).HTSurfaceFirst = 0; + state->dataHeatBal->Zone(1).HTSurfaceLast = -1; state->dataHeatBal->Zone(1).Volume = 4000; state->dataGlobal->TimeStepZone = 10.0 / 60.0; // Zone timestep in hours TimeStepSys = 10.0 / 60.0; diff --git a/tst/EnergyPlus/unit/OutputReportTabular.unit.cc b/tst/EnergyPlus/unit/OutputReportTabular.unit.cc index 20fd21db396..6791cd9ab3c 100644 --- a/tst/EnergyPlus/unit/OutputReportTabular.unit.cc +++ b/tst/EnergyPlus/unit/OutputReportTabular.unit.cc @@ -6794,8 +6794,8 @@ TEST_F(EnergyPlusFixture, OutputReportTabularTest_GetDelaySequencesTwice_test) state->dataGlobal->NumOfZones = 4; state->dataHeatBal->Zone.allocate(state->dataGlobal->NumOfZones); - state->dataHeatBal->Zone(iZone).SurfaceFirst = 1; - state->dataHeatBal->Zone(iZone).SurfaceLast = 1; + state->dataHeatBal->Zone(iZone).HTSurfaceFirst = 1; + state->dataHeatBal->Zone(iZone).HTSurfaceLast = 1; state->dataHeatBal->Zone(iZone).RadiantEnclosureNum = 1; TotSurfaces = 4; @@ -6957,8 +6957,8 @@ TEST_F(SQLiteFixture, OutputReportTabular_WriteLoadComponentSummaryTables_AirLoo state->dataHeatBal->Zone(1).ListMultiplier = 1; state->dataHeatBal->Zone(1).FloorArea = 100.; // Trick E+ into not iterating on Surfaces - state->dataHeatBal->Zone(1).SurfaceFirst = 1; - state->dataHeatBal->Zone(1).SurfaceLast = 0; + state->dataHeatBal->Zone(1).HTSurfaceFirst = 1; + state->dataHeatBal->Zone(1).HTSurfaceLast = 0; @@ -8131,8 +8131,8 @@ TEST_F(EnergyPlusFixture, OutputReportTabularTest_GetDelaySequencesSurfaceOrder_ state->dataGlobal->NumOfZones = 1; state->dataHeatBal->Zone.allocate(state->dataGlobal->NumOfZones); - state->dataHeatBal->Zone(iZone).SurfaceFirst = 1; - state->dataHeatBal->Zone(iZone).SurfaceLast = 4; + state->dataHeatBal->Zone(iZone).HTSurfaceFirst = 1; + state->dataHeatBal->Zone(iZone).HTSurfaceLast = 4; state->dataHeatBal->Zone(iZone).RadiantEnclosureNum = 1; int radEnclosureNum = 1; diff --git a/tst/EnergyPlus/unit/PurchasedAirManager.unit.cc b/tst/EnergyPlus/unit/PurchasedAirManager.unit.cc index dadb1513052..e3ae8595f5f 100644 --- a/tst/EnergyPlus/unit/PurchasedAirManager.unit.cc +++ b/tst/EnergyPlus/unit/PurchasedAirManager.unit.cc @@ -391,8 +391,8 @@ TEST_F(ZoneIdealLoadsTest, IdealLoads_PlenumTest) bool ErrorsFound = false; GetZoneData(*state, ErrorsFound); - state->dataHeatBal->Zone(1).SurfaceFirst = 1; - state->dataHeatBal->Zone(1).SurfaceLast = 1; + state->dataHeatBal->Zone(1).HTSurfaceFirst = 1; + state->dataHeatBal->Zone(1).HTSurfaceLast = 1; ScheduleManager::Schedule.allocate(1); AllocateHeatBalArrays(*state); EXPECT_FALSE(ErrorsFound); // expect no errors @@ -501,8 +501,8 @@ TEST_F(ZoneIdealLoadsTest, IdealLoads_ExhaustNodeTest) bool ErrorsFound = false; GetZoneData(*state, ErrorsFound); - state->dataHeatBal->Zone(1).SurfaceFirst = 1; - state->dataHeatBal->Zone(1).SurfaceLast = 1; + state->dataHeatBal->Zone(1).HTSurfaceFirst = 1; + state->dataHeatBal->Zone(1).HTSurfaceLast = 1; ScheduleManager::Schedule.allocate(1); AllocateHeatBalArrays(*state); EXPECT_FALSE(ErrorsFound); // expect no errors @@ -623,8 +623,8 @@ TEST_F(ZoneIdealLoadsTest, IdealLoads_IntermediateOutputVarsTest) bool ErrorsFound = false; GetZoneData(*state, ErrorsFound); - state->dataHeatBal->Zone(1).SurfaceFirst = 1; - state->dataHeatBal->Zone(1).SurfaceLast = 1; + state->dataHeatBal->Zone(1).HTSurfaceFirst = 1; + state->dataHeatBal->Zone(1).HTSurfaceLast = 1; ScheduleManager::Schedule.allocate(1); AllocateHeatBalArrays(*state); EXPECT_FALSE(ErrorsFound); // expect no errors @@ -799,8 +799,8 @@ TEST_F(ZoneIdealLoadsTest, IdealLoads_EMSOverrideTest) bool ErrorsFound = false; GetZoneData(*state, ErrorsFound); - state->dataHeatBal->Zone(1).SurfaceFirst = 1; - state->dataHeatBal->Zone(1).SurfaceLast = 1; + state->dataHeatBal->Zone(1).HTSurfaceFirst = 1; + state->dataHeatBal->Zone(1).HTSurfaceLast = 1; ScheduleManager::Schedule.allocate(1); AllocateHeatBalArrays(*state); EXPECT_FALSE(ErrorsFound); // expect no errors @@ -909,8 +909,8 @@ TEST_F(ZoneIdealLoadsTest, IdealLoads_NoCapacityTest) bool ErrorsFound = false; GetZoneData(*state, ErrorsFound); - state->dataHeatBal->Zone(1).SurfaceFirst = 1; - state->dataHeatBal->Zone(1).SurfaceLast = 1; + state->dataHeatBal->Zone(1).HTSurfaceFirst = 1; + state->dataHeatBal->Zone(1).HTSurfaceLast = 1; ScheduleManager::Schedule.allocate(1); AllocateHeatBalArrays(*state); EXPECT_FALSE(ErrorsFound); // expect no errors diff --git a/tst/EnergyPlus/unit/RoomAirflowNetwork.unit.cc b/tst/EnergyPlus/unit/RoomAirflowNetwork.unit.cc index e2c18ae45c2..125a2b0d38b 100644 --- a/tst/EnergyPlus/unit/RoomAirflowNetwork.unit.cc +++ b/tst/EnergyPlus/unit/RoomAirflowNetwork.unit.cc @@ -247,8 +247,8 @@ TEST_F(RoomAirflowNetworkTest, RAFNTest) state->dataHeatBal->Zone(ZoneNum).Volume = 100; state->dataHeatBal->Zone(ZoneNum).IsControlled = true; - state->dataHeatBal->Zone(ZoneNum).SurfaceFirst = 1; - state->dataHeatBal->Zone(ZoneNum).SurfaceLast = 2; + state->dataHeatBal->Zone(ZoneNum).HTSurfaceFirst = 1; + state->dataHeatBal->Zone(ZoneNum).HTSurfaceLast = 2; state->dataHeatBal->Zone(ZoneNum).ZoneVolCapMultpMoist = 0; state->dataHeatBal->ZoneIntGain(ZoneNum).NumberOfDevices = 1; diff --git a/tst/EnergyPlus/unit/SurfaceGeometry.unit.cc b/tst/EnergyPlus/unit/SurfaceGeometry.unit.cc index 32fa3124f3e..15641ce9ec8 100644 --- a/tst/EnergyPlus/unit/SurfaceGeometry.unit.cc +++ b/tst/EnergyPlus/unit/SurfaceGeometry.unit.cc @@ -2496,9 +2496,9 @@ TEST_F(EnergyPlusFixture, CalculateZoneVolume_SimpleBox_test) enteredCeilingHeight.dimension(state->dataGlobal->NumOfZones, false); state->dataHeatBal->Zone.dimension(state->dataGlobal->NumOfZones); state->dataHeatBal->Zone(1).HasFloor = true; - state->dataHeatBal->Zone(1).SurfaceFirst = 1; + state->dataHeatBal->Zone(1).HTSurfaceFirst = 1; state->dataHeatBal->Zone(1).AllSurfaceFirst = 1; - state->dataHeatBal->Zone(1).SurfaceLast = 6; + state->dataHeatBal->Zone(1).AllSurfaceLast = 6; Surface.dimension(6); @@ -2567,9 +2567,9 @@ TEST_F(EnergyPlusFixture, CalculateZoneVolume_BoxOneWallMissing_test) enteredCeilingHeight.dimension(state->dataGlobal->NumOfZones, false); state->dataHeatBal->Zone.dimension(state->dataGlobal->NumOfZones); state->dataHeatBal->Zone(1).HasFloor = true; - state->dataHeatBal->Zone(1).SurfaceFirst = 1; +// Zone(1).HTSurfaceFirst = 1; state->dataHeatBal->Zone(1).AllSurfaceFirst = 1; - state->dataHeatBal->Zone(1).SurfaceLast = 5; + state->dataHeatBal->Zone(1).AllSurfaceLast = 5; Surface.dimension(5); @@ -2632,9 +2632,9 @@ TEST_F(EnergyPlusFixture, CalculateZoneVolume_BoxNoCeiling_test) enteredCeilingHeight.dimension(state->dataGlobal->NumOfZones, false); state->dataHeatBal->Zone.dimension(state->dataGlobal->NumOfZones); state->dataHeatBal->Zone(1).HasFloor = true; - state->dataHeatBal->Zone(1).SurfaceFirst = 1; + state->dataHeatBal->Zone(1).HTSurfaceFirst = 1; state->dataHeatBal->Zone(1).AllSurfaceFirst = 1; - state->dataHeatBal->Zone(1).SurfaceLast = 5; + state->dataHeatBal->Zone(1).AllSurfaceLast = 5; Surface.dimension(5); @@ -2697,9 +2697,9 @@ TEST_F(EnergyPlusFixture, CalculateZoneVolume_BoxNoFloor_test) enteredCeilingHeight.dimension(state->dataGlobal->NumOfZones, false); state->dataHeatBal->Zone.dimension(state->dataGlobal->NumOfZones); state->dataHeatBal->Zone(1).HasFloor = true; - state->dataHeatBal->Zone(1).SurfaceFirst = 1; + state->dataHeatBal->Zone(1).HTSurfaceFirst = 1; state->dataHeatBal->Zone(1).AllSurfaceFirst = 1; - state->dataHeatBal->Zone(1).SurfaceLast = 5; + state->dataHeatBal->Zone(1).AllSurfaceLast = 5; Surface.dimension(5); @@ -2761,9 +2761,9 @@ TEST_F(EnergyPlusFixture, CalculateZoneVolume_BoxNoCeilingFloor_test) state->dataGlobal->NumOfZones = 1; enteredCeilingHeight.dimension(state->dataGlobal->NumOfZones, false); state->dataHeatBal->Zone.dimension(state->dataGlobal->NumOfZones); - state->dataHeatBal->Zone(1).SurfaceFirst = 1; + state->dataHeatBal->Zone(1).HTSurfaceFirst = 1; state->dataHeatBal->Zone(1).AllSurfaceFirst = 1; - state->dataHeatBal->Zone(1).SurfaceLast = 4; + state->dataHeatBal->Zone(1).AllSurfaceLast = 4; Surface.dimension(4); @@ -5546,12 +5546,15 @@ TEST_F(EnergyPlusFixture, HeatBalanceIntRadExchange_SetupEnclosuresWithAirBounda EXPECT_EQ(state->dataHeatBal->Zone(1).AllSurfaceFirst + 1, Zone1Surface1); // air boundary surface EXPECT_EQ(state->dataHeatBal->Zone(2).AllSurfaceFirst, Zone2Surface1); // no air boundary surfaces in Zone 2 EXPECT_EQ(state->dataHeatBal->Zone(3).AllSurfaceFirst, Zone3Surface1); // air boundary surface - EXPECT_EQ(state->dataHeatBal->Zone(1).SurfaceFirst, Zone1Surface1); // first non-air boundary surface - EXPECT_EQ(state->dataHeatBal->Zone(2).SurfaceFirst, Zone2Surface1); // first non-air boundary surface - EXPECT_EQ(state->dataHeatBal->Zone(3).SurfaceFirst, Zone3Floor); // first non-air boundary surface - EXPECT_EQ(state->dataHeatBal->Zone(1).SurfaceLast, Zone1Floor); - EXPECT_EQ(state->dataHeatBal->Zone(2).SurfaceLast, Zone2Floor); - EXPECT_EQ(state->dataHeatBal->Zone(3).SurfaceLast, Zone3Floor); + EXPECT_EQ(state->dataHeatBal->Zone(1).HTSurfaceFirst, Zone1Surface1); // first non-air boundary surface + EXPECT_EQ(state->dataHeatBal->Zone(2).HTSurfaceFirst, Zone2Surface1); // first non-air boundary surface + EXPECT_EQ(state->dataHeatBal->Zone(3).HTSurfaceFirst, Zone3Floor); // first non-air boundary surface + EXPECT_EQ(state->dataHeatBal->Zone(1).AllSurfaceLast, Zone1Floor); + EXPECT_EQ(state->dataHeatBal->Zone(2).AllSurfaceLast, Zone2Floor); + EXPECT_EQ(state->dataHeatBal->Zone(3).AllSurfaceLast, Zone3Floor); + EXPECT_EQ(state->dataHeatBal->Zone(1).HTSurfaceLast, Zone1Floor); + EXPECT_EQ(state->dataHeatBal->Zone(2).HTSurfaceLast, Zone2Floor); + EXPECT_EQ(state->dataHeatBal->Zone(3).HTSurfaceLast, Zone3Floor); } @@ -6743,6 +6746,7 @@ TEST_F(EnergyPlusFixture, GetSurfaceData_SurfaceOrder) // Internal Mass // Doors // Windows + // TDD_Domes // // Reporting Order (preserving the old surface order scheme) // @@ -6757,7 +6761,7 @@ TEST_F(EnergyPlusFixture, GetSurfaceData_SurfaceOrder) // Internal Mass // // Special cases: - // TubularDaylightDome is treated as a "non-window" subsurface + // TubularDaylightDome is treated as a separate surface type // TubularDaylightDiffuser is treated as a window subsurface // For this test, the order should be @@ -6805,8 +6809,8 @@ TEST_F(EnergyPlusFixture, GetSurfaceData_SurfaceOrder) // 36. NorthRoof4 (roof) // 37. EastRoof (roof) // 38. WestRoof (roof) - // 39. TubularDaylightingDome1 (not a window) - // 40. AtticSkylight (window) + // 39. AtticSkylight (window) + // 40. TubularDaylightingDome1 (not a window) // For this test, the order should be // Reporting (legacy) Order (zero-based): @@ -6847,14 +6851,15 @@ TEST_F(EnergyPlusFixture, GetSurfaceData_SurfaceOrder) // 29. Attic:LivingFloor (floor) // 30. Attic:GarageFloor (floor) // 31. NorthRoof1 (roof) - // 32. TubularDaylightingDome1 (not a window) - // 33. SouthRoof (roof) - // 34. NorthRoof2 (roof) - // 35. NorthRoof3 (roof) - // 36. NorthRoof4 (roof) - // 37. EastRoof (roof) + + // 32. SouthRoof (roof) + // 33. NorthRoof2 (roof) + // 34. NorthRoof3 (roof) + // 35. NorthRoof4 (roof) + // 36. EastRoof (roof) + // 37. WestRoof (roof) // 38. AtticSkylight (window) - // 39. WestRoof (roof) + // 39. TubularDaylightingDome1 (not a window) // Simulation Order (1-based): // SHADING SURFACES: @@ -6901,15 +6906,15 @@ TEST_F(EnergyPlusFixture, GetSurfaceData_SurfaceOrder) EXPECT_EQ(floorLivingFloor, 12); EXPECT_EQ(ceilingLivingCeiling, 13); EXPECT_EQ(doorWestDoor, 14); - EXPECT_EQ(windowTubularDaylightingDiffuser1, 15); - EXPECT_EQ(windowNorthWindow, 16); - EXPECT_EQ(windowEastWindow, 17); - EXPECT_EQ(windowSouthWindow, 18); - EXPECT_EQ(windowWestWindow, 19); - EXPECT_EQ(state->dataHeatBal->Zone(1).SurfaceFirst, 7); - EXPECT_EQ(state->dataHeatBal->Zone(1).SurfaceLast, 19); - EXPECT_EQ(state->dataHeatBal->Zone(1).NonWindowSurfaceFirst, 7); - EXPECT_EQ(state->dataHeatBal->Zone(1).NonWindowSurfaceLast, 14); + EXPECT_EQ(windowTubularDaylightingDiffuser1, 19); + EXPECT_EQ(windowNorthWindow, 15); + EXPECT_EQ(windowEastWindow, 16); + EXPECT_EQ(windowSouthWindow, 17); + EXPECT_EQ(windowWestWindow, 18); + EXPECT_EQ(state->dataHeatBal->Zone(1).HTSurfaceFirst, 7); + EXPECT_EQ(state->dataHeatBal->Zone(1).HTSurfaceLast, 19); + EXPECT_EQ(state->dataHeatBal->Zone(1).OpaqOrIntMassSurfaceFirst, 7); + EXPECT_EQ(state->dataHeatBal->Zone(1).OpaqOrIntMassSurfaceLast, 14); EXPECT_EQ(state->dataHeatBal->Zone(1).WindowSurfaceFirst, 15); EXPECT_EQ(state->dataHeatBal->Zone(1).WindowSurfaceLast, 19); @@ -6929,10 +6934,10 @@ TEST_F(EnergyPlusFixture, GetSurfaceData_SurfaceOrder) EXPECT_EQ(floorGarageFloor, 24); EXPECT_EQ(ceilingGarageInterior, 25); EXPECT_EQ(intmassEVChargingStation, 26); - EXPECT_EQ(state->dataHeatBal->Zone(2).SurfaceFirst, 20); - EXPECT_EQ(state->dataHeatBal->Zone(2).SurfaceLast, 26); - EXPECT_EQ(state->dataHeatBal->Zone(2).NonWindowSurfaceFirst, 20); - EXPECT_EQ(state->dataHeatBal->Zone(2).NonWindowSurfaceLast, 26); + EXPECT_EQ(state->dataHeatBal->Zone(2).HTSurfaceFirst, 20); + EXPECT_EQ(state->dataHeatBal->Zone(2).HTSurfaceLast, 26); + EXPECT_EQ(state->dataHeatBal->Zone(2).OpaqOrIntMassSurfaceFirst, 20); + EXPECT_EQ(state->dataHeatBal->Zone(2).OpaqOrIntMassSurfaceLast, 26); EXPECT_EQ(state->dataHeatBal->Zone(2).WindowSurfaceFirst, 0); EXPECT_EQ(state->dataHeatBal->Zone(2).WindowSurfaceLast, -1); @@ -6965,14 +6970,17 @@ TEST_F(EnergyPlusFixture, GetSurfaceData_SurfaceOrder) EXPECT_EQ(roofNorthRoof4, 36); EXPECT_EQ(roofEastRoof, 37); EXPECT_EQ(roofWestRoof, 38); - EXPECT_EQ(nonwindowTubularDaylightingDome1, 39); - EXPECT_EQ(windowAtticSkylight, 40); - EXPECT_EQ(state->dataHeatBal->Zone(3).SurfaceFirst, 27); - EXPECT_EQ(state->dataHeatBal->Zone(3).SurfaceLast, 40); - EXPECT_EQ(state->dataHeatBal->Zone(3).NonWindowSurfaceFirst, 27); - EXPECT_EQ(state->dataHeatBal->Zone(3).NonWindowSurfaceLast, 39); - EXPECT_EQ(state->dataHeatBal->Zone(3).WindowSurfaceFirst, 40); - EXPECT_EQ(state->dataHeatBal->Zone(3).WindowSurfaceLast, 40); + EXPECT_EQ(nonwindowTubularDaylightingDome1, 40); + EXPECT_EQ(windowAtticSkylight, 39); + EXPECT_EQ(state->dataHeatBal->Zone(3).HTSurfaceFirst, 27); + EXPECT_EQ(state->dataHeatBal->Zone(3).HTSurfaceLast, 40); + EXPECT_EQ(state->dataHeatBal->Zone(3).OpaqOrIntMassSurfaceFirst, 27); + EXPECT_EQ(state->dataHeatBal->Zone(3).OpaqOrIntMassSurfaceLast, 38); + EXPECT_EQ(state->dataHeatBal->Zone(3).WindowSurfaceFirst, 39); + EXPECT_EQ(state->dataHeatBal->Zone(3).WindowSurfaceLast, 39); + EXPECT_EQ(state->dataHeatBal->Zone(3).OpaqOrWinSurfaceLast, 39); + EXPECT_EQ(state->dataHeatBal->Zone(3).TDDDomeFirst, 40); + EXPECT_EQ(state->dataHeatBal->Zone(3).TDDDomeLast, 40); // Reporting (legacy) Order (zero-based) // SHADING SURFACES: diff --git a/tst/EnergyPlus/unit/ThermalComfort.unit.cc b/tst/EnergyPlus/unit/ThermalComfort.unit.cc index aa2798c27c6..2e2d3b60eb4 100644 --- a/tst/EnergyPlus/unit/ThermalComfort.unit.cc +++ b/tst/EnergyPlus/unit/ThermalComfort.unit.cc @@ -779,8 +779,8 @@ TEST_F(EnergyPlusFixture, ThermalComfort_CalcSurfaceWeightedMRT) Surface(1).Zone = 1; Surface(2).Zone = 1; Surface(3).Zone = 1; - state->dataHeatBal->Zone(1).SurfaceFirst = 1; - state->dataHeatBal->Zone(1).SurfaceLast = 3; + state->dataHeatBal->Zone(1).HTSurfaceFirst = 1; + state->dataHeatBal->Zone(1).HTSurfaceLast = 3; TH(2, 1, 1) = 20.0; TH(2, 1, 2) = 15.0; TH(2, 1, 3) = 10.0; diff --git a/tst/EnergyPlus/unit/ZoneTempPredictorCorrector.unit.cc b/tst/EnergyPlus/unit/ZoneTempPredictorCorrector.unit.cc index f2c9f56bd81..6e0e049b9f3 100644 --- a/tst/EnergyPlus/unit/ZoneTempPredictorCorrector.unit.cc +++ b/tst/EnergyPlus/unit/ZoneTempPredictorCorrector.unit.cc @@ -142,8 +142,8 @@ TEST_F(EnergyPlusFixture, ZoneTempPredictorCorrector_CorrectZoneHumRatTest) ZT(1) = 24.0; ZoneAirHumRat.allocate(1); - state->dataHeatBal->Zone(1).SurfaceFirst = 1; - state->dataHeatBal->Zone(1).SurfaceLast = 2; + state->dataHeatBal->Zone(1).HTSurfaceFirst = 1; + state->dataHeatBal->Zone(1).HTSurfaceLast = 2; Surface.allocate(2); state->dataZonePlenum->NumZoneReturnPlenums = 0; @@ -1000,8 +1000,8 @@ TEST_F(EnergyPlusFixture, ZoneTempPredictorCorrector_CalcZoneSums_SurfConvection ZoneAirHumRat.allocate(1); ZoneAirHumRat(1) = 0.001; - state->dataHeatBal->Zone(1).SurfaceFirst = 1; - state->dataHeatBal->Zone(1).SurfaceLast = 3; + state->dataHeatBal->Zone(1).HTSurfaceFirst = 1; + state->dataHeatBal->Zone(1).HTSurfaceLast = 3; Surface.allocate(3); state->dataHeatBal->HConvIn.allocate(3); Node.allocate(4);