Add selectable 3D mortar triangulation options

- add triangulation selection for 3D mortar contact
- add triangulate_triangles control for triangular polygons
- add regression coverage for centroid, ear_clipping, and delaunay paths

refs #32816

Author: Andreas Henrik Frederiksen

framework/include/constraints/AutomaticMortarGeneration.h

@@ -74,7 +74,9 @@ class AutomaticMortarGeneration : public ConsoleStreamInterface
                             bool periodic,
                             const bool debug,
                             const bool correct_edge_dropping,
-                            const Real minimum_projection_angle);
+                            const Real minimum_projection_angle,
+                            const MortarSegmentTriangulationMode triangulation_mode,
+                            const bool triangulate_triangles);
 
   /**
    * Once the secondary_requested_boundary_ids and
@@ -516,6 +518,12 @@ class AutomaticMortarGeneration : public ConsoleStreamInterface
   /// segment mesh in extreme cases. This parameter is mostly intended for mortar mesh debugging purposes in 2D.
   const Real _minimum_projection_angle;
 
+  /// Triangulation mode used for clipped 3D mortar polygons.
+  const MortarSegmentTriangulationMode _triangulation_mode;
+
+  /// Whether already-triangular clipped polygons should still be centroid-subdivided.
+  const bool _triangulate_triangles;
+
   /// Storage for the input parameters used by the mortar nodal geometry output
   std::unique_ptr<InputParameters> _output_params;
 

framework/include/constraints/MortarInterfaceWarehouse.h

@@ -16,10 +16,12 @@
 
 #include <unordered_map>
 #include <set>
+#include <string>
 
 class SubProblem;
 class MortarExecutorInterface;
 class AutomaticMortarGeneration;
+class MooseEnum;
 
 class MortarInterfaceWarehouse : public libMesh::ParallelObject
 {
@@ -39,6 +41,9 @@ class MortarInterfaceWarehouse : public libMesh::ParallelObject
    * @param correct_edge_dropping edge dropping treatment selection
    * @param minimum_projection_angle minimum projection angle allowed for building mortar segment
    * mesh
+   * @param triangulation triangulation strategy used for clipped 3D mortar polygons
+   * @param triangulate_triangles whether a clipped polygon that is already a triangle should still
+   * be subdivided
    */
   void createMortarInterface(const std::pair<BoundaryID, BoundaryID> & boundary_key,
                              const std::pair<SubdomainID, SubdomainID> & subdomain_key,
@@ -47,7 +52,9 @@ class MortarInterfaceWarehouse : public libMesh::ParallelObject
                              bool periodic,
                              const bool debug,
                              const bool correct_edge_dropping,
-                             const Real minimum_projection_angle);
+                             const Real minimum_projection_angle,
+                             const MooseEnum & triangulation,
+                             const bool triangulate_triangles);
 
   /**
    * Getter to retrieve the AutomaticMortarGeneration object corresponding to the boundary and
@@ -165,6 +172,18 @@ class MortarInterfaceWarehouse : public libMesh::ParallelObject
   /// Map from displaced AMG key to whether the displaced AMG object is to output mortar segment mesh
   std::unordered_map<MortarKey, bool> _displaced_debug_flag_map;
 
+  /// Map from undisplaced AMG key to the selected mortar segment triangulation strategy
+  std::unordered_map<MortarKey, std::string> _mortar_segment_triangulation_map;
+
+  /// Map from displaced AMG key to the selected mortar segment triangulation strategy
+  std::unordered_map<MortarKey, std::string> _displaced_mortar_segment_triangulation_map;
+
+  /// Map from undisplaced AMG key to whether already-triangular polygons are further subdivided
+  std::unordered_map<MortarKey, bool> _triangulate_triangles_map;
+
+  /// Map from displaced AMG key to whether already-triangular polygons are further subdivided
+  std::unordered_map<MortarKey, bool> _displaced_triangulate_triangles_map;
+
   /// Map from lower dimensional subdomain ids to corresponding higher simensional subdomain ids
   /// (e.g. the ids of the interior parents)
   std::unordered_map<SubdomainID, std::set<SubdomainID>> _lower_d_sub_to_higher_d_subs;

framework/include/constraints/MortarSegmentHelper.h

@@ -9,6 +9,8 @@
 
 #pragma once
 
+#include "MortarSegmentInfo.h"
+
 #include "libmesh/point.h"
 #include "libmesh/int_range.h"
 
@@ -28,7 +30,9 @@ class MortarSegmentHelper
 public:
   MortarSegmentHelper(const std::vector<Point> secondary_nodes,
                       const Point & center,
-                      const Point & normal);
+                      const Point & normal,
+                      const MortarSegmentTriangulationMode triangulation_mode,
+                      const bool triangulate_triangles);
 
   /**
    * Computes the intersection between line segments defined by point pairs (p1,p2) and (q1,q2)
@@ -48,14 +52,19 @@ class MortarSegmentHelper
    */
   bool isDisjoint(const std::vector<Point> & poly) const;
 
+  /**
+   * Project a primary polygon into the helper plane while preserving the clipping orientation.
+   */
+  std::vector<Point> projectPrimaryPoly(const std::vector<Point> & primary_nodes) const;
+
   /**
    * Clip secondary element (defined in instantiation) against given primary polygon
    * result is a set of 2D nodes defining clipped polygon
    */
   std::vector<Point> clipPoly(const std::vector<Point> & primary_nodes) const;
 
   /**
-   * Triangulate a polygon (currently uses center of polygon to define triangulation)
+   * Triangulate a polygon according to the configured mortar-segment triangulation mode.
    * @param poly_nodes List of 2D nodes defining polygon
    * @param offset Current size of 3D nodes array (not poly_nodes)
    * @return tri_map List of integer arrays defining which nodes belong to each triangle
@@ -132,6 +141,16 @@ class MortarSegmentHelper
    */
   Real _tolerance = 1e-8;
 
+  /**
+   * Triangulation mode used for clipped polygons.
+   */
+  const MortarSegmentTriangulationMode _triangulation_mode;
+
+  /**
+   * Whether already-triangular polygons should still be centroid-subdivided.
+   */
+  const bool _triangulate_triangles;
+
   /**
    * Tolerance times secondary area for dimensional consistency
    */

framework/include/constraints/MortarSegmentInfo.h

@@ -25,6 +25,14 @@ class Elem;
 using libMesh::Elem;
 using libMesh::Real;
 
+enum class MortarSegmentTriangulationMode : unsigned char
+{
+  delaunay,
+  centroid,
+  ear_clipping,
+  vertex
+};
+
 /**
  * Holds xi^(1), xi^(2), and other data for a given mortar segment.
  */

framework/include/problems/FEProblemBase.h

@@ -1964,7 +1964,9 @@ class FEProblemBase : public SubProblem, public Restartable
       bool periodic,
       const bool debug,
       const bool correct_edge_dropping,
-      const Real minimum_projection_angle);
+      const Real minimum_projection_angle,
+      const MooseEnum & triangulation,
+      const bool triangulate_triangles);
 
   /**
    * Return the undisplaced or displaced mortar generation object associated with the provided

framework/src/constraints/AutomaticMortarGeneration.C

@@ -223,7 +223,9 @@ AutomaticMortarGeneration::AutomaticMortarGeneration(
     bool periodic,
     const bool debug,
     const bool correct_edge_dropping,
-    const Real minimum_projection_angle)
+    const Real minimum_projection_angle,
+    const MortarSegmentTriangulationMode triangulation_mode,
+    const bool triangulate_triangles)
   : ConsoleStreamInterface(app),
     _app(app),
     _mesh(mesh_in),
@@ -233,7 +235,9 @@ AutomaticMortarGeneration::AutomaticMortarGeneration(
     // We always ghost the entire mortar interface when it is allowed to displace
     _distributed(_on_displaced ? false : !_mesh.is_replicated()),
     _correct_edge_dropping(correct_edge_dropping),
-    _minimum_projection_angle(minimum_projection_angle)
+    _minimum_projection_angle(minimum_projection_angle),
+    _triangulation_mode(triangulation_mode),
+    _triangulate_triangles(triangulate_triangles)
 {
   _primary_secondary_boundary_id_pairs.push_back(boundary_key);
   _primary_requested_boundary_ids.insert(boundary_key.first);
@@ -1080,7 +1084,8 @@ AutomaticMortarGeneration::buildMortarSegmentMesh3d()
         normal = normal.unit();
 
         // Build and store linearized sub-elements for later use
-        mortar_segment_helper[sel] = std::make_unique<MortarSegmentHelper>(nodes, center, normal);
+        mortar_segment_helper[sel] = std::make_unique<MortarSegmentHelper>(
+            nodes, center, normal, _triangulation_mode, _triangulate_triangles);
       }
 
       /**

framework/src/constraints/MortarInterfaceWarehouse.C

@@ -11,9 +11,55 @@
 #include "SubProblem.h"
 #include "MooseMesh.h"
 #include "MooseError.h"
+#include "MooseEnum.h"
 #include "MortarExecutorInterface.h"
 #include "AutomaticMortarGeneration.h"
 
+namespace
+{
+struct ParsedMortarTriangulationOptions
+{
+  MortarSegmentTriangulationMode mode = MortarSegmentTriangulationMode::vertex;
+  std::string canonical_name = "vertex";
+};
+
+ParsedMortarTriangulationOptions
+parseTriangulationOptions(const MooseEnum & triangulation)
+{
+  ParsedMortarTriangulationOptions options;
+
+  if (triangulation == "vertex")
+  {
+    options.mode = MortarSegmentTriangulationMode::vertex;
+    options.canonical_name = "vertex";
+    return options;
+  }
+  if (triangulation == "centroid")
+  {
+    options.mode = MortarSegmentTriangulationMode::centroid;
+    options.canonical_name = "centroid";
+    return options;
+  }
+  if (triangulation == "ear_clipping")
+  {
+    options.mode = MortarSegmentTriangulationMode::ear_clipping;
+    options.canonical_name = "ear_clipping";
+    return options;
+  }
+#if defined(LIBMESH_HAVE_TRIANGLE) || defined(LIBMESH_HAVE_POLY2TRI)
+  if (triangulation == "delaunay")
+  {
+    options.mode = MortarSegmentTriangulationMode::delaunay;
+    options.canonical_name = "delaunay";
+    return options;
+  }
+#endif
+
+  mooseError("Unsupported mortar triangulation option: ", triangulation);
+  return options;
+}
+}
+
 MortarInterfaceWarehouse::MortarInterfaceWarehouse(const libMesh::ParallelObject & other)
   : libMesh::ParallelObject(other), _mortar_initd(false)
 {
@@ -28,7 +74,9 @@ MortarInterfaceWarehouse::createMortarInterface(
     bool periodic,
     const bool debug,
     const bool correct_edge_dropping,
-    const Real minimum_projection_angle)
+    const Real minimum_projection_angle,
+    const MooseEnum & triangulation,
+    const bool triangulate_triangles)
 {
   _mortar_subdomain_coverage.insert(subdomain_key.first);
   _mortar_subdomain_coverage.insert(subdomain_key.second);
@@ -40,7 +88,14 @@ MortarInterfaceWarehouse::createMortarInterface(
 
   auto & periodic_map = on_displaced ? _displaced_periodic_map : _periodic_map;
   auto & debug_flag_map = on_displaced ? _displaced_debug_flag_map : _debug_flag_map;
+  auto & mortar_segment_triangulation_map =
+      on_displaced ? _displaced_mortar_segment_triangulation_map : _mortar_segment_triangulation_map;
+  auto & triangulate_triangles_map =
+      on_displaced ? _displaced_triangulate_triangles_map : _triangulate_triangles_map;
   auto & mortar_interfaces = on_displaced ? _displaced_mortar_interfaces : _mortar_interfaces;
+  const auto parsed_options = parseTriangulationOptions(triangulation);
+  const auto & mortar_segment_triangulation_name = parsed_options.canonical_name;
+  const auto triangulation_mode = parsed_options.mode;
 
   // Periodic flag
   auto periodic_map_iterator = periodic_map.find(boundary_key);
@@ -60,6 +115,26 @@ MortarInterfaceWarehouse::createMortarInterface(
   else
     debug_flag_map.insert(debug_flag_map_iterator, std::make_pair(boundary_key, debug));
 
+  auto mortar_segment_triangulation_map_iterator =
+      mortar_segment_triangulation_map.find(boundary_key);
+  if (mortar_segment_triangulation_map_iterator != mortar_segment_triangulation_map.end() &&
+      mortar_segment_triangulation_map_iterator->second != mortar_segment_triangulation_name)
+    mooseError("We do not currently support multiple values of 'triangulation' on the same "
+               "boundary primary-secondary surface pair.");
+  else
+    mortar_segment_triangulation_map.insert(
+        mortar_segment_triangulation_map_iterator,
+        std::make_pair(boundary_key, mortar_segment_triangulation_name));
+
+  auto triangulate_triangles_map_iterator = triangulate_triangles_map.find(boundary_key);
+  if (triangulate_triangles_map_iterator != triangulate_triangles_map.end() &&
+      triangulate_triangles_map_iterator->second != triangulate_triangles)
+    mooseError("We do not currently support multiple values of 'triangulate_triangles' on the "
+               "same boundary primary-secondary surface pair.");
+  else
+    triangulate_triangles_map.insert(triangulate_triangles_map_iterator,
+                                     std::make_pair(boundary_key, triangulate_triangles));
+
   // Generate lower-d mesh
   if (mortar_interfaces.find(boundary_key) == mortar_interfaces.end())
   {
@@ -73,7 +148,9 @@ MortarInterfaceWarehouse::createMortarInterface(
                                                     periodic,
                                                     debug,
                                                     correct_edge_dropping,
-                                                    minimum_projection_angle));
+                                                    minimum_projection_angle,
+                                                    triangulation_mode,
+                                                    triangulate_triangles));
     if (inserted)
       it->second->initOutput();
   }