Merge pull request #31268 from lindsayad/mpai60-contact-input-30433

Avoid exceptions during projection of primary nodes when nodes are aligned

Author: lindsayad

framework/doc/content/source/constraints/AutomaticMortarGeneration.md

@@ -1,6 +1,20 @@
 # AutomaticMortarGeneration
 
 The `AutomaticMortarGeneration` class is used to define mortar segment meshes to properly integrate discontinuities caused by normal projections of non-matching, faceted meshes.
+The mortar segment mesh is always replicated when the parent mesh is allowed to displace, otherwise
+its distribution type (replicated/distributed) is determined by the type of the parent mesh. The
+reason the mortar mesh is replicated during displacement is that we always build the mortar mesh by
+looping over all active elements associated with the secondary and primary interface, not just
+active local elements. When displacement is occurring we cannot know *a priori* what elements will
+project onto each other, so absent that knowledge we keep copies of all interface elements on each
+process. In the future we may eliminate this replication and implement communication patterns that
+occur during each residual and Jacobian evaluation to pull remote elements. This would improve
+memory scalability. Even for the current implementation where the interface of the parent mesh is
+replicated, one could legitimately ask why the mortar mesh needs to be so. The answer is that
+`MortarNodalAuxKernel` derived classes require access to all mortar segment elements, local or not,
+that have support from the shape function associated with a given node. In the future we may add
+ghosting functors to the mortar segment mesh, which would allow us to delete unnecessary non-local
+elements.
 
 ## 2D
 
@@ -25,7 +39,7 @@ While first-order, QUAD4 faces are (in general) not linear. The 'twisting' or 'p
 Elements defined on second order geometries are curvilinear so to simplify the 'clipping' procedure both secondary and primary face elements are subdivided into first-order face elements then subsequently linearized (illustrated below). The same clipping and triangularization routine is then applied on the linearized sub-elements to create the mortar segments. See [!cite](puso2008segment).
 
 !media media/framework/constraints/Second-Order-Linearized.jpg
-       style=display:block;margin:auto;width:70%   
+       style=display:block;margin:auto;width:70%
        alt=A second order quad element is converted to 4 first-order elements, which are then linearized and "clipped".
 
 Quadrature points defined on mortar segments (which live on linearized elements) are mapped back to second order elements following an analogous but reverse procedure to the one illustrated above; points are mapped from linearized elements to first order sub-elements then subsequently transformed to the original second order elements.

framework/include/constraints/AutomaticMortarGeneration.h

@@ -474,6 +474,18 @@ class AutomaticMortarGeneration : public ConsoleStreamInterface
   void
   householderOrthogolization(const Point & normal, Point & tangent_one, Point & tangent_two) const;
 
+  /**
+   * Process aligned nodes
+   * @returns whether mortar segment(s) were created
+   */
+  bool processAlignedNodes(const Node & secondary_node,
+                           const Node & primary_node,
+                           const std::vector<const Elem *> * secondary_node_neighbors,
+                           const std::vector<const Elem *> * primary_node_neighbors,
+                           const VectorValue<Real> & nodal_normal,
+                           const Elem & candidate_element,
+                           std::set<const Elem *> & rejected_element_candidates);
+
   /// Whether to print debug output
   const bool _debug;
 
@@ -507,6 +519,13 @@ class AutomaticMortarGeneration : public ConsoleStreamInterface
   /// Storage for the input parameters used by the mortar nodal geometry output
   std::unique_ptr<InputParameters> _output_params;
 
+  /// Debugging container for printing information about fraction of successful projections for
+  /// secondary nodes. If !_debug then this should always be empty
+  std::unordered_set<dof_id_type> _projected_secondary_nodes;
+
+  /// Secondary nodes that failed to project
+  std::unordered_set<dof_id_type> _failed_secondary_node_projections;
+
   friend class MortarNodalGeometryOutput;
   friend class AugmentSparsityOnInterface;
 };

framework/include/constraints/MortarData.h

@@ -9,167 +9,4 @@
 
 #pragma once
 
-#include "AutomaticMortarGeneration.h"
-#include "MooseHashing.h"
-
-#include "libmesh/parallel_object.h"
-
-#include <unordered_map>
-#include <set>
-
-class SubProblem;
-class MortarExecutorInterface;
-
-class MortarData : public libMesh::ParallelObject
-{
-public:
-  MortarData(const libMesh::ParallelObject & other);
-
-  /**
-   * Create mortar generation object
-   * @param boundary_key The primary-secondary boundary pair on which the AMG objects lives
-   * @param subdomain_key The primary-secondary subdomain pair on which the AMG objects lives
-   * @param subproblem A reference to the subproblem
-   * @param on_displaced Whether the AMG object lives on the displaced mesh
-   * @param periodic Whether the AMG object will be used for enforcing periodic constraints. Note
-   * that this changes the direction of the projection normals so one AMG object cannot be used to
-   * enforce both periodic and non-periodic constraints
-   * @param debug whether to output mortar segment mesh exodus file for debugging purposes
-   * @param correct_edge_dropping edge dropping treatment selection
-   * @param minimum_projection_angle minimum projection angle allowed for building mortar segment
-   * mesh
-   */
-  void createMortarInterface(const std::pair<BoundaryID, BoundaryID> & boundary_key,
-                             const std::pair<SubdomainID, SubdomainID> & subdomain_key,
-                             SubProblem & subproblem,
-                             bool on_displaced,
-                             bool periodic,
-                             const bool debug,
-                             const bool correct_edge_dropping,
-                             const Real minimum_projection_angle);
-
-  /**
-   * Getter to retrieve the AutomaticMortarGeneration object corresponding to the boundary and
-   * subdomain keys. If the AutomaticMortarGeneration object does not yet exist, then we error
-   */
-  const AutomaticMortarGeneration &
-  getMortarInterface(const std::pair<BoundaryID, BoundaryID> & boundary_key,
-                     const std::pair<SubdomainID, SubdomainID> & /*subdomain_key*/,
-                     bool on_displaced) const;
-
-  /**
-   * Non-const getter to retrieve the AutomaticMortarGeneration object corresponding to the boundary
-   * and subdomain keys. If the AutomaticMortarGeneration object does not yet exist, then we error
-   */
-  AutomaticMortarGeneration &
-  getMortarInterface(const std::pair<BoundaryID, BoundaryID> & boundary_key,
-                     const std::pair<SubdomainID, SubdomainID> & /*subdomain_key*/,
-                     bool on_displaced);
-
-  /**
-   * Return all automatic mortar generation objects on either the displaced or undisplaced mesh
-   */
-  const std::unordered_map<std::pair<BoundaryID, BoundaryID>, AutomaticMortarGeneration> &
-  getMortarInterfaces(bool on_displaced) const
-  {
-    if (on_displaced)
-      return _displaced_mortar_interfaces;
-    else
-      return _mortar_interfaces;
-  }
-
-  /**
-   * Returns the mortar covered subdomains
-   */
-  const std::set<SubdomainID> & getMortarSubdomainIDs() const { return _mortar_subdomain_coverage; }
-
-  /**
-   * Returns the mortar covered boundaries
-   */
-  const std::set<BoundaryID> & getMortarBoundaryIDs() const { return _mortar_boundary_coverage; }
-
-  /**
-   * Builds mortar segment meshes for each mortar interface
-   */
-  void update();
-
-  /**
-   * Returns whether any of the AutomaticMortarGeneration objects are running on a displaced mesh
-   */
-  bool hasDisplacedObjects() const { return _displaced_mortar_interfaces.size(); }
-
-  /**
-   * Returns whether we have **any** active AutomaticMortarGeneration objects
-   */
-  bool hasObjects() const { return _mortar_interfaces.size(); }
-
-  /**
-   * Returns the higher dimensional subdomain ids of the interior parents of the given lower-d
-   * subdomain id
-   */
-  const std::set<SubdomainID> & getHigherDimSubdomainIDs(SubdomainID lower_d_subdomain_id) const;
-
-  /**
-   * \em Adds \p mei to the container of objects that will have their \p mortarSetup method called
-   * as soon as the mortar mesh has been generated for the first time
-   */
-  void notifyWhenMortarSetup(MortarExecutorInterface * mei);
-
-  /**
-   * \em Removes \p mei from the container of objects that will have their \p mortarSetup method
-   * called as soon as the mortar mesh has been generated for the first time
-   */
-  void dontNotifyWhenMortarSetup(MortarExecutorInterface * mei);
-
-  /**
-   * @return whether we have performed an initial mortar mesh construction
-   */
-  bool initialized() const { return _mortar_initd; }
-
-private:
-  /**
-   * Builds mortar segment mesh from specific AutomaticMortarGeneration object
-   */
-  void update(AutomaticMortarGeneration & amg);
-
-  typedef std::pair<BoundaryID, BoundaryID> MortarKey;
-
-  /// Map from primary-secondary (in that order) boundary ID pair to the corresponding
-  /// undisplaced AutomaticMortarGeneration object
-  std::unordered_map<MortarKey, AutomaticMortarGeneration> _mortar_interfaces;
-
-  /// Map from primary-secondary (in that order) boundary ID pair to the corresponding
-  /// displaced AutomaticMortarGeneration object
-  std::unordered_map<MortarKey, AutomaticMortarGeneration> _displaced_mortar_interfaces;
-
-  /// A set containing the subdomain ids covered by all the mortar interfaces in this MortarData
-  /// object
-  std::set<SubdomainID> _mortar_subdomain_coverage;
-
-  /// A set containing the boundary ids covered by all the mortar interfaces in this MortarData
-  /// object
-  std::set<BoundaryID> _mortar_boundary_coverage;
-
-  /// Map from undisplaced AMG key to whether the undisplaced AMG object is enforcing periodic constraints
-  std::unordered_map<MortarKey, bool> _periodic_map;
-
-  /// Map from displaced AMG key to whether the displaced AMG object is enforcing periodic constraints
-  std::unordered_map<MortarKey, bool> _displaced_periodic_map;
-
-  /// Map from undisplaced AMG key to whether the undisplaced AMG object is to output mortar segment mesh
-  std::unordered_map<MortarKey, bool> _debug_flag_map;
-
-  /// 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 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;
-
-  /// A container of objects for whom the \p mortarSetup method will be called after the mortar mesh
-  /// has been setup for the first time
-  std::set<MortarExecutorInterface *> _mei_objs;
-
-  /// Whether we have performed any mortar mesh construction
-  bool _mortar_initd;
-};
+#include "MortarInterfaceWarehouse.h"