#include <StressDivergenceTensorsTruss.h>

Inheritance diagram for StressDivergenceTensorsTruss:

Public Member Functions
	StressDivergenceTensorsTruss (const InputParameters &parameters)

Static Public Member Functions
static InputParameters	validParams ()

Protected Member Functions
virtual void	initialSetup () override

virtual void	computeResidual () override

virtual Real	computeQpResidual () override

virtual Real	computeStiffness (unsigned int i, unsigned int j)

virtual void	computeJacobian () override

virtual void	computeOffDiagJacobian (MooseVariableFEBase &jvar) override

Protected Attributes
const std::string	_base_name

const MaterialProperty< Real > &	_axial_stress

const MaterialProperty< Real > &	_e_over_l

Private Attributes
const unsigned int	_component

const unsigned int	_ndisp

const bool	_temp_coupled

const unsigned int	_temp_var

std::vector< unsigned int >	_disp_var

const VariableValue &	_area

const std::vector< RealGradient > *	_orientation

Detailed Description

Definition at line 20 of file StressDivergenceTensorsTruss.h.

Constructor & Destructor Documentation

◆ StressDivergenceTensorsTruss()

StressDivergenceTensorsTruss::StressDivergenceTensorsTruss ( const InputParameters & parameters )

Definition at line 40 of file StressDivergenceTensorsTruss.C.

   : Kernel(parameters),
     _base_name(isParamValid("base_name") ? getParam<std::string>("base_name") + "_" : ""),
     _axial_stress(getMaterialPropertyByName<Real>(_base_name + "axial_stress")),
     _e_over_l(getMaterialPropertyByName<Real>(_base_name + "e_over_l")),
     _component(getParam<unsigned int>("component")),
     _ndisp(coupledComponents("displacements")),
     _temp_coupled(isCoupled("temperature")),
     _temp_var(_temp_coupled ? coupled("temperature") : 0),
     _area(coupledValue("area")),
     _orientation(NULL)
 {
   for (unsigned int i = 0; i < _ndisp; ++i)
     _disp_var.push_back(coupled("displacements", i));
 }

Member Function Documentation

◆ computeJacobian()

void StressDivergenceTensorsTruss::computeJacobian ( )

overrideprotectedvirtual

Definition at line 97 of file StressDivergenceTensorsTruss.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)
       _local_ke(i, j) += (i == j ? 1 : -1) * computeStiffness(_component, _component);
  
   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 StressDivergenceTensorsTruss::computeOffDiagJacobian ( MooseVariableFEBase & jvar )

overrideprotectedvirtual

Definition at line 121 of file StressDivergenceTensorsTruss.C.

 {
   size_t jvar_num = jvar.number();
   if (jvar_num == _var.number())
     computeJacobian();
   else
   {
     // This (undisplaced) jvar could potentially yield the wrong phi size if this object is acting
     // on the displaced mesh
     auto phi_size = _sys.getVariable(_tid, jvar.number()).dofIndices().size();
  
     unsigned int coupled_component = 0;
     bool disp_coupled = false;
  
     for (unsigned int i = 0; i < _ndisp; ++i)
       if (jvar_num == _disp_var[i])
       {
         coupled_component = i;
         disp_coupled = true;
         break;
       }
  
     if (disp_coupled)
     {
       prepareMatrixTag(_assembly, _var.number(), jvar_num);
  
       for (unsigned int i = 0; i < _test.size(); ++i)
         for (unsigned int j = 0; j < phi_size; ++j)
           _local_ke(i, j) += (i == j ? 1 : -1) * computeStiffness(_component, coupled_component);
  
       accumulateTaggedLocalMatrix();
     }
     else if (false) // Need some code here for coupling with temperature
     {
     }
   }
 }

◆ computeQpResidual()

virtual Real StressDivergenceTensorsTruss::computeQpResidual ( )

inlineoverrideprotectedvirtual

Definition at line 30 of file StressDivergenceTensorsTruss.h.

30 { return 0.0; }

◆ computeResidual()

void StressDivergenceTensorsTruss::computeResidual ( )

overrideprotectedvirtual

Definition at line 63 of file StressDivergenceTensorsTruss.C.

 {
   prepareVectorTag(_assembly, _var.number());
  
   mooseAssert(_local_re.size() == 2, "Truss element has and only has two nodes.");
  
   RealGradient orientation((*_orientation)[0]);
   orientation /= orientation.norm();
  
   VectorValue<Real> force_local = _axial_stress[0] * _area[0] * orientation;
  
   _local_re(0) = -force_local(_component);
   _local_re(1) = -_local_re(0);
  
   accumulateTaggedLocalResidual();
  
   if (_has_save_in)
   {
     Threads::spin_mutex::scoped_lock lock(Threads::spin_mtx);
     for (unsigned int i = 0; i < _save_in.size(); ++i)
       _save_in[i]->sys().solution().add_vector(_local_re, _save_in[i]->dofIndices());
   }
 }

◆ computeStiffness()

Real StressDivergenceTensorsTruss::computeStiffness	(	unsigned int	i,
		unsigned int	j
	)

protectedvirtual

Definition at line 88 of file StressDivergenceTensorsTruss.C.

 {
   RealGradient orientation((*_orientation)[0]);
   orientation /= orientation.norm();
  
   return orientation(i) * orientation(j) * _e_over_l[0] * _area[0];
 }

Referenced by computeJacobian(), and computeOffDiagJacobian().

◆ initialSetup()

void StressDivergenceTensorsTruss::initialSetup ( )

overrideprotectedvirtual

Definition at line 57 of file StressDivergenceTensorsTruss.C.

 {
   _orientation = &_subproblem.assembly(_tid).getFE(FEType(), 1)->get_dxyzdxi();
 }

◆ validParams()

InputParameters StressDivergenceTensorsTruss::validParams ( )

static

Definition at line 23 of file StressDivergenceTensorsTruss.C.

 {
   InputParameters params = Kernel::validParams();
   params.addClassDescription("Kernel for truss element");
   params.addRequiredParam<unsigned int>("component",
                                         "An integer corresponding to the direction "
                                         "the variable this kernel acts in. (0 for x, "
                                         "1 for y, 2 for z)");
   params.addCoupledVar("displacements",
                        "The string of displacements suitable for the problem statement");
   params.addCoupledVar("temperature", "The temperature");
   params.addCoupledVar("area", "Cross-sectional area of truss element");
   params.addParam<std::string>("base_name", "Material property base name");
   params.set<bool>("use_displaced_mesh") = true;
   return params;
 }