MultiDContactConstraint Class Reference

A MultiDContactConstraint forces the value of a variable to be the same on both sides of an interface. More...

#include <MultiDContactConstraint.h>

Inheritance diagram for MultiDContactConstraint:

Public Member Functions
	MultiDContactConstraint (const InputParameters &parameters)
virtual	~MultiDContactConstraint ()
virtual void	timestepSetup ()
virtual void	jacobianSetup ()
virtual void	updateContactSet ()
virtual Real	computeQpSlaveValue ()
virtual Real	computeQpResidual (Moose::ConstraintType type)
virtual Real	computeQpJacobian (Moose::ConstraintJacobianType type)
bool	shouldApply ()

Protected Attributes
NumericVector< Number > &	_residual_copy
bool	_jacobian_update
const unsigned int	_component
const ContactModel	_model
Real	_penalty
unsigned int	_x_var
unsigned int	_y_var
unsigned int	_z_var
const unsigned int	_mesh_dimension
std::vector< unsigned int >	_vars

Detailed Description

A MultiDContactConstraint forces the value of a variable to be the same on both sides of an interface.

Definition at line 27 of file MultiDContactConstraint.h.

Constructor & Destructor Documentation

MultiDContactConstraint()

MultiDContactConstraint::MultiDContactConstraint

(

const InputParameters &

parameters

)

Definition at line 58 of file MultiDContactConstraint.C.

  : NodeFaceConstraint(parameters),
    _residual_copy(_sys.residualGhosted()),
    _jacobian_update(getParam<bool>("jacobian_update")),
    _component(getParam<unsigned int>("component")),
    _model(getParam<MooseEnum>("model").getEnum<ContactModel>()),
    _penalty(getParam<Real>("penalty")),
    _mesh_dimension(_mesh.dimension()),
    _vars(3, libMesh::invalid_uint)
{
  _overwrite_slave_residual = false;
 
  if (isParamValid("displacements"))
  {
    // modern parameter scheme for displacements
    for (unsigned int i = 0; i < coupledComponents("displacements"); ++i)
      _vars[i] = coupled("displacements", i);
  }
  else
  {
    // Legacy parameter scheme for displacements
    if (isParamValid("disp_x"))
      _vars[0] = coupled("disp_x");
    if (isParamValid("disp_y"))
      _vars[1] = coupled("disp_y");
    if (isParamValid("disp_z"))
      _vars[2] = coupled("disp_z");
 
    mooseDeprecated("use the `displacements` parameter rather than the `disp_*` parameters (those "
                    "will go away with the deprecation of the Solid Mechanics module).");
  }
}

~MultiDContactConstraint()

virtual MultiDContactConstraint::~MultiDContactConstraint ( )

inlinevirtual

Definition at line 31 of file MultiDContactConstraint.h.

{}

Member Function Documentation

computeQpJacobian()

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

virtual

Definition at line 264 of file MultiDContactConstraint.C.

{
  PenetrationInfo * pinfo = _penetration_locator._penetration_info[_current_node->id()];
 
  Real slave_jac = 0.0;
  switch (type)
  {
    case Moose::SlaveSlave:
      switch (_model)
      {
        case ContactModel::FRICTIONLESS:
 
          slave_jac = pinfo->_normal(_component) * pinfo->_normal(_component) *
                      (_penalty * _phi_slave[_j][_qp] -
                       (*_jacobian)(_current_node->dof_number(0, _var.number(), 0),
                                    _connected_dof_indices[_j]));
          break;
 
        case ContactModel::GLUED:
          // resid = pen_force(_component) - res_vec(_component);
          break;
 
        default:
          mooseError("Invalid or unavailable contact model");
          break;
      }
      return _test_slave[_i][_qp] * slave_jac;
 
    case Moose::SlaveMaster:
      switch (_model)
      {
        case ContactModel::FRICTIONLESS:
 
          slave_jac = pinfo->_normal(_component) * pinfo->_normal(_component) *
                      (-_penalty * _phi_master[_j][_qp]);
          break;
 
        case ContactModel::GLUED:
          /*
                resid = pen_force(_component)
                  - res_vec(_component)
                  ;
          */
          break;
 
        default:
          mooseError("Invalid or unavailable contact model");
          break;
      }
      return _test_slave[_i][_qp] * slave_jac;
 
    case Moose::MasterSlave:
      slave_jac =
          (*_jacobian)(_current_node->dof_number(0, _var.number(), 0), _connected_dof_indices[_j]);
      return slave_jac * _test_master[_i][_qp];
 
    case Moose::MasterMaster:
      return 0.0;
 
    default:
      mooseError("Unhandled ConstraintJacobianType");
  }
  return 0.0;
}

computeQpResidual()

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

virtual

Definition at line 208 of file MultiDContactConstraint.C.

{
  PenetrationInfo * pinfo = _penetration_locator._penetration_info[_current_node->id()];
  const Node * node = pinfo->_node;
 
  RealVectorValue res_vec;
  // Build up residual vector
  for (unsigned int i = 0; i < _mesh_dimension; ++i)
  {
    dof_id_type dof_number = node->dof_number(0, _vars[i], 0);
    res_vec(i) = _residual_copy(dof_number);
  }
 
  const RealVectorValue distance_vec(_mesh.nodeRef(node->id()) - pinfo->_closest_point);
  const RealVectorValue pen_force(_penalty * distance_vec);
  Real resid = 0.0;
 
  switch (type)
  {
    case Moose::Slave:
      switch (_model)
      {
        case ContactModel::FRICTIONLESS:
          resid = pinfo->_normal(_component) * (pinfo->_normal * (pen_force - res_vec));
          break;
 
        case ContactModel::GLUED:
          resid = pen_force(_component) - res_vec(_component);
          break;
 
        default:
          mooseError("Invalid or unavailable contact model");
          break;
      }
      return _test_slave[_i][_qp] * resid;
    case Moose::Master:
      switch (_model)
      {
        case ContactModel::FRICTIONLESS:
          resid = pinfo->_normal(_component) * (pinfo->_normal * res_vec);
          break;
 
        case ContactModel::GLUED:
          resid = res_vec(_component);
          break;
 
        default:
          mooseError("Invalid or unavailable contact model");
          break;
      }
      return _test_master[_i][_qp] * resid;
  }
  return 0.0;
}

computeQpSlaveValue()

Real MultiDContactConstraint::computeQpSlaveValue ( )

virtual

Definition at line 184 of file MultiDContactConstraint.C.

{
  PenetrationInfo * pinfo = _penetration_locator._penetration_info[_current_node->id()];
 
  // Moose::err << std::endl
  //            << "Popping out node: " << _current_node->id() << std::endl
  //            << "Closest Point " << _component << ": " << pinfo->_closest_point(_component)
  //            << std::endl
  //            << "Current Node " << _component << ": " << (*_current_node)(_component) <<
  //            std::endl
  //            << "Current Value: " << _u_slave[_qp] << std::endl
  //            << "New Value: "
  //            << pinfo->_closest_point(_component) - ((*_current_node)(_component)-_u_slave[_qp])
  //            << std::endl
  //            << "Change: "
  //            << _u_slave[_qp] - (pinfo->_closest_point(_component) -
  //                                ((*_current_node)(_component)-_u_slave[_qp]))
  //            << std::endl
  //            << std::endl;
 
  return pinfo->_closest_point(_component) - ((*_current_node)(_component)-_u_slave[_qp]);
}

jacobianSetup()

void MultiDContactConstraint::jacobianSetup ( )

virtual

Definition at line 99 of file MultiDContactConstraint.C.

{
  if (_component == 0)
    updateContactSet();
}

shouldApply()

bool MultiDContactConstraint::shouldApply

(

)

Definition at line 176 of file MultiDContactConstraint.C.

{
  std::set<dof_id_type>::iterator hpit =
      _penetration_locator._has_penetrated.find(_current_node->id());
  return (hpit != _penetration_locator._has_penetrated.end());
}

timestepSetup()

void MultiDContactConstraint::timestepSetup ( )

virtual

Definition at line 92 of file MultiDContactConstraint.C.

{
  if (_component == 0)
    updateContactSet();
}

updateContactSet()

void MultiDContactConstraint::updateContactSet ( )

virtual

Definition at line 106 of file MultiDContactConstraint.C.

{
  auto & has_penetrated = _penetration_locator._has_penetrated;
 
  for (auto & pinfo_pair : _penetration_locator._penetration_info)
  {
    PenetrationInfo * pinfo = pinfo_pair.second;
 
    // Skip this pinfo if there are no DOFs on this node.
    if (!pinfo || pinfo->_node->n_comp(_sys.number(), _vars[_component]) < 1)
      continue;
 
    const Node * node = pinfo->_node;
 
    dof_id_type slave_node_num = pinfo_pair.first;
    auto hpit = has_penetrated.find(slave_node_num);
 
    RealVectorValue res_vec;
    // Build up residual vector
    for (unsigned int i = 0; i < _mesh_dimension; ++i)
    {
      dof_id_type dof_number = node->dof_number(0, _vars[i], 0);
      res_vec(i) = _residual_copy(dof_number);
    }
 
    // Real resid = 0;
    switch (_model)
    {
      case ContactModel::FRICTIONLESS:
        // resid = pinfo->_normal * res_vec;
        break;
 
      case ContactModel::GLUED:
        // resid = pinfo->_normal * res_vec;
        break;
 
      default:
        mooseError("Invalid or unavailable contact model");
        break;
    }
 
    // if (hpit != has_penetrated.end() && resid < 0)
    //   Moose::err << resid << std::endl;
    //
    // if (hpit != has_penetrated.end() && resid < -.15)
    // {
    //   Moose::err << std::endl
    //              << "Unlocking node " << node->id()
    //              << " because resid:
    //                 "<<resid<<std::endl<<std::endl;
    //
    //                 has_penetrated.erase(hpit);
    //   unlocked_this_step[slave_node_num] = true;
    // }
    // else
 
    if (pinfo->_distance > 0 &&
        hpit == has_penetrated.end()) // && !unlocked_this_step[slave_node_num])
    {
      // Moose::err << std::endl
      //            << "Locking node " << node->id() << " because distance:" << pinfo->_distance
      //            << std::endl
      //            << std::endl;
 
      has_penetrated.insert(slave_node_num);
    }
  }
}

Referenced by jacobianSetup(), and timestepSetup().

Member Data Documentation

_component

const unsigned int MultiDContactConstraint::_component

protected

Definition at line 51 of file MultiDContactConstraint.h.

Referenced by computeQpJacobian(), computeQpResidual(), computeQpSlaveValue(), jacobianSetup(), timestepSetup(), and updateContactSet().

_jacobian_update

bool MultiDContactConstraint::_jacobian_update

protected

Definition at line 49 of file MultiDContactConstraint.h.

_mesh_dimension

const unsigned int MultiDContactConstraint::_mesh_dimension

protected

Definition at line 61 of file MultiDContactConstraint.h.

Referenced by computeQpResidual(), and updateContactSet().

_model

const ContactModel MultiDContactConstraint::_model

protected

Definition at line 53 of file MultiDContactConstraint.h.

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

_penalty

Real MultiDContactConstraint::_penalty

protected

Definition at line 55 of file MultiDContactConstraint.h.

Referenced by computeQpJacobian(), and computeQpResidual().

_residual_copy

NumericVector<Number>& MultiDContactConstraint::_residual_copy

protected

Definition at line 47 of file MultiDContactConstraint.h.

Referenced by computeQpResidual(), and updateContactSet().

_vars

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

protected

Definition at line 63 of file MultiDContactConstraint.h.

Referenced by computeQpResidual(), MultiDContactConstraint(), and updateContactSet().

_x_var

unsigned int MultiDContactConstraint::_x_var

protected

Definition at line 57 of file MultiDContactConstraint.h.

_y_var

unsigned int MultiDContactConstraint::_y_var

protected

Definition at line 58 of file MultiDContactConstraint.h.

_z_var

unsigned int MultiDContactConstraint::_z_var

protected

Definition at line 59 of file MultiDContactConstraint.h.

---

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

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