TorqueTempl< is_ad > Class Template Reference

Apply a torque as tractions distributed over a surface. More...

#include <Torque.h>

Inheritance diagram for TorqueTempl< is_ad >:

Public Member Functions
	TorqueTempl (const InputParameters &parameters)

Static Public Member Functions
static InputParameters	validParams ()

Protected Member Functions
virtual GenericReal< is_ad >	computeQpResidual ()
Real	componentJacobian (unsigned int component)
virtual Real	computeQpJacobian ()
virtual Real	computeQpOffDiagJacobian (unsigned int)
ADReal	computeQpResidual ()
Real	computeQpResidual ()
Real	componentJacobian (unsigned int component)
Real	componentJacobian (unsigned int)

Protected Attributes
unsigned int	_component
	coordinte axis this BC acts on
const Point	_origin
	pivot point for the torque
const RealVectorValue	_torque
	applied torque vector
const Function &	_factor
	prefactor function (can only be time dependent)
const Real &	_alpha
	alpha parameter required for HHT time integration scheme
const PostprocessorValue &	_pmi
	postprocessor that computes the polar moment of inertia
const unsigned int	_ndisp
	number of coupled displacement variables
std::vector< unsigned int >	_dvars
	coupled displacement variables
const Point	_dummy_point
	dummy point (zero) used in evaluating the time dependent prefactor
	usingTransientInterfaceMembers

Detailed Description

template<bool is_ad>
class TorqueTempl< is_ad >

Apply a torque as tractions distributed over a surface.

Definition at line 25 of file Torque.h.

Constructor & Destructor Documentation

TorqueTempl()

template<bool is_ad>

TorqueTempl< is_ad >::TorqueTempl

(

const InputParameters &

parameters

)

Definition at line 39 of file Torque.C.

  : TorqueParent<is_ad>(parameters),
    _component(libMesh::invalid_uint),
    _origin(this->template getParam<Point>("origin")),
    _torque(this->template getParam<RealVectorValue>("direction")),
    _factor(this->getFunction("factor")),
    _alpha(this->template getParam<Real>("alpha")),
    _pmi(this->getPostprocessorValue("polar_moment_of_inertia")),
    _ndisp(this->coupledComponents("displacements")),
    _dvars(_ndisp),
    _dummy_point()
{
  for (unsigned int i = 0; i < _ndisp; ++i)
  {
    _dvars[i] = this->getVar("displacements", i)->number();
    if (this->_var.number() == _dvars[i])
      _component = i;
  }
 
  if (_component == libMesh::invalid_uint)
    this->paramError("variable",
                     "The kernel variable needs to be one of the 'displacements' variables");
  if (this->template getParam<bool>("use_displaced_mesh"))
    this->paramError("use_displaced_mesh", "This BC is only validated for small strains");
}

Member Function Documentation

componentJacobian() [1/3]

template<bool is_ad>

Real TorqueTempl< is_ad >::componentJacobian ( unsigned int  component )

protected

componentJacobian() [2/3]

Real TorqueTempl< false >::componentJacobian ( unsigned int  component )

protected

Definition at line 95 of file Torque.C.

{
  // vector phi
  RealGradient phi;
  phi(component) = this->_phi[_j][_qp];
 
  // force calculation
  auto d_local_force = _factor.value(_t + _alpha * _dt, _dummy_point) * _torque.cross(phi) / _pmi;
  return -d_local_force(_component) * _test[_i][_qp];
}

componentJacobian() [3/3]

Real TorqueTempl< true >::componentJacobian ( unsigned int  )

protected

Definition at line 108 of file Torque.C.

{
  mooseError("This should never get called");
}

computeQpJacobian()

template<bool is_ad>

Real TorqueTempl< is_ad >::computeQpJacobian ( )

protectedvirtual

Definition at line 115 of file Torque.C.

{
  return componentJacobian(_component);
}

computeQpOffDiagJacobian()

template<bool is_ad>

Real TorqueTempl< is_ad >::computeQpOffDiagJacobian ( unsigned int  jvar )

protectedvirtual

Definition at line 122 of file Torque.C.

{
  for (unsigned int i = 0; i < _ndisp; ++i)
    if (jvar == _dvars[i])
      return componentJacobian(i);
 
  return 0.0;
}

computeQpResidual() [1/3]

template<bool is_ad>

virtual GenericReal< is_ad > TorqueTempl< is_ad >::computeQpResidual ( )

protectedvirtual

computeQpResidual() [2/3]

ADReal TorqueTempl< true >::computeQpResidual ( )

protected

Definition at line 67 of file Torque.C.

{
  // local lever (distance to the origin)
  auto local_lever = this->_ad_q_points[_qp] - _origin;
 
  // force calculation
  auto local_force =
      _factor.value(_t + _alpha * _dt, _dummy_point) * _torque.cross(local_lever) / _pmi;
 
  return -local_force(_component) * _test[_i][_qp];
}

computeQpResidual() [3/3]

Real TorqueTempl< false >::computeQpResidual ( )

protected

Definition at line 81 of file Torque.C.

{
  // local lever (distance to the origin)
  auto local_lever = this->_q_point[_qp] - _origin;
 
  // force calculation
  auto local_force =
      _factor.value(_t + _alpha * _dt, _dummy_point) * _torque.cross(local_lever) / _pmi;
 
  return -local_force(_component) * _test[_i][_qp];
}

validParams()

template<bool is_ad>

InputParameters TorqueTempl< is_ad >::validParams ( )

static

Definition at line 18 of file Torque.C.

{
  InputParameters params = TorqueParent<is_ad>::validParams();
  params.addClassDescription(
      "Apply a moment as tractions distributed over a surface around a "
      "pivot point. This should operate on the displaced mesh for large deformations.");
  MooseEnum component("x=0 y=1 z=2");
  params.addRequiredParam<Point>(
      "origin", "Reference point defining the location for the axis the torque is applied to");
  params.addRequiredParam<RealVectorValue>("direction", "Torque vector");
  params.addParam<FunctionName>(
      "factor", "1", "Prefactor for the force (can only be time dependent)");
  params.addRequiredParam<PostprocessorName>(
      "polar_moment_of_inertia", "Postprocessor that computes the polar moment of inertia");
  params.addParam<Real>("alpha", 0.0, "alpha parameter required for HHT time integration scheme");
  params.addParamNamesToGroup("alpha factor", "Advanced");
  params.addCoupledVar("displacements", "The displacements");
  return params;
}

Member Data Documentation

_alpha

template<bool is_ad>

const Real& TorqueTempl< is_ad >::_alpha

protected

alpha parameter required for HHT time integration scheme

Definition at line 51 of file Torque.h.

_component

template<bool is_ad>

unsigned int TorqueTempl< is_ad >::_component

protected

coordinte axis this BC acts on

Definition at line 41 of file Torque.h.

Referenced by TorqueTempl< is_ad >::TorqueTempl().

_dummy_point

template<bool is_ad>

const Point TorqueTempl< is_ad >::_dummy_point

protected

dummy point (zero) used in evaluating the time dependent prefactor

Definition at line 61 of file Torque.h.

_dvars

template<bool is_ad>

std::vector<unsigned int> TorqueTempl< is_ad >::_dvars

protected

coupled displacement variables

Definition at line 58 of file Torque.h.

Referenced by TorqueTempl< is_ad >::TorqueTempl().

_factor

template<bool is_ad>

const Function& TorqueTempl< is_ad >::_factor

protected

prefactor function (can only be time dependent)

Definition at line 49 of file Torque.h.

_ndisp

template<bool is_ad>

const unsigned int TorqueTempl< is_ad >::_ndisp

protected

number of coupled displacement variables

Definition at line 56 of file Torque.h.

Referenced by TorqueTempl< is_ad >::TorqueTempl().

_origin

template<bool is_ad>

const Point TorqueTempl< is_ad >::_origin

protected

pivot point for the torque

Definition at line 44 of file Torque.h.

_pmi

template<bool is_ad>

const PostprocessorValue& TorqueTempl< is_ad >::_pmi

protected

postprocessor that computes the polar moment of inertia

Definition at line 53 of file Torque.h.

_torque

template<bool is_ad>

const RealVectorValue TorqueTempl< is_ad >::_torque

protected

applied torque vector

Definition at line 46 of file Torque.h.

usingTransientInterfaceMembers

template<bool is_ad>

TorqueTempl< is_ad >::usingTransientInterfaceMembers

protected

Definition at line 63 of file Torque.h.

---

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

• solid_mechanics/include/bcs/Torque.h
• solid_mechanics/src/bcs/Torque.C