#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

Static Public Member Functions
static InputParameters	validParams ()

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 23 of file StressDivergenceBeam.h.

Constructor & Destructor Documentation

◆ StressDivergenceBeam()

StressDivergenceBeam::StressDivergenceBeam ( const InputParameters & parameters )

Definition at line 54 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 254 of file StressDivergenceBeam.C.

 {
   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);
   }
 }

Referenced by computeResidual().

◆ 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 290 of file StressDivergenceBeam.C.

 {
   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];
   }
 }

Referenced by computeDynamicTerms(), and computeResidual().

◆ computeJacobian()

void StressDivergenceBeam::computeJacobian ( )

overridevirtual

Definition at line 139 of file StressDivergenceBeam.C.

 {
   prepareMatrixTag(_assembly, _var.number(), _var.number());
  
   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);
  
   accumulateTaggedLocalMatrix();
  
   if (_has_diag_save_in)
   {
     unsigned int rows = _local_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());
   }
 }

Referenced by computeOffDiagJacobian().

◆ computeOffDiagJacobian()

void StressDivergenceBeam::computeOffDiagJacobian ( MooseVariableFEBase & jvar )

overridevirtual

Definition at line 179 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;
       }
     }
  
     prepareMatrixTag(_assembly, _var.number(), jvar_num);
  
     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);
  
     accumulateTaggedLocalMatrix();
   }
 }

◆ computeQpResidual()

virtual Real StressDivergenceBeam::computeQpResidual ( )

inlineoverrideprotectedvirtual

Definition at line 35 of file StressDivergenceBeam.h.

35 { return 0.0; }

◆ computeResidual()

void StressDivergenceBeam::computeResidual ( )

overridevirtual

Definition at line 103 of file StressDivergenceBeam.C.

 {
   prepareVectorTag(_assembly, _var.number());
  
   mooseAssert(_local_re.size() == 2,
               "StressDivergenceBeam: Beam element must have two nodes only.");
  
   _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);
   }
  
   accumulateTaggedLocalResidual();
  
   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());
   }
 }

◆ validParams()

InputParameters StressDivergenceBeam::validParams ( )

static

Definition at line 28 of file StressDivergenceBeam.C.

 {
   InputParameters params = Kernel::validParams();
   params.addClassDescription("Quasi-static and dynamic stress divergence kernel for Beam element");
   params.addRequiredParam<unsigned int>(
       "component",
       "An integer corresponding to the direction "
       "the variable this kernel acts in. (0 for disp_x, "
       "1 for disp_y, 2 for disp_z, 3 for rot_x, 4 for rot_y and 5 for rot_z)");
   params.addRequiredCoupledVar(
       "displacements",
       "The displacements appropriate for the simulation geometry and coordinate system");
   params.addRequiredCoupledVar(
       "rotations", "The rotations appropriate for the simulation geometry and coordinate system");
   params.addParam<MaterialPropertyName>(
       "zeta",
       0.0,
       "Name of material property or a constant real number defining the zeta parameter for the "
       "Rayleigh damping.");
   params.addRangeCheckedParam<Real>(
       "alpha", 0.0, "alpha >= -0.3333 & alpha <= 0.0", "alpha parameter for HHT time integration");
  
   params.set<bool>("use_displaced_mesh") = true;
   return params;
 }

Member Data Documentation

◆ _alpha

const Real& StressDivergenceBeam::_alpha

protected

HHT time integration parameter.

Definition at line 94 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 49 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 55 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 64 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 124 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 100 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 109 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 118 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 121 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 97 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 70 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 82 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 79 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 73 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 76 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 130 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 133 of file StressDivergenceBeam.h.

Referenced by computeGlobalResidual().

◆ _moment

const MaterialProperty<RealVectorValue>& StressDivergenceBeam::_moment

protected

Current moment vector in global coordinate system.

Definition at line 67 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 127 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 103 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 112 of file StressDivergenceBeam.h.

Referenced by computeDynamicTerms().

◆ _ndisp

unsigned int StressDivergenceBeam::_ndisp

protected

Number of coupled displacement variables.

Definition at line 52 of file StressDivergenceBeam.h.

Referenced by computeOffDiagJacobian(), and StressDivergenceBeam().

◆ _nrot

unsigned int StressDivergenceBeam::_nrot

protected

Number of coupled rotational variables.

Definition at line 58 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 85 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 61 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 88 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 106 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 115 of file StressDivergenceBeam.h.

Referenced by computeDynamicTerms().

◆ _zeta

const MaterialProperty<Real>& StressDivergenceBeam::_zeta

protected

Stiffness proportional Rayleigh damping parameter.

Definition at line 91 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

Public Member Functions

Static Public Member Functions

Protected Member Functions

Protected Attributes

Detailed Description

Constructor & Destructor Documentation

◆ StressDivergenceBeam()

Member Function Documentation

◆ computeDynamicTerms()

◆ computeGlobalResidual()

◆ computeJacobian()

◆ computeOffDiagJacobian()

◆ computeQpResidual()

◆ computeResidual()

◆ validParams()

Member Data Documentation

◆ _alpha

◆ _component

◆ _disp_var

◆ _force

◆ _force_local_t

◆ _force_old

◆ _force_older

◆ _global_force_res

◆ _global_moment_res

◆ _isDamped

◆ _K11

◆ _K21

◆ _K21_cross

◆ _K22

◆ _K22_cross

◆ _local_force_res

◆ _local_moment_res

◆ _moment

◆ _moment_local_t

◆ _moment_old

◆ _moment_older

◆ _ndisp

◆ _nrot

◆ _original_length

◆ _rot_var

◆ _total_rotation

◆ _total_rotation_old

◆ _total_rotation_older

◆ _zeta