Example #1
0
void
ContactMaster::addPoints()
{
  _point_to_info.clear();

  std::map<dof_id_type, PenetrationInfo *>::iterator
    it  = _penetration_locator._penetration_info.begin(),
    end = _penetration_locator._penetration_info.end();

  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;

    if ( pinfo->isCaptured() )
    {
      addPoint(pinfo->_elem, pinfo->_closest_point);
      _point_to_info[pinfo->_closest_point] = pinfo;
      computeContactForce(pinfo);
    }
  }
}
Example #2
0
void
ContactMaster::addPoints()
{
    _point_to_info.clear();

    std::set<unsigned int> & has_penetrated = _penetration_locator._has_penetrated;

    std::map<unsigned int, PenetrationInfo *>::iterator it = _penetration_locator._penetration_info.begin();
    std::map<unsigned int, PenetrationInfo *>::iterator end = _penetration_locator._penetration_info.end();

    for (; it!=end; ++it)
    {
        PenetrationInfo * pinfo = it->second;

        if (!pinfo)
            continue;


        unsigned int slave_node_num = it->first;

        std::set<unsigned int>::iterator hpit = has_penetrated.find(slave_node_num);

        if ( hpit != has_penetrated.end() )
        {
            addPoint(pinfo->_elem, pinfo->_closest_point);
            _point_to_info[pinfo->_closest_point] = pinfo;
            computeContactForce(pinfo);
        }
    }
}
Real
MechanicalContactConstraint::computeQpResidual(Moose::ConstraintType type)
{
  PenetrationInfo * pinfo = _penetration_locator._penetration_info[_current_node->id()];
  computeContactForce(pinfo);
  Real resid = pinfo->_contact_force(_component);

  switch (type)
  {
    case Moose::Slave:
      if (_formulation == CF_DEFAULT)
      {
        RealVectorValue distance_vec(*_current_node - pinfo->_closest_point);
        const Real penalty = getPenalty(*pinfo);
        RealVectorValue pen_force(penalty * distance_vec);

        if (_model == CM_FRICTIONLESS)
          resid += pinfo->_normal(_component) * pinfo->_normal * pen_force;

        else if (_model == CM_GLUED || _model == CM_COULOMB)
          resid += pen_force(_component);

      }
      return _test_slave[_i][_qp] * resid;
    case Moose::Master:
      return _test_master[_i][_qp] * -resid;
  }

  return 0;
}
bool
MechanicalContactConstraint::shouldApply()
{
  bool in_contact = false;

  std::map<dof_id_type, PenetrationInfo *>::iterator found =
    _penetration_locator._penetration_info.find(_current_node->id());
  if ( found != _penetration_locator._penetration_info.end() )
  {
    PenetrationInfo * pinfo = found->second;
    if ( pinfo != NULL && pinfo->isCaptured() )
    {
      in_contact = true;

      // This does the contact force once per constraint, rather than once per quad point and for
      // both master and slave cases.
      computeContactForce(pinfo);
    }
  }

  return in_contact;
}