StressDivergenceBeam Class Reference

#include <StressDivergenceBeam.h>

Inheritance diagram for StressDivergenceBeam:

Public Member Functions
	StressDivergenceBeam (const InputParameters &parameters)
virtual void	computeResidual () override
virtual void	computeJacobian () override
virtual void	computeOffDiagJacobian (MooseVariableFEBase &jvar) override

Protected Member Functions
virtual Real	computeQpResidual () override
void	computeDynamicTerms (std::vector< RealVectorValue > &global_force_res, std::vector< RealVectorValue > &global_moment_res)
	Computes the force and moment due to stiffness proportional damping and HHT time integration. More...
void	computeGlobalResidual (const MaterialProperty< RealVectorValue > *force, const MaterialProperty< RealVectorValue > *moment, const MaterialProperty< RankTwoTensor > *total_rotation, std::vector< RealVectorValue > &global_force_res, std::vector< RealVectorValue > &global_moment_res)
	Computes the residual corresponding to displacement and rotational variables given the forces and moments. More...

Protected Attributes
const unsigned int	_component
	Direction along which force/moment is calculated. More...
unsigned int	_ndisp
	Number of coupled displacement variables. More...
std::vector< unsigned int >	_disp_var
	Variable numbers corresponding to displacement variables. More...
unsigned int	_nrot
	Number of coupled rotational variables. More...
std::vector< unsigned int >	_rot_var
	Variable numbers corresponding to rotational variables. More...
const MaterialProperty< RealVectorValue > &	_force
	Current force vector in global coordinate system. More...
const MaterialProperty< RealVectorValue > &	_moment
	Current moment vector in global coordinate system. More...
const MaterialProperty< RankTwoTensor > &	_K11
	Stiffness matrix relating displacement DOFs of same node or across nodes. More...
const MaterialProperty< RankTwoTensor > &	_K22
	Stiffness matrix relating rotational DOFs of same node. More...
const MaterialProperty< RankTwoTensor > &	_K22_cross
	Stiffness matrix relating rotational DOFs across nodes. More...
const MaterialProperty< RankTwoTensor > &	_K21_cross
	Stiffness matrix relating displacement of one node to rotations of another node. More...
const MaterialProperty< RankTwoTensor > &	_K21
	Stiffness matrix relating displacement and rotations of same node. More...
const MaterialProperty< Real > &	_original_length
	Initial length of beam. More...
const MaterialProperty< RankTwoTensor > &	_total_rotation
	Rotational transformation from global to current beam local coordinate system. More...
const MaterialProperty< Real > &	_zeta
	Stiffness proportional Rayleigh damping parameter. More...
const Real &	_alpha
	HHT time integration parameter. More...
const bool	_isDamped
	Boolean flag to turn on Rayleigh damping or numerical damping due to HHT time integration. More...
const MaterialProperty< RealVectorValue > *	_force_old
	Old force vector in global coordinate system. More...
const MaterialProperty< RealVectorValue > *	_moment_old
	Old moment vector in global coordinate system. More...
const MaterialProperty< RankTwoTensor > *	_total_rotation_old
	Rotational transformation from global to old beam local coordinate system. More...
const MaterialProperty< RealVectorValue > *	_force_older
	Older force vector in global coordinate system. More...
const MaterialProperty< RealVectorValue > *	_moment_older
	Older moment vector in global coordinate system. More...
const MaterialProperty< RankTwoTensor > *	_total_rotation_older
	Rotational transformation from global to older beam local coordinate system. More...
std::vector< RealVectorValue >	_global_force_res
	Residual corresponding to displacement DOFs at the nodes in global coordinate system. More...
std::vector< RealVectorValue >	_global_moment_res
	Residual corresponding to rotational DOFs at the nodes in global coordinate system. More...
std::vector< RealVectorValue >	_force_local_t
	Forces at each Qp in the beam local configuration. More...
std::vector< RealVectorValue >	_moment_local_t
	Moments at each Qp in the beam local configuration. More...
std::vector< RealVectorValue >	_local_force_res
	Residual corresponding to displacement DOFs at the nodes in beam local coordinate system. More...
std::vector< RealVectorValue >	_local_moment_res
	Residual corresponding to rotational DOFs at the nodes in beam local coordinate system. More...

Detailed Description

Definition at line 19 of file StressDivergenceBeam.h.

Constructor & Destructor Documentation

StressDivergenceBeam()

StressDivergenceBeam::StressDivergenceBeam

(

const InputParameters &

parameters

)

Definition at line 51 of file StressDivergenceBeam.C.

  : Kernel(parameters),
    _component(getParam<unsigned int>("component")),
    _ndisp(coupledComponents("displacements")),
    _disp_var(_ndisp),
    _nrot(coupledComponents("rotations")),
    _rot_var(_nrot),
    _force(getMaterialPropertyByName<RealVectorValue>("forces")),
    _moment(getMaterialPropertyByName<RealVectorValue>("moments")),
    _K11(getMaterialPropertyByName<RankTwoTensor>("Jacobian_11")),
    _K22(getMaterialPropertyByName<RankTwoTensor>("Jacobian_22")),
    _K22_cross(getMaterialPropertyByName<RankTwoTensor>("Jacobian_22_cross")),
    _K21_cross(getMaterialPropertyByName<RankTwoTensor>("Jacobian_12")),
    _K21(getMaterialPropertyByName<RankTwoTensor>("Jacobian_21")),
    _original_length(getMaterialPropertyByName<Real>("original_length")),
    _total_rotation(getMaterialPropertyByName<RankTwoTensor>("total_rotation")),
    _zeta(getMaterialProperty<Real>("zeta")),
    _alpha(getParam<Real>("alpha")),
    _isDamped(getParam<MaterialPropertyName>("zeta") != "0.0" || std::abs(_alpha) > 0.0),
    _force_old(_isDamped ? &getMaterialPropertyOld<RealVectorValue>("forces") : nullptr),
    _moment_old(_isDamped ? &getMaterialPropertyOld<RealVectorValue>("moments") : nullptr),
    _total_rotation_old(_isDamped ? &getMaterialPropertyOld<RankTwoTensor>("total_rotation")
                                  : nullptr),
    _force_older(std::abs(_alpha) > 0.0 ? &getMaterialPropertyOlder<RealVectorValue>("forces")
                                        : nullptr),
    _moment_older(std::abs(_alpha) > 0.0 ? &getMaterialPropertyOlder<RealVectorValue>("moments")
                                         : nullptr),
    _total_rotation_older(std::abs(_alpha) > 0.0
                              ? &getMaterialPropertyOlder<RankTwoTensor>("total_rotation")
                              : nullptr),
    _global_force_res(0),
    _global_moment_res(0),
    _force_local_t(0),
    _moment_local_t(0),
    _local_force_res(0),
    _local_moment_res(0)
{
  if (_ndisp != _nrot)
    mooseError(
        "StressDivergenceBeam: The number of displacement and rotation variables should be same.");

  for (unsigned int i = 0; i < _ndisp; ++i)
    _disp_var[i] = coupled("displacements", i);

  for (unsigned int i = 0; i < _nrot; ++i)
    _rot_var[i] = coupled("rotations", i);
}

Member Function Documentation

computeDynamicTerms()

void StressDivergenceBeam::computeDynamicTerms ( std::vector< RealVectorValue > &  global_force_res, std::vector< RealVectorValue > &  global_moment_res  )

protected

Computes the force and moment due to stiffness proportional damping and HHT time integration.

Definition at line 255 of file StressDivergenceBeam.C.

Referenced by computeResidual().

{
  mooseAssert(_zeta[0] >= 0.0, "StressDivergenceBeam: Zeta parameter should be non-negative.");
  std::vector<RealVectorValue> global_force_res_old(_test.size());
  std::vector<RealVectorValue> global_moment_res_old(_test.size());
  computeGlobalResidual(
      _force_old, _moment_old, _total_rotation_old, global_force_res_old, global_moment_res_old);

  // For HHT calculation, the global force and moment residual from t_older is required
  std::vector<RealVectorValue> global_force_res_older(_test.size());
  std::vector<RealVectorValue> global_moment_res_older(_test.size());

  if (std::abs(_alpha) > 0.0)
    computeGlobalResidual(_force_older,
                          _moment_older,
                          _total_rotation_older,
                          global_force_res_older,
                          global_moment_res_older);

  // Update the global_force_res and global_moment_res to include HHT and Rayleigh damping
  // contributions
  for (_i = 0; _i < _test.size(); ++_i)
  {
    global_force_res[_i] =
        global_force_res[_i] * (1.0 + _alpha + (1.0 + _alpha) * _zeta[0] / _dt) -
        global_force_res_old[_i] * (_alpha + (1.0 + 2.0 * _alpha) * _zeta[0] / _dt) +
        global_force_res_older[_i] * (_alpha * _zeta[0] / _dt);
    global_moment_res[_i] =
        global_moment_res[_i] * (1.0 + _alpha + (1.0 + _alpha) * _zeta[0] / _dt) -
        global_moment_res_old[_i] * (_alpha + (1.0 + 2.0 * _alpha) * _zeta[0] / _dt) +
        global_moment_res_older[_i] * (_alpha * _zeta[0] / _dt);
  }
}

computeGlobalResidual()

void StressDivergenceBeam::computeGlobalResidual ( const MaterialProperty< RealVectorValue > *  force, const MaterialProperty< RealVectorValue > *  moment, const MaterialProperty< RankTwoTensor > *  total_rotation, std::vector< RealVectorValue > &  global_force_res, std::vector< RealVectorValue > &  global_moment_res  )

protected

Computes the residual corresponding to displacement and rotational variables given the forces and moments.

Definition at line 291 of file StressDivergenceBeam.C.

Referenced by computeDynamicTerms(), and computeResidual().

{
  RealVectorValue a;
  _force_local_t.resize(_qrule->n_points());
  _moment_local_t.resize(_qrule->n_points());
  _local_force_res.resize(_test.size());
  _local_moment_res.resize(_test.size());

  // convert forces/moments from global coordinate system to current beam local configuration
  for (_qp = 0; _qp < _qrule->n_points(); ++_qp)
  {
    _force_local_t[_qp] = (*total_rotation)[0] * (*force)[_qp];
    _moment_local_t[_qp] = (*total_rotation)[0] * (*moment)[_qp];
  }

  // residual for displacement variables
  for (_i = 0; _i < _test.size(); ++_i)
  {
    _local_force_res[_i] = a;
    for (unsigned int component = 0; component < 3; ++component)
    {
      for (_qp = 0; _qp < _qrule->n_points(); ++_qp)
        _local_force_res[_i](component) +=
            (_i == 0 ? -1 : 1) * _force_local_t[_qp](component) * 0.5;
    }
  }

  // residual for rotation variables
  for (_i = 0; _i < _test.size(); ++_i)
  {
    _local_moment_res[_i] = a;
    for (unsigned int component = 3; component < 6; ++component)
    {
      for (_qp = 0; _qp < _qrule->n_points(); ++_qp)
      {
        if (component == 3)
          _local_moment_res[_i](component - 3) +=
              (_i == 0 ? -1 : 1) * _moment_local_t[_qp](0) * 0.5;
        else if (component == 4)
          _local_moment_res[_i](component - 3) +=
              (_i == 0 ? -1 : 1) * _moment_local_t[_qp](1) * 0.5 +
              _force_local_t[_qp](2) * 0.25 * _original_length[0];
        else
          _local_moment_res[_i](component - 3) +=
              (_i == 0 ? -1 : 1) * -_moment_local_t[_qp](2) * 0.5 -
              _force_local_t[_qp](1) * 0.25 * _original_length[0];
      }
    }
  }

  // convert residual for each variable from current beam local configuration to global
  // configuration
  for (_i = 0; _i < _test.size(); ++_i)
  {
    global_force_res[_i] = (*total_rotation)[0].transpose() * _local_force_res[_i];
    global_moment_res[_i] = (*total_rotation)[0].transpose() * _local_moment_res[_i];
  }
}

computeJacobian()

void StressDivergenceBeam::computeJacobian ( )

overridevirtual

Definition at line 136 of file StressDivergenceBeam.C.

Referenced by computeOffDiagJacobian().

{
  DenseMatrix<Number> & ke = _assembly.jacobianBlock(_var.number(), _var.number());
  _local_ke.resize(ke.m(), ke.n());
  _local_ke.zero();

  for (unsigned int i = 0; i < _test.size(); ++i)
  {
    for (unsigned int j = 0; j < _phi.size(); ++j)
    {
      if (_component < 3)
        _local_ke(i, j) = (i == j ? 1 : -1) * _K11[0](_component, _component);
      else
      {
        if (i == j)
          _local_ke(i, j) = _K22[0](_component - 3, _component - 3);
        else
          _local_ke(i, j) = _K22_cross[0](_component - 3, _component - 3);
      }
    }
  }

  // scaling factor for Rayliegh damping and HHT time integration
  if (_isDamped && _dt > 0.0)
    _local_ke *= (1.0 + _alpha + (1.0 + _alpha) * _zeta[0] / _dt);

  ke += _local_ke;

  if (_has_diag_save_in)
  {
    unsigned int rows = ke.m();
    DenseVector<Number> diag(rows);
    for (unsigned int i = 0; i < rows; ++i)
      diag(i) = _local_ke(i, i);

    Threads::spin_mutex::scoped_lock lock(Threads::spin_mtx);
    for (unsigned int i = 0; i < _diag_save_in.size(); ++i)
      _diag_save_in[i]->sys().solution().add_vector(diag, _diag_save_in[i]->dofIndices());
  }
}

computeOffDiagJacobian()

void StressDivergenceBeam::computeOffDiagJacobian ( MooseVariableFEBase &  jvar )

overridevirtual

Definition at line 178 of file StressDivergenceBeam.C.

{
  size_t jvar_num = jvar.number();
  if (jvar_num == _var.number())
    computeJacobian();
  else
  {
    unsigned int coupled_component = 0;
    bool disp_coupled = false;
    bool rot_coupled = false;

    for (unsigned int i = 0; i < _ndisp; ++i)
    {
      if (jvar_num == _disp_var[i])
      {
        coupled_component = i;
        disp_coupled = true;
        break;
      }
    }

    for (unsigned int i = 0; i < _nrot; ++i)
    {
      if (jvar_num == _rot_var[i])
      {
        coupled_component = i + 3;
        rot_coupled = true;
        break;
      }
    }

    DenseMatrix<Number> & ke = _assembly.jacobianBlock(_var.number(), jvar_num);
    _local_ke.resize(ke.m(), ke.n());
    _local_ke.zero();

    if (disp_coupled || rot_coupled)
    {
      for (unsigned int i = 0; i < _test.size(); ++i)
      {
        for (unsigned int j = 0; j < _phi.size(); ++j)
        {
          if (_component < 3 && coupled_component < 3)
            _local_ke(i, j) += (i == j ? 1 : -1) * _K11[0](_component, coupled_component);
          else if (_component < 3 && coupled_component > 2)
          {
            if (i == 0)
              _local_ke(i, j) += _K21[0](coupled_component - 3, _component);
            else
              _local_ke(i, j) += _K21_cross[0](coupled_component - 3, _component);
          }
          else if (_component > 2 && coupled_component < 3)
          {
            if (j == 0)
              _local_ke(i, j) += _K21[0](_component - 3, coupled_component);
            else
              _local_ke(i, j) += _K21_cross[0](_component - 3, coupled_component);
          }
          else
          {
            if (i == j)
              _local_ke(i, j) += _K22[0](_component - 3, coupled_component - 3);
            else
              _local_ke(i, j) += _K22_cross[0](_component - 3, coupled_component - 3);
          }
        }
      }
    }

    // scaling factor for Rayleigh damping and HHT time integration
    if (_isDamped && _dt > 0.0)
      _local_ke *= (1.0 + _alpha + (1.0 + _alpha) * _zeta[0] / _dt);

    ke += _local_ke;
  }
}

computeQpResidual()

virtual Real StressDivergenceBeam::computeQpResidual ( )

inlineoverrideprotectedvirtual

Definition at line 29 of file StressDivergenceBeam.h.

{ return 0.0; }

computeResidual()

void StressDivergenceBeam::computeResidual ( )

overridevirtual

Definition at line 100 of file StressDivergenceBeam.C.

{
  DenseVector<Number> & re = _assembly.residualBlock(_var.number());
  mooseAssert(re.size() == 2, "StressDivergenceBeam: Beam element must have two nodes only.");
  _local_re.resize(re.size());
  _local_re.zero();

  _global_force_res.resize(_test.size());
  _global_moment_res.resize(_test.size());

  computeGlobalResidual(&_force, &_moment, &_total_rotation, _global_force_res, _global_moment_res);

  // add contributions from stiffness proportional damping (non-zero _zeta) or HHT time integration
  // (non-zero _alpha)
  if (_isDamped && _dt > 0.0)
    computeDynamicTerms(_global_force_res, _global_moment_res);

  for (_i = 0; _i < _test.size(); ++_i)
  {
    if (_component < 3)
      _local_re(_i) = _global_force_res[_i](_component);
    else
      _local_re(_i) = _global_moment_res[_i](_component - 3);
  }

  re += _local_re;

  if (_has_save_in)
  {
    Threads::spin_mutex::scoped_lock lock(Threads::spin_mtx);
    for (_i = 0; _i < _save_in.size(); ++_i)
      _save_in[_i]->sys().solution().add_vector(_local_re, _save_in[_i]->dofIndices());
  }
}

Member Data Documentation

_alpha

const Real& StressDivergenceBeam::_alpha

protected

HHT time integration parameter.

Definition at line 88 of file StressDivergenceBeam.h.

Referenced by computeDynamicTerms(), computeJacobian(), and computeOffDiagJacobian().

_component

const unsigned int StressDivergenceBeam::_component

protected

Direction along which force/moment is calculated.

Definition at line 43 of file StressDivergenceBeam.h.

Referenced by computeJacobian(), computeOffDiagJacobian(), and computeResidual().

_disp_var

std::vector<unsigned int> StressDivergenceBeam::_disp_var

protected

Variable numbers corresponding to displacement variables.

Definition at line 49 of file StressDivergenceBeam.h.

Referenced by computeOffDiagJacobian(), and StressDivergenceBeam().

_force

const MaterialProperty<RealVectorValue>& StressDivergenceBeam::_force

protected

Current force vector in global coordinate system.

Definition at line 58 of file StressDivergenceBeam.h.

Referenced by computeResidual().

_force_local_t

std::vector<RealVectorValue> StressDivergenceBeam::_force_local_t

protected

Forces at each Qp in the beam local configuration.

Definition at line 118 of file StressDivergenceBeam.h.

Referenced by computeGlobalResidual().

_force_old

const MaterialProperty<RealVectorValue>* StressDivergenceBeam::_force_old

protected

Old force vector in global coordinate system.

Definition at line 94 of file StressDivergenceBeam.h.

Referenced by computeDynamicTerms().

_force_older

const MaterialProperty<RealVectorValue>* StressDivergenceBeam::_force_older

protected

Older force vector in global coordinate system.

Definition at line 103 of file StressDivergenceBeam.h.

Referenced by computeDynamicTerms().

_global_force_res

std::vector<RealVectorValue> StressDivergenceBeam::_global_force_res

protected

Residual corresponding to displacement DOFs at the nodes in global coordinate system.

Definition at line 112 of file StressDivergenceBeam.h.

Referenced by computeResidual().

_global_moment_res

std::vector<RealVectorValue> StressDivergenceBeam::_global_moment_res

protected

Residual corresponding to rotational DOFs at the nodes in global coordinate system.

Definition at line 115 of file StressDivergenceBeam.h.

Referenced by computeResidual().

_isDamped

const bool StressDivergenceBeam::_isDamped

protected

Boolean flag to turn on Rayleigh damping or numerical damping due to HHT time integration.

Definition at line 91 of file StressDivergenceBeam.h.

Referenced by computeJacobian(), computeOffDiagJacobian(), and computeResidual().

_K11

const MaterialProperty<RankTwoTensor>& StressDivergenceBeam::_K11

protected

Stiffness matrix relating displacement DOFs of same node or across nodes.

Definition at line 64 of file StressDivergenceBeam.h.

Referenced by computeJacobian(), and computeOffDiagJacobian().

_K21

const MaterialProperty<RankTwoTensor>& StressDivergenceBeam::_K21

protected

Stiffness matrix relating displacement and rotations of same node.

Definition at line 76 of file StressDivergenceBeam.h.

Referenced by computeOffDiagJacobian().

_K21_cross

const MaterialProperty<RankTwoTensor>& StressDivergenceBeam::_K21_cross

protected

Stiffness matrix relating displacement of one node to rotations of another node.

Definition at line 73 of file StressDivergenceBeam.h.

Referenced by computeOffDiagJacobian().

_K22

const MaterialProperty<RankTwoTensor>& StressDivergenceBeam::_K22

protected

Stiffness matrix relating rotational DOFs of same node.

Definition at line 67 of file StressDivergenceBeam.h.

Referenced by computeJacobian(), and computeOffDiagJacobian().

_K22_cross

const MaterialProperty<RankTwoTensor>& StressDivergenceBeam::_K22_cross

protected

Stiffness matrix relating rotational DOFs across nodes.

Definition at line 70 of file StressDivergenceBeam.h.

Referenced by computeJacobian(), and computeOffDiagJacobian().

_local_force_res

std::vector<RealVectorValue> StressDivergenceBeam::_local_force_res

protected

Residual corresponding to displacement DOFs at the nodes in beam local coordinate system.

Definition at line 124 of file StressDivergenceBeam.h.

Referenced by computeGlobalResidual().

_local_moment_res

std::vector<RealVectorValue> StressDivergenceBeam::_local_moment_res

protected

Residual corresponding to rotational DOFs at the nodes in beam local coordinate system.

Definition at line 127 of file StressDivergenceBeam.h.

Referenced by computeGlobalResidual().

_moment

const MaterialProperty<RealVectorValue>& StressDivergenceBeam::_moment

protected

Current moment vector in global coordinate system.

Definition at line 61 of file StressDivergenceBeam.h.

Referenced by computeResidual().

_moment_local_t

std::vector<RealVectorValue> StressDivergenceBeam::_moment_local_t

protected

Moments at each Qp in the beam local configuration.

Definition at line 121 of file StressDivergenceBeam.h.

Referenced by computeGlobalResidual().

_moment_old

const MaterialProperty<RealVectorValue>* StressDivergenceBeam::_moment_old

protected

Old moment vector in global coordinate system.

Definition at line 97 of file StressDivergenceBeam.h.

Referenced by computeDynamicTerms().

_moment_older

const MaterialProperty<RealVectorValue>* StressDivergenceBeam::_moment_older

protected

Older moment vector in global coordinate system.

Definition at line 106 of file StressDivergenceBeam.h.

Referenced by computeDynamicTerms().

_ndisp

unsigned int StressDivergenceBeam::_ndisp

protected

Number of coupled displacement variables.

Definition at line 46 of file StressDivergenceBeam.h.

Referenced by computeOffDiagJacobian(), and StressDivergenceBeam().

_nrot

unsigned int StressDivergenceBeam::_nrot

protected

Number of coupled rotational variables.

Definition at line 52 of file StressDivergenceBeam.h.

Referenced by computeOffDiagJacobian(), and StressDivergenceBeam().

_original_length

const MaterialProperty<Real>& StressDivergenceBeam::_original_length

protected

Initial length of beam.

Definition at line 79 of file StressDivergenceBeam.h.

Referenced by computeGlobalResidual().

_rot_var

std::vector<unsigned int> StressDivergenceBeam::_rot_var

protected

Variable numbers corresponding to rotational variables.

Definition at line 55 of file StressDivergenceBeam.h.

Referenced by computeOffDiagJacobian(), and StressDivergenceBeam().

_total_rotation

const MaterialProperty<RankTwoTensor>& StressDivergenceBeam::_total_rotation

protected

Rotational transformation from global to current beam local coordinate system.

Definition at line 82 of file StressDivergenceBeam.h.

Referenced by computeResidual().

_total_rotation_old

const MaterialProperty<RankTwoTensor>* StressDivergenceBeam::_total_rotation_old

protected

Rotational transformation from global to old beam local coordinate system.

Definition at line 100 of file StressDivergenceBeam.h.

Referenced by computeDynamicTerms().

_total_rotation_older

const MaterialProperty<RankTwoTensor>* StressDivergenceBeam::_total_rotation_older

protected

Rotational transformation from global to older beam local coordinate system.

Definition at line 109 of file StressDivergenceBeam.h.

Referenced by computeDynamicTerms().

_zeta

const MaterialProperty<Real>& StressDivergenceBeam::_zeta

protected

Stiffness proportional Rayleigh damping parameter.

Definition at line 85 of file StressDivergenceBeam.h.

Referenced by computeDynamicTerms(), computeJacobian(), and computeOffDiagJacobian().

---

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

• tensor_mechanics/include/kernels/StressDivergenceBeam.h
• tensor_mechanics/src/kernels/StressDivergenceBeam.C