Moose::Mortar Namespace Reference

Functions
std::vector< unsigned int >	getMortarSubElementNodeIndices (const Elem &parent_elem, unsigned int sub_elem)
	Return the node indices for a first-order sub-element of a parent face.
void	projectQPoints3d (const Elem *msm_elem, const Elem *primal_elem, unsigned int sub_elem_index, const QBase &qrule_msm, std::vector< Point > &q_pts)
	3D projection operator for mapping qpoints on mortar segments to secondary or primary elements
void	mapQPoints3dFromReference (const Elem &mortar_segment_elem, const MortarSegmentReferencePoints &reference_points, const QBase &qrule_msm, std::vector< Point > &secondary_q_pts, std::vector< Point > &primary_q_pts)
	3D mapping operator that interpolates stored parent reference points on each triangular mortar segment.
template<typename Iterators , typename Consumers , typename ActionFunctor >
void	loopOverMortarSegments (const Iterators &secondary_elems_to_mortar_segments, Assembly &assembly, SubProblem &subproblem, FEProblemBase &fe_problem, const AutomaticMortarGeneration &amg, const bool displaced, const Consumers &consumers, const THREAD_ID tid, const std::map< SubdomainID, std::deque< MaterialBase * > > &secondary_ip_sub_to_mats, const std::map< SubdomainID, std::deque< MaterialBase * > > &primary_ip_sub_to_mats, const std::deque< MaterialBase * > &secondary_boundary_mats, const ActionFunctor act, const bool reinit_mortar_user_objects)
	This method will loop over pairs of secondary elements and their corresponding mortar segments, reinitialize all finite element shape functions, variables, and material properties, and then call a provided action function for each mortar segment.
template<typename Consumers >
void	setupMortarMaterials (const Consumers &consumers, FEProblemBase &fe_problem, const AutomaticMortarGeneration &amg, const THREAD_ID tid, std::map< SubdomainID, std::deque< MaterialBase * > > &secondary_ip_sub_to_mats, std::map< SubdomainID, std::deque< MaterialBase * > > &primary_ip_sub_to_mats, std::deque< MaterialBase * > &secondary_boundary_mats)
	This function creates containers of materials necessary to execute the mortar method for a supplied set of consumers.

Function Documentation

getMortarSubElementNodeIndices()

std::vector< unsigned int > Moose::Mortar::getMortarSubElementNodeIndices	(	const Elem &	parent_elem,
		unsigned int	sub_elem
	)

Return the node indices for a first-order sub-element of a parent face.

Definition at line 67 of file MortarUtils.C.

{
  if (sub_elem >= parent_elem.n_sub_elem())
    mooseError("Invalid 3D mortar sub-element index ",
               sub_elem,
               " for parent element ",
               parent_elem.id(),
               " of type ",
               libMesh::Utility::enum_to_string<ElemType>(parent_elem.type()),
               ", which has ",
               parent_elem.n_sub_elem(),
               " sub-elements.");
 
  switch (parent_elem.type())
  {
    case TRI3:
      return {0, 1, 2};
    case QUAD4:
      return {0, 1, 2, 3};
    case TRI6:
    case TRI7:
      switch (sub_elem)
      {
        case 0:
          return {0, 3, 5};
        case 1:
          return {3, 4, 5};
        case 2:
          return {3, 1, 4};
        case 3:
          return {5, 4, 2};
        default:
          mooseError("Invalid 3D mortar triangular sub-element index ", sub_elem, ".");
      }
    case QUAD8:
      switch (sub_elem)
      {
        case 0:
          return {0, 4, 7};
        case 1:
          return {4, 1, 5};
        case 2:
          return {5, 2, 6};
        case 3:
          return {7, 6, 3};
        case 4:
          return {4, 5, 6, 7};
        default:
          mooseError("Invalid 3D mortar QUAD8 sub-element index ", sub_elem, ".");
      }
    case QUAD9:
      switch (sub_elem)
      {
        case 0:
          return {0, 4, 8, 7};
        case 1:
          return {4, 1, 5, 8};
        case 2:
          return {8, 5, 2, 6};
        case 3:
          return {7, 8, 6, 3};
        default:
          mooseError("Invalid 3D mortar QUAD9 sub-element index ", sub_elem, ".");
      }
    default:
      mooseError("Parent face element ",
                 parent_elem.id(),
                 " has unsupported type ",
                 libMesh::Utility::enum_to_string<ElemType>(parent_elem.type()),
                 " for 3D mortar sub-element topology.");
  }
}

Referenced by AutomaticMortarGeneration::buildMortarSegmentMesh3d(), and projectQPoints3d().

loopOverMortarSegments()

template<typename Iterators , typename Consumers , typename ActionFunctor >

void Moose::Mortar::loopOverMortarSegments	(	const Iterators &	secondary_elems_to_mortar_segments,
		Assembly &	assembly,
		SubProblem &	subproblem,
		FEProblemBase &	fe_problem,
		const AutomaticMortarGeneration &	amg,
		const bool	displaced,
		const Consumers &	consumers,
		const THREAD_ID	tid,
		const std::map< SubdomainID, std::deque< MaterialBase * > > &	secondary_ip_sub_to_mats,
		const std::map< SubdomainID, std::deque< MaterialBase * > > &	primary_ip_sub_to_mats,
		const std::deque< MaterialBase * > &	secondary_boundary_mats,
		const ActionFunctor	act,
		const bool	reinit_mortar_user_objects
	)

This method will loop over pairs of secondary elements and their corresponding mortar segments, reinitialize all finite element shape functions, variables, and material properties, and then call a provided action function for each mortar segment.

Parameters

secondary_elems_to_mortar_segments	This is a container of iterators. Each iterator should point to a pair. The first member of the pair should be a pointer to a secondary face element and the second member of the pair should correspond to a container of mortar segment element pointers that correspond to the secondary face element.
assembly	The object we will to use to reinitalize finite element data
subproblem	The object we will use to reinitialize variables
fe_problem	The object we will use to reinitialize material properties
amg	The mortar mesh generation object which holds all the mortar mesh data
displaced	Whether the mortar mesh was built from a displaced parent mesh
consumers	A container of objects that are going to be using all the data that we are reinitializing within this function. This may be, for instance, a container of mortar constraints or auxiliary kernels. This consumers parameter is important as it allows us to build up variable and material property dependencies that we must make sure we reinit
act	The action functor that we will call for each mortar segment after we have reinitalized all of our prereq data. This functor may, for instance, call computeResidual or computeJacobian on mortar constraints, or computeValue for an auxiliary kernel

Definition at line 91 of file MortarUtils.h.

{
  const auto & primary_secondary_boundary_id_pair = amg.primarySecondaryBoundaryIDPair();
 
  const auto primary_boundary_id = primary_secondary_boundary_id_pair.first;
  const auto secondary_boundary_id = primary_secondary_boundary_id_pair.second;
 
  // For 3D mortar get index for retrieving sub-element info
  unsigned int secondary_sub_elem_index = 0, primary_sub_elem_index = 0;
  if (amg.dim() == 3)
  {
    secondary_sub_elem_index = amg.mortarSegmentMesh().get_elem_integer_index("secondary_sub_elem");
    primary_sub_elem_index = amg.mortarSegmentMesh().get_elem_integer_index("primary_sub_elem");
  }
 
  // The mortar quadrature rule. Necessary for sizing the number of custom points for re-init'ing
  // the secondary interior, primary interior, and secondary face elements
  const auto & qrule_msm = assembly.qRuleMortar();
 
  // The element Jacobian times weights
  const auto & JxW_msm = assembly.jxWMortar();
 
  // Set required material properties
  std::unordered_set<unsigned int> needed_mat_props;
  for (const auto & consumer : consumers)
  {
    const auto & mp_deps = consumer->getMatPropDependencies();
    needed_mat_props.insert(mp_deps.begin(), mp_deps.end());
  }
  fe_problem.setActiveMaterialProperties(needed_mat_props, /*tid=*/tid);
 
  // Loop through secondary elements, accumulating quadrature points for all corresponding mortar
  // segments
  for (const auto elem_to_msm : secondary_elems_to_mortar_segments)
  {
    const Elem * secondary_face_elem = subproblem.mesh().getMesh().elem_ptr(elem_to_msm->first);
    // Set the secondary interior parent and side ids
    const Elem * secondary_ip = secondary_face_elem->interior_parent();
    unsigned int secondary_side_id = secondary_ip->which_side_am_i(secondary_face_elem);
    const auto & secondary_ip_mats =
        libmesh_map_find(secondary_ip_sub_to_mats, secondary_ip->subdomain_id());
 
    const auto & msm_elems = elem_to_msm->second;
 
    // Need to be able to check if there's edge dropping, in 3D we can't just compare
 
    // Map mortar segment integration points to primary and secondary sides
    // Note points for segments will be held contiguously to allow reinit without moving
    // cleaner way to do this would be with contiguously allocated 2D array but would either
    // need to move into vector for calling
    std::vector<Point> secondary_xi_pts, primary_xi_pts;
 
    std::vector<Real> JxW;
 
#ifndef NDEBUG
    unsigned int expected_length = 0;
#endif
 
    // Loop through contributing msm elements
    for (const auto msm_elem : msm_elems)
    {
      // Initialize mortar segment quadrature and compute JxW
      subproblem.reinitMortarElem(msm_elem, tid);
 
      // Get a reference to the MortarSegmentInfo for this Elem.
      const MortarSegmentInfo & msinfo = amg.mortarSegmentMeshElemToInfo().at(msm_elem);
 
      if (msm_elem->dim() == 1)
      {
        for (unsigned int qp = 0; qp < qrule_msm->n_points(); qp++)
        {
          const Real eta = qrule_msm->qp(qp)(0);
 
          // Map quadrature points to secondary side
          const Real xi1_eta = 0.5 * (1 - eta) * msinfo.xi1_a + 0.5 * (1 + eta) * msinfo.xi1_b;
          secondary_xi_pts.push_back(xi1_eta);
 
          // Map quadrature points to primary side
          const Real xi2_eta = 0.5 * (1 - eta) * msinfo.xi2_a + 0.5 * (1 + eta) * msinfo.xi2_b;
          primary_xi_pts.push_back(xi2_eta);
        }
      }
      else
      {
        if (amg.mortar3DQpMapping() == Mortar3DQuadraturePointMapping::REFERENCE_INTERPOLATION)
          mapQPoints3dFromReference(*msm_elem,
                                    amg.mortarSegmentReferencePoints(*msm_elem),
                                    *qrule_msm,
                                    secondary_xi_pts,
                                    primary_xi_pts);
        else
        {
          // Map independently because the parent-face linearizations differ.
          projectQPoints3d(msm_elem,
                           msinfo.secondary_elem,
                           secondary_sub_elem_index,
                           *qrule_msm,
                           secondary_xi_pts);
          projectQPoints3d(
              msm_elem, msinfo.primary_elem, primary_sub_elem_index, *qrule_msm, primary_xi_pts);
        }
      }
 
      // If edge dropping case we need JxW on the msm to compute dual shape functions
      if (assembly.needDual())
        std::copy(std::begin(JxW_msm), std::end(JxW_msm), std::back_inserter(JxW));
 
#ifndef NDEBUG
      // Verify that the expected number of quadrature points have been inserted
      expected_length += qrule_msm->n_points();
      mooseAssert(secondary_xi_pts.size() == expected_length,
                  "Fewer than expected secondary quadrature points");
      mooseAssert(primary_xi_pts.size() == expected_length,
                  "Fewer than expected primary quadrature points");
 
      if (assembly.needDual())
        mooseAssert(JxW.size() == expected_length, "Fewer than expected JxW values computed");
#endif
    } // end loop over msm_elems
 
    // Reinit dual shape coeffs if dual shape functions needed
    // lindsayad: is there any need to make sure we do this on both reference and displaced?
    if (assembly.needDual())
      assembly.reinitDual(secondary_face_elem, secondary_xi_pts, JxW);
 
    unsigned int n_segment = 0;
 
    // Loop through contributing msm elements, computing residual and Jacobian this time
    for (const auto msm_elem : msm_elems)
    {
      n_segment++;
 
      // These will hold quadrature points for each segment
      std::vector<Point> xi1_pts, xi2_pts;
 
      // Get a reference to the MortarSegmentInfo for this Elem.
      const MortarSegmentInfo & msinfo = amg.mortarSegmentMeshElemToInfo().at(msm_elem);
 
      // Set the primary interior parent and side ids
      const Elem * primary_ip = msinfo.primary_elem->interior_parent();
      unsigned int primary_side_id = primary_ip->which_side_am_i(msinfo.primary_elem);
      const auto & primary_ip_mats =
          libmesh_map_find(primary_ip_sub_to_mats, primary_ip->subdomain_id());
 
      // Compute a JxW for the actual mortar segment element (not the lower dimensional element on
      // the secondary face!)
      subproblem.reinitMortarElem(msm_elem, tid);
 
      // Extract previously computed mapped quadrature points for secondary and primary face
      // elements
      const unsigned int start = (n_segment - 1) * qrule_msm->n_points();
      const unsigned int end = n_segment * qrule_msm->n_points();
      xi1_pts.insert(
          xi1_pts.begin(), secondary_xi_pts.begin() + start, secondary_xi_pts.begin() + end);
      xi2_pts.insert(xi2_pts.begin(), primary_xi_pts.begin() + start, primary_xi_pts.begin() + end);
 
      const Elem * reinit_secondary_elem = secondary_ip;
 
      // If we're on the displaced mesh, we need to get the corresponding undisplaced elem before
      // calling fe_problem.reinitElemFaceRef
      if (displaced)
        reinit_secondary_elem = fe_problem.mesh().elemPtr(reinit_secondary_elem->id());
 
      // NOTE to future developers: it can be tempting to try and change calls on fe_problem to
      // calls on subproblem because it seems wasteful to reinit data on both the reference and
      // displaced problems regardless of whether we are running on a "reference" or displaced
      // mortar mesh. But making such changes opens a can of worms. For instance, a user may define
      // constant material properties that are used by mortar constraints and not think about
      // whether they should set `use_displaced_mesh` for the material (and indeed the user may want
      // those constant properties usable by both reference and displaced consumer objects). If we
      // reinit that material and we haven't reinit'd it's assembly member, then we will get things
      // like segmentation faults. Moreover, one can easily imagine that a material may couple in
      // variables so we need to make sure those are reinit'd too. So even though it's inefficient,
      // it's safest to keep making calls on fe_problem instead of subproblem
 
      // reinit the variables/residuals/jacobians on the secondary interior
      fe_problem.reinitElemFaceRef(
          reinit_secondary_elem, secondary_side_id, TOLERANCE, &xi1_pts, nullptr, tid);
 
      const Elem * reinit_primary_elem = primary_ip;
 
      // If we're on the displaced mesh, we need to get the corresponding undisplaced elem before
      // calling fe_problem.reinitElemFaceRef
      if (displaced)
        reinit_primary_elem = fe_problem.mesh().elemPtr(reinit_primary_elem->id());
 
      // reinit the variables/residuals/jacobians on the primary interior
      fe_problem.reinitNeighborFaceRef(
          reinit_primary_elem, primary_side_id, TOLERANCE, &xi2_pts, nullptr, tid);
 
      // reinit neighbor materials, but be careful not to execute stateful materials since
      // conceptually they don't make sense with mortar (they're not interpolary)
      fe_problem.reinitMaterialsNeighbor(primary_ip->subdomain_id(),
                                         /*tid=*/tid,
                                         /*swap_stateful=*/false,
                                         &primary_ip_mats);
 
      // reinit the variables/residuals/jacobians on the lower dimensional element corresponding to
      // the secondary face. This must be done last after the dof indices have been prepared for the
      // secondary (element) and primary (neighbor)
      subproblem.reinitLowerDElem(secondary_face_elem, /*tid=*/tid, &xi1_pts);
 
      // All this does currently is sets the neighbor/primary lower dimensional elem in Assembly and
      // computes its volume for potential use in the MortarConstraints. Solution continuity
      // stabilization for example relies on being able to access the volume
      subproblem.reinitNeighborLowerDElem(msinfo.primary_elem, tid);
 
      // reinit higher-dimensional secondary face/boundary materials. Do this after we reinit
      // lower-d variables in case we want to pull the lower-d variable values into the secondary
      // face/boundary materials. Be careful not to execute stateful materials since conceptually
      // they don't make sense with mortar (they're not interpolary)
      fe_problem.reinitMaterialsFace(secondary_ip->subdomain_id(),
                                     /*tid=*/tid,
                                     /*swap_stateful=*/false,
                                     &secondary_ip_mats);
      fe_problem.reinitMaterialsBoundary(
          secondary_boundary_id, /*tid=*/tid, /*swap_stateful=*/false, &secondary_boundary_mats);
 
      if (reinit_mortar_user_objects)
        fe_problem.reinitMortarUserObjects(primary_boundary_id, secondary_boundary_id, displaced);
 
      act();
 
    } // End loop over msm segments on secondary face elem
  } // End loop over (active) secondary elems
}

Referenced by MortarNodalAuxKernelTempl< ComputeValueType >::compute(), MortarUserObjectThread::operator()(), and ComputeMortarFunctor::operator()().

mapQPoints3dFromReference()

void Moose::Mortar::mapQPoints3dFromReference	(	const Elem &	mortar_segment_elem,
		const MortarSegmentReferencePoints &	reference_points,
		const QBase &	qrule_msm,
		std::vector< Point > &	secondary_q_pts,
		std::vector< Point > &	primary_q_pts
	)

3D mapping operator that interpolates stored parent reference points on each triangular mortar segment.

Parameters

mortar_segment_elem	The triangular mortar segment carrying the quadrature rule
reference_points	Parent-face reference points stored for the mortar segment
qrule_msm	The rule that governs quadrature on the mortar segment element
secondary_q_pts	Reference-space quadrature points on the secondary face
primary_q_pts	Reference-space quadrature points on the primary face

Definition at line 523 of file MortarUtils.C.

{
  mooseAssert(mortar_segment_elem.type() == TRI3,
              "Reference interpolation expects triangular mortar segments.");
  const FEType fe_type(FIRST, LAGRANGE);
 
  for (const auto qp : make_range(qrule_msm.n_points()))
  {
    Point secondary_qp;
    Point primary_qp;
 
    for (const auto n : index_range(reference_points.secondary_reference_points))
    {
      const auto phi =
          FEInterface::shape(fe_type, &mortar_segment_elem, n, qrule_msm.qp(qp), false);
      secondary_qp += phi * reference_points.secondary_reference_points[n];
      primary_qp += phi * reference_points.primary_reference_points[n];
    }
 
    secondary_q_pts.push_back(secondary_qp);
    primary_q_pts.push_back(primary_qp);
  }
}

Referenced by loopOverMortarSegments().

projectQPoints3d()

void Moose::Mortar::projectQPoints3d	(	const Elem *	msm_elem,
		const Elem *	primal_elem,
		unsigned int	sub_elem_index,
		const QBase &	qrule_msm,
		std::vector< Point > &	q_pts
	)

3D projection operator for mapping qpoints on mortar segments to secondary or primary elements

Parameters

msm_elem	The mortar segment element that we will be mapping quadrature points from
primal_elem	The "persistent" mesh element (e.g. it exists on the simulation's MooseMesh) that we will be mapping quadrature points for. This can be either an element on the secondary or primary face
sub_elem_index	We will call msm_elem->get_extra_integer(sub_elem_index) in the implementation in order to determine which sub-element of the primal element the mortar segment element corresponds to. This sub_elem_index should correspond to the secondary element index if primal_elem is a secondary face element and the primary element index if primal_elem is a primary face element
qrule_msm	The rule that governs quadrature on the mortar segment element
q_pts	The output of this function. This will correspond to the the (reference space) quadrature points that we wish to evaluate shape functions, etc., at on the primal element

Definition at line 552 of file MortarUtils.C.

{
  const auto msm_elem_order = msm_elem->default_order();
  const auto msm_elem_type = msm_elem->type();
 
  // Get normal to linearized element, could store and query but computation is easy
  const Point e1 = msm_elem->point(0) - msm_elem->point(1);
  const Point e2 = msm_elem->point(2) - msm_elem->point(1);
  const Point normal = e2.cross(e1).unit();
 
  // Get sub-elem (for second order meshes, otherwise trivial)
  const auto sub_elem = msm_elem->get_extra_integer(sub_elem_index);
  const ElemType primal_type = primal_elem->type();
  const ElemType sub_elem_type = subElementType(primal_type, sub_elem);
 
  // Transforms quadrature point from first order sub-elements (in case of second-order)
  // to primal element
  auto transform_qp = [primal_type, sub_elem](const Real nu, const Real xi)
  {
    switch (primal_type)
    {
      case TRI3:
        return Point(nu, xi, 0);
      case QUAD4:
        return Point(nu, xi, 0);
      case TRI6:
      case TRI7:
        switch (sub_elem)
        {
          case 0:
            return Point(0.5 * nu, 0.5 * xi, 0);
          case 1:
            return Point(0.5 * (1 - xi), 0.5 * (nu + xi), 0);
          case 2:
            return Point(0.5 * (1 + nu), 0.5 * xi, 0);
          case 3:
            return Point(0.5 * nu, 0.5 * (1 + xi), 0);
          default:
            mooseError("get_sub_elem_indices: Invalid sub_elem: ", sub_elem);
        }
      case QUAD8:
        switch (sub_elem)
        {
          case 0:
            return Point(nu - 1, xi - 1, 0);
          case 1:
            return Point(nu + xi, xi - 1, 0);
          case 2:
            return Point(1 - xi, nu + xi, 0);
          case 3:
            return Point(nu - 1, nu + xi, 0);
          case 4:
            return Point(0.5 * (nu - xi), 0.5 * (nu + xi), 0);
          default:
            mooseError("get_sub_elem_indices: Invalid sub_elem: ", sub_elem);
        }
      case QUAD9:
        switch (sub_elem)
        {
          case 0:
            return Point(0.5 * (nu - 1), 0.5 * (xi - 1), 0);
          case 1:
            return Point(0.5 * (nu + 1), 0.5 * (xi - 1), 0);
          case 2:
            return Point(0.5 * (nu + 1), 0.5 * (xi + 1), 0);
          case 3:
            return Point(0.5 * (nu - 1), 0.5 * (xi + 1), 0);
          default:
            mooseError("get_sub_elem_indices: Invalid sub_elem: ", sub_elem);
        }
      default:
        mooseError("transform_qp: Face element type: ",
                   libMesh::Utility::enum_to_string<ElemType>(primal_type),
                   " invalid for 3D mortar");
    }
  };
 
  // Get sub-elem node indices
  const auto sub_elem_node_indices = getMortarSubElementNodeIndices(*primal_elem, sub_elem);
 
  // Loop through quadrature points on msm_elem
  for (auto qp : make_range(qrule_msm.n_points()))
  {
    // Get physical point on msm_elem to project
    Point x0;
    for (auto n : make_range(msm_elem->n_nodes()))
      x0 += Moose::fe_lagrange_2D_shape(msm_elem_type,
                                        msm_elem_order,
                                        n,
                                        static_cast<const TypeVector<Real> &>(qrule_msm.qp(qp))) *
            msm_elem->point(n);
 
    if (sub_elem_type == TRI3)
    {
      const Point sub_elem_point = analyticalTriangleInverse(
          *msm_elem, *primal_elem, sub_elem_node_indices, normal, x0, sub_elem, qp);
      const Point parent_point = transform_qp(sub_elem_point(0), sub_elem_point(1));
      if (!MooseUtils::isFinitePoint(parent_point) ||
          !primal_elem->on_reference_element(parent_point, mortar_reference_tolerance))
        projectionFailure(*msm_elem,
                          *primal_elem,
                          sub_elem,
                          qp,
                          "the recovered TRI3 point is outside the parent face");
      q_pts.push_back(parent_point);
      continue;
    }
 
    // Use msm_elem quadrature point as initial guess
    // (will be correct for aligned meshes)
    Dual2 xi1{};
    xi1.value() = qrule_msm.qp(qp)(0);
    xi1.derivatives()[0] = 1.0;
    Dual2 xi2{};
    xi2.value() = qrule_msm.qp(qp)(1);
    xi2.derivatives()[1] = 1.0;
    VectorValue<Dual2> xi(xi1, xi2, 0);
    unsigned int current_iterate = 0, max_iterates = 10;
 
    // Project qp from mortar segments to first order sub-elements (elements in case of first order
    // geometry)
    do
    {
      VectorValue<Dual2> x1;
      for (auto n : make_range(sub_elem_node_indices.size()))
        x1 += Moose::fe_lagrange_2D_shape(sub_elem_type, FIRST, n, xi) *
              primal_elem->point(sub_elem_node_indices[n]);
      auto u = x1 - x0;
 
      VectorValue<Dual2> F(u(1) * normal(2) - u(2) * normal(1),
                           u(2) * normal(0) - u(0) * normal(2),
                           u(0) * normal(1) - u(1) * normal(0));
 
      Real projection_tolerance(1e-10);
 
      // Normalize tolerance with quantities involved in the projection.
      // Absolute projection tolerance is loosened for displacements larger than those on the order
      // of one. Tightening the tolerance for displacements of smaller orders causes this tolerance
      // to not be reached in a number of tests.
      if (!u.is_zero() && u.norm().value() > 1.0)
        projection_tolerance *= u.norm().value();
 
      if (MetaPhysicL::raw_value(F).norm() < projection_tolerance)
        break;
 
      RealEigenMatrix J(3, 2);
      J << F(0).derivatives()[0], F(0).derivatives()[1], F(1).derivatives()[0],
          F(1).derivatives()[1], F(2).derivatives()[0], F(2).derivatives()[1];
      RealEigenVector f(3);
      f << F(0).value(), F(1).value(), F(2).value();
      const RealEigenVector dxi = -J.colPivHouseholderQr().solve(f);
 
      xi(0) += dxi(0);
      xi(1) += dxi(1);
    } while (++current_iterate < max_iterates);
 
    const Point newton_sub_elem_point(xi(0).value(), xi(1).value());
    const Point newton_parent_point =
        transform_qp(newton_sub_elem_point(0), newton_sub_elem_point(1));
    const bool newton_point_is_valid =
        current_iterate < max_iterates && MooseUtils::isFinitePoint(newton_sub_elem_point) &&
        MooseUtils::isFinitePoint(newton_parent_point) &&
        quadrilateralReferenceViolation(newton_sub_elem_point) == 0 &&
        primal_elem->on_reference_element(newton_parent_point, mortar_reference_tolerance);
 
    if (newton_point_is_valid)
    {
      q_pts.push_back(newton_parent_point);
      continue;
    }
 
    if (sub_elem_type == QUAD4)
    {
      // Newton can converge to the exterior root of a distorted bilinear QUAD.
      const Point fallback_point = analyticalQuadrilateralInverse(
          *msm_elem, *primal_elem, sub_elem_node_indices, normal, x0, sub_elem, qp);
      const Point parent_point = transform_qp(fallback_point(0), fallback_point(1));
      if (!MooseUtils::isFinitePoint(parent_point) ||
          !primal_elem->on_reference_element(parent_point, mortar_reference_tolerance))
        projectionFailure(*msm_elem,
                          *primal_elem,
                          sub_elem,
                          qp,
                          "the recovered point is outside the parent face");
      q_pts.push_back(parent_point);
      continue;
    }
 
    if (current_iterate == max_iterates)
      mooseError("Newton iteration for mortar quadrature mapping msm element: ",
                 msm_elem->id(),
                 " to elem: ",
                 primal_elem->id(),
                 " didn't converge. MSM element volume: ",
                 msm_elem->volume());
 
    projectionFailure(
        *msm_elem, *primal_elem, sub_elem, qp, "the Newton result is outside the parent face");
  }
}

Referenced by loopOverMortarSegments().

setupMortarMaterials()

template<typename Consumers >

void Moose::Mortar::setupMortarMaterials	(	const Consumers &	consumers,
		FEProblemBase &	fe_problem,
		const AutomaticMortarGeneration &	amg,
		const THREAD_ID	tid,
		std::map< SubdomainID, std::deque< MaterialBase * > > &	secondary_ip_sub_to_mats,
		std::map< SubdomainID, std::deque< MaterialBase * > > &	primary_ip_sub_to_mats,
		std::deque< MaterialBase * > &	secondary_boundary_mats
	)

This function creates containers of materials necessary to execute the mortar method for a supplied set of consumers.

Parameters

consumers	The objects that we're building the material dependencies for. This could be a container of mortar constraints or a "mortar" auxiliary kernel for example
fe_problem	The finite element problem that we'll be querying for material warehouses
tid	The thread ID that we will use for pulling the material warehouse
secondary_ip_sub_to_mats	A map from the secondary interior parent subdomain IDs to the required secondary block materials we will need to evaluate for the consumers
primary_ip_sub_to_mats	A map from the primary interior parent subdomain IDs to the required primary block materials we will need to evaluate for the consumers
secondary_boundary_mats	The secondary boundary materials we will need to evaluate for the consumers

Definition at line 347 of file MortarUtils.h.

{
  secondary_ip_sub_to_mats.clear();
  primary_ip_sub_to_mats.clear();
  secondary_boundary_mats.clear();
 
  auto & mat_warehouse = fe_problem.getRegularMaterialsWarehouse();
  auto get_required_sub_mats =
      [&mat_warehouse, tid, &consumers](
          const SubdomainID sub_id,
          const Moose::MaterialDataType mat_data_type) -> std::deque<MaterialBase *>
  {
    if (mat_warehouse[mat_data_type].hasActiveBlockObjects(sub_id, tid))
    {
      auto & sub_mats = mat_warehouse[mat_data_type].getActiveBlockObjects(sub_id, tid);
      return MaterialBase::buildRequiredMaterials(consumers, sub_mats, /*allow_stateful=*/false);
    }
    else
      return {};
  };
 
  // Construct secondary *block* materials container
  const auto & secondary_ip_sub_ids = amg.secondaryIPSubIDs();
  for (const auto secondary_ip_sub : secondary_ip_sub_ids)
    secondary_ip_sub_to_mats.emplace(
        secondary_ip_sub, get_required_sub_mats(secondary_ip_sub, Moose::FACE_MATERIAL_DATA));
 
  // Construct primary *block* materials container
  const auto & primary_ip_sub_ids = amg.primaryIPSubIDs();
  for (const auto primary_ip_sub : primary_ip_sub_ids)
    primary_ip_sub_to_mats.emplace(
        primary_ip_sub, get_required_sub_mats(primary_ip_sub, Moose::NEIGHBOR_MATERIAL_DATA));
 
  // Construct secondary *boundary* materials container
  const auto & boundary_pr = amg.primarySecondaryBoundaryIDPair();
  const auto secondary_boundary = boundary_pr.second;
  if (mat_warehouse.hasActiveBoundaryObjects(secondary_boundary, tid))
  {
    auto & boundary_mats = mat_warehouse.getActiveBoundaryObjects(secondary_boundary, tid);
    secondary_boundary_mats =
        MaterialBase::buildRequiredMaterials(consumers, boundary_mats, /*allow_stateful=*/false);
  }
}

Referenced by ComputeMortarFunctor::ComputeMortarFunctor(), MortarNodalAuxKernelTempl< ComputeValueType >::initialSetup(), MortarUserObjectThread::MortarUserObjectThread(), and ComputeMortarFunctor::setupMortarMaterials().