RANFSNormalMechanicalContact Class Reference

#include <RANFSNormalMechanicalContact.h>

Inheritance diagram for RANFSNormalMechanicalContact:

Public Member Functions
	RANFSNormalMechanicalContact (const InputParameters &parameters)
bool	shouldApply () override
void	residualSetup () override
void	timestepSetup () override
void	initialSetup () override
bool	overwriteSlaveResidual () override
void	computeSlaveValue (NumericVector< Number > &solution) override

Protected Member Functions
virtual Real	computeQpSlaveValue () override
virtual Real	computeQpResidual (Moose::ConstraintType type) override
virtual Real	computeQpJacobian (Moose::ConstraintJacobianType type) override

Protected Attributes
const MooseEnum	_component
const unsigned int	_mesh_dimension
NumericVector< Number > &	_residual_copy
unsigned int	_largest_component
std::vector< unsigned int >	_vars
std::vector< MooseVariable * >	_var_objects
std::unordered_map< dof_id_type, Real >	_node_to_contact_lm
std::unordered_map< dof_id_type, Real >	_node_to_tied_lm
std::unordered_map< dof_id_type, std::vector< const Elem * > >	_node_to_master_elem_sequence
Real	_contact_lm
Real	_tied_lm
PenetrationInfo *	_pinfo
std::unordered_map< dof_id_type, const Node * >	_ping_pong_slave_node_to_master_node
Real	_distance
bool	_tie_nodes
unsigned int	_master_index
RealVectorValue	_res_vec
const Node *	_nearest_node
std::vector< std::unordered_map< dof_id_type, Number > >	_dof_number_to_value
CouplingMatrix	_disp_coupling

Detailed Description

Definition at line 33 of file RANFSNormalMechanicalContact.h.

Constructor & Destructor Documentation

RANFSNormalMechanicalContact()

RANFSNormalMechanicalContact::RANFSNormalMechanicalContact

(

const InputParameters &

parameters

)

Definition at line 42 of file RANFSNormalMechanicalContact.C.

  : NodeFaceConstraint(parameters),
    _component(getParam<MooseEnum>("component")),
    _mesh_dimension(_mesh.dimension()),
    _residual_copy(_sys.residualGhosted()),
    _dof_number_to_value(coupledComponents("displacements")),
    _disp_coupling(coupledComponents("displacements"))
{
  // modern parameter scheme for displacements
  for (unsigned int i = 0; i < coupledComponents("displacements"); ++i)
  {
    _vars.push_back(coupled("displacements", i));
    _var_objects.push_back(getVar("displacements", i));
  }
 
  for (auto & var : _var_objects)
    if (var->feType().family != LAGRANGE)
      mooseError("This object only works when the displacement variables use a Lagrange basis");
 
  if (_vars.size() != _mesh_dimension)
    mooseError("The number of displacement variables does not match the mesh dimension!");
}

Member Function Documentation

computeQpJacobian()

Real RANFSNormalMechanicalContact::computeQpJacobian ( Moose::ConstraintJacobianType  type )

overrideprotectedvirtual

Definition at line 303 of file RANFSNormalMechanicalContact.C.

{
  switch (type)
  {
    case Moose::ConstraintJacobianType::SlaveSlave:
    {
      if (_tie_nodes)
        return _phi_slave[_j][_qp];
 
      // doing contact
      else
      {
        // corresponds to gap equation
        if (_largest_component == static_cast<unsigned int>(_component))
          // _phi_slave has been set such that it is 1 when _j corresponds to the degree of freedom
          // associated with the _current node and 0 otherwise
          return std::abs(_pinfo->_normal(_component)) * _phi_slave[_j][_qp];
 
        // corresponds to regular residual with Lagrange Multiplier applied
        else
        {
          Real ret_val = 0;
          for (MooseIndex(_disp_coupling) i = 0; i < _disp_coupling.size(); ++i)
            if (_disp_coupling(_component, i))
            {
              mooseAssert(
                  _dof_number_to_value[i].find(_connected_dof_indices[_j]) !=
                      _dof_number_to_value[i].end(),
                  "The connected dof index is not found in the _dof_number_to_value container. "
                  "This must mean that insufficient sparsity was allocated");
              ret_val += -_pinfo->_normal(_component) * _pinfo->_normal(i) *
                         _dof_number_to_value[i][_connected_dof_indices[_j]];
            }
          return ret_val;
        }
      }
    }
 
    case Moose::ConstraintJacobianType::SlaveMaster:
    {
      if (_tie_nodes)
      {
        if (_master_index == _j)
          return -1;
 
        // We're tying the slave node to only one node on the master side (specified by
        // _master_index). If the current _j doesn't correspond to that tied master node, then the
        // slave residual doesn't depend on it
        else
          return 0;
      }
      else
      {
        if (_largest_component == static_cast<unsigned int>(_component))
          return -std::abs(_pinfo->_normal(_component)) * _phi_master[_j][_qp];
 
        // If we're not applying the gap constraint equation on this _component, then we're
        // applying a Lagrange multiplier, and consequently there is no dependence of the slave
        // residual on the master dofs because the Lagrange multiplier is only a functon of the
        // slave residuals
        else
          return 0;
      }
    }
 
    case Moose::ConstraintJacobianType::MasterSlave:
    {
      if (_tie_nodes)
      {
        if (_i == _master_index)
        {
          mooseAssert(_dof_number_to_value[_component].find(_connected_dof_indices[_j]) !=
                          _dof_number_to_value[_component].end(),
                      "The connected dof index is not found in the _dof_number_to_value container. "
                      "This must mean that insufficient sparsity was allocated");
          return _dof_number_to_value[_component][_connected_dof_indices[_j]];
        }
 
        // We only apply the tied node Lagrange multiplier to the closest master node
        else
          return 0;
      }
      else
      {
        Real ret_val = 0;
        for (MooseIndex(_disp_coupling) i = 0; i < _disp_coupling.size(); ++i)
          if (_disp_coupling(_component, i))
          {
            mooseAssert(
                _dof_number_to_value[i].find(_connected_dof_indices[_j]) !=
                    _dof_number_to_value[i].end(),
                "The connected dof index is not found in the _dof_number_to_value container. "
                "This must mean that insufficient sparsity was allocated");
            ret_val += _test_master[_i][_qp] * _pinfo->_normal(_component) * _pinfo->_normal(i) *
                       _dof_number_to_value[i][_connected_dof_indices[_j]];
          }
        return ret_val;
      }
    }
 
      // The only master-master dependence would come from the dependence of the normal and also the
      // location of the integration (quadrature) points. We assume (valid or not) that this
      // dependence is weak
      // case MooseConstraintJacobianType::MasterMaster
 
    default:
      return 0;
  }
}

computeQpResidual()

Real RANFSNormalMechanicalContact::computeQpResidual ( Moose::ConstraintType  type )

overrideprotectedvirtual

Definition at line 259 of file RANFSNormalMechanicalContact.C.

{
  switch (type)
  {
    case Moose::ConstraintType::Slave:
    {
      if (_tie_nodes)
        return (*_current_node - *_nearest_node)(_component);
      else
      {
        if (_largest_component == static_cast<unsigned int>(_component))
        {
          mooseAssert(_pinfo->_normal(_component) != 0,
                      "We should be selecting the largest normal component, hence it should be "
                      "impossible for this normal component to be zero");
 
          return _distance;
        }
 
        else
          // The normal points out of the master face
          return _contact_lm * -_pinfo->_normal(_component);
      }
    }
 
    case Moose::ConstraintType::Master:
    {
      if (_tie_nodes)
      {
        if (_i == _master_index)
          return _tied_lm;
        else
          return 0;
      }
      else
        return _test_master[_i][_qp] * _contact_lm * _pinfo->_normal(_component);
    }
 
    default:
      return 0;
  }
}

computeQpSlaveValue()

Real RANFSNormalMechanicalContact::computeQpSlaveValue ( )

overrideprotectedvirtual

Definition at line 419 of file RANFSNormalMechanicalContact.C.

{
  mooseError("We overrode commputeSlaveValue so computeQpSlaveValue should never get called");
}

computeSlaveValue()

void RANFSNormalMechanicalContact::computeSlaveValue ( NumericVector< Number > &  solution )

override

Definition at line 414 of file RANFSNormalMechanicalContact.C.

{
}

initialSetup()

void RANFSNormalMechanicalContact::initialSetup ( )

override

Definition at line 66 of file RANFSNormalMechanicalContact.C.

{
  auto system_coupling_matrix = _subproblem.couplingMatrix();
 
  for (MooseIndex(_vars) i = 0; i < _vars.size(); ++i)
    for (MooseIndex(_vars) j = 0; j < _vars.size(); ++j)
      _disp_coupling(i, j) = (*system_coupling_matrix)(_vars[i], _vars[j]);
}

overwriteSlaveResidual()

bool RANFSNormalMechanicalContact::overwriteSlaveResidual ( )

override

Definition at line 91 of file RANFSNormalMechanicalContact.C.

{
  if (_tie_nodes)
    return true;
  else
    return _largest_component == static_cast<unsigned int>(_component);
}

residualSetup()

void RANFSNormalMechanicalContact::residualSetup ( )

override

Definition at line 83 of file RANFSNormalMechanicalContact.C.

{
  _node_to_contact_lm.clear();
  _node_to_tied_lm.clear();
  NodeFaceConstraint::residualSetup();
}

shouldApply()

bool RANFSNormalMechanicalContact::shouldApply ( )

override

Definition at line 100 of file RANFSNormalMechanicalContact.C.

{
  std::map<dof_id_type, PenetrationInfo *>::iterator found =
      _penetration_locator._penetration_info.find(_current_node->id());
  if (found != _penetration_locator._penetration_info.end())
  {
    _pinfo = found->second;
    if (_pinfo)
    {
      // We overwrite the slave residual when constraints are active so we cannot use the residual
      // copy for determining the Lagrange multiplier when computing the Jacobian
      if (!_subproblem.currentlyComputingJacobian())
      {
        // Build up residual vector corresponding to contact forces
        _res_vec.zero();
        for (unsigned int i = 0; i < _mesh_dimension; ++i)
        {
          dof_id_type dof_number = _current_node->dof_number(0, _vars[i], 0);
          _res_vec(i) = _residual_copy(dof_number) / _var_objects[i]->scalingFactor();
        }
 
        _node_to_contact_lm.insert(std::make_pair(_current_node->id(), _res_vec * _pinfo->_normal));
        _node_to_tied_lm.insert(std::make_pair(_current_node->id(), _res_vec(_component)));
      }
      else
      {
        std::vector<dof_id_type> cols;
        std::vector<Number> values;
 
        for (auto & d_to_v : _dof_number_to_value)
          d_to_v.clear();
 
        mooseAssert(_vars.size() == _dof_number_to_value.size() &&
                        _vars.size() == _var_objects.size(),
                    "Somehow the sizes of our variable containers got out of sync");
        for (MooseIndex(_var_objects) i = 0; i < _var_objects.size(); ++i)
        {
          auto slave_dof_number = _current_node->dof_number(0, _vars[i], 0);
 
          _jacobian->get_row(slave_dof_number, cols, values);
          mooseAssert(cols.size() == values.size(),
                      "The size of the dof container and value container are different");
 
          for (MooseIndex(cols) j = 0; j < cols.size(); ++j)
            _dof_number_to_value[i].insert(
                std::make_pair(cols[j], values[j] / _var_objects[i]->scalingFactor()));
        }
      }
 
      mooseAssert(_node_to_contact_lm.find(_current_node->id()) != _node_to_contact_lm.end(),
                  "The node " << _current_node->id()
                              << " should map to a contact lagrange multiplier");
      mooseAssert(_node_to_tied_lm.find(_current_node->id()) != _node_to_tied_lm.end(),
                  "The node " << _current_node->id()
                              << " should map to a tied lagrange multiplier");
      _contact_lm = _node_to_contact_lm[_current_node->id()];
      _tied_lm = _node_to_tied_lm[_current_node->id()];
 
      // Check to see whether we've locked a ping-ponging node
      if (_ping_pong_slave_node_to_master_node.find(_current_node->id()) ==
          _ping_pong_slave_node_to_master_node.end())
      {
        if (_contact_lm > -_pinfo->_distance)
        {
          // Ok, our math is telling us we should apply the constraint, but what if we are
          // ping-ponging back and forth between different master faces?
 
          // This only works for a basic line search! Write assertion here
          if (_subproblem.computingNonlinearResid())
          {
            auto & master_elem_sequence = _node_to_master_elem_sequence[_current_node->id()];
            mooseAssert(
                _current_master == _pinfo->_elem,
                "The current master element and the PenetrationInfo object's element should "
                "be the same");
            master_elem_sequence.push_back(_pinfo->_elem);
 
            // 5 here is a heuristic choice. In testing, generally speaking, if a node ping-pongs
            // back and forth 5 times then it will ping pong indefinitely. However, if it goes 3
            // times for example, it is not guaranteed to ping-pong indefinitely and the Newton
            // iteration may naturally resolve the correct face dofs that need to be involved in the
            // constraint.
            if (master_elem_sequence.size() >= 5 &&
                _pinfo->_elem == *(master_elem_sequence.rbegin() + 2) &&
                _pinfo->_elem == *(master_elem_sequence.rbegin() + 4) &&
                _pinfo->_elem != *(master_elem_sequence.rbegin() + 1) &&
                *(master_elem_sequence.rbegin() + 1) == *(master_elem_sequence.rbegin() + 3))
            {
              // Ok we are ping-ponging. Determine the master node
              auto master_node =
                  _penetration_locator._nearest_node.nearestNode(_current_node->id());
 
              // Sanity checks
              mooseAssert(_pinfo->_elem->get_node_index(master_node) != libMesh::invalid_uint,
                          "The master node is not on the current element");
              mooseAssert((*(master_elem_sequence.rbegin() + 1))->get_node_index(master_node) !=
                              libMesh::invalid_uint,
                          "The master node is not on the other ping-ponging element");
 
              _ping_pong_slave_node_to_master_node.insert(
                  std::make_pair(_current_node->id(), master_node));
            }
          }
        }
        else
          // We have not locked the node into contact nor is the gap smaller than the Lagrange
          // Multiplier so we should not apply
          return false;
      }
 
      // Determine whether we're going to apply the tied node equality constraint or the contact
      // inequality constraint
      auto it = _ping_pong_slave_node_to_master_node.find(_current_node->id());
      if (it != _ping_pong_slave_node_to_master_node.end())
      {
        _tie_nodes = true;
        _nearest_node = it->second;
        _master_index = _current_master->get_node_index(_nearest_node);
        mooseAssert(_master_index != libMesh::invalid_uint,
                    "nearest node not a node on the current master element");
      }
      else
      {
        _distance = _pinfo->_distance;
        // Do this to make sure constraint equation has a positive on the diagonal
        if (_pinfo->_normal(_component) > 0)
          _distance *= -1;
        _tie_nodes = false;
 
        // The contact constraint is active -> we're going to use our linear solve to ensure that
        // the gap is driven to zero. We only have one zero-penetration constraint per node, so we
        // choose to apply the zero penetration constraint only to the displacement component with
        // the largest magnitude normal
        auto largest_component_magnitude = std::abs(_pinfo->_normal(0));
        _largest_component = 0;
        for (MooseIndex(_mesh_dimension) i = 1; i < _mesh_dimension; ++i)
        {
          auto component_magnitude = std::abs(_pinfo->_normal(i));
          if (component_magnitude > largest_component_magnitude)
          {
            largest_component_magnitude = component_magnitude;
            _largest_component = i;
          }
        }
      }
 
      return true;
    }
  }
 
  // If we're not applying the constraint then we can clear the node to master elem sequence for
  // this node
  if (_node_to_master_elem_sequence.find(_current_node->id()) !=
      _node_to_master_elem_sequence.end())
    _node_to_master_elem_sequence[_current_node->id()].clear();
  return false;
}

timestepSetup()

void RANFSNormalMechanicalContact::timestepSetup ( )

override

Definition at line 76 of file RANFSNormalMechanicalContact.C.

{
  _node_to_master_elem_sequence.clear();
  _ping_pong_slave_node_to_master_node.clear();
}

Member Data Documentation

_component

const MooseEnum RANFSNormalMechanicalContact::_component

protected

Definition at line 51 of file RANFSNormalMechanicalContact.h.

Referenced by computeQpJacobian(), computeQpResidual(), overwriteSlaveResidual(), and shouldApply().

_contact_lm

Real RANFSNormalMechanicalContact::_contact_lm

protected

Definition at line 61 of file RANFSNormalMechanicalContact.h.

Referenced by computeQpResidual(), and shouldApply().

_disp_coupling

CouplingMatrix RANFSNormalMechanicalContact::_disp_coupling

protected

Definition at line 71 of file RANFSNormalMechanicalContact.h.

Referenced by computeQpJacobian(), and initialSetup().

_distance

Real RANFSNormalMechanicalContact::_distance

protected

Definition at line 65 of file RANFSNormalMechanicalContact.h.

Referenced by computeQpResidual(), and shouldApply().

_dof_number_to_value

std::vector<std::unordered_map<dof_id_type, Number> > RANFSNormalMechanicalContact::_dof_number_to_value

protected

Definition at line 70 of file RANFSNormalMechanicalContact.h.

Referenced by computeQpJacobian(), and shouldApply().

_largest_component

unsigned int RANFSNormalMechanicalContact::_largest_component

protected

Definition at line 55 of file RANFSNormalMechanicalContact.h.

Referenced by computeQpJacobian(), computeQpResidual(), overwriteSlaveResidual(), and shouldApply().

_master_index

unsigned int RANFSNormalMechanicalContact::_master_index

protected

Definition at line 67 of file RANFSNormalMechanicalContact.h.

Referenced by computeQpJacobian(), computeQpResidual(), and shouldApply().

_mesh_dimension

const unsigned int RANFSNormalMechanicalContact::_mesh_dimension

protected

Definition at line 52 of file RANFSNormalMechanicalContact.h.

Referenced by RANFSNormalMechanicalContact(), and shouldApply().

_nearest_node

const Node* RANFSNormalMechanicalContact::_nearest_node

protected

Definition at line 69 of file RANFSNormalMechanicalContact.h.

Referenced by computeQpResidual(), and shouldApply().

_node_to_contact_lm

std::unordered_map<dof_id_type, Real> RANFSNormalMechanicalContact::_node_to_contact_lm

protected

Definition at line 58 of file RANFSNormalMechanicalContact.h.

Referenced by residualSetup(), and shouldApply().

_node_to_master_elem_sequence

std::unordered_map<dof_id_type, std::vector<const Elem *> > RANFSNormalMechanicalContact::_node_to_master_elem_sequence

protected

Definition at line 60 of file RANFSNormalMechanicalContact.h.

Referenced by shouldApply(), and timestepSetup().

_node_to_tied_lm

std::unordered_map<dof_id_type, Real> RANFSNormalMechanicalContact::_node_to_tied_lm

protected

Definition at line 59 of file RANFSNormalMechanicalContact.h.

Referenced by residualSetup(), and shouldApply().

_pinfo

PenetrationInfo* RANFSNormalMechanicalContact::_pinfo

protected

Definition at line 63 of file RANFSNormalMechanicalContact.h.

Referenced by computeQpJacobian(), computeQpResidual(), and shouldApply().

_ping_pong_slave_node_to_master_node

std::unordered_map<dof_id_type, const Node *> RANFSNormalMechanicalContact::_ping_pong_slave_node_to_master_node

protected

Definition at line 64 of file RANFSNormalMechanicalContact.h.

Referenced by shouldApply(), and timestepSetup().

_res_vec

RealVectorValue RANFSNormalMechanicalContact::_res_vec

protected

Definition at line 68 of file RANFSNormalMechanicalContact.h.

Referenced by shouldApply().

_residual_copy

NumericVector<Number>& RANFSNormalMechanicalContact::_residual_copy

protected

Definition at line 53 of file RANFSNormalMechanicalContact.h.

Referenced by shouldApply().

_tie_nodes

bool RANFSNormalMechanicalContact::_tie_nodes

protected

Definition at line 66 of file RANFSNormalMechanicalContact.h.

Referenced by computeQpJacobian(), computeQpResidual(), overwriteSlaveResidual(), and shouldApply().

_tied_lm

Real RANFSNormalMechanicalContact::_tied_lm

protected

Definition at line 62 of file RANFSNormalMechanicalContact.h.

Referenced by computeQpResidual(), and shouldApply().

_var_objects

std::vector<MooseVariable *> RANFSNormalMechanicalContact::_var_objects

protected

Definition at line 57 of file RANFSNormalMechanicalContact.h.

Referenced by RANFSNormalMechanicalContact(), and shouldApply().

_vars

std::vector<unsigned int> RANFSNormalMechanicalContact::_vars

protected

Definition at line 56 of file RANFSNormalMechanicalContact.h.

Referenced by initialSetup(), RANFSNormalMechanicalContact(), and shouldApply().

---

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

• contact/include/constraints/RANFSNormalMechanicalContact.h
• contact/src/constraints/RANFSNormalMechanicalContact.C