Increase the default number of colors.

Author: jblueh

Common/include/geometry/CGeometry.hpp

@@ -1724,12 +1724,10 @@ class CGeometry {
    * CGeometry::edgeColorGroupSize that yields a coloring that is at least as efficient as #COLORING_EFF_THRESH.
    * \param[out] efficiency - optional output of the coloring efficiency.
    * \param[in] maximizeEdgeColorGroupSize - use the maximum edge color group size that gives an efficient coloring.
-   * \param[in] largeNumberOfColors - allow up to 255 colors instead of 64 (default)
    * \return Reference to the coloring.
    */
   const CCompressedSparsePatternUL& GetEdgeColoring(su2double* efficiency = nullptr,
-                                                    bool maximizeEdgeColorGroupSize = false,
-                                                    bool largeNumberOfColors = false);
+                                                    bool maximizeEdgeColorGroupSize = false);
 
   /*!
    * \brief Force the natural (sequential) edge coloring.

Common/include/toolboxes/graph_toolbox.hpp

@@ -484,7 +484,7 @@ T createNaturalColoring(Index_t numInnerIndexes) {
  * \param[out] indexColor - Optional, vector with colors given to the outer indices.
  * \return Coloring in the same type of the input pattern.
  */
-template <typename Color_t = char, size_t MaxColors = 64, size_t MaxMB = 128, class T>
+template <typename Color_t = unsigned char, size_t MaxColors = 255, size_t MaxMB = 128, class T>
 T colorSparsePattern(const T& pattern, size_t groupSize = 1, bool balanceColors = false,
                      std::vector<Color_t>* indexColor = nullptr) {
   static_assert(std::is_integral<Color_t>::value, "");

Common/src/geometry/CGeometry.cpp

@@ -3609,8 +3609,7 @@ const su2vector<unsigned long>& CGeometry::GetTransposeSparsePatternMap(Connecti
   return pattern.transposePtr();
 }
 
-const CCompressedSparsePatternUL& CGeometry::GetEdgeColoring(su2double* efficiency, bool maximizeEdgeColorGroupSize,
-                                                             bool largeNumberOfColors) {
+const CCompressedSparsePatternUL& CGeometry::GetEdgeColoring(su2double* efficiency, bool maximizeEdgeColorGroupSize) {
   /*--- Check for dry run mode with dummy geometry. ---*/
   if (nEdge == 0) return edgeColoring;
 
@@ -3639,23 +3638,14 @@ const CCompressedSparsePatternUL& CGeometry::GetEdgeColoring(su2double* efficien
     /*--- Color the edges. ---*/
     constexpr bool balanceColors = true;
 
-    /*--- Lambda to account for different numbers of colors. ---*/
-    auto getColorSparsePattern = [&](unsigned long edgeColorGroupSize) {
-      if (largeNumberOfColors) {
-        return colorSparsePattern<unsigned char, 255>(pattern, edgeColorGroupSize, balanceColors);
-      } else {
-        return colorSparsePattern(pattern, edgeColorGroupSize, balanceColors);
-      }
-    };
-
     /*--- if requested, find an efficient coloring with maximum color group size (up to edgeColorGroupSize) ---*/
     if (maximizeEdgeColorGroupSize) {
       auto upperEdgeColorGroupSize = edgeColorGroupSize + 1; /* upper bound that is deemed too large */
       auto nextEdgeColorGroupSize = edgeColorGroupSize;      /* next value that we are going to try */
       auto lowerEdgeColorGroupSize = 1ul;                    /* lower bound that is known to work */
 
       while (true) {
-        auto currentEdgeColoring = getColorSparsePattern(nextEdgeColorGroupSize);
+        const auto currentEdgeColoring = colorSparsePattern(pattern, edgeColorGroupSize, balanceColors);
 
         /*--- if the coloring fails, reduce the color group size ---*/
         if (currentEdgeColoring.empty()) {
@@ -3675,7 +3665,7 @@ const CCompressedSparsePatternUL& CGeometry::GetEdgeColoring(su2double* efficien
         else {
           lowerEdgeColorGroupSize = nextEdgeColorGroupSize;
         }
-        auto increment = (upperEdgeColorGroupSize - lowerEdgeColorGroupSize) / 2;
+        const auto increment = (upperEdgeColorGroupSize - lowerEdgeColorGroupSize) / 2;
 
         nextEdgeColorGroupSize = lowerEdgeColorGroupSize + increment;
 
@@ -3687,7 +3677,7 @@ const CCompressedSparsePatternUL& CGeometry::GetEdgeColoring(su2double* efficien
       edgeColorGroupSize = nextEdgeColorGroupSize;
     }
 
-    edgeColoring = getColorSparsePattern(edgeColorGroupSize);
+    edgeColoring = colorSparsePattern(pattern, edgeColorGroupSize, balanceColors);
 
     /*--- If the coloring fails use the natural coloring. This is a
      *    "soft" failure as this "bad" coloring should be detected

SU2_CFD/include/solvers/CFVMFlowSolverBase.inl

@@ -294,7 +294,7 @@ void CFVMFlowSolverBase<V, R>::HybridParallelInitialization(const CConfig& confi
    *    group size. Find the maximum edge color group size that yields an efficient coloring. Also, allow larger numbers
    *    of colors. ---*/
   const bool relax =  config.GetEdgeColoringRelaxDiscAdj();
-  const auto& coloring = geometry.GetEdgeColoring(&parallelEff, relax, relax);
+  const auto& coloring = geometry.GetEdgeColoring(&parallelEff, relax);
 #else
   const auto& coloring = geometry.GetEdgeColoring(&parallelEff);
 #endif

SU2_CFD/include/solvers/CScalarSolver.inl

@@ -51,7 +51,7 @@ CScalarSolver<VariableType>::CScalarSolver(CGeometry* geometry, CConfig* config,
    *    group size. Find the maximum edge color group size that yields an efficient coloring. Also, allow larger numbers
    *    of colors. ---*/
   const bool relax =  config->GetEdgeColoringRelaxDiscAdj();
-  const auto& coloring = geometry->GetEdgeColoring(&parallelEff, relax, relax);
+  const auto& coloring = geometry->GetEdgeColoring(&parallelEff, relax);
 #else
   const auto& coloring = geometry->GetEdgeColoring(&parallelEff);
 #endif