Moose::Mortar::Contact Namespace Reference

Enumerations
enum class	FrictionProjectionDegree { ONE , TWO }

Functions
template<typename T >
T	augmentedNormalPressure (const T &normal_pressure, const T &scaled_normal_gap)
	Return the augmented normal pressure p_n - C_n g_bar.
template<typename T >
T	coulombFrictionRadius (const T &friction_coefficient, const T &augmented_normal_pressure)
	Return the nonnegative Coulomb friction radius.
template<typename T , std::size_t N>
std::array< T, N >	projectToClosedSphere (const std::array< T, N > &vector, const T &radius)
	Project vector onto a closed sphere centered at the origin with radius radius.
template<typename T , std::size_t N>
std::array< T, N >	alartCurnierFrictionResidual (const std::array< T, N > &tangential_pressure, const std::array< T, N > &augmented_tangential_pressure, const T &radius)
	Return the degree-one Alart-Curnier friction residual p_t - Proj_{B_radius}(q_t).
template<typename T , std::size_t N>
std::array< T, N >	alartCurnierFrictionResidual (const std::array< T, N > &tangential_pressure, const std::array< T, N > &augmented_tangential_pressure, const T &radius, const T &normal_pressure, const T &epsilon)
	Same as the three-argument alartCurnierFrictionResidual, but additionally short-circuits to the trivial identity residual whenever the raw, unaugmented normal contact pressure normal_pressure falls below epsilon, mirroring the epsilon-gated hueberStadlerWohlmuthFrictionResidual overload below so both friction-residual degrees apply the same active-set transition guard.
template<typename T , std::size_t N>
std::array< T, N >	hueberStadlerWohlmuthFrictionResidual (const std::array< T, N > &tangential_pressure, const std::array< T, N > &augmented_tangential_pressure, const T &radius)
	Return the degree-two Hueber-Stadler-Wohlmuth friction residual max(radius, ||q_t||) p_t - radius q_t.
template<typename T , std::size_t N>
std::array< T, N >	hueberStadlerWohlmuthFrictionResidual (const std::array< T, N > &tangential_pressure, const std::array< T, N > &augmented_tangential_pressure, const T &radius, const T &normal_pressure, const T &epsilon)
	Same as the three-argument hueberStadlerWohlmuthFrictionResidual, but additionally short-circuits to the trivial identity residual whenever the raw, unaugmented normal contact pressure normal_pressure falls below epsilon.
template<typename T , std::size_t N>
std::array< T, N >	frictionalContactResidual (const std::array< T, N > &tangential_pressure, const std::array< T, N > &tangential_velocity, const T &c_t, const T &dt, const T &normal_pressure, const T &scaled_normal_gap, const T &friction_coefficient, const T &epsilon, const FrictionProjectionDegree projection_degree)
	Compute the epsilon-gated frictional residual for a mortar contact node.
template<typename T >
void	communicateVelocities (std::unordered_map< const DofObject *, T > &dof_map, const MooseMesh &mesh, const bool nodal, const Parallel::Communicator &communicator, const bool send_data_back)
	This function is used to communicate velocities across processes.
void	communicateR2T (std::unordered_map< const DofObject *, ADRankTwoTensor > &dof_map_adr2t, const MooseMesh &mesh, const bool nodal, const Parallel::Communicator &communicator, const bool send_data_back)
	This function is used to communicate velocities across processes.
template<typename T >
void	communicateRealObject (std::unordered_map< const DofObject *, T > &dof_to_adreal, const MooseMesh &mesh, const bool nodal, const Parallel::Communicator &communicator, const bool send_data_back)
void	communicateGaps (std::unordered_map< const DofObject *, std::pair< ADReal, Real > > &dof_to_weighted_gap, const MooseMesh &mesh, bool nodal, bool normalize_c, const Parallel::Communicator &communicator, bool send_data_back)
	This function is used to communicate gaps across processes.

Enumeration Type Documentation

FrictionProjectionDegree

enum class Moose::Mortar::Contact::FrictionProjectionDegree

strong

Enumerator
ONE
TWO

Definition at line 62 of file MortarContactUtils.h.

{
  ONE,
  TWO
};

Function Documentation

alartCurnierFrictionResidual() [1/2]

template<typename T , std::size_t N>

std::array< T, N > Moose::Mortar::Contact::alartCurnierFrictionResidual	(	const std::array< T, N > &	tangential_pressure,
		const std::array< T, N > &	augmented_tangential_pressure,
		const T &	radius
	)

Return the degree-one Alart-Curnier friction residual p_t - Proj_{B_radius}(q_t).

Parameters

tangential_pressure	The tangential contact pressure p_t
augmented_tangential_pressure	The velocity-augmented tangential pressure q_t (see frictionalContactResidual)
radius	The Coulomb friction radius (see coulombFrictionRadius)

Returns

The degree-one Alart-Curnier friction residual

Definition at line 127 of file MortarContactUtils.h.

{
  const auto projection = projectToClosedSphere(augmented_tangential_pressure, radius);
  std::array<T, N> residual;
  for (const auto i : index_range(residual))
    residual[i] = tangential_pressure[i] - projection[i];
  return residual;
}

Referenced by alartCurnierFrictionResidual(), frictionalContactResidual(), TYPED_TEST(), TYPED_TEST(), TYPED_TEST(), TYPED_TEST(), and TYPED_TEST().

alartCurnierFrictionResidual() [2/2]

template<typename T , std::size_t N>

std::array< T, N > Moose::Mortar::Contact::alartCurnierFrictionResidual	(	const std::array< T, N > &	tangential_pressure,
		const std::array< T, N > &	augmented_tangential_pressure,
		const T &	radius,
		const T &	normal_pressure,
		const T &	epsilon
	)

Same as the three-argument alartCurnierFrictionResidual, but additionally short-circuits to the trivial identity residual whenever the raw, unaugmented normal contact pressure normal_pressure falls below epsilon, mirroring the epsilon-gated hueberStadlerWohlmuthFrictionResidual overload below so both friction-residual degrees apply the same active-set transition guard.

Parameters

tangential_pressure	The tangential contact pressure p_t
augmented_tangential_pressure	The velocity-augmented tangential pressure q_t (see frictionalContactResidual)
radius	The Coulomb friction radius (see coulombFrictionRadius)
normal_pressure	The raw, unaugmented normal contact pressure
epsilon	The minimum normal contact pressure required to enable frictional enforcement

Returns

The epsilon-gated, degree-one Alart-Curnier friction residual

Definition at line 154 of file MortarContactUtils.h.

{
  if (normal_pressure < epsilon)
    return tangential_pressure;
 
  return alartCurnierFrictionResidual(tangential_pressure, augmented_tangential_pressure, radius);
}

augmentedNormalPressure()

template<typename T >

T Moose::Mortar::Contact::augmentedNormalPressure	(	const T &	normal_pressure,
		const T &	scaled_normal_gap
	)

Return the augmented normal pressure p_n - C_n g_bar.

Parameters

normal_pressure	The normal contact pressure p_n
scaled_normal_gap	The normal gap g_bar scaled by a factor C_n, intended to bring it onto the order of the contact pressure for a well-conditioned complementarity function

Returns

The augmented normal pressure

Definition at line 77 of file MortarContactUtils.h.

{
  return normal_pressure - scaled_normal_gap;
}

Referenced by frictionalContactResidual(), and TYPED_TEST().

communicateGaps()

void Moose::Mortar::Contact::communicateGaps	(	std::unordered_map< const DofObject *, std::pair< ADReal, Real > > &	dof_to_weighted_gap,
		const MooseMesh &	mesh,
		bool	nodal,
		bool	normalize_c,
		const Parallel::Communicator &	communicator,
		bool	send_data_back
	)

This function is used to communicate gaps across processes.

Parameters

dof_to_weighted_gap	Map from degree of freedom to weighted (weak) gap
mesh	Mesh used to locate nodes or elements
nodal	Whether the element has Lagrange interpolation
normalize_c	Whether to normalize with size the c coefficient in contact constraint
communicator	Process communicator
send_data_back	After aggregating data on the owning process, whether to send the aggregate back to senders. This can be necessary for things like penalty contact in which the constraint is not enforced by the owner but in a weighted way by the displacement constraints

Definition at line 21 of file MortarContactUtils.C.

{
  libmesh_parallel_only(communicator);
  const auto our_proc_id = communicator.rank();
 
  // We may have weighted gap information that should go to other processes that own the dofs
  using Datum = std::tuple<dof_id_type, ADReal, Real>;
  std::unordered_map<processor_id_type, std::vector<Datum>> push_data;
 
  for (auto & pr : dof_to_weighted_gap)
  {
    const auto * const dof_object = pr.first;
    const auto proc_id = dof_object->processor_id();
    if (proc_id == our_proc_id)
      continue;
 
    push_data[proc_id].push_back(
        std::make_tuple(dof_object->id(), std::move(pr.second.first), pr.second.second));
  }
 
  const auto & lm_mesh = mesh.getMesh();
  std::unordered_map<processor_id_type, std::vector<const DofObject *>>
      pid_to_dof_object_for_sending_back;
 
  auto action_functor =
      [nodal,
       our_proc_id,
       &lm_mesh,
       &dof_to_weighted_gap,
       &normalize_c,
       &pid_to_dof_object_for_sending_back,
       send_data_back](const processor_id_type pid, const std::vector<Datum> & sent_data)
  {
    mooseAssert(pid != our_proc_id, "We do not send messages to ourself here");
    libmesh_ignore(our_proc_id);
 
    for (auto & [dof_id, weighted_gap, normalization] : sent_data)
    {
      const auto * const dof_object = nodal ? cast_ptr<const DofObject *>(lm_mesh.node_ptr(dof_id))
                                            : cast_ptr<const DofObject *>(lm_mesh.elem_ptr(dof_id));
      mooseAssert(dof_object, "This should be non-null");
      if (send_data_back)
        pid_to_dof_object_for_sending_back[pid].push_back(dof_object);
      auto & [our_weighted_gap, our_normalization] = dof_to_weighted_gap[dof_object];
      our_weighted_gap += weighted_gap;
      if (normalize_c)
        our_normalization += normalization;
    }
  };
 
  TIMPI::push_parallel_vector_data(communicator, push_data, action_functor);
 
  // Now send data back if requested
  if (!send_data_back)
    return;
 
  std::unordered_map<processor_id_type, std::vector<Datum>> push_back_data;
 
  for (const auto & [pid, dof_objects] : pid_to_dof_object_for_sending_back)
  {
    auto & pid_send_data = push_back_data[pid];
    pid_send_data.reserve(dof_objects.size());
    for (const DofObject * const dof_object : dof_objects)
    {
      const auto & [our_weighted_gap, our_normalization] =
          libmesh_map_find(dof_to_weighted_gap, dof_object);
      pid_send_data.push_back(
          std::make_tuple(dof_object->id(), our_weighted_gap, our_normalization));
    }
  }
 
  auto sent_back_action_functor =
      [nodal, our_proc_id, &lm_mesh, &dof_to_weighted_gap, &normalize_c](
          const processor_id_type libmesh_dbg_var(pid), const std::vector<Datum> & sent_data)
  {
    mooseAssert(pid != our_proc_id, "We do not send messages to ourself here");
    libmesh_ignore(our_proc_id);
 
    for (auto & [dof_id, weighted_gap, normalization] : sent_data)
    {
      const auto * const dof_object = nodal ? cast_ptr<const DofObject *>(lm_mesh.node_ptr(dof_id))
                                            : cast_ptr<const DofObject *>(lm_mesh.elem_ptr(dof_id));
      mooseAssert(dof_object, "This should be non-null");
      auto & [our_weighted_gap, our_normalization] = dof_to_weighted_gap[dof_object];
      our_weighted_gap = weighted_gap;
      if (normalize_c)
        our_normalization = normalization;
    }
  };
  TIMPI::push_parallel_vector_data(communicator, push_back_data, sent_back_action_functor);
}

Referenced by WeightedGapUserObject::finalize(), ComputeDynamicWeightedGapLMMechanicalContact::incorrectEdgeDroppingPost(), ComputeFrictionalForceCartesianLMMechanicalContact::incorrectEdgeDroppingPost(), ComputeWeightedGapCartesianLMMechanicalContact::incorrectEdgeDroppingPost(), ComputeDynamicWeightedGapLMMechanicalContact::post(), ComputeFrictionalForceCartesianLMMechanicalContact::post(), and ComputeWeightedGapCartesianLMMechanicalContact::post().

communicateR2T()

void Moose::Mortar::Contact::communicateR2T ( std::unordered_map< const DofObject *, ADRankTwoTensor > &  dof_map_adr2t, const MooseMesh &  mesh, const bool  nodal, const Parallel::Communicator &  communicator, const bool  send_data_back  )

inline

This function is used to communicate velocities across processes.

Parameters

dof_map_adr2t	Map from degree of freedom to weighted tank two tensor
mesh	Mesh used to locate nodes or elements
nodal	Whether the element has Lagrange interpolation
communicator	Process communicator
send_data_back	Whether to send back data to a distributed constraint

Definition at line 396 of file MortarContactUtils.h.

{
  libmesh_parallel_only(communicator);
  const auto our_proc_id = communicator.rank();
 
  // We may have weighted velocity information that should go to other processes that own the dofs
  using Datum = std::pair<dof_id_type, ADRankTwoTensor>;
  std::unordered_map<processor_id_type, std::vector<Datum>> push_data;
 
  for (auto & pr : dof_map_adr2t)
  {
    const auto * const dof_object = pr.first;
    const auto proc_id = dof_object->processor_id();
    if (proc_id == our_proc_id)
      continue;
 
    push_data[proc_id].push_back(std::make_pair(dof_object->id(), std::move(pr.second)));
  }
 
  const auto & lm_mesh = mesh.getMesh();
  std::unordered_map<processor_id_type, std::vector<const DofObject *>>
      pid_to_dof_object_for_sending_back;
 
  auto action_functor =
      [nodal,
       our_proc_id,
       &lm_mesh,
       &dof_map_adr2t,
       &pid_to_dof_object_for_sending_back,
       send_data_back](const processor_id_type pid, const std::vector<Datum> & sent_data)
  {
    mooseAssert(pid != our_proc_id, "We do not send messages to ourself here");
    libmesh_ignore(our_proc_id);
 
    for (auto & pr : sent_data)
    {
      const auto dof_id = pr.first;
      const auto * const dof_object = nodal ? cast_ptr<const DofObject *>(lm_mesh.node_ptr(dof_id))
                                            : cast_ptr<const DofObject *>(lm_mesh.elem_ptr(dof_id));
      mooseAssert(dof_object, "This should be non-null");
 
      if (send_data_back)
        pid_to_dof_object_for_sending_back[pid].push_back(dof_object);
 
      for (const auto i : make_range(3))
        for (const auto j : make_range(3))
          dof_map_adr2t[dof_object](i, j) += pr.second(i, j);
    }
  };
 
  TIMPI::push_parallel_vector_data(communicator, push_data, action_functor);
 
  // Now send data back if requested
  if (!send_data_back)
    return;
 
  std::unordered_map<processor_id_type, std::vector<Datum>> push_back_data;
 
  for (const auto & [pid, dof_objects] : pid_to_dof_object_for_sending_back)
  {
    auto & pid_send_data = push_back_data[pid];
    pid_send_data.reserve(dof_objects.size());
    for (const DofObject * const dof_object : dof_objects)
    {
      const auto & r2t = libmesh_map_find(dof_map_adr2t, dof_object);
      pid_send_data.push_back({dof_object->id(), r2t});
    }
  }
 
  auto sent_back_action_functor =
      [nodal, our_proc_id, &lm_mesh, &dof_map_adr2t](const processor_id_type libmesh_dbg_var(pid),
                                                     const std::vector<Datum> & sent_data)
  {
    mooseAssert(pid != our_proc_id, "We do not send messages to ourself here");
    libmesh_ignore(our_proc_id);
 
    for (auto & [dof_id, r2t_sent] : sent_data)
    {
      const auto * const dof_object = nodal ? cast_ptr<const DofObject *>(lm_mesh.node_ptr(dof_id))
                                            : cast_ptr<const DofObject *>(lm_mesh.elem_ptr(dof_id));
      mooseAssert(dof_object, "This should be non-null");
      auto & r2t = dof_map_adr2t[dof_object];
      r2t = r2t_sent;
    }
  };
 
  TIMPI::push_parallel_vector_data(communicator, push_back_data, sent_back_action_functor);
}

Referenced by CohesiveZoneModelBase::finalize().

communicateRealObject()

template<typename T >

void Moose::Mortar::Contact::communicateRealObject	(	std::unordered_map< const DofObject *, T > &	dof_to_adreal,
		const MooseMesh &	mesh,
		const bool	nodal,
		const Parallel::Communicator &	communicator,
		const bool	send_data_back
	)

Definition at line 491 of file MortarContactUtils.h.

{
  libmesh_parallel_only(communicator);
  const auto our_proc_id = communicator.rank();
 
  // We may have weighted gap information that should go to other processes that own the dofs
  using Datum = std::tuple<dof_id_type, T>;
  std::unordered_map<processor_id_type, std::vector<Datum>> push_data;
 
  for (auto & pr : dof_to_adreal)
  {
    const auto * const dof_object = pr.first;
    const auto proc_id = dof_object->processor_id();
    if (proc_id == our_proc_id)
      continue;
 
    push_data[proc_id].push_back(std::make_tuple(dof_object->id(), std::move(pr.second)));
  }
 
  const auto & lm_mesh = mesh.getMesh();
  std::unordered_map<processor_id_type, std::vector<const DofObject *>>
      pid_to_dof_object_for_sending_back;
 
  auto action_functor =
      [nodal,
       our_proc_id,
       &lm_mesh,
       &dof_to_adreal,
       &pid_to_dof_object_for_sending_back,
       send_data_back](const processor_id_type pid, const std::vector<Datum> & sent_data)
  {
    mooseAssert(pid != our_proc_id, "We do not send messages to ourself here");
    libmesh_ignore(our_proc_id);
 
    for (auto & [dof_id, weighted_gap] : sent_data)
    {
      const auto * const dof_object = nodal ? cast_ptr<const DofObject *>(lm_mesh.node_ptr(dof_id))
                                            : cast_ptr<const DofObject *>(lm_mesh.elem_ptr(dof_id));
      mooseAssert(dof_object, "This should be non-null");
      if (send_data_back)
        pid_to_dof_object_for_sending_back[pid].push_back(dof_object);
      auto & our_adreal = dof_to_adreal[dof_object];
      our_adreal += weighted_gap;
    }
  };
 
  TIMPI::push_parallel_vector_data(communicator, push_data, action_functor);
 
  // Now send data back if requested
  if (!send_data_back)
    return;
 
  std::unordered_map<processor_id_type, std::vector<Datum>> push_back_data;
 
  for (const auto & [pid, dof_objects] : pid_to_dof_object_for_sending_back)
  {
    auto & pid_send_data = push_back_data[pid];
    pid_send_data.reserve(dof_objects.size());
    for (const DofObject * const dof_object : dof_objects)
    {
      const auto & our_adreal = libmesh_map_find(dof_to_adreal, dof_object);
      pid_send_data.push_back(std::make_tuple(dof_object->id(), our_adreal));
    }
  }
 
  auto sent_back_action_functor =
      [nodal, our_proc_id, &lm_mesh, &dof_to_adreal](const processor_id_type libmesh_dbg_var(pid),
                                                     const std::vector<Datum> & sent_data)
  {
    mooseAssert(pid != our_proc_id, "We do not send messages to ourself here");
    libmesh_ignore(our_proc_id);
 
    for (auto & [dof_id, adreal] : sent_data)
    {
      const auto * const dof_object = nodal ? cast_ptr<const DofObject *>(lm_mesh.node_ptr(dof_id))
                                            : cast_ptr<const DofObject *>(lm_mesh.elem_ptr(dof_id));
      mooseAssert(dof_object, "This should be non-null");
      auto & our_adreal = dof_to_adreal[dof_object];
      our_adreal = adreal;
    }
  };
  TIMPI::push_parallel_vector_data(communicator, push_back_data, sent_back_action_functor);
}

Referenced by BilinearMixedModeCohesiveZoneModel::finalize(), CohesiveZoneModelBase::finalize(), and LMWeightedGapUserObject::finalizeNodalScaling().

communicateVelocities()

template<typename T >

void Moose::Mortar::Contact::communicateVelocities ( std::unordered_map< const DofObject *, T > &  dof_map, const MooseMesh &  mesh, const bool  nodal, const Parallel::Communicator &  communicator, const bool  send_data_back  )

inline

This function is used to communicate velocities across processes.

Parameters

dof_to_weighted_gap	Map from degree of freedom to weighted (weak) gap
mesh	Mesh used to locate nodes or elements
nodal	Whether the element has Lagrange interpolation
communicator	Process communicator
send_data_back	Whether to send back data to a distributed constraint

Definition at line 298 of file MortarContactUtils.h.

{
  libmesh_parallel_only(communicator);
  const auto our_proc_id = communicator.rank();
 
  // We may have weighted velocity information that should go to other processes that own the dofs
  using Datum = std::pair<dof_id_type, T>;
  std::unordered_map<processor_id_type, std::vector<Datum>> push_data;
 
  for (auto & pr : dof_map)
  {
    const auto * const dof_object = pr.first;
    const auto proc_id = dof_object->processor_id();
    if (proc_id == our_proc_id)
      continue;
 
    push_data[proc_id].push_back(std::make_pair(dof_object->id(), std::move(pr.second)));
  }
 
  const auto & lm_mesh = mesh.getMesh();
  std::unordered_map<processor_id_type, std::vector<const DofObject *>>
      pid_to_dof_object_for_sending_back;
 
  auto action_functor =
      [nodal, our_proc_id, &lm_mesh, &dof_map, &pid_to_dof_object_for_sending_back, send_data_back](
          const processor_id_type pid, const std::vector<Datum> & sent_data)
  {
    mooseAssert(pid != our_proc_id, "We do not send messages to ourself here");
    libmesh_ignore(our_proc_id);
 
    for (auto & pr : sent_data)
    {
      const auto dof_id = pr.first;
      const auto * const dof_object = nodal ? cast_ptr<const DofObject *>(lm_mesh.node_ptr(dof_id))
                                            : cast_ptr<const DofObject *>(lm_mesh.elem_ptr(dof_id));
      mooseAssert(dof_object, "This should be non-null");
 
      if (send_data_back)
        pid_to_dof_object_for_sending_back[pid].push_back(dof_object);
 
      dof_map[dof_object][0] += pr.second[0];
      dof_map[dof_object][1] += pr.second[1];
    }
  };
 
  TIMPI::push_parallel_vector_data(communicator, push_data, action_functor);
 
  // Now send data back if requested
  if (!send_data_back)
    return;
 
  std::unordered_map<processor_id_type, std::vector<Datum>> push_back_data;
 
  for (const auto & [pid, dof_objects] : pid_to_dof_object_for_sending_back)
  {
    auto & pid_send_data = push_back_data[pid];
    pid_send_data.reserve(dof_objects.size());
    for (const DofObject * const dof_object : dof_objects)
    {
      const auto & [tangent_one, tangent_two] = libmesh_map_find(dof_map, dof_object);
      pid_send_data.push_back({dof_object->id(), {tangent_one, tangent_two}});
    }
  }
 
  auto sent_back_action_functor =
      [nodal, our_proc_id, &lm_mesh, &dof_map](const processor_id_type libmesh_dbg_var(pid),
                                               const std::vector<Datum> & sent_data)
  {
    mooseAssert(pid != our_proc_id, "We do not send messages to ourself here");
    libmesh_ignore(our_proc_id);
 
    for (auto & [dof_id, tangents] : sent_data)
    {
      const auto * const dof_object = nodal ? cast_ptr<const DofObject *>(lm_mesh.node_ptr(dof_id))
                                            : cast_ptr<const DofObject *>(lm_mesh.elem_ptr(dof_id));
      mooseAssert(dof_object, "This should be non-null");
      auto & [our_tangent_one, our_tangent_two] = dof_map[dof_object];
      our_tangent_one = tangents[0];
      our_tangent_two = tangents[1];
    }
  };
 
  TIMPI::push_parallel_vector_data(communicator, push_back_data, sent_back_action_functor);
}

Referenced by WeightedVelocitiesUserObject::finalize(), ComputeDynamicFrictionalForceLMMechanicalContact::incorrectEdgeDroppingPost(), ComputeFrictionalForceCartesianLMMechanicalContact::incorrectEdgeDroppingPost(), ComputeDynamicFrictionalForceLMMechanicalContact::post(), and ComputeFrictionalForceCartesianLMMechanicalContact::post().

coulombFrictionRadius()

template<typename T >

T Moose::Mortar::Contact::coulombFrictionRadius	(	const T &	friction_coefficient,
		const T &	augmented_normal_pressure
	)

Return the nonnegative Coulomb friction radius.

Parameters

friction_coefficient	The Coulomb friction coefficient
augmented_normal_pressure	The augmented normal pressure (see augmentedNormalPressure)

Returns

The Coulomb friction radius, clamped to be nonnegative

Definition at line 90 of file MortarContactUtils.h.

{
  return friction_coefficient * std::max(T(0), augmented_normal_pressure);
}

Referenced by frictionalContactResidual(), and TYPED_TEST().

frictionalContactResidual()

template<typename T , std::size_t N>

std::array< T, N > Moose::Mortar::Contact::frictionalContactResidual	(	const std::array< T, N > &	tangential_pressure,
		const std::array< T, N > &	tangential_velocity,
		const T &	c_t,
		const T &	dt,
		const T &	normal_pressure,
		const T &	scaled_normal_gap,
		const T &	friction_coefficient,
		const T &	epsilon,
		const FrictionProjectionDegree	projection_degree
	)

Compute the epsilon-gated frictional residual for a mortar contact node.

This composes the tangential pressure augmentation tangential_pressure + c_t * tangential_velocity * dt with augmentedNormalPressure, coulombFrictionRadius, and the epsilon-gated, degree-selected (projection_degree) friction residual (alartCurnierFrictionResidual for FrictionProjectionDegree::ONE, hueberStadlerWohlmuthFrictionResidual for FrictionProjectionDegree::TWO), the composition shared by the normal, dynamic, and Cartesian mortar frictional contact constraints.

Parameters

tangential_pressure	The tangential contact pressure p_t
tangential_velocity	The relative (slip) velocity between the secondary and primary surfaces, resolved into the local tangential direction(s) at this node
c_t	Numerical factor used in the tangential constraints for convergence purposes
dt	The current time step size
normal_pressure	The raw, unaugmented normal contact pressure
scaled_normal_gap	The normal gap g_bar scaled by a factor C_n, intended to bring it onto the order of the contact pressure for a well-conditioned complementarity function
friction_coefficient	The Coulomb friction coefficient
epsilon	The minimum normal contact pressure required to enable frictional enforcement
projection_degree	Which friction-residual projection degree to use

Returns

The epsilon-gated frictional residual

Definition at line 258 of file MortarContactUtils.h.

{
  std::array<T, N> augmented_tangential_pressure;
  for (const auto i : index_range(augmented_tangential_pressure))
    augmented_tangential_pressure[i] = tangential_pressure[i] + c_t * tangential_velocity[i] * dt;
 
  const auto radius = coulombFrictionRadius(
      friction_coefficient, augmentedNormalPressure(normal_pressure, scaled_normal_gap));
 
  switch (projection_degree)
  {
    case FrictionProjectionDegree::ONE:
      return alartCurnierFrictionResidual(
          tangential_pressure, augmented_tangential_pressure, radius, normal_pressure, epsilon);
    case FrictionProjectionDegree::TWO:
      return hueberStadlerWohlmuthFrictionResidual(
          tangential_pressure, augmented_tangential_pressure, radius, normal_pressure, epsilon);
    default:
      mooseError("Unhandled projection degree");
  }
}

Referenced by ComputeDynamicFrictionalForceLMMechanicalContact::enforceConstraintOnDof(), ComputeFrictionalForceCartesianLMMechanicalContact::enforceConstraintOnDof(), ComputeFrictionalForceLMMechanicalContact::enforceConstraintOnDof(), ComputeDynamicFrictionalForceLMMechanicalContact::enforceConstraintOnDof3d(), and ComputeFrictionalForceLMMechanicalContact::enforceConstraintOnDof3d().

hueberStadlerWohlmuthFrictionResidual() [1/2]

template<typename T , std::size_t N>

std::array< T, N > Moose::Mortar::Contact::hueberStadlerWohlmuthFrictionResidual	(	const std::array< T, N > &	tangential_pressure,
		const std::array< T, N > &	augmented_tangential_pressure,
		const T &	radius
	)

Return the degree-two Hueber-Stadler-Wohlmuth friction residual max(radius, ||q_t||) p_t - radius q_t.

At radius = ||q_t|| = 0 the degree-two expression vanishes for every p_t. Returning p_t in that state preserves the Coulomb solution set during separation.

Parameters

tangential_pressure	The tangential contact pressure p_t
augmented_tangential_pressure	The velocity-augmented tangential pressure q_t (see frictionalContactResidual)
radius	The Coulomb friction radius (see coulombFrictionRadius)

Returns

The degree-two Hueber-Stadler-Wohlmuth friction residual

Definition at line 180 of file MortarContactUtils.h.

{
  const T augmented_norm = MathUtils::norm(augmented_tangential_pressure);
  const T weight = std::max(radius, augmented_norm);
  if (weight == 0)
    return tangential_pressure;
 
  std::array<T, N> residual;
  for (const auto i : index_range(residual))
    residual[i] = weight * tangential_pressure[i] - radius * augmented_tangential_pressure[i];
  return residual;
}

Referenced by frictionalContactResidual(), hueberStadlerWohlmuthFrictionResidual(), TYPED_TEST(), TYPED_TEST(), TYPED_TEST(), TYPED_TEST(), and TYPED_TEST().

hueberStadlerWohlmuthFrictionResidual() [2/2]

template<typename T , std::size_t N>

std::array< T, N > Moose::Mortar::Contact::hueberStadlerWohlmuthFrictionResidual	(	const std::array< T, N > &	tangential_pressure,
		const std::array< T, N > &	augmented_tangential_pressure,
		const T &	radius,
		const T &	normal_pressure,
		const T &	epsilon
	)

Same as the three-argument hueberStadlerWohlmuthFrictionResidual, but additionally short-circuits to the trivial identity residual whenever the raw, unaugmented normal contact pressure normal_pressure falls below epsilon.

The pure weight == 0 condition in the three-argument overload is an exact mathematical criterion, but it is a poor numerical proxy for "this dof is separated" during Newton iteration: augmented_tangential_pressure includes a c_t-scaled tangential velocity term that is essentially never exactly zero in floating point, so the full weight/radius expression stays active even for dofs whose normal contact state is still swinging between contact and separation as the active set settles. Because that expression is only piecewise smooth across the active-set boundary, evaluating it on a dof that has not yet settled can inject a large, poorly conditioned residual and Jacobian row into that Newton step. Gating on the raw normal Lagrange multiplier instead is a coarser but cheaper and more conservative criterion: it forces such transitioning dofs onto the trivial identity residual (a well-conditioned, constant-derivative Jacobian row) until the normal contact state has clearly resolved, trading a small amount of formulation fidelity for solver robustness during that transient.

Parameters

tangential_pressure	The tangential contact pressure p_t
augmented_tangential_pressure	The velocity-augmented tangential pressure q_t (see frictionalContactResidual)
radius	The Coulomb friction radius (see coulombFrictionRadius)
normal_pressure	The raw, unaugmented normal contact pressure
epsilon	The minimum normal contact pressure required to enable frictional enforcement

Returns

The epsilon-gated, degree-two Hueber-Stadler-Wohlmuth friction residual

Definition at line 222 of file MortarContactUtils.h.

{
  if (normal_pressure < epsilon)
    return tangential_pressure;
 
  return hueberStadlerWohlmuthFrictionResidual(
      tangential_pressure, augmented_tangential_pressure, radius);
}

projectToClosedSphere()

template<typename T , std::size_t N>

std::array< T, N > Moose::Mortar::Contact::projectToClosedSphere	(	const std::array< T, N > &	vector,
		const T &	radius
	)

Project vector onto a closed sphere centered at the origin with radius radius.

Parameters

vector	The vector to project
radius	The radius of the closed sphere to project onto

Returns

vector unchanged if its norm is already within radius, otherwise vector scaled down to have norm radius

Definition at line 104 of file MortarContactUtils.h.

{
  const T norm = MathUtils::norm(vector);
  if (norm <= radius)
    return vector;
 
  std::array<T, N> projection;
  for (const auto i : index_range(projection))
    projection[i] = radius * vector[i] / norm;
  return projection;
}

Referenced by alartCurnierFrictionResidual(), and TYPED_TEST().