[WIP] fix multigrid agglomeration

Common/include/geometry/CMultiGridGeometry.hpp

@@ -31,33 +31,33 @@
 
 /*!
  * \class CMultiGridGeometry
- * \brief Class for defining the multigrid geometry, the main delicated part is the
+ * \brief Class for defining the multigrid geometry, the main delegated part is the
  *        agglomeration stage, which is done in the declaration.
  * \author F. Palacios
  */
 class CMultiGridGeometry final : public CGeometry {
  private:
   /*!
-   * \brief Determine if a CVPoint van be agglomerated, if it have the same marker point as the seed.
+   * \brief Determine if a CVPoint can be agglomerated, if it has the same marker point as the seed.
    * \param[in] CVPoint - Control volume to be agglomerated.
    * \param[in] marker_seed - Marker of the seed.
    * \param[in] fine_grid - Geometrical definition of the problem.
    * \param[in] config - Definition of the particular problem.
    * \return <code>TRUE</code> or <code>FALSE</code> depending if the control volume can be agglomerated.
    */
-  bool SetBoundAgglomeration(unsigned long CVPoint, short marker_seed, const CGeometry* fine_grid,
+  bool SetBoundAgglomeration(unsigned long CVPoint, vector<short> marker_seed, const CGeometry* fine_grid,
                              const CConfig* config) const;
 
   /*!
-   * \brief Determine if a can be agglomerated using geometrical criteria.
+   * \brief Determine if a Point can be agglomerated using geometrical criteria.
    * \param[in] iPoint - Seed point.
    * \param[in] fine_grid - Geometrical definition of the problem.
    * \param[in] config - Definition of the particular problem.
    */
   bool GeometricalCheck(unsigned long iPoint, const CGeometry* fine_grid, const CConfig* config) const;
 
   /*!
-   * \brief Determine if a CVPoint van be agglomerated, if it have the same marker point as the seed.
+   * \brief Determine if a CVPoint can be agglomerated, if it has the same marker point as the seed.
    * \param[out] Suitable_Indirect_Neighbors - List of Indirect Neighbours that can be agglomerated.
    * \param[in] iPoint - Seed point.
    * \param[in] Index_CoarseCV - Index of agglomerated point.

Common/include/geometry/CMultiGridQueue.hpp

@@ -93,7 +93,7 @@ class CMultiGridQueue {
   void IncrPriorityCV(unsigned long incrPoint);
 
   /*!
-   * \brief Increase the priority of the CV.
+   * \brief Reduce the priority of the CV.
    * \param[in] redPoint - Index of the control volume.
    */
   void RedPriorityCV(unsigned long redPoint);

Common/src/geometry/CMultiGridGeometry.cpp

@@ -36,8 +36,8 @@
   /*--- Create a queue system to do the agglomeration
    1st) More than two markers ---> Vertices (never agglomerate)
    2nd) Two markers ---> Edges (agglomerate if same BC, never agglomerate if different BC)
-   3rd) One marker ---> Surface (always agglomarate)
-   4th) No marker ---> Internal Volume (always agglomarate) ---*/
+   3rd) One marker ---> Surface (always agglomerate)
+   4th) No marker ---> Internal Volume (always agglomerate) ---*/
 
   /*--- Set a marker to indicate indirect agglomeration, for quads and hexs,
    i.e. consider up to neighbors of neighbors of neighbors.
@@ -76,6 +76,7 @@
       /*--- If the element has not been previously agglomerated and it
        belongs to this physical domain, and it meets the geometrical
        criteria, the agglomeration is studied. ---*/
+      vector<short> marker_seed;
 
       if ((!fine_grid->nodes->GetAgglomerate(iPoint)) && (fine_grid->nodes->GetDomain(iPoint)) &&
           (GeometricalCheck(iPoint, fine_grid, config))) {
@@ -92,7 +93,7 @@
         bool agglomerate_seed = true;
         auto counter = 0;
         unsigned short copy_marker[3] = {};
-        const auto marker_seed = iMarker;
+        marker_seed.push_back(iMarker);
 
         /*--- For a particular point in the fine grid we save all the markers
          that are in that point ---*/
@@ -101,34 +102,42 @@
           if (fine_grid->nodes->GetVertex(iPoint, jMarker) != -1) {
             copy_marker[counter] = jMarker;
             counter++;
+
+            if (jMarker != iMarker) {
+              marker_seed.push_back(jMarker);
+            }
           }
         }
 
-        /*--- To aglomerate a vertex it must have only one physical bc!!
+        /*--- To agglomerate a vertex it must have only one physical bc!!
          This can be improved. If there is only a marker, it is a good
          candidate for agglomeration ---*/
 
+        /*--- Valley -> Valley : conditionally allowed when both points are on the same marker. ---*/
+        /*--- ! Note that in the case of MPI SEND_RECEIVE markers, we might need other conditions ---*/
         if (counter == 1) {
           agglomerate_seed = true;
 
           /*--- Euler walls can be curved and agglomerating them leads to difficulties ---*/
-          if (config->GetMarker_All_KindBC(marker_seed) == EULER_WALL) agglomerate_seed = false;
+          //if (config->GetMarker_All_KindBC(marker_seed[0]) == EULER_WALL)
+          //  agglomerate_seed = false;
         }
+
         /*--- If there are two markers, we will agglomerate if any of the
          markers is SEND_RECEIVE ---*/
 
         if (counter == 2) {
-          agglomerate_seed = (config->GetMarker_All_KindBC(copy_marker[0]) == SEND_RECEIVE) ||
-                             (config->GetMarker_All_KindBC(copy_marker[1]) == SEND_RECEIVE);
+          //agglomerate_seed = (config->GetMarker_All_KindBC(copy_marker[0]) == SEND_RECEIVE) ||
+          //                   (config->GetMarker_All_KindBC(copy_marker[1]) == SEND_RECEIVE);
 
           /* --- Euler walls can also not be agglomerated when the point has 2 markers ---*/
-          if ((config->GetMarker_All_KindBC(copy_marker[0]) == EULER_WALL) ||
-              (config->GetMarker_All_KindBC(copy_marker[1]) == EULER_WALL)) {
-            agglomerate_seed = false;
-          }
+          //if ((config->GetMarker_All_KindBC(copy_marker[0]) == EULER_WALL) ||
+          //    (config->GetMarker_All_KindBC(copy_marker[1]) == EULER_WALL)) {
+            agglomerate_seed = true;
+          //}
         }
 
-        /*--- If there are more than 2 markers, the aglomeration will be discarded ---*/
+        /*--- If there are more than 2 markers, the agglomeration will be discarded ---*/
 
         if (counter > 2) agglomerate_seed = false;
 
@@ -473,15 +482,18 @@
   SetGlobal_nPointDomain(Global_nPointCoarse);
 
   if (iMesh != MESH_0) {
-    const su2double factor = 1.5;
+    //const su2double factor = 1.5; //nijso: too high
+    const su2double factor = 1.0;
     const su2double Coeff = pow(su2double(Global_nPointFine) / Global_nPointCoarse, 1.0 / nDim);
     const su2double CFL = factor * config->GetCFL(iMesh - 1) / Coeff;
     config->SetCFL(iMesh, CFL);
   }
 
   const su2double ratio = su2double(Global_nPointFine) / su2double(Global_nPointCoarse);
 
-  if (((nDim == 2) && (ratio < 2.5)) || ((nDim == 3) && (ratio < 2.5))) {
+  //if (((nDim == 2) && (ratio < 2.5)) || ((nDim == 3) && (ratio < 2.5))) {
+  // nijso: too high for very small test meshes.
+  if (((nDim == 2) && (ratio < 2.0)) || ((nDim == 3) && (ratio < 2.0))) {
     config->SetMGLevels(iMesh - 1);
   } else if (rank == MASTER_NODE) {
     PrintingToolbox::CTablePrinter MGTable(&std::cout);
@@ -506,7 +518,7 @@
   edgeColorGroupSize = config->GetEdgeColoringGroupSize();
 }
 
-bool CMultiGridGeometry::SetBoundAgglomeration(unsigned long CVPoint, short marker_seed, const CGeometry* fine_grid,
+bool CMultiGridGeometry::SetBoundAgglomeration(unsigned long CVPoint, vector<short> marker_seed, const CGeometry* fine_grid,
                                                const CConfig* config) const {
   bool agglomerate_CV = false;
 
@@ -530,55 +542,61 @@
         }
       }
 
-      /*--- The basic condition is that the aglomerated vertex must have the same physical marker,
+      /*--- The basic condition is that the agglomerated vertex must have the same physical marker,
        but eventually a send-receive condition ---*/
 
-      /*--- Only one marker in the vertex that is going to be aglomerated ---*/
+      /*--- Only one marker in the vertex that is going to be agglomerated ---*/
 
+      /*--- Valley -> Valley: only if of the same type---*/
       if (counter == 1) {
         /*--- We agglomerate if there is only one marker and it is the same marker as the seed marker ---*/
         // note that this should be the same marker id, not just the same marker type
-        if (copy_marker[0] == marker_seed) agglomerate_CV = true;
+        if ((marker_seed.size()==1) && (copy_marker[0] == marker_seed[0])) agglomerate_CV = true;
 
         /*--- If there is only one marker, but the marker is the SEND_RECEIVE ---*/
 
-        if (config->GetMarker_All_KindBC(copy_marker[0]) == SEND_RECEIVE) {
-          agglomerate_CV = true;
-        }
+        //if (config->GetMarker_All_KindBC(copy_marker[0]) == SEND_RECEIVE) {
+        //  agglomerate_CV = true;
+        //}
 
-        if ((config->GetMarker_All_KindBC(marker_seed) == SYMMETRY_PLANE) ||
-            (config->GetMarker_All_KindBC(marker_seed) == EULER_WALL)) {
-          if (config->GetMarker_All_KindBC(copy_marker[0]) == SEND_RECEIVE) {
-            agglomerate_CV = false;
-          }
-        }
+        //if ((config->GetMarker_All_KindBC(marker_seed[0]) == SYMMETRY_PLANE) ||
+        //    (config->GetMarker_All_KindBC(marker_seed[0]) == EULER_WALL)) {
+        //  if (config->GetMarker_All_KindBC(copy_marker[0]) == SEND_RECEIVE) {
+        //    agglomerate_CV = false;
+        //  }
+        //}
       }
 
-      /*--- If there are two markers in the vertex that is going to be aglomerated ---*/
-
+      /*--- If there are two markers in the vertex that is going to be agglomerated ---*/
+      /*--- Ridge -> Ridge: only if of the same type (same marker ID) ---*/
       if (counter == 2) {
+
+        // check if the seed also has 2 markers
+        if (marker_seed.size() == 2) {
+          // now check if the seed is on the same 2 marker ID's (note that if we allow that they are of the same
+          //   marker type, we need to check that the alignement of the markers is correct as well. better not go there.)
+          if ( ((marker_seed[0] = copy_marker[0]) && (marker_seed[1] = copy_marker[1])) ||
+               ((marker_seed[0] = copy_marker[1]) && (marker_seed[1] = copy_marker[0])) ) {
+              agglomerate_CV = true;
+             }
+        }
         /*--- First we verify that the seed is a physical boundary ---*/
 
-        if (config->GetMarker_All_KindBC(marker_seed) != SEND_RECEIVE) {
-          /*--- Then we check that one of the markers is equal to the seed marker, and the other is send/receive ---*/
+      //  if (config->GetMarker_All_KindBC(marker_seed[0]) != SEND_RECEIVE) {
+      //    /*--- Then we check that one of the markers is equal to the seed marker, and the other is send/receive ---*/
 
-          if (((copy_marker[0] == marker_seed) && (config->GetMarker_All_KindBC(copy_marker[1]) == SEND_RECEIVE)) ||
-              ((config->GetMarker_All_KindBC(copy_marker[0]) == SEND_RECEIVE) && (copy_marker[1] == marker_seed))) {
-            agglomerate_CV = true;
-          }
-        }
+      //    if (((copy_marker[0] == marker_seed[0]) && (config->GetMarker_All_KindBC(copy_marker[1]) == SEND_RECEIVE)) ||
+      //        ((config->GetMarker_All_KindBC(copy_marker[0]) == SEND_RECEIVE) && (copy_marker[1] == marker_seed[0]))) {
+        agglomerate_CV = false;
+      //      agglomerate_CV = true;
+      //    }
+      //  }
       }
     }
-    /*--- If the element belongs to the domain, it is always agglomerated. ---*/
+    /*--- If the element belongs to the domain, it is never agglomerated. ---*/
+    /*--- Any -> Interior : disallowed ---*/
     else {
-      agglomerate_CV = true;
-
-      // actually, for symmetry (and possibly other cells) we only agglomerate cells that are on the marker
-      // at this point, the seed was on the boundary and the CV was not. so we check if the seed is a symmetry
-      if ((config->GetMarker_All_KindBC(marker_seed) == SYMMETRY_PLANE) ||
-          (config->GetMarker_All_KindBC(marker_seed) == EULER_WALL)) {
-        agglomerate_CV = false;
-      }
+      agglomerate_CV = false;
     }
   }
 

SU2_CFD/src/solvers/CSolverFactory.cpp

@@ -307,6 +307,7 @@
     case SUB_SOLVER_TYPE::TURB_SST:
       genericSolver = CreateTurbSolver(kindTurbModel, solver, geometry, config, iMGLevel, false);
       metaData.integrationType = INTEGRATION_TYPE::SINGLEGRID;
+      //metaData.integrationType = INTEGRATION_TYPE::MULTIGRID;
       break;
     case SUB_SOLVER_TYPE::TEMPLATE:
       genericSolver = new CTemplateSolver(geometry, config);