RANFSTieNode Class Reference

#include <RANFSTieNode.h>

Inheritance diagram for RANFSTieNode:

Public Member Functions
	RANFSTieNode (const InputParameters &parameters)
bool	shouldApply () override
void	residualSetup () 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
std::vector< unsigned int >	_vars
std::vector< MooseVariable * >	_var_objects
Real	_lagrange_multiplier
const Node *	_nearest_node
std::unordered_map< dof_id_type, Real >	_node_to_lm
dof_id_type	_master_index
std::unordered_map< dof_id_type, Number >	_dof_number_to_value

Detailed Description

Definition at line 31 of file RANFSTieNode.h.

Constructor & Destructor Documentation

RANFSTieNode()

RANFSTieNode::RANFSTieNode

(

const InputParameters &

parameters

)

Definition at line 38 of file RANFSTieNode.C.

  : NodeFaceConstraint(parameters),
    _component(getParam<MooseEnum>("component")),
    _mesh_dimension(_mesh.dimension()),
    _residual_copy(_sys.residualGhosted())
{
  // 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));
  }
 
  if (_vars.size() != _mesh_dimension)
    mooseError("The number of displacement variables does not match the mesh dimension!");
}

Member Function Documentation

computeQpJacobian()

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

overrideprotectedvirtual

Definition at line 134 of file RANFSTieNode.C.

{
  switch (type)
  {
    case Moose::ConstraintJacobianType::SlaveSlave:
      return _phi_slave[_j][_qp];
 
    case Moose::ConstraintJacobianType::SlaveMaster:
      if (_master_index == _j)
        return -1;
      else
        return 0;
 
    case Moose::ConstraintJacobianType::MasterSlave:
      if (_i == _master_index)
      {
        mooseAssert(_dof_number_to_value.find(_connected_dof_indices[_j]) !=
                        _dof_number_to_value.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[_connected_dof_indices[_j]];
      }
      else
        return 0;
 
    default:
      return 0;
  }
}

computeQpResidual()

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

overrideprotectedvirtual

Definition at line 112 of file RANFSTieNode.C.

{
  switch (type)
  {
    case Moose::ConstraintType::Slave:
      return (*_current_node - *_nearest_node)(_component);
 
    case Moose::ConstraintType::Master:
    {
      if (_i == _master_index)
        return _lagrange_multiplier;
 
      else
        return 0;
    }
 
    default:
      return 0;
  }
}

computeQpSlaveValue()

Real RANFSTieNode::computeQpSlaveValue ( )

overrideprotectedvirtual

Definition at line 170 of file RANFSTieNode.C.

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

computeSlaveValue()

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

override

Definition at line 165 of file RANFSTieNode.C.

{
}

overwriteSlaveResidual()

bool RANFSTieNode::overwriteSlaveResidual ( )

override

Definition at line 62 of file RANFSTieNode.C.

{
  return _nearest_node;
}

residualSetup()

void RANFSTieNode::residualSetup ( )

override

Definition at line 56 of file RANFSTieNode.C.

{
  _node_to_lm.clear();
}

shouldApply()

bool RANFSTieNode::shouldApply ( )

override

Definition at line 68 of file RANFSTieNode.C.

{
  auto & nearest_node_loc = _penetration_locator._nearest_node;
  _nearest_node = nearest_node_loc.nearestNode(_current_node->id());
  if (_nearest_node)
  {
    auto slave_dof_number = _current_node->dof_number(0, _vars[_component], 0);
    // We overwrite the slave residual so we cannot use the residual
    // copy for determining the Lagrange multiplier when computing the Jacobian
    if (!_subproblem.currentlyComputingJacobian())
      _node_to_lm.insert(std::make_pair(_current_node->id(),
                                        _residual_copy(slave_dof_number) /
                                            _var_objects[_component]->scalingFactor()));
    else
    {
      std::vector<dof_id_type> master_cols;
      std::vector<Number> master_values;
 
      _jacobian->get_row(slave_dof_number, master_cols, master_values);
      mooseAssert(master_cols.size() == master_values.size(),
                  "The size of the dof container and value container are different");
 
      _dof_number_to_value.clear();
 
      for (MooseIndex(master_cols) i = 0; i < master_cols.size(); ++i)
        _dof_number_to_value.insert(
            std::make_pair(master_cols[i], master_values[i] / _var.scalingFactor()));
    }
 
    mooseAssert(_node_to_lm.find(_current_node->id()) != _node_to_lm.end(),
                "The node " << _current_node->id() << " should map to a lagrange multiplier");
    _lagrange_multiplier = _node_to_lm[_current_node->id()];
 
    _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");
 
    return true;
  }
 
  return false;
}

Member Data Documentation

_component

const MooseEnum RANFSTieNode::_component

protected

Definition at line 47 of file RANFSTieNode.h.

Referenced by computeQpResidual(), and shouldApply().

_dof_number_to_value

std::unordered_map<dof_id_type, Number> RANFSTieNode::_dof_number_to_value

protected

Definition at line 58 of file RANFSTieNode.h.

Referenced by computeQpJacobian(), and shouldApply().

_lagrange_multiplier

Real RANFSTieNode::_lagrange_multiplier

protected

Definition at line 53 of file RANFSTieNode.h.

Referenced by computeQpResidual(), and shouldApply().

_master_index

dof_id_type RANFSTieNode::_master_index

protected

Definition at line 56 of file RANFSTieNode.h.

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

_mesh_dimension

const unsigned int RANFSTieNode::_mesh_dimension

protected

Definition at line 48 of file RANFSTieNode.h.

Referenced by RANFSTieNode().

_nearest_node

const Node* RANFSTieNode::_nearest_node

protected

Definition at line 54 of file RANFSTieNode.h.

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

_node_to_lm

std::unordered_map<dof_id_type, Real> RANFSTieNode::_node_to_lm

protected

Definition at line 55 of file RANFSTieNode.h.

Referenced by residualSetup(), and shouldApply().

_residual_copy

NumericVector<Number>& RANFSTieNode::_residual_copy

protected

Definition at line 49 of file RANFSTieNode.h.

Referenced by shouldApply().

_var_objects

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

protected

Definition at line 52 of file RANFSTieNode.h.

Referenced by RANFSTieNode(), and shouldApply().

_vars

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

protected

Definition at line 51 of file RANFSTieNode.h.

Referenced by RANFSTieNode(), and shouldApply().

---

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

• contact/test/include/constraints/RANFSTieNode.h
• contact/test/src/constraints/RANFSTieNode.C