ContactAction Class Reference

Action class for creating constraints, kernels, and user objects necessary for mechanical contact. More...

#include <ContactAction.h>

Inheritance diagram for ContactAction:

Classes
struct	MortarInfo

Public Types
typedef DataFileName	DataFileParameterType

Public Member Functions
	ContactAction (const InputParameters &params)
virtual void	act () override
virtual void	addRelationshipManagers (Moose::RelationshipManagerType input_rm_type) override
virtual void	addRelationshipManagers (Moose::RelationshipManagerType when_type)
bool	addRelationshipManagers (Moose::RelationshipManagerType when_type, const InputParameters &moose_object_pars)
void	timedAct ()
MooseObjectName	uniqueActionName () const
const std::string &	specificTaskName () const
const std::set< std::string > &	getAllTasks () const
void	appendTask (const std::string &task)
MooseApp &	getMooseApp () const
const std::string &	type () const
const std::string &	name () const
std::string	typeAndName () const
MooseObjectParameterName	uniqueParameterName (const std::string &parameter_name) const
MooseObjectName	uniqueName () const
const InputParameters &	parameters () const
const hit::Node *	getHitNode () const
bool	hasBase () const
const std::string &	getBase () const
const T &	getParam (const std::string &name) const
std::vector< std::pair< T1, T2 > >	getParam (const std::string &param1, const std::string &param2) const
const T *	queryParam (const std::string &name) const
const T &	getRenamedParam (const std::string &old_name, const std::string &new_name) const
T	getCheckedPointerParam (const std::string &name, const std::string &error_string="") const
bool	haveParameter (const std::string &name) const
bool	isParamValid (const std::string &name) const
bool	isParamSetByUser (const std::string &name) const
void	connectControllableParams (const std::string &parameter, const std::string &object_type, const std::string &object_name, const std::string &object_parameter) const
void	paramError (const std::string &param, Args... args) const
void	paramWarning (const std::string &param, Args... args) const
void	paramWarning (const std::string &param, Args... args) const
void	paramInfo (const std::string &param, Args... args) const
std::string	messagePrefix (const bool hit_prefix=true) const
std::string	errorPrefix (const std::string &) const
void	mooseError (Args &&... args) const
void	mooseDocumentedError (const std::string &repo_name, const unsigned int issue_num, Args &&... args) const
void	mooseErrorNonPrefixed (Args &&... args) const
void	mooseWarning (Args &&... args) const
void	mooseWarning (Args &&... args) const
void	mooseWarningNonPrefixed (Args &&... args) const
void	mooseWarningNonPrefixed (Args &&... args) const
void	mooseDeprecated (Args &&... args) const
void	mooseDeprecated (Args &&... args) const
void	mooseDeprecatedNoTrace (Args &&... args) const
void	mooseInfo (Args &&... args) const
void	callMooseError (std::string msg, const bool with_prefix, const hit::Node *node=nullptr, const bool show_trace=true) const
std::string	getDataFileName (const std::string &param) const
std::string	getDataFileNameByName (const std::string &relative_path) const
std::string	getDataFilePath (const std::string &relative_path) const
PerfGraph &	perfGraph ()
const Parallel::Communicator &	comm () const
processor_id_type	n_processors () const
processor_id_type	processor_id () const

Static Public Member Functions
static InputParameters	validParams ()
static MooseEnum	getModelEnum ()
	Get contact model. More...
static MooseEnum	getFormulationEnum ()
	Get contact formulation. More...
static MooseEnum	getSystemEnum ()
	Get contact system. More...
static MooseEnum	getSmoothingEnum ()
	Get smoothing type. More...
static MooseEnum	getProximityMethod ()
	Get proximity method for automatic pairing. More...
static InputParameters	commonParameters ()
	Define parameters used by multiple contact objects. More...
static void	callMooseError (MooseApp *const app, const InputParameters &params, std::string msg, const bool with_prefix, const hit::Node *node, const bool show_trace=true)

Public Attributes
	usingCombinedWarningSolutionWarnings
const ConsoleStream	_console

Static Public Attributes
static const std::string	unique_action_name_param
static const std::string	type_param
static const std::string	name_param
static const std::string	unique_name_param
static const std::string	app_param
static const std::string	moose_base_param
static const std::string	kokkos_object_param
static constexpr auto	SYSTEM
static constexpr auto	NAME

Protected Member Functions
bool	addRelationshipManagers (Moose::RelationshipManagerType when_type, const InputParameters &moose_object_pars)
void	associateWithParameter (const std::string &param_name, InputParameters &params) const
void	associateWithParameter (const InputParameters &from_params, const std::string &param_name, InputParameters &params) const
const T &	getMeshProperty (const std::string &data_name, const std::string &prefix)
const T &	getMeshProperty (const std::string &data_name)
bool	hasMeshProperty (const std::string &data_name, const std::string &prefix) const
bool	hasMeshProperty (const std::string &data_name, const std::string &prefix) const
bool	hasMeshProperty (const std::string &data_name) const
bool	hasMeshProperty (const std::string &data_name) const
std::string	meshPropertyName (const std::string &data_name) const
PerfID	registerTimedSection (const std::string &section_name, const unsigned int level) const
PerfID	registerTimedSection (const std::string &section_name, const unsigned int level, const std::string &live_message, const bool print_dots=true) const
std::string	timedSectionName (const std::string &section_name) const
void	flagInvalidSolutionInternal (const InvalidSolutionID invalid_solution_id) const
InvalidSolutionID	registerInvalidSolutionInternal (const std::string &message, const bool warning) const

Static Protected Member Functions
static std::string	meshPropertyName (const std::string &data_name, const std::string &prefix)

Protected Attributes
std::vector< std::pair< BoundaryName, BoundaryName > >	_boundary_pairs
	Primary/Secondary boundary name pairs for mechanical contact. More...
std::vector< BoundaryName >	_automatic_pairing_boundaries
	List of all possible boundaries for contact for automatic pairing (optional) More...
const ContactModel	_model
	Contact model type enum. More...
const ContactFormulation	_formulation
	Contact formulation. More...
bool	_use_dual
	Whether to use the dual Mortar approach. More...
const bool	_generate_mortar_mesh
	Whether to generate the mortar mesh (useful in a restart simulation e.g.). More...
const bool	_mortar_dynamics
	Whether mortar dynamic contact constraints are to be used. More...
std::map< std::pair< BoundaryName, BoundaryName >, const MortarInfo >	_bnd_pair_to_mortar_info
	Map from boundary pair to mortar user object name. More...
std::string	_registered_identifier
std::string	_specific_task_name
std::set< std::string >	_all_tasks
ActionWarehouse &	_awh
const std::string &	_current_task
std::shared_ptr< MooseMesh > &	_mesh
std::shared_ptr< MooseMesh > &	_displaced_mesh
std::shared_ptr< FEProblemBase > &	_problem
PerfID	_act_timer
MooseApp &	_app
Factory &	_factory
ActionFactory &	_action_factory
const std::string &	_type
const std::string &	_name
const InputParameters &	_pars
MooseApp &	_pg_moose_app
const std::string	_prefix
const Parallel::Communicator &	_communicator

Private Member Functions
void	addMortarContact ()
	Generate mesh and other Moose objects for Mortar contact. More...
void	addNodeFaceContact ()
	Generate constraints for node to face contact. More...
void	addContactPressureAuxKernel ()
	Add single contact pressure auxiliary kernel for various contact action objects. More...
void	removeRepeatedPairs ()
	Remove repeated contact pairs from _boundary_pairs. More...
void	createSidesetPairsFromGeometry ()
	Create contact pairs between all boundaries whose centroids are within a user-specified distance of each other. More...
void	createSidesetsFromNodeProximity ()
	Create contact pairs between all boundaries by determining that nodes on both boundaries are close enough. More...

Detailed Description

Action class for creating constraints, kernels, and user objects necessary for mechanical contact.

Definition at line 31 of file ContactAction.h.

Constructor & Destructor Documentation

ContactAction()

ContactAction::ContactAction

(

const InputParameters &

params

)

Definition at line 330 of file ContactAction.C.

  : Action(params),
    _boundary_pairs(getParam<BoundaryName, BoundaryName>("primary", "secondary")),
    _model(getParam<MooseEnum>("model").getEnum<ContactModel>()),
    _formulation(getParam<MooseEnum>("formulation").getEnum<ContactFormulation>()),
    _generate_mortar_mesh(getParam<bool>("generate_mortar_mesh")),
    _mortar_dynamics(getParam<bool>("mortar_dynamics"))
{
  // Check for automatic selection of contact pairs.
  if (getParam<std::vector<BoundaryName>>("automatic_pairing_boundaries").size() > 1)
    _automatic_pairing_boundaries =
        getParam<std::vector<BoundaryName>>("automatic_pairing_boundaries");

  if (_automatic_pairing_boundaries.size() > 0 && !isParamValid("automatic_pairing_distance"))
    paramError("automatic_pairing_distance",
               "For automatic selection of contact pairs (for particular geometries) in contact "
               "action, 'automatic_pairing_distance' needs to be provided.");

  if (_automatic_pairing_boundaries.size() > 0 && !isParamValid("automatic_pairing_method"))
    paramError("automatic_pairing_distance",
               "For automatic selection of contact pairs (for particular geometries) in contact "
               "action, 'automatic_pairing_method' needs to be provided.");

  if (_automatic_pairing_boundaries.size() > 0 && _boundary_pairs.size() != 0)
    paramError("automatic_pairing_boundaries",
               "If a boundary list is provided, primary and secondary surfaces will be identified "
               "automatically. Therefore, one cannot provide an automatic pairing boundary list "
               "and primary/secondary lists.");
  else if (_automatic_pairing_boundaries.size() == 0 && _boundary_pairs.size() == 0)
    paramError("primary",
               "'primary' and 'secondary' surfaces or a list of boundaries for automatic pair "
               "generation need to be provided.");

  // End of checks for automatic selection of contact pairs.

  if (_boundary_pairs.size() != 1 && _formulation == ContactFormulation::MORTAR)
    paramError("formulation", "When using mortar, a vector of contact pairs cannot be used");

  if ((_formulation == ContactFormulation::MORTAR ||
       _formulation == ContactFormulation::MORTAR_PENALTY) &&
      params.isParamSetByUser("ghost_whole_interface"))
    paramError("ghost_whole_interface",
               "The 'ghost_whole_interface' parameter is only supported for node-face contact "
               "formulations. Mortar contact always geometrically and algebraically ghosts the "
               "interface.");

  if (_formulation == ContactFormulation::TANGENTIAL_PENALTY && _model != ContactModel::COULOMB)
    paramError("formulation",
               "The 'tangential_penalty' formulation can only be used with the 'coulomb' model");

  if (_formulation == ContactFormulation::MORTAR_PENALTY)
  {
    // Use dual basis functions for contact traction interpolation
    if (isParamValid("use_dual"))
      _use_dual = getParam<bool>("use_dual");
    else
      _use_dual = true;

    if (_model == ContactModel::GLUED)
      paramError("model", "The 'mortar_penalty' formulation does not support glued contact");

    if (getParam<bool>("mortar_dynamics"))
      paramError("mortar_dynamics",
                 "The 'mortar_penalty' formulation does not support implicit dynamic simulations");

    if (getParam<bool>("use_petrov_galerkin"))
      paramError("use_petrov_galerkin",
                 "The 'mortar_penalty' formulation does not support usage of the Petrov-Galerkin "
                 "flag. The default (use_dual = true) behavior is such that contact tractions are "
                 "interpolated with dual bases whereas mortar or weighted contact quantities are "
                 "interpolated with Lagrange shape functions.");
  }

  if (_formulation == ContactFormulation::MORTAR)
  {
    if (_model == ContactModel::GLUED)
      paramError("model", "The 'mortar' formulation does not support glued contact (yet)");

    // use dual basis function for Lagrange multipliers?
    if (isParamValid("use_dual"))
      _use_dual = getParam<bool>("use_dual");
    else
      _use_dual = true;

    if (!getParam<bool>("mortar_dynamics"))
    {
      if (params.isParamSetByUser("newmark_beta"))
        paramError("newmark_beta", "newmark_beta can only be used with the mortar_dynamics option");

      if (params.isParamSetByUser("newmark_gamma"))
        paramError("newmark_gamma",
                   "newmark_gamma can only be used with the mortar_dynamics option");
    }

    if (isParamSetByUser("penalty"))
      paramError("penalty",
                 "The 'penalty' parameter is not used for the 'mortar' formulation which instead "
                 "uses Lagrange multipliers");
  }
  else
  {
    if (params.isParamSetByUser("correct_edge_dropping"))
      paramError(
          "correct_edge_dropping",
          "The 'correct_edge_dropping' option can only be used with the 'mortar' formulation "
          "(weighted)");
    else if (params.isParamSetByUser("use_dual") &&
             _formulation != ContactFormulation::MORTAR_PENALTY)
      paramError("use_dual",
                 "The 'use_dual' option can only be used with the 'mortar' formulation");
    else if (params.isParamSetByUser("c_normal"))
      paramError("c_normal",
                 "The 'c_normal' option can only be used with the 'mortar' formulation");
    else if (params.isParamSetByUser("c_tangential"))
      paramError("c_tangential",
                 "The 'c_tangential' option can only be used with the 'mortar' formulation");
    else if (params.isParamSetByUser("mortar_dynamics"))
      paramError("mortar_dynamics",
                 "The 'mortar_dynamics' constraint option can only be used with the 'mortar' "
                 "formulation and in dynamic simulations using Newmark-beta");
    else if (params.isParamSetByUser("segment_quadrature"))
      paramError("segment_quadrature",
                 "The 'segment_quadrature' option can only be used with the "
                 "'mortar' formulation.");
  }

  if (_formulation == ContactFormulation::RANFS)
  {
    if (isParamValid("secondary_gap_offset"))
      paramError("secondary_gap_offset",
                 "The 'secondary_gap_offset' option can only be used with the "
                 "'MechanicalContactConstraint'");
    if (isParamValid("mapped_primary_gap_offset"))
      paramError("mapped_primary_gap_offset",
                 "The 'mapped_primary_gap_offset' option can only be used with the "
                 "'MechanicalContactConstraint'");
  }
  else if (getParam<bool>("ping_pong_protection"))
    paramError("ping_pong_protection",
               "The 'ping_pong_protection' option can only be used with the 'ranfs' formulation");

  // Remove repeated pairs from input file.
  removeRepeatedPairs();
}

Member Function Documentation

act()

void ContactAction::act ( )

overridevirtual

Implements Action.

Definition at line 517 of file ContactAction.C.

{
  // proform problem checks/corrections once during the first feasible task
  if (_current_task == "add_contact_aux_variable")
  {
    if (!_problem->getDisplacedProblem())
      mooseError(
          "Contact requires updated coordinates.  Use the 'displacements = ...' parameter in the "
          "Mesh block.");

    // It is risky to apply this optimization to contact problems
    // since the problem configuration may be changed during Jacobian
    // evaluation. We therefore turn it off for all contact problems so that
    // PETSc-3.8.4 or higher will have the same behavior as PETSc-3.8.3.
    if (!_problem->isSNESMFReuseBaseSetbyUser())
      _problem->setSNESMFReuseBase(false, false);
  }

  if (_formulation == ContactFormulation::MORTAR ||
      _formulation == ContactFormulation::MORTAR_PENALTY)
    addMortarContact();
  else
    addNodeFaceContact();

  if (_current_task == "add_aux_kernel")
  {
    if (!_problem->getDisplacedProblem())
      mooseError("Contact requires updated coordinates.  Use the 'displacements = ...' line in the "
                 "Mesh block.");

    // Create auxiliary kernels for each contact pairs
    for (const auto & contact_pair : _boundary_pairs)
    {
      const auto & [primary_name, secondary_name] = contact_pair;
      if ((_formulation != ContactFormulation::MORTAR) &&
          (_formulation != ContactFormulation::MORTAR_PENALTY))
      {
        InputParameters params = _factory.getValidParams("PenetrationAux");
        params.applyParameters(parameters(),
                               {"secondary_gap_offset", "mapped_primary_gap_offset", "order"});

        std::vector<VariableName> displacements =
            getParam<std::vector<VariableName>>("displacements");
        const auto order = _problem->systemBaseNonlinear(/*nl_sys_num=*/0)
                               .system()
                               .variable_type(displacements[0])
                               .order.get_order();

        params.set<MooseEnum>("order") = Utility::enum_to_string<Order>(OrderWrapper{order});
        params.set<ExecFlagEnum>("execute_on") = {EXEC_INITIAL, EXEC_LINEAR};
        params.set<std::vector<BoundaryName>>("boundary") = {secondary_name};
        params.set<BoundaryName>("paired_boundary") = primary_name;
        params.set<AuxVariableName>("variable") = "penetration";
        if (isParamValid("secondary_gap_offset"))
          params.set<std::vector<VariableName>>("secondary_gap_offset") = {
              getParam<VariableName>("secondary_gap_offset")};
        if (isParamValid("mapped_primary_gap_offset"))
          params.set<std::vector<VariableName>>("mapped_primary_gap_offset") = {
              getParam<VariableName>("mapped_primary_gap_offset")};
        params.set<bool>("use_displaced_mesh") = true;
        std::string name = _name + "_contact_" + Moose::stringify(contact_auxkernel_counter++);

        _problem->addAuxKernel("PenetrationAux", name, params);
      }
      else
      {
        const auto type = "MortarUserObjectAux";
        InputParameters params = _factory.getValidParams(type);
        params.set<std::vector<BoundaryName>>("boundary") = {secondary_name};
        params.set<AuxVariableName>("variable") = "gap";
        params.set<bool>("use_displaced_mesh") = true; // Unnecessary as this object only operates
                                                       // on nodes, but we'll do it for consistency
        params.set<MooseEnum>("contact_quantity") = "normal_gap";
        const auto & [primary_id, secondary_id, uo_name] =
            libmesh_map_find(_bnd_pair_to_mortar_info, contact_pair);
        params.set<UserObjectName>("user_object") = uo_name;
        std::string name = _name + "_contact_gap_" + std::to_string(primary_id) + "_" +
                           std::to_string(secondary_id);

        _problem->addAuxKernel(type, name, params);
      }
    }

    addContactPressureAuxKernel();

    const unsigned int ndisp = getParam<std::vector<VariableName>>("displacements").size();

    // Add MortarFrictionalPressureVectorAux
    if (_formulation == ContactFormulation::MORTAR && _model == ContactModel::COULOMB && ndisp > 2)
    {
      {
        InputParameters params = _factory.getValidParams("MortarFrictionalPressureVectorAux");

        params.set<BoundaryName>("primary_boundary") = _boundary_pairs[0].first;
        params.set<BoundaryName>("secondary_boundary") = _boundary_pairs[0].second;
        params.set<std::vector<BoundaryName>>("boundary") = {_boundary_pairs[0].second};
        params.set<ExecFlagEnum>("execute_on", true) = {EXEC_NONLINEAR};

        std::string action_name = MooseUtils::shortName(name());
        const std::string tangential_lagrange_multiplier_name = action_name + "_tangential_lm";
        const std::string tangential_lagrange_multiplier_3d_name =
            action_name + "_tangential_3d_lm";

        params.set<std::vector<VariableName>>("tangent_one") = {
            tangential_lagrange_multiplier_name};
        params.set<std::vector<VariableName>>("tangent_two") = {
            tangential_lagrange_multiplier_3d_name};

        std::vector<std::string> disp_components({"x", "y", "z"});
        unsigned component_index = 0;

        // Loop over three displacements
        for (const auto & disp_component : disp_components)
        {
          params.set<AuxVariableName>("variable") = _name + "_tangent_" + disp_component;
          params.set<unsigned int>("component") = component_index;

          std::string name = _name + "_mortar_frictional_pressure_" + disp_component + "_" +
                             Moose::stringify(contact_mortar_auxkernel_counter++);

          _problem->addAuxKernel("MortarFrictionalPressureVectorAux", name, params);
          component_index++;
        }
      }
    }
  }

  if (_current_task == "add_contact_aux_variable")
  {
    std::vector<VariableName> displacements = getParam<std::vector<VariableName>>("displacements");
    const auto order = _problem->systemBaseNonlinear(/*nl_sys_num=*/0)
                           .system()
                           .variable_type(displacements[0])
                           .order.get_order();
    std::unique_ptr<InputParameters> current_params;
    const auto create_aux_var_params = [this, order, &current_params]() -> InputParameters &
    {
      current_params = std::make_unique<InputParameters>(_factory.getValidParams("MooseVariable"));
      current_params->set<MooseEnum>("order") = Utility::enum_to_string<Order>(OrderWrapper{order});
      current_params->set<MooseEnum>("family") = "LAGRANGE";
      return *current_params;
    };

    if ((_formulation != ContactFormulation::MORTAR) &&
        (_formulation != ContactFormulation::MORTAR_PENALTY))
    {
      // Add penetration aux variable
      _problem->addAuxVariable("MooseVariable", "penetration", create_aux_var_params());
      // Add nodal area aux variable
      _problem->addAuxVariable("MooseVariable", "nodal_area", create_aux_var_params());
    }
    else
      _problem->addAuxVariable("MooseVariable", "gap", create_aux_var_params());

    // Add contact pressure aux variable
    _problem->addAuxVariable("MooseVariable", "contact_pressure", create_aux_var_params());

    const unsigned int ndisp = getParam<std::vector<VariableName>>("displacements").size();

    // Add MortarFrictionalPressureVectorAux variables
    if (_formulation == ContactFormulation::MORTAR && _model == ContactModel::COULOMB && ndisp > 2)
    {
      {
        std::vector<std::string> disp_components({"x", "y", "z"});
        // Loop over three displacements
        for (const auto & disp_component : disp_components)
        {
          auto var_params = _factory.getValidParams("MooseVariable");
          var_params.set<MooseEnum>("order") = Utility::enum_to_string<Order>(OrderWrapper{order});
          var_params.set<MooseEnum>("family") = "LAGRANGE";

          _problem->addAuxVariable(
              "MooseVariable", _name + "_tangent_" + disp_component, var_params);
        }
      }
    }
  }

  if (_current_task == "add_user_object" && (_formulation != ContactFormulation::MORTAR) &&
      (_formulation != ContactFormulation::MORTAR_PENALTY))
  {
    auto var_params = _factory.getValidParams("NodalArea");

    // Get secondary_boundary_vector from possibly updated set from the
    // ContactAction constructor cleanup
    const auto actions = _awh.getActions<ContactAction>();

    std::vector<BoundaryName> secondary_boundary_vector;
    for (const auto * const action : actions)
      for (const auto j : index_range(action->_boundary_pairs))
        secondary_boundary_vector.push_back(action->_boundary_pairs[j].second);

    var_params.set<std::vector<BoundaryName>>("boundary") = secondary_boundary_vector;
    var_params.set<std::vector<VariableName>>("variable") = {"nodal_area"};

    mooseAssert(_problem, "Problem pointer is NULL");
    var_params.set<ExecFlagEnum>("execute_on", true) = {EXEC_INITIAL, EXEC_TIMESTEP_BEGIN};
    var_params.set<bool>("use_displaced_mesh") = true;

    _problem->addUserObject("NodalArea",
                            "nodal_area_object_" + Moose::stringify(contact_userobject_counter++),
                            var_params);
  }
}

addContactPressureAuxKernel()

void ContactAction::addContactPressureAuxKernel ( )

private

Add single contact pressure auxiliary kernel for various contact action objects.

Definition at line 723 of file ContactAction.C.

Referenced by act().

{
  // Increment counter for contact action objects
  contact_action_counter++;

  if ((_formulation != ContactFormulation::MORTAR) &&
      (_formulation != ContactFormulation::MORTAR_PENALTY))
  {
    // Add ContactPressureAux: Only one object for all contact pairs
    const auto actions = _awh.getActions<ContactAction>();

    // Add auxiliary kernel if we are the last contact action object.
    if (contact_action_counter == actions.size())
    {
      std::vector<BoundaryName> boundary_vector;
      std::vector<BoundaryName> pair_boundary_vector;

      for (const auto * const action : actions)
        for (const auto j : index_range(action->_boundary_pairs))
        {
          boundary_vector.push_back(action->_boundary_pairs[j].second);
          pair_boundary_vector.push_back(action->_boundary_pairs[j].first);
        }

      InputParameters params = _factory.getValidParams("ContactPressureAux");
      params.applyParameters(parameters(), {"order"});

      std::vector<VariableName> displacements =
          getParam<std::vector<VariableName>>("displacements");
      const auto order = _problem->systemBaseNonlinear(/*nl_sys_num=*/0)
                             .system()
                             .variable_type(displacements[0])
                             .order.get_order();

      params.set<MooseEnum>("order") = Utility::enum_to_string<Order>(OrderWrapper{order});
      params.set<std::vector<BoundaryName>>("boundary") = boundary_vector;
      params.set<std::vector<BoundaryName>>("paired_boundary") = pair_boundary_vector;
      params.set<AuxVariableName>("variable") = "contact_pressure";
      params.addRequiredCoupledVar("nodal_area", "The nodal area");
      params.set<std::vector<VariableName>>("nodal_area") = {"nodal_area"};
      params.set<bool>("use_displaced_mesh") = true;

      std::string name = _name + "_contact_pressure";
      params.set<ExecFlagEnum>("execute_on",
                               true) = {EXEC_NONLINEAR, EXEC_TIMESTEP_END, EXEC_TIMESTEP_BEGIN};
      _problem->addAuxKernel("ContactPressureAux", name, params);
    }
  }
  else
    for (const auto & contact_pair : _boundary_pairs)
    {
      const auto & [_, secondary_name] = contact_pair;
      const auto type = "MortarUserObjectAux";
      InputParameters params = _factory.getValidParams(type);
      params.set<std::vector<BoundaryName>>("boundary") = {secondary_name};
      params.set<AuxVariableName>("variable") = "contact_pressure";
      params.set<bool>("use_displaced_mesh") = true; // Unecessary as this object only operates on
                                                     // nodes, but we'll do it for consistency
      params.set<MooseEnum>("contact_quantity") = "normal_pressure";
      const auto & [primary_id, secondary_id, uo_name] =
          libmesh_map_find(_bnd_pair_to_mortar_info, contact_pair);
      params.set<UserObjectName>("user_object") = uo_name;
      const std::string name = _name + "_contact_pressure" + std::to_string(primary_id) + "_" +
                               std::to_string(secondary_id);

      _problem->addAuxKernel(type, name, params);
    }
}

addMortarContact()

void ContactAction::addMortarContact ( )

private

Generate mesh and other Moose objects for Mortar contact.

Definition at line 829 of file ContactAction.C.

Referenced by act().

{
  std::string action_name = MooseUtils::shortName(name());

  std::vector<VariableName> displacements = getParam<std::vector<VariableName>>("displacements");
  const unsigned int ndisp = displacements.size();

  // Definitions for mortar contact.
  const std::string primary_subdomain_name = action_name + "_primary_subdomain";
  const std::string secondary_subdomain_name = action_name + "_secondary_subdomain";
  const std::string normal_lagrange_multiplier_name = action_name + "_normal_lm";
  const std::string tangential_lagrange_multiplier_name = action_name + "_tangential_lm";
  const std::string tangential_lagrange_multiplier_3d_name = action_name + "_tangential_3d_lm";
  const std::string auxiliary_lagrange_multiplier_name = action_name + "_aux_lm";

  if (_current_task == "append_mesh_generator")
  {
    // Don't do mesh generators when recovering or when the user has requested for us not to
    // (presumably because the lower-dimensional blocks are already in the mesh due to manual
    // addition or because we are restarting)
    if (!(_app.isRecovering() && _app.isUltimateMaster()) && !_app.useMasterMesh() &&
        _generate_mortar_mesh)
    {
      const MeshGeneratorName primary_name = primary_subdomain_name + "_generator";
      const MeshGeneratorName secondary_name = secondary_subdomain_name + "_generator";

      auto primary_params = _factory.getValidParams("LowerDBlockFromSidesetGenerator");
      auto secondary_params = _factory.getValidParams("LowerDBlockFromSidesetGenerator");

      primary_params.set<SubdomainName>("new_block_name") = primary_subdomain_name;
      secondary_params.set<SubdomainName>("new_block_name") = secondary_subdomain_name;

      primary_params.set<std::vector<BoundaryName>>("sidesets") = {_boundary_pairs[0].first};
      secondary_params.set<std::vector<BoundaryName>>("sidesets") = {_boundary_pairs[0].second};

      _app.appendMeshGenerator("LowerDBlockFromSidesetGenerator", primary_name, primary_params);
      _app.appendMeshGenerator("LowerDBlockFromSidesetGenerator", secondary_name, secondary_params);
    }
  }

  // Add the lagrange multiplier on the secondary subdomain.
  const auto addLagrangeMultiplier =
      [this, &secondary_subdomain_name, &displacements](const std::string & variable_name,
                                                        const Real scaling_factor,
                                                        const bool add_aux_lm,
                                                        const bool penalty_traction) //
  {
    InputParameters params = _factory.getValidParams("MooseVariableBase");

    // Allow the user to select "weighted" constraints and standard bases (use_dual = false) or
    // "legacy" constraints and dual bases (use_dual = true). Unless it's for testing purposes,
    // this combination isn't recommended
    if (!add_aux_lm || penalty_traction)
      params.set<bool>("use_dual") = _use_dual;

    mooseAssert(_problem->systemBaseNonlinear(/*nl_sys_num=*/0).hasVariable(displacements[0]),
                "Displacement variable is missing");
    const auto primal_type =
        _problem->systemBaseNonlinear(/*nl_sys_num=*/0).system().variable_type(displacements[0]);

    const int lm_order = primal_type.order.get_order();

    if (primal_type.family == LAGRANGE)
    {
      params.set<MooseEnum>("family") = Utility::enum_to_string<FEFamily>(primal_type.family);
      params.set<MooseEnum>("order") = Utility::enum_to_string<Order>(OrderWrapper{lm_order});
    }
    else
      mooseError("Invalid bases for mortar contact.");

    params.set<std::vector<SubdomainName>>("block") = {secondary_subdomain_name};
    if (!(add_aux_lm || penalty_traction))
      params.set<std::vector<Real>>("scaling") = {scaling_factor};

    auto fe_type = AddVariableAction::feType(params);
    auto var_type = AddVariableAction::variableType(fe_type);
    if (add_aux_lm || penalty_traction)
      _problem->addAuxVariable(var_type, variable_name, params);
    else
      _problem->addVariable(var_type, variable_name, params);
  };

  if (_current_task == "add_mortar_variable" && _formulation == ContactFormulation::MORTAR)
  {
    addLagrangeMultiplier(
        normal_lagrange_multiplier_name, getParam<Real>("normal_lm_scaling"), false, false);

    if (_model == ContactModel::COULOMB)
    {
      addLagrangeMultiplier(tangential_lagrange_multiplier_name,
                            getParam<Real>("tangential_lm_scaling"),
                            false,
                            false);
      if (ndisp > 2)
        addLagrangeMultiplier(tangential_lagrange_multiplier_3d_name,
                              getParam<Real>("tangential_lm_scaling"),
                              false,
                              false);
    }

    if (getParam<bool>("use_petrov_galerkin"))
      addLagrangeMultiplier(auxiliary_lagrange_multiplier_name, 1.0, true, false);
  }
  else if (_current_task == "add_mortar_variable" &&
           _formulation == ContactFormulation::MORTAR_PENALTY)
  {
    if (_use_dual)
      addLagrangeMultiplier(auxiliary_lagrange_multiplier_name, 1.0, false, true);
  }

  if (_current_task == "add_user_object")
  {
    const auto register_mortar_uo_name = [this](const auto & bnd_pair, const auto & uo_prefix)
    {
      const auto & [primary_name, secondary_name] = bnd_pair;
      const auto primary_id = _mesh->getBoundaryID(primary_name);
      const auto secondary_id = _mesh->getBoundaryID(secondary_name);
      const auto uo_name = uo_prefix + name();
      _bnd_pair_to_mortar_info.emplace(bnd_pair, MortarInfo{primary_id, secondary_id, uo_name});
      return uo_name;
    };

    // check if the correct problem class is selected if AL parameters are provided
    if (_formulation == ContactFormulation::MORTAR_PENALTY &&
        !dynamic_cast<AugmentedLagrangianContactProblemInterface *>(_problem.get()))
    {
      const std::vector<std::string> params = {"penalty_multiplier",
                                               "penalty_multiplier_friction",
                                               "al_penetration_tolerance",
                                               "al_incremental_slip_tolerance",
                                               "al_frictional_force_tolerance"};
      for (const auto & param : params)
        if (parameters().isParamSetByUser(param))
          paramError(param,
                     "Augmented Lagrange parameter was specified, but the selected problem type "
                     "does not support Augmented Lagrange iterations.");
    }

    if (_model != ContactModel::COULOMB && _formulation == ContactFormulation::MORTAR)
    {
      auto uo_params = _factory.getValidParams("LMWeightedGapUserObject");

      uo_params.set<BoundaryName>("primary_boundary") = _boundary_pairs[0].first;
      uo_params.set<BoundaryName>("secondary_boundary") = _boundary_pairs[0].second;
      uo_params.set<SubdomainName>("primary_subdomain") = primary_subdomain_name;
      uo_params.set<SubdomainName>("secondary_subdomain") = secondary_subdomain_name;
      uo_params.set<std::vector<VariableName>>("disp_x") = {displacements[0]};
      uo_params.set<std::vector<VariableName>>("disp_y") = {displacements[1]};
      if (ndisp > 2)
        uo_params.set<std::vector<VariableName>>("disp_z") = {displacements[2]};
      uo_params.set<bool>("use_displaced_mesh") = true;
      uo_params.set<std::vector<VariableName>>("lm_variable") = {normal_lagrange_multiplier_name};
      uo_params.applySpecificParameters(
          parameters(), {"correct_edge_dropping", "use_petrov_galerkin", "debug_mesh"});
      if (getParam<bool>("use_petrov_galerkin"))
        uo_params.set<std::vector<VariableName>>("aux_lm") = {auxiliary_lagrange_multiplier_name};

      _problem->addUserObject("LMWeightedGapUserObject",
                              register_mortar_uo_name(_boundary_pairs[0], "lm_weightedgap_object_"),
                              uo_params);
    }
    else if (_model == ContactModel::COULOMB && _formulation == ContactFormulation::MORTAR)
    {
      auto uo_params = _factory.getValidParams("LMWeightedVelocitiesUserObject");
      uo_params.set<BoundaryName>("primary_boundary") = _boundary_pairs[0].first;
      uo_params.set<BoundaryName>("secondary_boundary") = _boundary_pairs[0].second;
      uo_params.set<SubdomainName>("primary_subdomain") = primary_subdomain_name;
      uo_params.set<SubdomainName>("secondary_subdomain") = secondary_subdomain_name;
      uo_params.set<std::vector<VariableName>>("disp_x") = {displacements[0]};
      uo_params.set<std::vector<VariableName>>("disp_y") = {displacements[1]};
      if (ndisp > 2)
        uo_params.set<std::vector<VariableName>>("disp_z") = {displacements[2]};

      uo_params.set<VariableName>("secondary_variable") = displacements[0];
      uo_params.set<bool>("use_displaced_mesh") = true;
      uo_params.set<std::vector<VariableName>>("lm_variable_normal") = {
          normal_lagrange_multiplier_name};
      uo_params.set<std::vector<VariableName>>("lm_variable_tangential_one") = {
          tangential_lagrange_multiplier_name};
      if (ndisp > 2)
        uo_params.set<std::vector<VariableName>>("lm_variable_tangential_two") = {
            tangential_lagrange_multiplier_3d_name};
      uo_params.applySpecificParameters(
          parameters(), {"correct_edge_dropping", "use_petrov_galerkin", "debug_mesh"});
      if (getParam<bool>("use_petrov_galerkin"))
        uo_params.set<std::vector<VariableName>>("aux_lm") = {auxiliary_lagrange_multiplier_name};

      const auto uo_name = _problem->addUserObject(
          "LMWeightedVelocitiesUserObject",
          register_mortar_uo_name(_boundary_pairs[0], "lm_weightedvelocities_object_"),
          uo_params);
    }

    if (_model != ContactModel::COULOMB && _formulation == ContactFormulation::MORTAR_PENALTY)
    {
      auto uo_params = _factory.getValidParams("PenaltyWeightedGapUserObject");

      uo_params.set<BoundaryName>("primary_boundary") = _boundary_pairs[0].first;
      uo_params.set<BoundaryName>("secondary_boundary") = _boundary_pairs[0].second;
      uo_params.set<SubdomainName>("primary_subdomain") = primary_subdomain_name;
      uo_params.set<SubdomainName>("secondary_subdomain") = secondary_subdomain_name;
      uo_params.set<std::vector<VariableName>>("disp_x") = {displacements[0]};
      uo_params.set<std::vector<VariableName>>("disp_y") = {displacements[1]};

      // AL parameters
      uo_params.applySpecificParameters(parameters(),
                                        {"correct_edge_dropping",
                                         "penalty",
                                         "debug_mesh",
                                         "max_penalty_multiplier",
                                         "adaptivity_penalty_normal"});

      if (isParamValid("al_penetration_tolerance"))
        uo_params.set<Real>("penetration_tolerance") = getParam<Real>("al_penetration_tolerance");
      if (isParamValid("penalty_multiplier"))
        uo_params.set<Real>("penalty_multiplier") = getParam<Real>("penalty_multiplier");
      // In the contact action, we force the physical value of the normal gap, which also normalizes
      // the penalty factor with the "area" around the node
      uo_params.set<bool>("use_physical_gap") = true;

      if (_use_dual)
        uo_params.set<std::vector<VariableName>>("aux_lm") = {auxiliary_lagrange_multiplier_name};

      if (ndisp > 2)
        uo_params.set<std::vector<VariableName>>("disp_z") = {displacements[2]};
      uo_params.set<bool>("use_displaced_mesh") = true;

      _problem->addUserObject(
          "PenaltyWeightedGapUserObject",
          register_mortar_uo_name(_boundary_pairs[0], "penalty_weightedgap_object_"),
          uo_params);
      _problem->haveADObjects(true);
    }
    else if (_model == ContactModel::COULOMB && _formulation == ContactFormulation::MORTAR_PENALTY)
    {
      auto uo_params = _factory.getValidParams("PenaltyFrictionUserObject");
      uo_params.set<BoundaryName>("primary_boundary") = _boundary_pairs[0].first;
      uo_params.set<BoundaryName>("secondary_boundary") = _boundary_pairs[0].second;
      uo_params.set<SubdomainName>("primary_subdomain") = primary_subdomain_name;
      uo_params.set<SubdomainName>("secondary_subdomain") = secondary_subdomain_name;
      uo_params.set<std::vector<VariableName>>("disp_x") = {displacements[0]};
      uo_params.set<bool>("correct_edge_dropping") = getParam<bool>("correct_edge_dropping");
      uo_params.set<std::vector<VariableName>>("disp_y") = {displacements[1]};
      if (ndisp > 2)
        uo_params.set<std::vector<VariableName>>("disp_z") = {displacements[2]};

      uo_params.set<VariableName>("secondary_variable") = displacements[0];
      uo_params.set<bool>("use_displaced_mesh") = true;
      uo_params.set<Real>("friction_coefficient") = getParam<Real>("friction_coefficient");
      uo_params.set<Real>("penalty") = getParam<Real>("penalty");
      uo_params.set<Real>("penalty_friction") = getParam<Real>("penalty_friction");

      // AL parameters
      uo_params.set<Real>("max_penalty_multiplier") = getParam<Real>("max_penalty_multiplier");
      uo_params.set<MooseEnum>("adaptivity_penalty_normal") =
          getParam<MooseEnum>("adaptivity_penalty_normal");
      uo_params.set<MooseEnum>("adaptivity_penalty_friction") =
          getParam<MooseEnum>("adaptivity_penalty_friction");
      if (isParamValid("al_penetration_tolerance"))
        uo_params.set<Real>("penetration_tolerance") = getParam<Real>("al_penetration_tolerance");
      if (isParamValid("penalty_multiplier"))
        uo_params.set<Real>("penalty_multiplier") = getParam<Real>("penalty_multiplier");
      if (isParamValid("penalty_multiplier_friction"))
        uo_params.set<Real>("penalty_multiplier_friction") =
            getParam<Real>("penalty_multiplier_friction");

      if (isParamValid("al_incremental_slip_tolerance"))
        uo_params.set<Real>("slip_tolerance") = getParam<Real>("al_incremental_slip_tolerance");
      // In the contact action, we force the physical value of the normal gap, which also normalizes
      // the penalty factor with the "area" around the node
      uo_params.set<bool>("use_physical_gap") = true;

      if (_use_dual)
        uo_params.set<std::vector<VariableName>>("aux_lm") = {auxiliary_lagrange_multiplier_name};

      uo_params.applySpecificParameters(parameters(),
                                        {"friction_coefficient", "penalty", "penalty_friction"});

      _problem->addUserObject(
          "PenaltyFrictionUserObject",
          register_mortar_uo_name(_boundary_pairs[0], "penalty_friction_object_"),
          uo_params);
      _problem->haveADObjects(true);
    }
  }

  if (_current_task == "add_constraint")
  {
    // Prepare problem for enforcement with Lagrange multipliers
    if (_model != ContactModel::COULOMB && _formulation == ContactFormulation::MORTAR)
    {
      std::string mortar_constraint_name;

      if (!_mortar_dynamics)
        mortar_constraint_name = "ComputeWeightedGapLMMechanicalContact";
      else
        mortar_constraint_name = "ComputeDynamicWeightedGapLMMechanicalContact";

      InputParameters params = _factory.getValidParams(mortar_constraint_name);
      if (_mortar_dynamics)
        params.applySpecificParameters(
            parameters(), {"newmark_beta", "newmark_gamma", "capture_tolerance", "wear_depth"});

      else // We need user objects for quasistatic constraints
        params.set<UserObjectName>("weighted_gap_uo") = "lm_weightedgap_object_" + name();

      params.set<BoundaryName>("primary_boundary") = _boundary_pairs[0].first;
      params.set<BoundaryName>("secondary_boundary") = _boundary_pairs[0].second;
      params.set<SubdomainName>("primary_subdomain") = primary_subdomain_name;
      params.set<SubdomainName>("secondary_subdomain") = secondary_subdomain_name;
      params.set<NonlinearVariableName>("variable") = normal_lagrange_multiplier_name;
      params.set<std::vector<VariableName>>("disp_x") = {displacements[0]};
      params.set<Real>("c") = getParam<Real>("c_normal");

      if (ndisp > 1)
        params.set<std::vector<VariableName>>("disp_y") = {displacements[1]};
      if (ndisp > 2)
        params.set<std::vector<VariableName>>("disp_z") = {displacements[2]};

      params.set<bool>("use_displaced_mesh") = true;

      params.applySpecificParameters(parameters(),
                                     {"correct_edge_dropping",
                                      "normalize_c",
                                      "extra_vector_tags",
                                      "absolute_value_vector_tags",
                                      "debug_mesh"});

      _problem->addConstraint(
          mortar_constraint_name, action_name + "_normal_lm_weighted_gap", params);
      _problem->haveADObjects(true);
    }
    // Add the tangential and normal Lagrange's multiplier constraints on the secondary boundary.
    else if (_model == ContactModel::COULOMB && _formulation == ContactFormulation::MORTAR)
    {
      std::string mortar_constraint_name;

      if (!_mortar_dynamics)
        mortar_constraint_name = "ComputeFrictionalForceLMMechanicalContact";
      else
        mortar_constraint_name = "ComputeDynamicFrictionalForceLMMechanicalContact";

      InputParameters params = _factory.getValidParams(mortar_constraint_name);
      if (_mortar_dynamics)
        params.applySpecificParameters(
            parameters(), {"newmark_beta", "newmark_gamma", "capture_tolerance", "wear_depth"});
      else
      { // We need user objects for quasistatic constraints
        params.set<UserObjectName>("weighted_gap_uo") = "lm_weightedvelocities_object_" + name();
        params.set<UserObjectName>("weighted_velocities_uo") =
            "lm_weightedvelocities_object_" + name();
      }

      params.set<bool>("correct_edge_dropping") = getParam<bool>("correct_edge_dropping");
      params.set<BoundaryName>("primary_boundary") = _boundary_pairs[0].first;
      params.set<BoundaryName>("secondary_boundary") = _boundary_pairs[0].second;
      params.set<SubdomainName>("primary_subdomain") = primary_subdomain_name;
      params.set<SubdomainName>("secondary_subdomain") = secondary_subdomain_name;
      params.set<bool>("use_displaced_mesh") = true;
      params.set<Real>("c_t") = getParam<Real>("c_tangential");
      params.set<Real>("c") = getParam<Real>("c_normal");
      params.set<bool>("normalize_c") = getParam<bool>("normalize_c");
      params.set<bool>("compute_primal_residuals") = false;

      params.set<MooseEnum>("segment_quadrature") = getParam<MooseEnum>("segment_quadrature");

      params.set<std::vector<VariableName>>("disp_x") = {displacements[0]};

      if (ndisp > 1)
        params.set<std::vector<VariableName>>("disp_y") = {displacements[1]};
      if (ndisp > 2)
        params.set<std::vector<VariableName>>("disp_z") = {displacements[2]};

      params.set<NonlinearVariableName>("variable") = normal_lagrange_multiplier_name;
      params.set<std::vector<VariableName>>("friction_lm") = {tangential_lagrange_multiplier_name};

      if (ndisp > 2)
        params.set<std::vector<VariableName>>("friction_lm_dir") = {
            tangential_lagrange_multiplier_3d_name};

      params.set<Real>("mu") = getParam<Real>("friction_coefficient");
      params.applySpecificParameters(
          parameters(), {"extra_vector_tags", "absolute_value_vector_tags", "debug_mesh"});

      _problem->addConstraint(mortar_constraint_name, action_name + "_tangential_lm", params);
      _problem->haveADObjects(true);
    }

    const auto addMechanicalContactConstraints =
        [this, &primary_subdomain_name, &secondary_subdomain_name, &displacements](
            const std::string & variable_name,
            const std::string & constraint_prefix,
            const std::string & constraint_type,
            const bool is_additional_frictional_constraint,
            const bool is_normal_constraint)
    {
      InputParameters params = _factory.getValidParams(constraint_type);

      params.set<bool>("correct_edge_dropping") = getParam<bool>("correct_edge_dropping");
      params.set<BoundaryName>("primary_boundary") = _boundary_pairs[0].first;
      params.set<BoundaryName>("secondary_boundary") = _boundary_pairs[0].second;
      params.set<SubdomainName>("primary_subdomain") = primary_subdomain_name;
      params.set<SubdomainName>("secondary_subdomain") = secondary_subdomain_name;

      if (_formulation == ContactFormulation::MORTAR)
        params.set<NonlinearVariableName>("variable") = variable_name;

      params.set<MooseEnum>("segment_quadrature") = getParam<MooseEnum>("segment_quadrature");
      params.set<bool>("use_displaced_mesh") = true;
      params.set<bool>("compute_lm_residuals") = false;

      // Additional displacement residual for frictional problem
      // The second frictional LM acts on a perpendicular direction.
      if (is_additional_frictional_constraint)
        params.set<MooseEnum>("direction") = "direction_2";
      params.applySpecificParameters(
          parameters(), {"extra_vector_tags", "absolute_value_vector_tags", "debug_mesh"});

      for (unsigned int i = 0; i < displacements.size(); ++i)
      {
        std::string constraint_name = constraint_prefix + Moose::stringify(i);

        params.set<VariableName>("secondary_variable") = displacements[i];
        params.set<MooseEnum>("component") = i;

        if (is_normal_constraint && _model != ContactModel::COULOMB &&
            _formulation == ContactFormulation::MORTAR)
          params.set<UserObjectName>("weighted_gap_uo") = "lm_weightedgap_object_" + name();
        else if (is_normal_constraint && _model == ContactModel::COULOMB &&
                 _formulation == ContactFormulation::MORTAR)
          params.set<UserObjectName>("weighted_gap_uo") = "lm_weightedvelocities_object_" + name();
        else if (_formulation == ContactFormulation::MORTAR)
          params.set<UserObjectName>("weighted_velocities_uo") =
              "lm_weightedvelocities_object_" + name();
        else if (is_normal_constraint && _model != ContactModel::COULOMB &&
                 _formulation == ContactFormulation::MORTAR_PENALTY)
          params.set<UserObjectName>("weighted_gap_uo") = "penalty_weightedgap_object_" + name();
        else if (is_normal_constraint && _model == ContactModel::COULOMB &&
                 _formulation == ContactFormulation::MORTAR_PENALTY)
          params.set<UserObjectName>("weighted_gap_uo") = "penalty_friction_object_" + name();
        else if (_formulation == ContactFormulation::MORTAR_PENALTY)
          params.set<UserObjectName>("weighted_velocities_uo") =
              "penalty_friction_object_" + name();

        _problem->addConstraint(constraint_type, constraint_name, params);
      }
      _problem->haveADObjects(true);
    };

    // Add mortar mechanical contact constraint objects for primal variables
    addMechanicalContactConstraints(normal_lagrange_multiplier_name,
                                    action_name + "_normal_constraint_",
                                    "NormalMortarMechanicalContact",
                                    /* is_additional_frictional_constraint = */ false,
                                    /* is_normal_constraint = */ true);

    if (_model == ContactModel::COULOMB)
    {
      addMechanicalContactConstraints(tangential_lagrange_multiplier_name,
                                      action_name + "_tangential_constraint_",
                                      "TangentialMortarMechanicalContact",
                                      /* is_additional_frictional_constraint = */ false,
                                      /* is_normal_constraint = */ false);
      if (ndisp > 2)
        addMechanicalContactConstraints(tangential_lagrange_multiplier_3d_name,
                                        action_name + "_tangential_constraint_3d_",
                                        "TangentialMortarMechanicalContact",
                                        /* is_additional_frictional_constraint = */ true,
                                        /* is_normal_constraint = */ false);
    }
  }
}

addNodeFaceContact()

void ContactAction::addNodeFaceContact ( )

private

Generate constraints for node to face contact.

Definition at line 1303 of file ContactAction.C.

Referenced by act().

{
  if (_current_task == "post_mesh_prepared" && _automatic_pairing_boundaries.size() > 0)
  {
    if (getParam<MooseEnum>("automatic_pairing_method").getEnum<ProximityMethod>() ==
        ProximityMethod::NODE)
      createSidesetsFromNodeProximity();
    else if (getParam<MooseEnum>("automatic_pairing_method").getEnum<ProximityMethod>() ==
             ProximityMethod::CENTROID)
      createSidesetPairsFromGeometry();
  }

  if (_current_task != "add_constraint")
    return;

  std::string action_name = MooseUtils::shortName(name());
  std::vector<VariableName> displacements = getParam<std::vector<VariableName>>("displacements");
  const unsigned int ndisp = displacements.size();

  std::string constraint_type;

  if (_formulation == ContactFormulation::RANFS)
    constraint_type = "RANFSNormalMechanicalContact";
  else
    constraint_type = "MechanicalContactConstraint";

  InputParameters params = _factory.getValidParams(constraint_type);

  params.applyParameters(parameters(),
                         {"displacements",
                          "secondary_gap_offset",
                          "mapped_primary_gap_offset",
                          "primary",
                          "secondary"});

  const auto order = _problem->systemBaseNonlinear(/*nl_sys_num=*/0)
                         .system()
                         .variable_type(displacements[0])
                         .order.get_order();

  params.set<std::vector<VariableName>>("displacements") = displacements;
  params.set<bool>("use_displaced_mesh") = true;
  params.set<MooseEnum>("order") = Utility::enum_to_string<Order>(OrderWrapper{order});

  for (const auto & contact_pair : _boundary_pairs)
  {
    if (_formulation != ContactFormulation::RANFS)
    {
      params.set<std::vector<VariableName>>("nodal_area") = {"nodal_area"};
      params.set<BoundaryName>("boundary") = contact_pair.first;
      if (isParamValid("secondary_gap_offset"))
        params.set<std::vector<VariableName>>("secondary_gap_offset") = {
            getParam<VariableName>("secondary_gap_offset")};
      if (isParamValid("mapped_primary_gap_offset"))
        params.set<std::vector<VariableName>>("mapped_primary_gap_offset") = {
            getParam<VariableName>("mapped_primary_gap_offset")};
    }

    for (unsigned int i = 0; i < ndisp; ++i)
    {
      std::string name = action_name + "_constraint_" + Moose::stringify(contact_pair, "_") + "_" +
                         Moose::stringify(i);

      if (_formulation == ContactFormulation::RANFS)
        params.set<MooseEnum>("component") = i;
      else
        params.set<unsigned int>("component") = i;

      params.set<BoundaryName>("primary") = contact_pair.first;
      params.set<BoundaryName>("secondary") = contact_pair.second;
      params.set<NonlinearVariableName>("variable") = displacements[i];
      params.set<std::vector<VariableName>>("primary_variable") = {displacements[i]};
      params.applySpecificParameters(parameters(),
                                     {"extra_vector_tags", "absolute_value_vector_tags"});
      _problem->addConstraint(constraint_type, name, params);
    }
  }
}

addRelationshipManagers() [1/3]

bool Action::addRelationshipManagers

addRelationshipManagers() [2/3]

virtual void Action::addRelationshipManagers

addRelationshipManagers() [3/3]

void ContactAction::addRelationshipManagers ( Moose::RelationshipManagerType  input_rm_type )

overridevirtual

Reimplemented from Action.

Definition at line 793 of file ContactAction.C.

{
  if (_formulation == ContactFormulation::MORTAR ||
      _formulation == ContactFormulation::MORTAR_PENALTY)
  {
    auto params = MortarConstraintBase::validParams();
    params.set<bool>("use_displaced_mesh") = true;
    std::string action_name = MooseUtils::shortName(name());
    const std::string primary_subdomain_name = action_name + "_primary_subdomain";
    const std::string secondary_subdomain_name = action_name + "_secondary_subdomain";
    params.set<BoundaryName>("primary_boundary") = _boundary_pairs[0].first;
    params.set<BoundaryName>("secondary_boundary") = _boundary_pairs[0].second;
    params.set<SubdomainName>("primary_subdomain") = primary_subdomain_name;
    params.set<SubdomainName>("secondary_subdomain") = secondary_subdomain_name;
    params.set<bool>("use_petrov_galerkin") = getParam<bool>("use_petrov_galerkin");
    addRelationshipManagers(input_rm_type, params);
  }
  else
  {
    const std::string constraint_type = _formulation == ContactFormulation::RANFS
                                            ? "RANFSNormalMechanicalContact"
                                            : "MechanicalContactConstraint";

    for (const auto & contact_pair : _boundary_pairs)
    {
      auto params = _factory.getValidParams(constraint_type);
      params.set<bool>("use_displaced_mesh") = true;
      params.set<bool>("ghost_whole_interface") = getParam<bool>("ghost_whole_interface");
      params.set<BoundaryName>("primary") = contact_pair.first;
      params.set<BoundaryName>("secondary") = contact_pair.second;
      addRelationshipManagers(input_rm_type, params);
    }
  }
}

commonParameters()

InputParameters ContactAction::commonParameters ( )

static

Define parameters used by multiple contact objects.

Returns

InputParameters object populated with common parameters

Definition at line 1717 of file ContactAction.C.

Referenced by MechanicalContactConstraint::validParams(), and validParams().

{
  InputParameters params = emptyInputParameters();

  params.addParam<MooseEnum>("normal_smoothing_method",
                             ContactAction::getSmoothingEnum(),
                             "Method to use to smooth normals");
  params.addParam<Real>(
      "normal_smoothing_distance",
      "Distance from edge in parametric coordinates over which to smooth contact normal");

  params.addParam<MooseEnum>(
      "formulation", ContactAction::getFormulationEnum(), "The contact formulation");

  params.addParam<MooseEnum>("model", ContactAction::getModelEnum(), "The contact model to use");

  return params;
}

createSidesetPairsFromGeometry()

void ContactAction::createSidesetPairsFromGeometry ( )

private

Create contact pairs between all boundaries whose centroids are within a user-specified distance of each other.

Definition at line 1530 of file ContactAction.C.

Referenced by addNodeFaceContact().

{
  mooseInfo("The contact action is reading the list of boundaries and automatically pairs them "
            "if their centroids fall within a specified distance of each other.");

  if (!_mesh)
    mooseError("Failed to obtain mesh for automatically generating contact pairs.");

  if (!_mesh->getMesh().is_serial())
    paramError(
        "automatic_pairing_boundaries",
        "The generation of automatic contact pairs in the contact action requires a serial mesh.");

  // Compute centers of gravity for each sideset
  std::vector<std::pair<BoundaryName, Point>> automatic_pairing_boundaries_cog;
  const auto & sideset_ids = _mesh->meshSidesetIds();

  const auto & bnd_to_elem_map = _mesh->getBoundariesToActiveSemiLocalElemIds();

  for (const auto & sideset_name : _automatic_pairing_boundaries)
  {
    // If the sideset provided in the input file isn't in the mesh, error out.
    const auto find_set = sideset_ids.find(_mesh->getBoundaryID(sideset_name));
    if (find_set == sideset_ids.end())
      paramError("automatic_pairing_boundaries",
                 sideset_name,
                 " is not defined as a sideset in the mesh.");

    auto dofs_set = bnd_to_elem_map.find(_mesh->getBoundaryID(sideset_name));

    // Initialize data for sideset
    Point center_of_gravity(0, 0, 0);
    Real accumulated_sideset_area(0);

    // Pointer to lower-dimensional element on the sideset
    std::unique_ptr<const Elem> side_ptr;
    const std::unordered_set<dof_id_type> & bnd_elems = dofs_set->second;

    for (auto elem_id : bnd_elems)
    {
      const Elem * elem = _mesh->elemPtr(elem_id);
      unsigned int side = _mesh->sideWithBoundaryID(elem, _mesh->getBoundaryID(sideset_name));

      // update side_ptr
      elem->side_ptr(side_ptr, side);

      // area of the (linearized) side
      const auto side_area = side_ptr->volume();

      // position of the side
      const auto side_position = side_ptr->true_centroid();

      center_of_gravity += side_position * side_area;
      accumulated_sideset_area += side_area;
    }

    // Average each element's center of gravity (centroid) with its area
    center_of_gravity /= accumulated_sideset_area;

    // Add sideset-cog pair to vector
    automatic_pairing_boundaries_cog.emplace_back(sideset_name, center_of_gravity);
  }

  // Vectors of distances for each pair
  std::vector<std::pair<std::pair<BoundaryName, BoundaryName>, Real>> pairs_distances;

  // Assign distances to identify nearby pairs.
  for (std::size_t i = 0; i < automatic_pairing_boundaries_cog.size() - 1; i++)
    for (std::size_t j = i + 1; j < automatic_pairing_boundaries_cog.size(); j++)
    {
      const Point & distance_vector =
          automatic_pairing_boundaries_cog[i].second - automatic_pairing_boundaries_cog[j].second;

      if (automatic_pairing_boundaries_cog[i].first != automatic_pairing_boundaries_cog[j].first)
      {
        const Real distance = distance_vector.norm();
        const std::pair pair = std::make_pair(automatic_pairing_boundaries_cog[i].first,
                                              automatic_pairing_boundaries_cog[j].first);
        pairs_distances.emplace_back(std::make_pair(pair, distance));
      }
    }

  const auto automatic_pairing_distance = getParam<Real>("automatic_pairing_distance");

  // Loop over all pairs
  std::vector<std::pair<std::pair<BoundaryName, BoundaryName>, Real>> lean_pairs_distances;
  for (const auto & pair_distance : pairs_distances)
    if (pair_distance.second <= automatic_pairing_distance)
    {
      lean_pairs_distances.emplace_back(pair_distance);
      mooseInfoRepeated("Generating contact pair primary--secondary ",
                        pair_distance.first.first,
                        "--",
                        pair_distance.first.second,
                        ", with a relative distance of ",
                        pair_distance.second);
    }

  // Create the boundary pairs (possibly with repeated pairs depending on user input)
  for (const auto & lean_pairs_distance : lean_pairs_distances)
  {
    // Make sure secondary surface's boundary ID is less than primary surface's boundary ID.
    // This is done to ensure some consistency in the boundary matching, which helps in defining
    // auxiliary kernels in the input file.
    if (_mesh->getBoundaryID(lean_pairs_distance.first.first) >
        _mesh->getBoundaryID(lean_pairs_distance.first.second))
      _boundary_pairs.push_back(
          {lean_pairs_distance.first.first, lean_pairs_distance.first.second});
    else
      _boundary_pairs.push_back(
          {lean_pairs_distance.first.second, lean_pairs_distance.first.first});
  }

  // Let's remove possibly repeated pairs
  removeRepeatedPairs();
}

createSidesetsFromNodeProximity()

void ContactAction::createSidesetsFromNodeProximity ( )

private

Create contact pairs between all boundaries by determining that nodes on both boundaries are close enough.

Definition at line 1392 of file ContactAction.C.

Referenced by addNodeFaceContact().

{
  mooseInfo("The contact action is reading the list of boundaries and automatically pairs them "
            "if the distance between nodes is less than a specified distance.");

  if (!_mesh)
    mooseError("Failed to obtain mesh for automatically generating contact pairs.");

  if (!_mesh->getMesh().is_serial())
    paramError(
        "automatic_pairing_boundaries",
        "The generation of automatic contact pairs in the contact action requires a serial mesh.");

  // Create automatic_pairing_boundaries_id
  std::vector<BoundaryID> _automatic_pairing_boundaries_id;
  for (const auto & sideset_name : _automatic_pairing_boundaries)
    _automatic_pairing_boundaries_id.emplace_back(_mesh->getBoundaryID(sideset_name));

  // Vector of pairs node-boundary id
  std::vector<NodeBoundaryIDInfo> node_boundary_id_vector;

  // Data structures to hold the boundary nodes
  const ConstBndNodeRange & bnd_nodes = *_mesh->getBoundaryNodeRange();

  for (const auto & bnode : bnd_nodes)
  {
    const BoundaryID boundary_id = bnode->_bnd_id;
    const Node * node_ptr = bnode->_node;

    // Make sure node is on a boundary chosen for contact mechanics
    auto it = std::find(_automatic_pairing_boundaries_id.begin(),
                        _automatic_pairing_boundaries_id.end(),
                        boundary_id);

    if (it != _automatic_pairing_boundaries_id.end())
      node_boundary_id_vector.emplace_back(node_ptr, boundary_id);
  }

  // sort by increasing boundary id
  std::sort(node_boundary_id_vector.begin(),
            node_boundary_id_vector.end(),
            [](const NodeBoundaryIDInfo & first_pair, const NodeBoundaryIDInfo & second_pair)
            { return first_pair.second < second_pair.second; });

  // build kd-tree
  using KDTreeType = nanoflann::KDTreeSingleIndexAdaptor<
      nanoflann::L2_Simple_Adaptor<Real, PointListAdaptor<NodeBoundaryIDInfo>, Real, std::size_t>,
      PointListAdaptor<NodeBoundaryIDInfo>,
      LIBMESH_DIM,
      std::size_t>;

  // This parameter can be tuned. Others use '10'
  const unsigned int max_leaf_size = 20;

  // Build point list adaptor with all nodes-sidesets pairs for possible mechanical contact
  auto point_list = PointListAdaptor<NodeBoundaryIDInfo>(node_boundary_id_vector.begin(),
                                                         node_boundary_id_vector.end());
  auto kd_tree = std::make_unique<KDTreeType>(
      LIBMESH_DIM, point_list, nanoflann::KDTreeSingleIndexAdaptorParams(max_leaf_size));

  if (!kd_tree)
    mooseError("Internal error. KDTree was not properly initialized in the contact action.");

  kd_tree->buildIndex();

  // data structures for kd-tree search
  nanoflann::SearchParameters search_params;
  std::vector<nanoflann::ResultItem<std::size_t, Real>> ret_matches;

  const auto radius_for_search = getParam<Real>("automatic_pairing_distance");

  // For all nodes
  for (const auto & pair : node_boundary_id_vector)
  {
    // clear result buffer
    ret_matches.clear();

    // position where we expect a periodic partner for the current node and boundary
    const Point search_point = *pair.first;

    // search at the expected point
    kd_tree->radiusSearch(
        &(search_point)(0), radius_for_search * radius_for_search, ret_matches, search_params);

    for (auto & match_pair : ret_matches)
    {
      const auto & match = node_boundary_id_vector[match_pair.first];

      //
      // If the proximity node identified belongs to a boundary in the input, add boundary pair
      //

      // Make sure node is on a boundary chosen for contact mechanics
      auto it = std::find(_automatic_pairing_boundaries_id.begin(),
                          _automatic_pairing_boundaries_id.end(),
                          match.second);

      // If nodes are on the same boundary, pass.
      if (match.second == pair.second)
        continue;

      // At this point we will likely create many repeated pairs because many nodal pairs may
      // fulfill the distance condition imposed by the automatic_pairing_distance user input
      // parameter.
      if (it != _automatic_pairing_boundaries_id.end())
      {
        const auto index_one = cast_int<int>(it - _automatic_pairing_boundaries_id.begin());
        auto it_other = std::find(_automatic_pairing_boundaries_id.begin(),
                                  _automatic_pairing_boundaries_id.end(),
                                  pair.second);

        mooseAssert(it_other != _automatic_pairing_boundaries_id.end(),
                    "Error in contact action. Unable to find boundary ID for node proximity "
                    "automatic pairing.");

        const auto index_two = cast_int<int>(it_other - _automatic_pairing_boundaries_id.begin());

        if (pair.second > match.second)
          _boundary_pairs.push_back(
              {_automatic_pairing_boundaries[index_two], _automatic_pairing_boundaries[index_one]});
        else
          _boundary_pairs.push_back(
              {_automatic_pairing_boundaries[index_one], _automatic_pairing_boundaries[index_two]});
      }
    }
  }

  // Let's remove likely repeated pairs
  removeRepeatedPairs();

  mooseInfo(
      "The following boundary pairs were created by the contact action using nodal proximity: ");
  for (const auto & [primary, secondary] : _boundary_pairs)
    mooseInfoRepeated(
        "Primary boundary ID: ", primary, " and secondary boundary ID: ", secondary, ".");
}

getFormulationEnum()

MooseEnum ContactAction::getFormulationEnum ( )

static

Get contact formulation.

Returns

enum

Definition at line 1660 of file ContactAction.C.

Referenced by commonParameters().

{
  auto formulations = MooseEnum(getContactFormulationOptions(), "kinematic");

  formulations.addDocumentation(
      "ranfs",
      "Reduced Active Nonlinear Function Set scheme for node-on-face contact. Provides exact "
      "enforcement without Lagrange multipliers or penalty terms.");
  formulations.addDocumentation(
      "kinematic",
      "Kinematic contact constraint enforcement transfers the internal forces at secondary nodes "
      "to the corresponding primary face for node-on-face contact. Provides exact "
      "enforcement without Lagrange multipliers or penalty terms.");
  formulations.addDocumentation(
      "penalty",
      "Node-on-face penalty based contact constraint enforcement. Interpenetration is penalized. "
      "Enforcement depends on the penalty magnitude. High penalties can introduce ill conditioning "
      "of the system.");
  formulations.addDocumentation("augmented_lagrange",
                                "Node-on-face augmented Lagrange penalty based contact constraint "
                                "enforcement. Interpenetration is enforced up to a user specified "
                                "tolerance, ill-conditioning is generally avoided. Requires an "
                                "Augmented Lagrange Problem class to be used in the simulation.");
  formulations.addDocumentation(
      "tangential_penalty",
      "Node-on-face penalty based frictional contact constraint enforcement. Interpenetration and "
      "slip distance for sticking nodes are penalized. Enforcement depends on the penalty "
      "magnitudes. High penalties can introduce ill conditioning of the system.");
  formulations.addDocumentation(
      "mortar",
      "Mortar based contact constraint enforcement using Lagrange multipliers. Provides exact "
      "enforcement and a variationally consistent formulation. Lagrange multipliers introduce a "
      "saddle point character in the system matrix which can have a negative impact on scalability "
      "with iterative solvers");
  formulations.addDocumentation(
      "mortar_penalty",
      "Mortar and penalty based contact constraint enforcement. When using an Augmented Lagrange "
      "Problem class this provides normal (and tangential) contact constratint enforced up to a "
      "user specified tolerances. Without AL the enforcement depends on the penalty magnitudes. "
      "High penalties can introduce ill conditioning of the system.");

  return formulations;
}

getModelEnum()

MooseEnum ContactAction::getModelEnum ( )

static

Get contact model.

Returns

enum

Definition at line 1648 of file ContactAction.C.

Referenced by commonParameters(), and validParams().

{
  return MooseEnum(getContactModelOptions(), "frictionless");
}

getProximityMethod()

MooseEnum ContactAction::getProximityMethod ( )

static

Get proximity method for automatic pairing.

Returns

enum

Definition at line 1654 of file ContactAction.C.

Referenced by validParams().

{
  return MooseEnum(getProximityMethodOptions());
}

getSmoothingEnum()

MooseEnum ContactAction::getSmoothingEnum ( )

static

Get smoothing type.

Returns

enum

Definition at line 1711 of file ContactAction.C.

Referenced by commonParameters().

{
  return MooseEnum("edge_based nodal_normal_based", "");
}

getSystemEnum()

MooseEnum ContactAction::getSystemEnum ( )

static

Get contact system.

Returns

enum

Definition at line 1705 of file ContactAction.C.

{
  return MooseEnum("Constraint", "Constraint");
}

removeRepeatedPairs()

void ContactAction::removeRepeatedPairs ( )

private

Remove repeated contact pairs from _boundary_pairs.

Definition at line 476 of file ContactAction.C.

Referenced by ContactAction(), createSidesetPairsFromGeometry(), and createSidesetsFromNodeProximity().

{
  if (_boundary_pairs.size() == 0 && _automatic_pairing_boundaries.size() == 0)
    paramError(
        "primary",
        "Number of contact pairs in the contact action is zero. Please revise your input file.");

  // Remove repeated interactions
  std::vector<std::pair<BoundaryName, BoundaryName>> lean_boundary_pairs;

  for (const auto & [primary, secondary] : _boundary_pairs)
  {
    // Structured bindings are not capturable (primary_copy, secondary_copy)
    auto it = std::find_if(lean_boundary_pairs.begin(),
                           lean_boundary_pairs.end(),
                           [&, primary_copy = primary, secondary_copy = secondary](
                               const std::pair<BoundaryName, BoundaryName> & lean_pair)
                           {
                             const bool match_one = lean_pair.second == secondary_copy &&
                                                    lean_pair.first == primary_copy;
                             const bool match_two = lean_pair.second == primary_copy &&
                                                    lean_pair.first == secondary_copy;
                             const bool exist = match_one || match_two;
                             return exist;
                           });

    if (it == lean_boundary_pairs.end())
      lean_boundary_pairs.emplace_back(primary, secondary);
    else
      mooseInfo("Contact pair ",
                primary,
                "--",
                secondary,
                " has been removed from the contact interaction list due to "
                "duplicates in the input file.");
  }

  _boundary_pairs = lean_boundary_pairs;
}

validParams()

InputParameters ContactAction::validParams ( )

static

Definition at line 72 of file ContactAction.C.

{
  InputParameters params = Action::validParams();
  params += ContactAction::commonParameters();

  params.addParam<std::vector<BoundaryName>>(
      "primary", "The list of boundary IDs referring to primary sidesets");
  params.addParam<std::vector<BoundaryName>>(
      "secondary", "The list of boundary IDs referring to secondary sidesets");
  params.addParam<std::vector<BoundaryName>>(
      "automatic_pairing_boundaries",
      {},
      "List of boundary IDs for sidesets that are automatically paired with any other boundary in "
      "this list having a centroid-to-centroid distance less than the value specified in the "
      "'automatic_pairing_distance' parameter. ");
  params.addRangeCheckedParam<Real>(
      "automatic_pairing_distance",
      "automatic_pairing_distance>=0",
      "The maximum distance the centroids of the boundaries provided in the "
      "'automatic_pairing_boundaries' parameter can be to generate a contact pair automatically. "
      "Due to numerical error in the determination of the centroids, it is encouraged that "
      "the user adds a tolerance to this distance (e.g. extra 10%) to make sure no suitable "
      "contact pair is missed. If the 'automatic_pairing_method = NODE' option is chosen instead, "
      "this distance is recommended to be set to at least twice the minimum distance between "
      "nodes of boundaries to be paired.");
  params.addDeprecatedParam<MeshGeneratorName>(
      "mesh",
      "The mesh generator for mortar method",
      "This parameter is not used anymore and can simply be removed");
  params.addParam<VariableName>("secondary_gap_offset",
                                "Offset to gap distance from secondary side");
  params.addParam<VariableName>("mapped_primary_gap_offset",
                                "Offset to gap distance mapped from primary side");
  params.addParam<std::vector<VariableName>>(
      "displacements",
      {},
      "The displacements appropriate for the simulation geometry and coordinate system");
  params.addParam<Real>(
      "penalty",
      1e8,
      "The penalty to apply.  This can vary depending on the stiffness of your materials");
  params.addParam<Real>(
      "penalty_friction",
      1e8,
      "The penalty factor to apply in mortar penalty frictional constraints.  It is applied to the "
      "tangential accumulated slip to build the frictional force");
  params.addRangeCheckedParam<Real>(
      "penalty_multiplier",
      1.0,
      "penalty_multiplier > 0",
      "The growth factor for the penalty applied at the end of each augmented "
      "Lagrange update iteration (a value larger than one, e.g., 10, tends to speed up "
      "convergence.)");
  params.addRangeCheckedParam<Real>(
      "penalty_multiplier_friction",
      1.0,
      "penalty_multiplier_friction > 0",
      "The penalty growth factor between augmented Lagrange "
      "iterations for penalizing relative slip distance if the node is under stick conditions.(a "
      "value larger than one, e.g., 10, tends to speed up convergence.)");
  params.addParam<Real>("friction_coefficient", 0, "The friction coefficient");
  params.addParam<Real>("tension_release",
                        0.0,
                        "Tension release threshold.  A node in contact "
                        "will not be released if its tensile load is below "
                        "this value.  No tension release if negative.");
  params.addParam<MooseEnum>("model", ContactAction::getModelEnum(), "The contact model to use");
  params.addParam<Real>("tangential_tolerance",
                        "Tangential distance to extend edges of contact surfaces");
  params.addParam<Real>("capture_tolerance",
                        0.0,
                        "Normal distance from surface within which nodes are captured. This "
                        "parameter is used for node-face and mortar formulations.");
  params.addParam<Real>(
      "normal_smoothing_distance",
      "Distance from edge in parametric coordinates over which to smooth contact normal");

  params.addParam<bool>("normalize_penalty",
                        false,
                        "Whether to normalize the penalty parameter with the nodal area.");
  params.addParam<bool>(
      "primary_secondary_jacobian",
      true,
      "Whether to include Jacobian entries coupling primary and secondary nodes.");
  params.addParam<bool>(
      "ghost_whole_interface",
      false,
      "Whether to geometrically and algebraically ghost the entire primary side of the interface "
      "for node-face contact constraints.");
  params.addParam<Real>("al_penetration_tolerance",
                        "The tolerance of the penetration for augmented Lagrangian method.");
  params.addParam<Real>("al_incremental_slip_tolerance",
                        "The tolerance of the incremental slip for augmented Lagrangian method.");
  params.addRangeCheckedParam<Real>(
      "max_penalty_multiplier",
      1.0e3,
      "max_penalty_multiplier >= 1.0",
      "Maximum multiplier applied to penalty factors when adaptivity is used in an augmented "
      "Lagrange setting. The penalty factor supplied by the user is used as a reference to "
      "determine its maximum. If this multiplier is too large, the condition number of the system "
      "to be solved may be negatively impacted.");
  MooseEnum adaptivity_penalty_normal("SIMPLE BUSSETTA", "SIMPLE");
  adaptivity_penalty_normal.addDocumentation(
      "SIMPLE", "Keep multiplying by the penalty multiplier between AL iterations");
  adaptivity_penalty_normal.addDocumentation(
      "BUSSETTA",
      "Modify the penalty using an algorithm from Bussetta et al, 2012, Comput Mech 49:259-275 "
      "between AL iterations.");
  params.addParam<MooseEnum>(
      "adaptivity_penalty_normal",
      adaptivity_penalty_normal,
      "The augmented Lagrange update strategy used on the normal penalty coefficient.");
  MooseEnum adaptivity_penalty_friction("SIMPLE FRICTION_LIMIT", "FRICTION_LIMIT");
  adaptivity_penalty_friction.addDocumentation(
      "SIMPLE", "Keep multiplying by the frictional penalty multiplier between AL iterations");
  adaptivity_penalty_friction.addDocumentation(
      "FRICTION_LIMIT",
      "This strategy will be guided by the Coulomb limit and be less reliant on the initial "
      "penalty factor provided by the user.");
  params.addParam<MooseEnum>(
      "adaptivity_penalty_friction",
      adaptivity_penalty_friction,
      "The augmented Lagrange update strategy used on the frictional penalty coefficient.");
  params.addParam<Real>("al_frictional_force_tolerance",
                        "The tolerance of the frictional force for augmented Lagrangian method.");
  params.addParam<Real>(
      "c_normal",
      1e6,
      "Parameter for balancing the size of the gap and contact pressure for a mortar formulation. "
      "This purely numerical "
      "parameter affects convergence behavior and, in general, should be larger for stiffer "
      "materials. It is recommended that the user tries out various orders of magnitude for this "
      "parameter if the default value generates poor contact convergence.");
  params.addParam<Real>(
      "c_tangential", 1, "Numerical parameter for nonlinear mortar frictional constraints");
  params.addParam<bool>("ping_pong_protection",
                        false,
                        "Whether to protect against ping-ponging, e.g. the oscillation of the "
                        "secondary node between two "
                        "different primary faces, by tying the secondary node to the "
                        "edge between the involved primary faces");
  params.addParam<Real>(
      "normal_lm_scaling",
      1.,
      "Scaling factor to apply to the normal LM variable for a mortar formulation");
  params.addParam<Real>(
      "tangential_lm_scaling",
      1.,
      "Scaling factor to apply to the tangential LM variable for a mortar formulation");
  params.addParam<bool>(
      "normalize_c",
      false,
      "Whether to normalize c by weighting function norm for mortar contact. When unnormalized "
      "the value of c effectively depends on element size since in the constraint we compare nodal "
      "Lagrange Multiplier values to integrated gap values (LM nodal value is independent of "
      "element size, where integrated values are dependent on element size).");
  params.addClassDescription("Sets up all objects needed for mechanical contact enforcement");
  params.addParam<bool>(
      "use_dual",
      "Whether to use the dual mortar approach within a mortar formulation. It is defaulted to "
      "true for "
      "weighted quantity approach, and to false for the legacy approach. To avoid instabilities "
      "in the solution and obtain the full benefits of a variational enforcement,"
      "use of dual mortar with weighted constraints is strongly recommended. This "
      "input is only intended for advanced users.");
  params.addParam<bool>(
      "correct_edge_dropping",
      false,
      "Whether to enable correct edge dropping treatment for mortar constraints. When disabled "
      "any Lagrange Multiplier degree of freedom on a secondary element without full primary "
      "contributions will be set (strongly) to 0.");
  params.addParam<bool>(
      "generate_mortar_mesh",
      true,
      "Whether to generate the mortar mesh from the action. Typically this will be the case, but "
      "one may also want to reuse an existing lower-dimensional mesh prior to a restart.");
  params.addParam<MooseEnum>("automatic_pairing_method",
                             ContactAction::getProximityMethod(),
                             "The proximity method used for automatic pairing of boundaries.");
  params.addParam<bool>(
      "mortar_dynamics",
      false,
      "Whether to use constraints that account for the persistency condition, giving rise to "
      "smoother normal contact pressure evolution. This flag should only be set to yes for dynamic "
      "simulations using the Newmark-beta numerical integrator");
  params.addParam<Real>(
      "newmark_beta",
      0.25,
      "Newmark-beta beta parameter for its inclusion in the weighted gap update formula");
  params.addParam<Real>(
      "newmark_gamma",
      0.5,
      "Newmark-beta gamma parameter for its inclusion in the weighted gap update formula");
  params.addCoupledVar("wear_depth",
                       "The name of the mortar auxiliary variable that is used to modify the "
                       "weighted gap definition");
  params.addParam<std::vector<TagName>>(
      "extra_vector_tags",
      "The tag names for extra vectors that residual data should be saved into");
  params.addParam<std::vector<TagName>>(
      "absolute_value_vector_tags",
      "The tags for the vectors this residual object should fill with the "
      "absolute value of the residual contribution");
  params.addParam<bool>(
      "use_petrov_galerkin",
      false,
      "Whether to use the Petrov-Galerkin approach for the mortar-based constraints. If set to "
      "true, we use the standard basis as the test function and dual basis as "
      "the shape function for the interpolation of the Lagrange multiplier variable.");
  params.addParam<bool>(
      "debug_mesh",
      false,
      "Whether we are going to enable mortar segment mesh debug information. An exodus"
      "file will be generated if the user sets this flag to true");
  params.transferParam<MooseEnum>(MortarConstraintBase::validParams(), "segment_quadrature");

  // Contact surface definition
  params.addParamNamesToGroup("primary secondary displacements", "Contact Surface Definition");
  // Automatic pairing
  params.addParamNamesToGroup(
      "automatic_pairing_boundaries automatic_pairing_distance automatic_pairing_method",
      "Automatic Contact Pair Generation");
  // Contact formulation and model
  params.addParamNamesToGroup("formulation model", "Contact Formulation");
  // Penalty parameters
  params.addParamNamesToGroup(
      "penalty penalty_friction penalty_multiplier penalty_multiplier_friction "
      "max_penalty_multiplier normalize_penalty",
      "Penalty Parameters");
  // Augmented Lagrange settings
  params.addParamNamesToGroup(
      "al_penetration_tolerance al_incremental_slip_tolerance al_frictional_force_tolerance "
      "adaptivity_penalty_normal adaptivity_penalty_friction",
      "Augmented Lagrange");
  // Friction
  params.addParamNamesToGroup("friction_coefficient tension_release", "Friction");
  // Mortar-specific parameters
  params.addParamNamesToGroup("c_normal c_tangential normal_lm_scaling tangential_lm_scaling "
                              "use_dual correct_edge_dropping normalize_c use_petrov_galerkin "
                              "generate_mortar_mesh segment_quadrature wear_depth debug_mesh",
                              "Mortar");
  // Mortar dynamics (Newmark-beta)
  params.addParamNamesToGroup("mortar_dynamics newmark_beta newmark_gamma", "Mortar Dynamics");
  // Gap and tolerance settings
  params.addParamNamesToGroup(
      "secondary_gap_offset mapped_primary_gap_offset capture_tolerance "
      "tangential_tolerance normal_smoothing_distance normal_smoothing_method",
      "Gap and Tolerance");
  // Jacobian and solver options
  params.addParamNamesToGroup("primary_secondary_jacobian ping_pong_protection", "Solver Options");
  // Interface ghosting
  params.addParamNamesToGroup("ghost_whole_interface", "Interface Ghosting");
  // Residual vector tags
  params.addParamNamesToGroup("extra_vector_tags absolute_value_vector_tags", "Residual Tags");

  return params;
}

Member Data Documentation

_automatic_pairing_boundaries

std::vector<BoundaryName> ContactAction::_automatic_pairing_boundaries

protected

List of all possible boundaries for contact for automatic pairing (optional)

Definition at line 84 of file ContactAction.h.

Referenced by addNodeFaceContact(), ContactAction(), createSidesetPairsFromGeometry(), createSidesetsFromNodeProximity(), and removeRepeatedPairs().

_bnd_pair_to_mortar_info

std::map<std::pair<BoundaryName, BoundaryName>, const MortarInfo> ContactAction::_bnd_pair_to_mortar_info

protected

Map from boundary pair to mortar user object name.

Definition at line 109 of file ContactAction.h.

Referenced by act(), addContactPressureAuxKernel(), and addMortarContact().

_boundary_pairs

std::vector<std::pair<BoundaryName, BoundaryName> > ContactAction::_boundary_pairs

protected

Primary/Secondary boundary name pairs for mechanical contact.

Definition at line 81 of file ContactAction.h.

Referenced by act(), addContactPressureAuxKernel(), addMortarContact(), addNodeFaceContact(), addRelationshipManagers(), ContactAction(), createSidesetPairsFromGeometry(), createSidesetsFromNodeProximity(), and removeRepeatedPairs().

_formulation

const ContactFormulation ContactAction::_formulation

protected

Contact formulation.

Definition at line 90 of file ContactAction.h.

Referenced by act(), addContactPressureAuxKernel(), addMortarContact(), addNodeFaceContact(), addRelationshipManagers(), and ContactAction().

_generate_mortar_mesh

const bool ContactAction::_generate_mortar_mesh

protected

Whether to generate the mortar mesh (useful in a restart simulation e.g.).

Definition at line 96 of file ContactAction.h.

Referenced by addMortarContact().

_model

const ContactModel ContactAction::_model

protected

Contact model type enum.

Definition at line 87 of file ContactAction.h.

Referenced by act(), addMortarContact(), and ContactAction().

_mortar_dynamics

const bool ContactAction::_mortar_dynamics

protected

Whether mortar dynamic contact constraints are to be used.

Definition at line 99 of file ContactAction.h.

Referenced by addMortarContact().

_use_dual

bool ContactAction::_use_dual

protected

Whether to use the dual Mortar approach.

Definition at line 93 of file ContactAction.h.

Referenced by addMortarContact(), and ContactAction().

---

The documentation for this class was generated from the following files:

• contact/include/actions/ContactAction.h
• contact/src/actions/ContactAction.C