PenaltyFrictionUserObject.C

Go to the documentation of this file.

//* This file is part of the MOOSE framework
//* https://mooseframework.inl.gov
//*
//* All rights reserved, see COPYRIGHT for full restrictions
//* https://github.com/idaholab/moose/blob/master/COPYRIGHT
//*
//* Licensed under LGPL 2.1, please see LICENSE for details
//* https://www.gnu.org/licenses/lgpl-2.1.html
 
#include "PenaltyFrictionUserObject.h"
#include "MooseVariableFE.h"
#include "SystemBase.h"
#include "MortarUtils.h"
#include "MooseUtils.h"
#include "MathUtils.h"
#include "MortarContactUtils.h"
#include "ADReal.h"
 
#include <Eigen/Core>
 
registerMooseObject("ContactApp", PenaltyFrictionUserObject);
 
InputParameters
PenaltyFrictionUserObject::validParams()
{
  InputParameters params = WeightedVelocitiesUserObject::validParams();
  params += PenaltyWeightedGapUserObject::validParams();
 
  params.addClassDescription(
      "Computes the mortar frictional contact force via a penalty approach.");
  params.addParam<Real>("penalty_friction",
                        "The penalty factor for frictional interaction. If not provide, the normal "
                        "penalty factor is also used for the frictional problem.");
  params.addRequiredParam<Real>("friction_coefficient",
                                "The friction coefficient ruling Coulomb friction equations.");
  params.addRangeCheckedParam<Real>(
      "slip_tolerance",
      "slip_tolerance > 0",
      "Acceptable slip distance at which augmented Lagrange iterations can be stopped");
  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.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.");
  return params;
}
 
PenaltyFrictionUserObject::PenaltyFrictionUserObject(const InputParameters & parameters)
  /*
   * We are using virtual inheritance to avoid the "Diamond inheritance" problem. This means that
   * that we have to construct WeightedGapUserObject explicitly as it will_not_ be constructed in
   * the intermediate base classes PenaltyWeightedGapUserObject and WeightedVelocitiesUserObject.
   * Virtual inheritance ensures that only one instance of WeightedGapUserObject is included in this
   * class. The inheritance diagram is as follows:
   *
   * WeightedGapUserObject         <-----   PenaltyWeightedGapUserObject
   *          ^                                         ^
   *          |                                         |
   * WeightedVelocitiesUserObject  <-----   PenaltyFrictionUserObject
   *
   */
  : WeightedGapUserObject(parameters),
    PenaltyWeightedGapUserObject(parameters),
    WeightedVelocitiesUserObject(parameters),
    _penalty(getParam<Real>("penalty")),
    _penalty_friction(isParamValid("penalty_friction") ? getParam<Real>("penalty_friction")
                                                       : getParam<Real>("penalty")),
    _slip_tolerance(isParamValid("slip_tolerance") ? getParam<Real>("slip_tolerance") : 0.0),
    _friction_coefficient(getParam<Real>("friction_coefficient")),
    _dof_to_step_slip(
        declareRestartableData<std::unordered_map<dof_id_type, std::pair<TwoVector, TwoVector>>>(
            "dof_to_step_slip")),
    _dof_to_accumulated_slip(
        declareRestartableData<std::unordered_map<dof_id_type, std::pair<TwoVector, TwoVector>>>(
            "dof_to_accumulated_slip")),
    _dof_to_tangential_traction(
        declareRestartableData<std::unordered_map<dof_id_type, std::pair<ADTwoVector, TwoVector>>>(
            "dof_to_tangential_traction")),
    _dof_to_frictional_lagrange_multipliers(
        declareRestartableData<std::unordered_map<dof_id_type, TwoVector>>(
            "dof_to_frictional_lagrange_multipliers")),
    _dof_to_local_penalty_friction(declareRestartableData<std::unordered_map<dof_id_type, Real>>(
        "dof_to_local_penalty_friction")),
    _penalty_multiplier_friction(getParam<Real>("penalty_multiplier_friction")),
    _adaptivity_friction(
        getParam<MooseEnum>("adaptivity_penalty_friction").getEnum<AdaptivityFrictionalPenalty>()),
    _t_step_old_friction(declareRestartableData<int>("t_step_old_friction", 0))
 
{
  if (!_augmented_lagrange_problem == isParamValid("slip_tolerance"))
    paramError("slip_tolerance",
               "This parameter must be supplied if and only if an augmented Lagrange problem "
               "object is used.");
}
 
const VariableTestValue &
PenaltyFrictionUserObject::test() const
{
  return _aux_lm_var ? _aux_lm_var->phiLower() : _disp_x_var->phiLower();
}
 
const ADVariableValue &
PenaltyFrictionUserObject::contactTangentialPressureDirOne() const
{
  return _frictional_contact_traction_one;
}
 
const ADVariableValue &
PenaltyFrictionUserObject::contactTangentialPressureDirTwo() const
{
  return _frictional_contact_traction_two;
}
 
void
PenaltyFrictionUserObject::timestepSetup()
{
  // these functions do not call WeightedGapUserObject::timestepSetup to avoid double initialization
  WeightedVelocitiesUserObject::selfTimestepSetup();
  PenaltyWeightedGapUserObject::selfTimestepSetup();
 
  // instead we call it explicitly here
  WeightedGapUserObject::timestepSetup();
 
  // timestepSetup() runs once per time step attempt, so on a retried timestep (e.g. --test-restep
  // or a rejected step) the maps below hold the discarded attempt's values and keys. Restore the
  // state saved at the start of the first attempt so the retry starts from the accepted state.
  const bool retried_timestep = _fe_problem.timeStep() == _t_step_old_friction;
  _t_step_old_friction = _fe_problem.timeStep();
  if (retried_timestep)
  {
    _dof_to_step_slip = _dof_to_step_slip_start;
    _dof_to_accumulated_slip = _dof_to_accumulated_slip_start;
    _dof_to_tangential_traction = _dof_to_tangential_traction_start;
    _dof_to_frictional_lagrange_multipliers = _dof_to_frictional_lagrange_multipliers_start;
    _dof_to_local_penalty_friction = _dof_to_local_penalty_friction_start;
    return;
  }
 
  // Clear step slip (values used in between AL iterations for penalty adaptivity)
  for (auto & map_pr : _dof_to_step_slip)
  {
    auto & [step_slip, old_step_slip] = map_pr.second;
    old_step_slip = {0.0, 0.0};
    step_slip = {0.0, 0.0};
  }
 
  // save off accumulated slip from the last timestep
  for (auto & map_pr : _dof_to_accumulated_slip)
  {
    auto & [accumulated_slip, old_accumulated_slip] = map_pr.second;
    old_accumulated_slip = accumulated_slip;
  }
 
  for (auto & dof_lp : _dof_to_local_penalty_friction)
    dof_lp.second = _penalty_friction;
 
  // save off tangential traction from the last timestep
  for (auto & map_pr : _dof_to_tangential_traction)
  {
    auto & [tangential_traction, old_tangential_traction] = map_pr.second;
    old_tangential_traction = {MetaPhysicL::raw_value(tangential_traction(0)),
                               MetaPhysicL::raw_value(tangential_traction(1))};
    tangential_traction = {0.0, 0.0};
  }
 
  for (auto & [dof_object, delta_tangential_lm] : _dof_to_frictional_lagrange_multipliers)
    delta_tangential_lm.setZero();
 
  _dof_to_step_slip_start = _dof_to_step_slip;
  _dof_to_accumulated_slip_start = _dof_to_accumulated_slip;
  _dof_to_tangential_traction_start = _dof_to_tangential_traction;
  _dof_to_frictional_lagrange_multipliers_start = _dof_to_frictional_lagrange_multipliers;
  _dof_to_local_penalty_friction_start = _dof_to_local_penalty_friction;
}
 
void
PenaltyFrictionUserObject::initialize()
{
  // these functions do not call WeightedGapUserObject::initialize to avoid double initialization
  WeightedVelocitiesUserObject::selfInitialize();
  PenaltyWeightedGapUserObject::selfInitialize();
 
  // instead we call it explicitly here
  WeightedGapUserObject::initialize();
}
 
Real
PenaltyFrictionUserObject::getFrictionalContactPressure(const Node * const node,
                                                        const unsigned int component) const
{
  const auto it = _dof_to_tangential_traction.find(node->id());
 
  if (it != _dof_to_tangential_traction.end())
    return MetaPhysicL::raw_value(it->second.first(component));
  else
    return 0.0;
}
 
Real
PenaltyFrictionUserObject::getAccumulatedSlip(const Node * const node,
                                              const unsigned int component) const
{
  const auto it = _dof_to_accumulated_slip.find(node->id());
 
  if (it != _dof_to_accumulated_slip.end())
    return MetaPhysicL::raw_value(it->second.first(component));
  else
    return 0.0;
}
 
Real
PenaltyFrictionUserObject::getTangentialVelocity(const Node * const node,
                                                 const unsigned int component) const
{
  const auto it = _dof_to_real_tangential_velocity.find(_subproblem.mesh().nodePtr(node->id()));
 
  if (it != _dof_to_real_tangential_velocity.end())
    return MetaPhysicL::raw_value(it->second[component]);
  else
    return 0.0;
}
 
Real
PenaltyFrictionUserObject::getDeltaTangentialLagrangeMultiplier(const Node * const node,
                                                                const unsigned int component) const
{
  const auto it = _dof_to_frictional_lagrange_multipliers.find(node->id());
 
  if (it != _dof_to_frictional_lagrange_multipliers.end())
    return MetaPhysicL::raw_value(it->second[component]);
  else
    return 0.0;
}
 
ADReal
PenaltyFrictionUserObject::nodalTangentialPressure(const Node & node,
                                                   const unsigned int direction) const
{
  mooseAssert(direction < 2, "There are at most two tangent directions.");
  return libmesh_map_find(_dof_to_tangential_traction, node.id()).first(direction);
}
 
void
PenaltyFrictionUserObject::reinit()
{
  // Normal contact pressure with penalty
  PenaltyWeightedGapUserObject::reinit();
 
  // Reset frictional pressure
  _frictional_contact_traction_one.resize(_qrule_msm->n_points());
  _frictional_contact_traction_two.resize(_qrule_msm->n_points()); // 3D
  for (const auto qp : make_range(_qrule_msm->n_points()))
  {
    _frictional_contact_traction_one[qp] = 0.0;
    _frictional_contact_traction_two[qp] = 0.0;
  }
 
  // zero vector
  const static TwoVector zero{0.0, 0.0};
 
  // iterate over nodes
  for (const auto i : make_range(_test->size()))
  {
    // current node
    const Node * const node = _lower_secondary_elem->node_ptr(i);
 
    const auto penalty_friction =
        findValue(_dof_to_local_penalty_friction, node->id(), _penalty_friction);
 
    // utilized quantities
    const auto & normal_pressure = _dof_to_normal_pressure[node];
 
    // map the tangential traction and accumulated slip
    auto & [tangential_traction, old_tangential_traction] = _dof_to_tangential_traction[node->id()];
    auto & [accumulated_slip, old_accumulated_slip] = _dof_to_accumulated_slip[node->id()];
 
    Real normal_lm = -1;
    if (_dof_to_lagrange_multiplier.find(node->id()) != _dof_to_lagrange_multiplier.end())
      normal_lm = libmesh_map_find(_dof_to_lagrange_multiplier, node->id());
 
    // Keep active set fixed from second Uzawa loop
    if (normal_lm < -TOLERANCE && normal_pressure > TOLERANCE)
    {
      const auto & real_tangential_velocity =
          libmesh_map_find(_dof_to_real_tangential_velocity, node);
      const ADTwoVector slip_distance = {real_tangential_velocity[0] * _dt,
                                         real_tangential_velocity[1] * _dt};
 
      // frictional lagrange multiplier (delta lambda^(k)_T)
      const auto & tangential_lm =
          _augmented_lagrange_problem ? _dof_to_frictional_lagrange_multipliers[node->id()] : zero;
 
      // tangential trial traction (Simo 3.12)
      ADTwoVector tangential_trial_traction =
          old_tangential_traction + tangential_lm + penalty_friction * slip_distance;
 
      // Nonlinearity below
      ADReal tangential_trial_traction_norm = tangential_trial_traction.norm();
      ADReal phi_trial = tangential_trial_traction_norm - _friction_coefficient * normal_pressure;
      tangential_traction = tangential_trial_traction;
 
      // Simo considers this a 'return mapping'; we are just capping friction to the Coulomb limit.
      if (phi_trial > 0.0)
        // Simo 3.13/3.14 (the penalty formulation has an error in the paper)
        tangential_traction -=
            phi_trial * tangential_trial_traction / tangential_trial_traction_norm;
 
      // track accumulated slip for output purposes
      accumulated_slip = old_accumulated_slip + MetaPhysicL::raw_value(slip_distance).cwiseAbs();
 
      // Keep track of slip vector for adaptive penalty
      auto & [step_slip, old_step_slip] = _dof_to_step_slip[node->id()];
      step_slip = MetaPhysicL::raw_value(slip_distance);
    }
    else
    {
      // reset slip and clear traction
      accumulated_slip.setZero();
      tangential_traction.setZero();
    }
 
    // Now that we have consistent nodal frictional values, create an interpolated frictional
    // pressure variable.
    const auto & test_i = (*_test)[i];
    for (const auto qp : make_range(_qrule_msm->n_points()))
    {
      _frictional_contact_traction_one[qp] += test_i[qp] * tangential_traction(0);
      _frictional_contact_traction_two[qp] += test_i[qp] * tangential_traction(1);
    }
  }
}
 
void
PenaltyFrictionUserObject::finalize()
{
  WeightedVelocitiesUserObject::finalize();
  PenaltyWeightedGapUserObject::selfFinalize();
}
 
bool
PenaltyFrictionUserObject::isAugmentedLagrangianConverged()
{
  // save off step slip
  // This method is called at the beginning of the AL iteration.
  for (auto & map_pr : _dof_to_step_slip)
  {
    auto & [step_slip, old_step_slip] = map_pr.second;
    old_step_slip = step_slip;
  }
 
  std::pair<Real, dof_id_type> max_slip{0.0, 0};
 
  for (const auto & [node_id, traction_pair] : _dof_to_tangential_traction)
  {
    const DofObject * const dof_object = _subproblem.mesh().nodePtr(node_id);
    const auto & tangential_traction = traction_pair.first;
    auto normal_pressure = _dof_to_normal_pressure[dof_object];
 
    // We may not find a node in the map because AL machinery gets called at different system
    // configurations. That is, we may want to find a key from a node that computed a zero traction
    // on the verge of not projecting. Since, when we computed the velocity, the system was at a
    // slightly different configuration, that node may not a computed physical weighted velocity.
    // This doesn't seem an issue at all as non-projecting nodes should be a corner case not
    // affecting the physics.
    TwoVector slip_velocity = {0.0, 0.0};
    if (_dof_to_real_tangential_velocity.find(dof_object) != _dof_to_real_tangential_velocity.end())
    {
      const auto & real_tangential_velocity =
          libmesh_map_find(_dof_to_real_tangential_velocity, dof_object);
      slip_velocity = {MetaPhysicL::raw_value(real_tangential_velocity[0]),
                       MetaPhysicL::raw_value(real_tangential_velocity[1])};
    }
 
    // Check slip/stick
    if (_friction_coefficient * normal_pressure < tangential_traction.norm() * (1 + TOLERANCE))
    {
      // If it's slipping, any slip distance is physical.
    }
    else if (slip_velocity.norm() * _dt > _slip_tolerance && normal_pressure > TOLERANCE)
    {
      const auto new_slip =
          std::make_pair<Real, dof_id_type>(slip_velocity.norm() * _dt, dof_object->id());
      if (new_slip > max_slip)
        max_slip = new_slip;
    }
  }
 
  // Communicate max_slip here where all ranks get to
  this->_communicator.max(max_slip);
 
  // Check normal contact convergence now, to make sure all ranks get here
  if (!PenaltyWeightedGapUserObject::isAugmentedLagrangianConverged())
    return false;
 
  // Did we observe any above tolerance slip anywhere?
  if (max_slip.first > _slip_tolerance)
  {
    if (this->_communicator.rank() == 0)
    {
      mooseInfoRepeated("Stick tolerance fails. Slip distance for sticking node ",
                        max_slip.second,
                        " is: ",
                        max_slip.first,
                        ", but slip tolerance is chosen to be ",
                        _slip_tolerance);
    }
    return false;
  }
 
  return true;
}
 
void
PenaltyFrictionUserObject::updateAugmentedLagrangianMultipliers()
{
  using std::abs;
 
  PenaltyWeightedGapUserObject::updateAugmentedLagrangianMultipliers();
 
  for (auto & [node_id, tangential_lm] : _dof_to_frictional_lagrange_multipliers)
  {
    const DofObject * const dof_object = _subproblem.mesh().nodePtr(node_id);
    auto & penalty_friction = _dof_to_local_penalty_friction[node_id];
    if (penalty_friction == 0.0)
      penalty_friction = _penalty_friction;
 
    // normal quantities
    const auto & normal_lm = libmesh_map_find(_dof_to_lagrange_multiplier, node_id);
 
    // tangential quantities
    const auto & real_tangential_velocity =
        libmesh_map_find(_dof_to_real_tangential_velocity, dof_object);
    const TwoVector slip_velocity = {MetaPhysicL::raw_value(real_tangential_velocity[0]),
                                     MetaPhysicL::raw_value(real_tangential_velocity[1])};
 
    auto & [tangential_traction, old_tangential_traction] = _dof_to_tangential_traction[node_id];
 
    const TwoVector tangential_trial_traction =
        old_tangential_traction + tangential_lm + penalty_friction * slip_velocity * _dt;
    const Real tangential_trial_traction_norm = tangential_trial_traction.norm();
 
    // Augment
    if (tangential_trial_traction_norm * (1 + TOLERANCE) <= abs(_friction_coefficient * normal_lm))
    {
      tangential_lm += penalty_friction * slip_velocity * _dt;
    }
    else
    {
      // Project the total tangential traction onto the Coulomb cone
      tangential_lm = tangential_trial_traction / tangential_trial_traction_norm *
                          abs(_friction_coefficient * normal_lm) -
                      old_tangential_traction;
    }
 
    // Update penalty.
    if (_adaptivity_friction == AdaptivityFrictionalPenalty::SIMPLE)
    {
      if (_slip_tolerance < _dt * slip_velocity.norm())
        penalty_friction *= _penalty_multiplier_friction;
 
      // Provide the user the ability of setting this maximum penalty
      if (penalty_friction > _penalty_friction * _max_penalty_multiplier)
        penalty_friction = _penalty_friction * _max_penalty_multiplier;
    }
    else if (_adaptivity_friction == AdaptivityFrictionalPenalty::FRICTION_LIMIT)
    {
      const auto & step_slip = libmesh_map_find(_dof_to_step_slip, node_id);
      // No change of direction: Adjust penalty factor for the frictional problem
      if (step_slip.first.dot(step_slip.second) > 0.0 && abs(normal_lm) > TOLERANCE &&
          _slip_tolerance < _dt * slip_velocity.norm())
      {
        penalty_friction =
            (_friction_coefficient * abs(normal_lm)) / 2 / (_dt * slip_velocity.norm());
        // Alternative: accumulated_slip.norm() - old_accumulated_slip.norm()
      }
      // Change of direction: Reduce penalty factor to avoid lack of convergence
      else if (step_slip.first.dot(step_slip.second) < 0.0)
        penalty_friction /= 2.0;
 
      // Heuristics to bound the penalty factor
      if (penalty_friction < _penalty_friction)
        penalty_friction = _penalty_friction;
      else if (penalty_friction > _penalty_friction * _max_penalty_multiplier)
        penalty_friction = _penalty_friction * _max_penalty_multiplier;
    }
  }
}