Produce Convexity Check Warning Only When Appropriate

src/EnergyPlus/DataSystemVariables.hh

@@ -112,6 +112,11 @@ struct SystemVarsData : BaseGlobalStruct
     bool ReportExtShadingSunlitFrac = false; // when true, the sunlit fraction for all surfaces are exported as a csv format output
     bool DisableGroupSelfShading = false;    // when true, defined shadowing surfaces group is ignored when calculating sunlit fraction
     bool DisableAllSelfShading = false;      // when true, all external shadowing surfaces is ignored when calculating sunlit fraction
+    bool DisableSelfShadingWithinGroup = false;
+    bool DisableSelfShadingBetweenGroup = false;
+
+    int shadingGroupsNum = 0;                 // number of shading groups
+    Array1D_string shadingGroupZoneListNames; // array of zone names in user input
 
     bool TrackAirLoopEnvFlag = false; // If TRUE generates a file with runtime statistics for each HVAC
     //  controller on each air loop

src/EnergyPlus/HeatBalanceManager.cc

@@ -1967,6 +1967,8 @@ namespace HeatBalanceManager {
         // METHODOLOGY EMPLOYED:
         // The GetObjectItem routines are employed to retrieve the data.
 
+        SolarShading::GetShadowingInput(state);
+
         GetZoneData(state, ErrorsFound); // Read Zone data from input file
 
         SurfaceGeometry::SetupZoneGeometry(state, ErrorsFound);

src/EnergyPlus/SolarShading.cc

@@ -196,7 +196,7 @@ void InitSolarCalculations(EnergyPlusData &state)
 
         if (state.dataSolarShading->GetInputFlag) {
             checkShadingSurfaceSchedules(state);
-            GetShadowingInput(state);
+            processShadowingInput(state);
             state.dataSolarShading->GetInputFlag = false;
             state.dataSolarShading->MaxHCV =
                 (((max(15, state.dataSurface->MaxVerticesPerSurface) + 16) / 16) * 16) - 1; // Assure MaxHCV+1 is multiple of 16 for 128 B alignment
@@ -514,18 +514,6 @@ void GetShadowingInput(EnergyPlusData &state)
         state.dataSysVars->shadingMethod = ShadingMethod::PolygonClipping;
     }
 
-    if ((state.dataSysVars->shadingMethod == DataSystemVariables::ShadingMethod::PixelCounting) &&
-        state.dataSolarShading->anyScheduledShadingSurface) {
-        ShowSevereError(state, "The Shading Calculation Method of choice is \"PixelCounting\"; ");
-        ShowContinueError(state, "and there is at least one shading surface of type ");
-        ShowContinueError(state, "Shading:Site:Detailed, Shading:Building:Detailed, or Shading:Zone:Detailed, ");
-        ShowContinueError(state, "that has an active transmittance schedule value greater than zero or may vary.");
-        ShowContinueError(state, "With \"PixelCounting\" Shading Calculation Method, the shading surfaces will be treated as ");
-        ShowContinueError(state, "completely opaque (transmittance = 0) during the shading calculation, ");
-        ShowContinueError(state, "which may result in inaccurate or unexpected results.");
-        ShowContinueError(state, "It is suggested switching to another Shading Calculation Method, such as \"PolygonClipping\".");
-    }
-
     aNum++;
     if (NumAlphas >= aNum) {
         if (Util::SameString(state.dataIPShortCut->cAlphaArgs(aNum), "Periodic")) {
@@ -629,30 +617,11 @@ void GetShadowingInput(EnergyPlusData &state)
         state.dataIPShortCut->cAlphaArgs(aNum) = "No";
         state.dataSysVars->ReportExtShadingSunlitFrac = false;
     }
-    if (state.dataSysVars->shadingMethod == ShadingMethod::Imported) {
-        int ExtShadingSchedNum;
-        for (int SurfNum = 1; SurfNum <= state.dataSurface->TotSurfaces; ++SurfNum) {
-            ExtShadingSchedNum = ScheduleManager::GetScheduleIndex(state, state.dataSurface->Surface(SurfNum).Name + "_shading");
-            if (ExtShadingSchedNum != 0) {
-                state.dataSurface->Surface(SurfNum).SurfSchedExternalShadingFrac = true;
-                state.dataSurface->Surface(SurfNum).SurfExternalShadingSchInd = ExtShadingSchedNum;
-            } else {
-                ShowWarningError(state,
-                                 format("{}: sunlit fraction schedule not found for {} when using ImportedShading.",
-                                        cCurrentModuleObject,
-                                        state.dataSurface->Surface(SurfNum).Name));
-                ShowContinueError(state, "These values are set to 1.0.");
-            }
-        }
-    }
-
-    bool DisableSelfShadingWithinGroup = false;
-    bool DisableSelfShadingBetweenGroup = false;
 
     aNum++;
     if (NumAlphas >= aNum) {
         if (Util::SameString(state.dataIPShortCut->cAlphaArgs(aNum), "Yes")) {
-            DisableSelfShadingWithinGroup = true;
+            state.dataSysVars->DisableSelfShadingWithinGroup = true;
             state.dataIPShortCut->cAlphaArgs(aNum) = "Yes";
         } else if (Util::SameString(state.dataIPShortCut->cAlphaArgs(aNum), "No")) {
             state.dataIPShortCut->cAlphaArgs(aNum) = "No";
@@ -668,7 +637,7 @@ void GetShadowingInput(EnergyPlusData &state)
     aNum++;
     if (NumAlphas >= aNum) {
         if (Util::SameString(state.dataIPShortCut->cAlphaArgs(aNum), "Yes")) {
-            DisableSelfShadingBetweenGroup = true;
+            state.dataSysVars->DisableSelfShadingBetweenGroup = true;
             state.dataIPShortCut->cAlphaArgs(aNum) = "Yes";
         } else if (Util::SameString(state.dataIPShortCut->cAlphaArgs(aNum), "No")) {
             state.dataIPShortCut->cAlphaArgs(aNum) = "No";
@@ -681,66 +650,17 @@ void GetShadowingInput(EnergyPlusData &state)
         state.dataIPShortCut->cAlphaArgs(aNum) = "No";
     }
 
-    if (DisableSelfShadingBetweenGroup && DisableSelfShadingWithinGroup) {
+    if (state.dataSysVars->DisableSelfShadingBetweenGroup && state.dataSysVars->DisableSelfShadingWithinGroup) {
         state.dataSysVars->DisableAllSelfShading = true;
-    } else if (DisableSelfShadingBetweenGroup || DisableSelfShadingWithinGroup) {
+    } else if (state.dataSysVars->DisableSelfShadingBetweenGroup || state.dataSysVars->DisableSelfShadingWithinGroup) {
         state.dataSysVars->DisableGroupSelfShading = true;
     }
 
     aNum++;
-    int SurfZoneGroup, CurZoneGroup;
-    if (state.dataSysVars->DisableGroupSelfShading) {
-        Array1D_int DisableSelfShadingGroups;
-        int NumOfShadingGroups;
-        if (NumAlphas >= aNum) {
-            // Read all shading groups
-            NumOfShadingGroups = NumAlphas - (aNum - 1);
-            DisableSelfShadingGroups.allocate(NumOfShadingGroups);
-            for (int i = 1; i <= NumOfShadingGroups; i++) {
-                Found = Util::FindItemInList(
-                    state.dataIPShortCut->cAlphaArgs(i + (aNum - 1)), state.dataHeatBal->ZoneList, state.dataHeatBal->NumOfZoneLists);
-                if (Found != 0) DisableSelfShadingGroups(i) = Found;
-            }
-
-            for (int SurfNum = 1; SurfNum <= state.dataSurface->TotSurfaces; SurfNum++) {
-                if (state.dataSurface->Surface(SurfNum).ExtBoundCond == 0) { // Loop through all exterior surfaces
-                    SurfZoneGroup = 0;
-                    // Check the shading zone group of each exterior surface
-                    for (int ZoneGroupLoop = 1; ZoneGroupLoop <= NumOfShadingGroups; ZoneGroupLoop++) { // Loop through all defined shading groups
-                        CurZoneGroup = DisableSelfShadingGroups(ZoneGroupLoop);
-                        for (int ZoneNum = 1; ZoneNum <= state.dataHeatBal->ZoneList(CurZoneGroup).NumOfZones;
-                             ZoneNum++) { // Loop through all zones in the zone list
-                            if (state.dataSurface->Surface(SurfNum).Zone == state.dataHeatBal->ZoneList(CurZoneGroup).Zone(ZoneNum)) {
-                                SurfZoneGroup = CurZoneGroup;
-                                break;
-                            }
-                        }
-                    }
-                    // if a surface is not in any zone group, no self shading is disabled for this surface
-                    if (SurfZoneGroup != 0) {
-                        // if DisableSelfShadingWithinGroup, add all zones in the same zone group to the surface's disabled zone list
-                        // if DisableSelfShadingBetweenGroups, add all zones in all other zone groups to the surface's disabled zone list
-                        for (int ZoneGroupLoop = 1; ZoneGroupLoop <= NumOfShadingGroups; ZoneGroupLoop++) { // Loop through all defined shading groups
-                            CurZoneGroup = DisableSelfShadingGroups(ZoneGroupLoop);
-                            if (SurfZoneGroup == CurZoneGroup && DisableSelfShadingWithinGroup) {
-                                for (int ZoneNum = 1; ZoneNum <= state.dataHeatBal->ZoneList(CurZoneGroup).NumOfZones;
-                                     ZoneNum++) { // Loop through all zones in the zone list
-                                    state.dataSurface->SurfShadowDisabledZoneList(SurfNum).push_back(
-                                        state.dataHeatBal->ZoneList(CurZoneGroup).Zone(ZoneNum));
-                                }
-                            } else if (SurfZoneGroup != CurZoneGroup && DisableSelfShadingBetweenGroup) {
-                                for (int ZoneNum = 1; ZoneNum <= state.dataHeatBal->ZoneList(CurZoneGroup).NumOfZones; ZoneNum++) {
-                                    state.dataSurface->SurfShadowDisabledZoneList(SurfNum).push_back(
-                                        state.dataHeatBal->ZoneList(CurZoneGroup).Zone(ZoneNum));
-                                }
-                            }
-                        }
-                    }
-                }
-            }
-        } else {
-            ShowFatalError(state, "No Shading groups are defined when disabling grouped self shading.");
-        }
+    state.dataSysVars->shadingGroupsNum = NumAlphas - (aNum - 1);
+    state.dataSysVars->shadingGroupZoneListNames.allocate(state.dataSysVars->shadingGroupsNum);
+    for (int numZone = 1; numZone <= state.dataSysVars->shadingGroupsNum; ++numZone) {
+        state.dataSysVars->shadingGroupZoneListNames(numZone) = state.dataIPShortCut->cAlphaArgs(aNum - 1 + numZone);
     }
 
     if (!state.dataSysVars->DetailedSolarTimestepIntegration && state.dataSurface->ShadingTransmittanceVaries &&
@@ -797,6 +717,93 @@ void GetShadowingInput(EnergyPlusData &state)
           state.dataIPShortCut->cAlphaArgs(7));
 }
 
+void processShadowingInput(EnergyPlusData &state)
+{
+    // all shadow input processing that needed zones and surfaces to already be read into data (part of fix for Defect #10299)
+
+    if ((state.dataSysVars->shadingMethod == DataSystemVariables::ShadingMethod::PixelCounting) &&
+        state.dataSolarShading->anyScheduledShadingSurface) {
+        ShowSevereError(state, "The Shading Calculation Method of choice is \"PixelCounting\"; ");
+        ShowContinueError(state, "and there is at least one shading surface of type ");
+        ShowContinueError(state, "Shading:Site:Detailed, Shading:Building:Detailed, or Shading:Zone:Detailed, ");
+        ShowContinueError(state, "that has an active transmittance schedule value greater than zero or may vary.");
+        ShowContinueError(state, "With \"PixelCounting\" Shading Calculation Method, the shading surfaces will be treated as ");
+        ShowContinueError(state, "completely opaque (transmittance = 0) during the shading calculation, ");
+        ShowContinueError(state, "which may result in inaccurate or unexpected results.");
+        ShowContinueError(state, "It is suggested switching to another Shading Calculation Method, such as \"PolygonClipping\".");
+    }
+
+    if (state.dataSysVars->shadingMethod == DataSystemVariables::ShadingMethod::Imported) {
+        int ExtShadingSchedNum;
+        for (int SurfNum = 1; SurfNum <= state.dataSurface->TotSurfaces; ++SurfNum) {
+            ExtShadingSchedNum = ScheduleManager::GetScheduleIndex(state, state.dataSurface->Surface(SurfNum).Name + "_shading");
+            if (ExtShadingSchedNum != 0) {
+                state.dataSurface->Surface(SurfNum).SurfSchedExternalShadingFrac = true;
+                state.dataSurface->Surface(SurfNum).SurfExternalShadingSchInd = ExtShadingSchedNum;
+            } else {
+                ShowWarningError(state,
+                                 format("processShadowingInput: sunlit fraction schedule not found for {} when using ImportedShading.",
+                                        state.dataSurface->Surface(SurfNum).Name));
+                ShowContinueError(state, "These values are set to 1.0.");
+            }
+        }
+    }
+
+    int SurfZoneGroup, CurZoneGroup;
+    int Found = 0;
+    if (state.dataSysVars->DisableGroupSelfShading) {
+        Array1D_int DisableSelfShadingGroups;
+        int NumOfShadingGroups = state.dataSysVars->shadingGroupsNum;
+        if (NumOfShadingGroups > 0) {
+            DisableSelfShadingGroups.allocate(NumOfShadingGroups);
+            for (int i = 1; i <= NumOfShadingGroups; i++) {
+                Found = Util::FindItemInList(
+                    state.dataSysVars->shadingGroupZoneListNames(i), state.dataHeatBal->ZoneList, state.dataHeatBal->NumOfZoneLists);
+                if (Found != 0) DisableSelfShadingGroups(i) = Found;
+            }
+
+            for (int SurfNum = 1; SurfNum <= state.dataSurface->TotSurfaces; SurfNum++) {
+                if (state.dataSurface->Surface(SurfNum).ExtBoundCond == 0) { // Loop through all exterior surfaces
+                    SurfZoneGroup = 0;
+                    // Check the shading zone group of each exterior surface
+                    for (int ZoneGroupLoop = 1; ZoneGroupLoop <= NumOfShadingGroups; ZoneGroupLoop++) { // Loop through all defined shading groups
+                        CurZoneGroup = DisableSelfShadingGroups(ZoneGroupLoop);
+                        for (int ZoneNum = 1; ZoneNum <= state.dataHeatBal->ZoneList(CurZoneGroup).NumOfZones;
+                             ZoneNum++) { // Loop through all zones in the zone list
+                            if (state.dataSurface->Surface(SurfNum).Zone == state.dataHeatBal->ZoneList(CurZoneGroup).Zone(ZoneNum)) {
+                                SurfZoneGroup = CurZoneGroup;
+                                break;
+                            }
+                        }
+                    }
+                    // if a surface is not in any zone group, no self shading is disabled for this surface
+                    if (SurfZoneGroup != 0) {
+                        // if DisableSelfShadingWithinGroup, add all zones in the same zone group to the surface's disabled zone list
+                        // if DisableSelfShadingBetweenGroups, add all zones in all other zone groups to the surface's disabled zone list
+                        for (int ZoneGroupLoop = 1; ZoneGroupLoop <= NumOfShadingGroups; ZoneGroupLoop++) { // Loop through all defined shading groups
+                            CurZoneGroup = DisableSelfShadingGroups(ZoneGroupLoop);
+                            if (SurfZoneGroup == CurZoneGroup && state.dataSysVars->DisableSelfShadingWithinGroup) {
+                                for (int ZoneNum = 1; ZoneNum <= state.dataHeatBal->ZoneList(CurZoneGroup).NumOfZones;
+                                     ZoneNum++) { // Loop through all zones in the zone list
+                                    state.dataSurface->SurfShadowDisabledZoneList(SurfNum).push_back(
+                                        state.dataHeatBal->ZoneList(CurZoneGroup).Zone(ZoneNum));
+                                }
+                            } else if (SurfZoneGroup != CurZoneGroup && state.dataSysVars->DisableSelfShadingBetweenGroup) {
+                                for (int ZoneNum = 1; ZoneNum <= state.dataHeatBal->ZoneList(CurZoneGroup).NumOfZones; ZoneNum++) {
+                                    state.dataSurface->SurfShadowDisabledZoneList(SurfNum).push_back(
+                                        state.dataHeatBal->ZoneList(CurZoneGroup).Zone(ZoneNum));
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        } else {
+            ShowFatalError(state, "No Shading groups are defined when disabling grouped self shading.");
+        }
+    }
+}
+
 void checkScheduledSurfacePresent(EnergyPlusData &state)
 {
     // User has chosen "Scheduled" for sunlit fraction so check to see which surfaces don't have a schedule

src/EnergyPlus/SolarShading.hh

@@ -99,6 +99,8 @@ namespace SolarShading {
 
     void GetShadowingInput(EnergyPlusData &state);
 
+    void processShadowingInput(EnergyPlusData &state);
+
     void checkScheduledSurfacePresent(EnergyPlusData &state);
 
     void AllocateModuleArrays(EnergyPlusData &state);

src/EnergyPlus/SurfaceGeometry.cc

@@ -68,6 +68,7 @@
 #include <EnergyPlus/DataIPShortCuts.hh>
 #include <EnergyPlus/DataLoopNode.hh>
 #include <EnergyPlus/DataReportingFlags.hh>
+#include <EnergyPlus/DataSystemVariables.hh>
 #include <EnergyPlus/DataViewFactorInformation.hh>
 #include <EnergyPlus/DataWindowEquivalentLayer.hh>
 #include <EnergyPlus/DataZoneEquipment.hh>
@@ -15680,9 +15681,9 @@ namespace SurfaceGeometry {
 
             if (SignFlag != PrevSignFlag) {
                 if (state.dataGlobal->DisplayExtraWarnings && surfaceTmp.ExtSolar &&
-                    (state.dataHeatBal->SolarDistribution != DataHeatBalance::Shadowing::Minimal) &&
-                    // Warn only once
-                    surfaceTmp.IsConvex) {
+                    (state.dataHeatBal->SolarDistribution != DataHeatBalance::Shadowing::Minimal) && surfaceTmp.IsConvex &&
+                    !state.dataSysVars->SutherlandHodgman &&
+                    (state.dataSysVars->shadingMethod == DataSystemVariables::ShadingMethod::PolygonClipping)) {
                     ShowWarningError(state,
                                      format("CheckConvexity: Zone=\"{}\", Surface=\"{}\" is non-convex.",
                                             state.dataHeatBal->Zone(surfaceTmp.Zone).Name,