Multigrid with 3D implicit line agglomeration

Common/include/geometry/CMultiGridGeometry.hpp

@@ -48,7 +48,16 @@ class CMultiGridGeometry final : public CGeometry {
    * \return <code>TRUE</code> or <code>FALSE</code> depending if the control volume can be agglomerated.
    */
   bool SetBoundAgglomeration(unsigned long CVPoint, vector<short> marker_seed, const CGeometry* fine_grid,
-                             const CConfig* config) const;
+                             const CConfig* config, const vector<char>& mixedBC) const;
+
+  /*!
+   * \brief Find nodes where two boundary conditions of different type meet. These are never
+   *        agglomerated, since a coarse CV holding one would average both conditions.
+   * \param[in] fine_grid - Geometrical definition of the problem.
+   * \param[in] config - Definition of the particular problem.
+   * \return One flag per fine grid point, set where that point must stay on its own.
+   */
+  vector<char> FindMixedBoundaryNodes(const CGeometry* fine_grid, const CConfig* config) const;
 
   /*!
    * \brief Determine if a Point can be agglomerated using geometrical criteria.
@@ -78,16 +87,71 @@ class CMultiGridGeometry final : public CGeometry {
   su2double ComputeLocalCurvature(const CGeometry* fine_grid, unsigned long iPoint, unsigned short iMarker) const;
 
   /*!
-   * \brief Agglomerate high-aspect-ratio interior cells along implicit lines from wall vertices.
+   * \brief Pave the domain with advancing fronts extruded from the boundary patches.
    * \param[in,out] Index_CoarseCV - Current coarse CV index, incremented as new coarse CVs are created.
    * \param[in] fine_grid - Fine grid geometry.
    * \param[in] config - Configuration.
-   * \param[in,out] MGQueue_InnerCV - Queue for domain agglomeration; processed points are removed.
+   * \param[in] iMesh - Multigrid level being built, used to label the summary.
+   * \return Summary of the paving, empty except on the master rank.
+   */
+  string AgglomerateImplicitLines(unsigned long& Index_CoarseCV, const CGeometry* fine_grid, const CConfig* config,
+                                  unsigned short iMesh);
+
+  /*!
+   * \brief Weakest and strongest dual-grid coupling at each node, and the neighbour across the
+   *        strongest edge. Their ratio is the local cell aspect ratio, available on every MG level.
+   */
+  struct CNodeStiffness {
+    vector<su2double> wMin, wMax;    /*!< \brief Weakest and strongest edge coupling at each node. */
+    vector<unsigned long> jStiffest; /*!< \brief Neighbour across the strongest edge. */
+
+    /*!< \brief Local aspect ratio at a node, 1.0 where it could not be measured. */
+    su2double AspectRatio(unsigned long iPoint) const {
+      return (wMin[iPoint] > 0.0) ? wMax[iPoint] / wMin[iPoint] : su2double(1.0);
+    }
+  };
+
+  /*!
+   * \brief Measure the dual-grid coupling at every node of a grid.
+   * \param[in] fine_grid - Grid to measure.
+   * \return Weakest/strongest coupling per node.
+   */
+  CNodeStiffness ComputeNodeStiffness(const CGeometry* fine_grid) const;
+
+  /*!
+   * \brief Boundary nodes that seed a front, with the direction each starts marching in.
+   */
+  struct CFrontSeeds {
+    vector<unsigned long> node;                    /*!< \brief Seed node on the boundary. */
+    vector<std::array<su2double, MAXNDIM>> normal; /*!< \brief Unit normal there, pointing into the domain. */
+  };
+
+  /*!
+   * \brief Collect the boundary nodes that seed an advancing front: those on a viscous wall, or on a
+   *        boundary carrying a stretched layer normal to itself.
+   * \param[in] fine_grid - Fine grid geometry.
+   * \param[in] config - Definition of the particular problem.
+   * \param[in] stiff - Node coupling from ComputeNodeStiffness.
+   * \return Seed nodes and their inward boundary normals.
    */
-  void AgglomerateImplicitLines(unsigned long& Index_CoarseCV, const CGeometry* fine_grid, const CConfig* config,
-                                CMultiGridQueue& MGQueue_InnerCV);
+  CFrontSeeds SeedFrontNodes(const CGeometry* fine_grid, const CConfig* config, const CNodeStiffness& stiff) const;
+
+  /*!
+   * \brief Partition the seed nodes into compact surface patches by repeated pairwise matching. Each
+   *        patch is the footprint of one front and fixes the shape of the stack above it.
+   * \param[in] seeds - Seed nodes from SeedFrontNodes.
+   * \param[in] fine_grid - Fine grid geometry.
+   * \param[in] config - Definition of the particular problem.
+   * \param[in] mixedBC - Nodes that must stay on their own, from FindMixedBoundaryNodes.
+   * \return One vector of indices into seeds.node per patch.
+   */
+  vector<vector<unsigned long>> BuildFrontPatches(const CFrontSeeds& seeds, const CGeometry* fine_grid,
+                                                  const CConfig* config, const vector<char>& mixedBC) const;
 
  public:
+  /*!< \brief Paving summary for this level. */
+  string pavingReport;
+
   /*--- This is to suppress Woverloaded-virtual, omitting it has no negative impact. ---*/
   using CGeometry::SetBoundControlVolume;
   using CGeometry::SetControlVolume;

Common/include/option_structure.hpp

@@ -1116,7 +1116,7 @@ inline SST_ParsedOptions ParseSSTOptions(const SST_OPTIONS *SST_Options, unsigne
 struct CMGOptions {
   su2double MG_Smooth_Res_Threshold{0.0}; /*!< \brief RMS reduction threshold for MG smoothing early exit. */
   su2double MG_Smooth_Coeff{0.0};         /*!< \brief Jacobi smoother coefficient for coarse-grid correction. */
-  unsigned long MG_Min_MeshSize{0};       /*!< \brief Minimum CVs on coarsest MG level. */
+  unsigned long MG_Min_MeshSize{0};       /*!< \brief Minimum CVs on coarsest MG level, per MPI rank. */
   std::vector<unsigned short> MG_PreSmooth;    /*!< \brief Multigrid pre-smoothing iterations per level. */
   std::vector<unsigned short> MG_PostSmooth;   /*!< \brief Multigrid post-smoothing iterations per level. */
   std::vector<unsigned short> MG_CorrecSmooth; /*!< \brief Multigrid Jacobi correction-smoothing per level. */
@@ -1125,7 +1125,6 @@ struct CMGOptions {
   bool MG_Smooth_Output{false};           /*!< \brief Output compact per-cycle smoothing summary. */
   su2double MG_Smooth_StagnationTol{0.0}; /*!< \brief Stagnation early exit: stop if current_rms >= prev_rms * tol. 0 = disabled. */
   bool MG_Implicit_Lines{false};          /*!< \brief Enable implicit-lines agglomeration from walls. */
-  unsigned long MG_Implicit_Lines_MaxLength{20}; /*!< \brief Maximum nodes on a wall-normal implicit line (including wall seed). */
   unsigned long MG_Startup_Iter{100};     /*!< \brief Iterations per mesh during FMG startup, and the length of each level's CFL ramp. 0 = no iteration budget. */
   su2double MG_Startup_Convergence{-2.0}; /*!< \brief FMG: orders of magnitude (log10) that CONV_FIELD must drop on the
                                                  active level before promoting to the next finer one. Negative is a

Common/src/CConfig.cpp

@@ -2061,16 +2061,16 @@ void CConfig::SetConfig_Options() {
   addDoubleOption("MG_SMOOTH_RES_THRESHOLD", MGOptions.MG_Smooth_Res_Threshold, 0.9);
   /*!\brief MG_SMOOTH_OUTPUT\n DESCRIPTION: Print compact per-cycle smoothing iteration summary. DEFAULT: NO \ingroup Config*/
   addBoolOption("MG_SMOOTH_OUTPUT", MGOptions.MG_Smooth_Output, false);
-  /*!\brief MG_SMOOTH_STAGNATION_TOL\n DESCRIPTION: Stop smoothing if current_rms >= previous_rms * this value. Values < 1.0 enable early exit on stagnation, 1.0 only exits on defect growth. DEFAULT: 0.99 \ingroup Config*/
+  /*!\brief MG_SMOOTH_STAGNATION_TOL\n DESCRIPTION: Stop smoothing if current_rms >= previous_rms * this value.
+   * Values < 1.0 enable early exit on stagnation, 1.0 only exits on defect growth. DEFAULT: 0.99 \ingroup Config*/
   addDoubleOption("MG_SMOOTH_STAGNATION_TOL", MGOptions.MG_Smooth_StagnationTol, 0.99);
   /*!\brief MG_SMOOTH_COEFF\n DESCRIPTION: Smoothing coefficient for the correction prolongation Jacobi smoother. DEFAULT: 1.25 \ingroup Config*/
   addDoubleOption("MG_SMOOTH_COEFF", MGOptions.MG_Smooth_Coeff, 1.25);
-  /*!\brief MG_MIN_MESHSIZE\n DESCRIPTION: Minimum number of CVs on the coarsest multigrid level. Levels that would produce fewer CVs are not created. DEFAULT: 50 \ingroup Config*/
+  /*!\brief MG_MIN_MESHSIZE\n DESCRIPTION: Minimum number of CVs on the coarsest multigrid level, checked per MPI rank
+   * (i.e. on the smallest partition). Levels that would produce fewer CVs on any rank are not created. DEFAULT: 500 \ingroup Config*/
   addUnsignedLongOption("MG_MIN_MESHSIZE", MGOptions.MG_Min_MeshSize, 500);
   /*!\brief MG_IMPLICIT_LINES\n DESCRIPTION: Enable agglomeration along implicit lines from wall seeds. DEFAULT: NO \ingroup Config*/
   addBoolOption("MG_IMPLICIT_LINES", MGOptions.MG_Implicit_Lines, false);
-  /*!\brief MG_IMPLICIT_LINES_MAX_LENGTH\n DESCRIPTION: Maximum number of nodes on a wall-normal implicit agglomeration line (including the wall seed node). DEFAULT: 20 \ingroup Config*/
-  addUnsignedLongOption("MG_IMPLICIT_LINES_MAX_LENGTH", MGOptions.MG_Implicit_Lines_MaxLength, 20);
   /*!\brief MG_STARTUP_ITER\n DESCRIPTION: Max number of iterations spent on each mesh during the Full
    * Multigrid (FMG) startup phase. DEFAULT: 100 \ingroup Config*/
   addUnsignedLongOption("MG_STARTUP_ITER", MGOptions.MG_Startup_Iter, 100);
@@ -2085,7 +2085,8 @@ void CConfig::SetConfig_Options() {
   /*!\brief MG_STARTUP_STAGNATION_ITER\n DESCRIPTION: Consecutive stalled iterations required before Full-MG promotes
    * on stagnation. 0 disables it, as MG_STARTUP_STAGNATION= 0 does. DEFAULT: 5 \ingroup Config*/
   addUnsignedLongOption("MG_STARTUP_STAGNATION_ITER", MGOptions.MG_Startup_Stagnation_Iter, 5);
-  /*!\brief MG_CFL_SCALING\n DESCRIPTION: Per-level CFL scaling factors for coarse MG levels. Entry i is the ratio CFL(i+1)/CFL(i). If fewer values than nMGLevels are given, the last value is repeated. DEFAULT: 0.25 (i.e., 1/4 per level) \ingroup Config*/
+  /*!\brief MG_CFL_SCALING\n DESCRIPTION: Per-level CFL scaling factors for coarse MG levels. Entry i is the ratio CFL(i+1)/CFL(i).
+   * If fewer values than nMGLevels are given, the last value is repeated. DEFAULT: 0.25 (i.e., 1/4 per level) \ingroup Config*/
   addDoubleListOption("MG_CFL_SCALING", nMG_CflScaling_p, MG_CflScaling_p);
 
   /*!\par CONFIG_CATEGORY: Spatial Discretization \ingroup Config*/