SlaveConstraint Class Reference

#include <SlaveConstraint.h>

Inheritance diagram for SlaveConstraint:

Public Member Functions
	SlaveConstraint (const InputParameters &parameters)
virtual void	addPoints ()
virtual Real	computeQpResidual ()
virtual Real	computeQpJacobian ()

Protected Member Functions
Real	nodalArea (PenetrationInfo &pinfo)

Protected Attributes
const unsigned int	_component
const ContactModel	_model
const ContactFormulation	_formulation
const bool	_normalize_penalty
PenetrationLocator &	_penetration_locator
const Real	_penalty
const Real	_friction_coefficient
NumericVector< Number > &	_residual_copy
std::map< Point, PenetrationInfo * >	_point_to_info
std::vector< unsigned int >	_vars
const unsigned int	_mesh_dimension
MooseVariable *	_nodal_area_var
SystemBase &	_aux_system
const NumericVector< Number > *	_aux_solution

Detailed Description

Definition at line 24 of file SlaveConstraint.h.

Constructor & Destructor Documentation

SlaveConstraint()

SlaveConstraint::SlaveConstraint

(

const InputParameters &

parameters

)

Definition at line 62 of file SlaveConstraint.C.

  : DiracKernel(parameters),
    _component(getParam<unsigned int>("component")),
    _model(getParam<MooseEnum>("model").getEnum<ContactModel>()),
    _formulation(getParam<MooseEnum>("formulation").getEnum<ContactFormulation>()),
    _normalize_penalty(getParam<bool>("normalize_penalty")),
    _penetration_locator(
        getPenetrationLocator(getParam<BoundaryName>("master"),
                              getParam<BoundaryName>("boundary"),
                              Utility::string_to_enum<Order>(getParam<MooseEnum>("order")))),
    _penalty(getParam<Real>("penalty")),
    _friction_coefficient(getParam<Real>("friction_coefficient")),
    _residual_copy(_sys.residualGhosted()),
    _vars(3, libMesh::invalid_uint),
    _mesh_dimension(_mesh.dimension()),
    _nodal_area_var(getVar("nodal_area", 0)),
    _aux_system(_nodal_area_var->sys()),
    _aux_solution(_aux_system.currentSolution())
{
  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).");
  }
 
  if (parameters.isParamValid("tangential_tolerance"))
    _penetration_locator.setTangentialTolerance(getParam<Real>("tangential_tolerance"));
 
  if (parameters.isParamValid("normal_smoothing_distance"))
    _penetration_locator.setNormalSmoothingDistance(getParam<Real>("normal_smoothing_distance"));
 
  if (parameters.isParamValid("normal_smoothing_method"))
    _penetration_locator.setNormalSmoothingMethod(
        parameters.get<std::string>("normal_smoothing_method"));
}

Member Function Documentation

addPoints()

void SlaveConstraint::addPoints ( )

virtual

Definition at line 113 of file SlaveConstraint.C.

{
  _point_to_info.clear();
 
  std::map<dof_id_type, PenetrationInfo *>::iterator
      it = _penetration_locator._penetration_info.begin(),
      end = _penetration_locator._penetration_info.end();
 
  const auto & node_to_elem_map = _mesh.nodeToElemMap();
  for (; it != end; ++it)
  {
    PenetrationInfo * pinfo = it->second;
 
    // Skip this pinfo if there are no DOFs on this node.
    if (!pinfo || pinfo->_node->n_comp(_sys.number(), _vars[_component]) < 1)
      continue;
 
    dof_id_type slave_node_num = it->first;
    const Node * node = pinfo->_node;
 
    if (pinfo->isCaptured() && node->processor_id() == processor_id())
    {
      // Find an element that is connected to this node that and that is also on this processor
      auto node_to_elem_pair = node_to_elem_map.find(slave_node_num);
      mooseAssert(node_to_elem_pair != node_to_elem_map.end(), "Missing node in node to elem map");
      const std::vector<dof_id_type> & connected_elems = node_to_elem_pair->second;
 
      Elem * elem = NULL;
 
      for (unsigned int i = 0; i < connected_elems.size() && !elem; ++i)
      {
        Elem * cur_elem = _mesh.elemPtr(connected_elems[i]);
        if (cur_elem->processor_id() == processor_id())
          elem = cur_elem;
      }
 
      mooseAssert(elem,
                  "Couldn't find an element on this processor that is attached to the slave node!");
 
      addPoint(elem, *node);
      _point_to_info[*node] = pinfo;
    }
  }
}

computeQpJacobian()

Real SlaveConstraint::computeQpJacobian ( )

virtual

Definition at line 186 of file SlaveConstraint.C.

{
 
  // TODO: for the default formulation,
  //   we should subtract off the existing Jacobian weighted by the effect of the normal
 
  PenetrationInfo * pinfo = _point_to_info[_current_point];
  const Node * node = pinfo->_node;
  //   long int dof_number = node->dof_number(0, _var.number(), 0);
 
  //  RealVectorValue jac_vec;
 
  // Build up jac vector
  //  for (unsigned int i=0; i<_dim; i++)
  //  {
  //    unsigned int dof_row = _dof_data._var_dof_indices[_var_num][_i];
  //    unsigned int dof_col = _dof_data._var_dof_indices[_var_num][_j];
 
  //    Real jac_value = _jacobian_copy(dof_row, dof_col);
  //  }
 
  //    Real jac_mag = pinfo->_normal(_component) * jac_value;
  /*
     return _test[_i][_qp] * (
       (1e8*-_phi[_j][_qp])
       -_jacobian_copy(dof_number, dof_number)
       );
     */
 
  RealVectorValue normal(pinfo->_normal);
 
  Real penalty = _penalty;
  if (_normalize_penalty)
    penalty *= nodalArea(*pinfo);
 
  Real term(0);
 
  if (ContactModel::FRICTIONLESS == _model)
  {
 
    const Real nnTDiag = normal(_component) * normal(_component);
    term = penalty * nnTDiag;
 
    const RealGradient & A1(pinfo->_dxyzdxi[0]);
    RealGradient A2;
    RealGradient d2;
    if (_mesh_dimension == 3)
    {
      A2 = pinfo->_dxyzdeta[0];
      d2 = pinfo->_d2xyzdxideta[0];
    }
    else
    {
      A2.zero();
      d2.zero();
    }
 
    const RealVectorValue distance_vec(_mesh.nodeRef(node->id()) - pinfo->_closest_point);
    const Real ATA11(A1 * A1);
    const Real ATA12(A1 * A2);
    const Real ATA22(A2 * A2);
    const Real D11(-ATA11);
    const Real D12(-ATA12 + d2 * distance_vec);
    const Real D22(-ATA22);
 
    Real invD11(0);
    Real invD12(0);
    Real invD22(0);
    if (_mesh_dimension == 3)
    {
      const Real detD(D11 * D22 - D12 * D12);
      invD11 = D22 / detD;
      invD12 = -D12 / detD;
      invD22 = D11 / detD;
    }
    else if (_mesh_dimension == 2)
    {
      invD11 = 1 / D11;
    }
 
    const Real AinvD11(A1(0) * invD11 + A2(0) * invD12);
    const Real AinvD12(A1(0) * invD12 + A2(0) * invD22);
    const Real AinvD21(A1(1) * invD11 + A2(1) * invD12);
    const Real AinvD22(A1(1) * invD12 + A2(1) * invD22);
    const Real AinvD31(A1(2) * invD11 + A2(2) * invD12);
    const Real AinvD32(A1(2) * invD12 + A2(2) * invD22);
 
    const Real AinvDAT11(AinvD11 * A1(0) + AinvD12 * A2(0));
    //     const Real AinvDAT12( AinvD11*A1(1) + AinvD12*A2(1) );
    //     const Real AinvDAT13( AinvD11*A1(2) + AinvD12*A2(2) );
    //     const Real AinvDAT21( AinvD21*A1(0) + AinvD22*A2(0) );
    const Real AinvDAT22(AinvD21 * A1(1) + AinvD22 * A2(1));
    //     const Real AinvDAT23( AinvD21*A1(2) + AinvD22*A2(2) );
    //     const Real AinvDAT31( AinvD31*A1(0) + AinvD32*A2(0) );
    //     const Real AinvDAT32( AinvD31*A1(1) + AinvD32*A2(1) );
    const Real AinvDAT33(AinvD31 * A1(2) + AinvD32 * A2(2));
 
    if (_component == 0)
      term += penalty * (1 - nnTDiag + AinvDAT11);
 
    else if (_component == 1)
      term += penalty * (1 - nnTDiag + AinvDAT22);
 
    else
      term += penalty * (1 - nnTDiag + AinvDAT33);
  }
  else if (ContactModel::GLUED == _model || ContactModel::COULOMB == _model)
  {
    normal.zero();
    normal(_component) = 1;
    term = penalty;
  }
  else
  {
    mooseError("Invalid or unavailable contact model");
  }
 
  return _test[_i][_qp] * term * _phi[_j][_qp];
}

computeQpResidual()

Real SlaveConstraint::computeQpResidual ( )

virtual

Definition at line 159 of file SlaveConstraint.C.

{
  PenetrationInfo * pinfo = _point_to_info[_current_point];
  const Node * node = pinfo->_node;
 
  Real resid = pinfo->_contact_force(_component);
 
  const Real area = nodalArea(*pinfo);
 
  if (_formulation == ContactFormulation::KINEMATIC)
  {
    RealVectorValue distance_vec(_mesh.nodeRef(node->id()) - pinfo->_closest_point);
    RealVectorValue pen_force(_penalty * distance_vec);
    if (_normalize_penalty)
      pen_force *= area;
 
    if (_model == ContactModel::FRICTIONLESS)
      resid += pinfo->_normal(_component) * pinfo->_normal * pen_force;
 
    else if (_model == ContactModel::GLUED || _model == ContactModel::COULOMB)
      resid += pen_force(_component);
  }
 
  return _test[_i][_qp] * resid;
}

nodalArea()

Real SlaveConstraint::nodalArea ( PenetrationInfo &  pinfo )

protected

Definition at line 307 of file SlaveConstraint.C.

{
  const Node * node = pinfo._node;
 
  dof_id_type dof = node->dof_number(_aux_system.number(), _nodal_area_var->number(), 0);
 
  Real area = (*_aux_solution)(dof);
  if (area == 0)
  {
    if (_t_step > 1)
      mooseError("Zero nodal area found");
 
    else
      area = 1; // Avoid divide by zero during initialization
  }
  return area;
}

Referenced by computeQpJacobian(), and computeQpResidual().

Member Data Documentation

_aux_solution

const NumericVector<Number>* SlaveConstraint::_aux_solution

protected

Definition at line 55 of file SlaveConstraint.h.

_aux_system

SystemBase& SlaveConstraint::_aux_system

protected

Definition at line 54 of file SlaveConstraint.h.

Referenced by nodalArea().

_component

const unsigned int SlaveConstraint::_component

protected

Definition at line 36 of file SlaveConstraint.h.

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

_formulation

const ContactFormulation SlaveConstraint::_formulation

protected

Definition at line 38 of file SlaveConstraint.h.

Referenced by computeQpResidual().

_friction_coefficient

const Real SlaveConstraint::_friction_coefficient

protected

Definition at line 43 of file SlaveConstraint.h.

_mesh_dimension

const unsigned int SlaveConstraint::_mesh_dimension

protected

Definition at line 51 of file SlaveConstraint.h.

Referenced by computeQpJacobian().

_model

const ContactModel SlaveConstraint::_model

protected

Definition at line 37 of file SlaveConstraint.h.

Referenced by computeQpJacobian(), and computeQpResidual().

_nodal_area_var

MooseVariable* SlaveConstraint::_nodal_area_var

protected

Definition at line 53 of file SlaveConstraint.h.

Referenced by nodalArea().

_normalize_penalty

const bool SlaveConstraint::_normalize_penalty

protected

Definition at line 39 of file SlaveConstraint.h.

Referenced by computeQpJacobian(), and computeQpResidual().

_penalty

const Real SlaveConstraint::_penalty

protected

Definition at line 42 of file SlaveConstraint.h.

Referenced by computeQpJacobian(), and computeQpResidual().

_penetration_locator

PenetrationLocator& SlaveConstraint::_penetration_locator

protected

Definition at line 40 of file SlaveConstraint.h.

Referenced by addPoints(), and SlaveConstraint().

_point_to_info

std::map<Point, PenetrationInfo *> SlaveConstraint::_point_to_info

protected

Definition at line 47 of file SlaveConstraint.h.

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

_residual_copy

NumericVector<Number>& SlaveConstraint::_residual_copy

protected

Definition at line 45 of file SlaveConstraint.h.

_vars

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

protected

Definition at line 49 of file SlaveConstraint.h.

Referenced by addPoints(), and SlaveConstraint().

---

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

• contact/include/dirackernels/SlaveConstraint.h
• contact/src/dirackernels/SlaveConstraint.C