Initial cleanup pass (kinda big, sorry)

Author: amirroth

src/EnergyPlus/AirflowNetwork/src/Solver.cpp

@@ -13381,9 +13381,9 @@ namespace AirflowNetwork {
         // REFERENCES:
         // na
 
-        auto &NetworkNumOfLinks = ActualNumOfLinks;
         auto &NetworkNumOfNodes = ActualNumOfNodes;
-
+        auto &NetworkNumOfLinks = ActualNumOfLinks;
+        
         // Argument array dimensioning (these used to be arguments, need to also test newAU and newIK)
         EP_SIZE_CHECK(IK, NetworkNumOfNodes + 1);
         EP_SIZE_CHECK(AD, NetworkNumOfNodes);

src/EnergyPlus/Construction.cc

@@ -210,7 +210,7 @@ void ConstructionProps::calculateTransferFunction(EnergyPlusData &state, bool &E
 
         // Obtain thermal properties from the Material derived type
 
-        auto *thisMaterial = dynamic_cast<Material::MaterialChild *>(state.dataMaterial->Material(CurrentLayer));
+        auto *thisMaterial = dynamic_cast<Material::MaterialChild *>(state.dataMaterial->materials(CurrentLayer));
         assert(thisMaterial != nullptr);
 
         dl(Layer) = thisMaterial->Thickness;
@@ -289,7 +289,7 @@ void ConstructionProps::calculateTransferFunction(EnergyPlusData &state, bool &E
                 // then use the "exact" approach to model a massless layer
                 // based on the node equations for the state space method.
 
-                if ((Layer == 1) || (Layer == this->TotLayers) || (!state.dataMaterial->Material(this->LayerPoint(Layer))->ROnly)) {
+                if ((Layer == 1) || (Layer == this->TotLayers) || (!state.dataMaterial->materials(this->LayerPoint(Layer))->ROnly)) {
                     cp(Layer) = 1.007;
                     rho(Layer) = 1.1614;
                     rk(Layer) = 0.0263;
@@ -928,12 +928,12 @@ void ConstructionProps::calculateTransferFunction(EnergyPlusData &state, bool &E
                 if (this->CTFTimeStep >= MaxAllowedTimeStep) {
                     ShowSevereError(state, format("CTF calculation convergence problem for Construction=\"{}\".", this->Name));
                     ShowContinueError(state, "...with Materials (outside layer to inside)");
-                    ShowContinueError(state, format("(outside)=\"{}\"", state.dataMaterial->Material(this->LayerPoint(1))->Name));
+                    ShowContinueError(state, format("(outside)=\"{}\"", state.dataMaterial->materials(this->LayerPoint(1))->Name));
                     for (int Layer = 2; Layer <= this->TotLayers; ++Layer) {
                         if (Layer != this->TotLayers) {
-                            ShowContinueError(state, format("(next)=\"{}\"", state.dataMaterial->Material(this->LayerPoint(Layer))->Name));
+                            ShowContinueError(state, format("(next)=\"{}\"", state.dataMaterial->materials(this->LayerPoint(Layer))->Name));
                         } else {
-                            ShowContinueError(state, format("(inside)=\"{}\"", state.dataMaterial->Material(this->LayerPoint(Layer))->Name));
+                            ShowContinueError(state, format("(inside)=\"{}\"", state.dataMaterial->materials(this->LayerPoint(Layer))->Name));
                         }
                     }
                     ShowContinueError(state,
@@ -1875,7 +1875,7 @@ void ConstructionProps::reportTransferFunction(EnergyPlusData &state, int const
 
     for (int I = 1; I <= this->TotLayers; ++I) {
         int Layer = this->LayerPoint(I);
-        auto const *thisMaterial = state.dataMaterial->Material(Layer);
+        auto const *thisMaterial = state.dataMaterial->materials(Layer);
         switch (thisMaterial->group) {
         case Material::Group::Air: {
             static constexpr std::string_view Format_702(" Material:Air,{},{:12.4N}\n");
@@ -1927,8 +1927,8 @@ void ConstructionProps::reportLayers(EnergyPlusData &state)
     if (state.dataOutRptPredefined->pdchOpqConsLayCol.size() > 0) {
         for (int i = 1; i <= this->TotLayers; ++i) {
             int layerIndex = this->LayerPoint(i);
-            auto &thisMaterial = state.dataMaterial->Material(layerIndex);
-            OutputReportPredefined::PreDefTableEntry(state, state.dataOutRptPredefined->pdchOpqConsLayCol[i - 1], this->Name, thisMaterial->Name);
+            auto const *mat = state.dataMaterial->materials(layerIndex);
+            OutputReportPredefined::PreDefTableEntry(state, state.dataOutRptPredefined->pdchOpqConsLayCol[i - 1], this->Name, mat->Name);
         }
     }
 }
@@ -1942,10 +1942,10 @@ bool ConstructionProps::isGlazingConstruction(EnergyPlusData &state) const
     // PURPOSE OF THIS SUBROUTINE:
     // Commonly used routine in several places in EnergyPlus which examines if current
     // construction is glazing construction
-    const Material::Group MaterialGroup = state.dataMaterial->Material(LayerPoint(1))->group;
-    return (MaterialGroup == Material::Group::WindowGlass) || (MaterialGroup == Material::Group::Shade) ||
-           (MaterialGroup == Material::Group::Screen) || (MaterialGroup == Material::Group::WindowBlind) ||
-           (MaterialGroup == Material::Group::WindowSimpleGlazing);
+    const Material::Group group = state.dataMaterial->materials(LayerPoint(1))->group;
+    return (group == Material::Group::WindowGlass) || (group == Material::Group::Shade) ||
+           (group == Material::Group::Screen) || (group == Material::Group::WindowBlind) ||
+           (group == Material::Group::WindowSimpleGlazing);
 }
 
 Real64 ConstructionProps::setThicknessPerpendicular(EnergyPlusData &state, Real64 userValue)

src/EnergyPlus/ConvectionCoefficients.cc

@@ -3628,7 +3628,7 @@ Real64 EvaluateExtHcModels(EnergyPlusData &state, int const SurfNum, HcExt const
     }
 
     Material::SurfaceRoughness Roughness =
-        state.dataMaterial->Material(state.dataConstruction->Construct(surface.Construction).LayerPoint(1))->Roughness;
+        state.dataMaterial->materials(state.dataConstruction->Construct(surface.Construction).LayerPoint(1))->Roughness;
 
     switch (ForcedConvModelEqNum) {
     case HcExt::None: {
@@ -6318,7 +6318,7 @@ Real64 CalcClearRoof(EnergyPlusData &state,
                      Real64 const RoofPerimeter)
 {
     Material::SurfaceRoughness const RoughnessIndex =
-        state.dataMaterial->Material(state.dataConstruction->Construct(state.dataSurface->Surface(SurfNum).Construction).LayerPoint(1))->Roughness;
+        state.dataMaterial->materials(state.dataConstruction->Construct(state.dataSurface->Surface(SurfNum).Construction).LayerPoint(1))->Roughness;
     // find x, don't know x. avoid time consuming geometry algorithm
     Real64 x = std::sqrt(RoofArea) / 2.0; // quick simplification, geometry routines to develop
 

src/EnergyPlus/DElightManagerF.cc

@@ -353,7 +353,7 @@ namespace DElightManagerF {
                                     // Get the outside visible reflectance of this material layer
                                     // (since Construct(iconstruct)%ReflectVisDiffFront always appears to == 0.0)
                                     auto const *thisMaterial =
-                                        dynamic_cast<const Material::MaterialChild *>(state.dataMaterial->Material(iMatlLayer));
+                                        dynamic_cast<const Material::MaterialChild *>(state.dataMaterial->materials(iMatlLayer));
                                     assert(thisMaterial != nullptr);
                                     rExtVisRefl = 1.0 - thisMaterial->AbsorpVisible;
                                 } else {

src/EnergyPlus/DataBSDFWindow.hh

@@ -74,6 +74,8 @@ namespace DataBSDFWindow {
         Num
     };
 
+    static constexpr std::array<std::string_view, (int)Basis::Num> basisNamesUC = {"LBNLWINDOW", "USERDEFINED"};
+
     enum class BasisSymmetry
     {
         Invalid = -1,
@@ -82,6 +84,8 @@ namespace DataBSDFWindow {
         Num
     };
 
+    static constexpr std::array<std::string_view, (int)BasisSymmetry::Num> basisSymmetryNamesUC = {"AXISSYMMETRIC", "NONE"};
+        
     // Thermal calculations for complex fenestration can be used to generate reports for standard cases
     // noCondition is used when performing timestep calculations
     // 'Summer' will override certain parameters so that produced results are matching standard summer WINDOW  = software results