www.mooseframework.org
Public Member Functions | Protected Member Functions | Protected Attributes | List of all members
StressDivergenceRSphericalTensors Class Reference

StressDivergenceRSphericalTensors is a modification of StressDivergenceTensors for 1D spherically symmetric problems. More...

#include <StressDivergenceRSphericalTensors.h>

Inheritance diagram for StressDivergenceRSphericalTensors:
[legend]

Public Member Functions

 StressDivergenceRSphericalTensors (const InputParameters &parameters)
 
virtual void computeJacobian () override
 
virtual void computeOffDiagJacobian (MooseVariableFEBase &jvar) override
 

Protected Member Functions

virtual void initialSetup () override
 
virtual Real computeQpResidual () override
 
virtual Real computeQpJacobian () override
 
virtual Real computeQpOffDiagJacobian (unsigned int jvar) override
 
Real calculateJacobian (unsigned int ivar, unsigned int jvar)
 
virtual void computeResidual () override
 
virtual void computeFiniteDeformJacobian ()
 
virtual void computeAverageGradientTest ()
 
virtual void computeAverageGradientPhi ()
 

Protected Attributes

std::string _base_name
 
bool _use_finite_deform_jacobian
 
const MaterialProperty< RankTwoTensor > & _stress
 
const MaterialProperty< RankFourTensor > & _Jacobian_mult
 
std::vector< RankFourTensor > _finite_deform_Jacobian_mult
 
const MaterialProperty< RankTwoTensor > * _deformation_gradient
 
const MaterialProperty< RankTwoTensor > * _deformation_gradient_old
 
const MaterialProperty< RankTwoTensor > * _rotation_increment
 
const unsigned int _component
 
unsigned int _ndisp
 Coupled displacement variables. More...
 
std::vector< unsigned int > _disp_var
 
const bool _temp_coupled
 
const unsigned int _temp_var
 
const MaterialProperty< RankTwoTensor > *const _deigenstrain_dT
 d(strain)/d(temperature), if computed by ComputeThermalExpansionEigenstrain More...
 
const bool _out_of_plane_strain_coupled
 
const unsigned int _out_of_plane_strain_var
 
const unsigned int _out_of_plane_direction
 
std::vector< std::vector< Real > > _avg_grad_test
 Gradient of test function averaged over the element. Used in volumetric locking correction calculation. More...
 
std::vector< std::vector< Real > > _avg_grad_phi
 Gradient of phi function averaged over the element. Used in volumetric locking correction calculation. More...
 
bool _volumetric_locking_correction
 Flag for volumetric locking correction. More...
 
Assembly & _assembly_undisplaced
 undisplaced problem More...
 
MooseVariable & _var_undisplaced
 Reference to this Kernel's undisplaced MooseVariable object. More...
 
const VariablePhiGradient & _grad_phi_undisplaced
 Shape and test functions on the undisplaced mesh. More...
 
const VariableTestGradient & _grad_test_undisplaced
 

Detailed Description

StressDivergenceRSphericalTensors is a modification of StressDivergenceTensors for 1D spherically symmetric problems.

The main modifications from the original StressDivergenceTensors code are requirements from the dependence of stress in the polar and azimuthal stresses on displacement and position in the radial direction. This kernel is for symmetrical loading only. If solving an anisotropic material problem, recall that the orientation of the basis vectors ({e}_r) change with position, so the components of the elasticity tensor are functions of position. Reference: Bower, A.F. Applied Mechanics of Solids (2012). Chapter 4. Available online at solidmechanics.org Within this kernel, '_disp_x' refers to displacement in the radial direction. The COORD_TYPE in the Problem block must be set to RSpherical.

Definition at line 35 of file StressDivergenceRSphericalTensors.h.

Constructor & Destructor Documentation

◆ StressDivergenceRSphericalTensors()

StressDivergenceRSphericalTensors::StressDivergenceRSphericalTensors ( const InputParameters &  parameters)

Definition at line 33 of file StressDivergenceRSphericalTensors.C.

35  : StressDivergenceTensors(parameters)
36 {
37  if (_component != 0)
38  mooseError("Invalid component for this 1D RSpherical problem.");
39 }
StressDivergenceTensors(const InputParameters &parameters)

Member Function Documentation

◆ calculateJacobian()

Real StressDivergenceRSphericalTensors::calculateJacobian ( unsigned int  ivar,
unsigned int  jvar 
)
protected

Definition at line 77 of file StressDivergenceRSphericalTensors.C.

Referenced by computeQpJacobian(), and computeQpOffDiagJacobian().

78 {
79  RealGradient test_r, phi_r;
80 
81  mooseAssert(ivar == 0 && jvar == 0,
82  "Invalid component in Jacobian Calculation"); // Only nonzero case for a 1D simulation
83 
84  if (ivar == 0) // Case grad_test for r, requires contributions from stress_{rr}, stress_{\theta
85  // \theta}, and stress_{\phi \phi}
86  {
87  test_r(0) = _grad_test[_i][_qp](0);
88  test_r(1) = _test[_i][_qp] / _q_point[_qp](0);
89  test_r(2) = _test[_i][_qp] / _q_point[_qp](0);
90  }
91 
92  if (jvar == 0)
93  {
94  phi_r(0) = _grad_phi[_j][_qp](0);
95  phi_r(1) = _phi[_j][_qp] / _q_point[_qp](0);
96  phi_r(2) = _phi[_j][_qp] / _q_point[_qp](0);
97  }
98 
99  return ElasticityTensorTools::elasticJacobian(_Jacobian_mult[_qp], ivar, jvar, test_r, phi_r);
100 }
Real elasticJacobian(const RankFourTensor &r4t, unsigned int i, unsigned int k, const RealGradient &grad_test, const RealGradient &grad_phi)
This is used for the standard kernel stress_ij*d(test)/dx_j, when varied wrt u_k Jacobian entry: d(st...
const MaterialProperty< RankFourTensor > & _Jacobian_mult

◆ computeAverageGradientPhi()

void StressDivergenceTensors::computeAverageGradientPhi ( )
protectedvirtualinherited

Reimplemented in StressDivergenceRZTensors.

Definition at line 402 of file StressDivergenceTensors.C.

Referenced by StressDivergenceTensors::computeJacobian(), and StressDivergenceTensors::computeOffDiagJacobian().

403 {
404  // Calculate volume average derivatives for phi
405  _avg_grad_phi.resize(_phi.size());
406  for (_i = 0; _i < _phi.size(); ++_i)
407  {
408  _avg_grad_phi[_i].resize(3);
409  for (unsigned int component = 0; component < _mesh.dimension(); ++component)
410  {
411  _avg_grad_phi[_i][component] = 0.0;
412  for (_qp = 0; _qp < _qrule->n_points(); ++_qp)
413  _avg_grad_phi[_i][component] += _grad_phi[_i][_qp](component) * _JxW[_qp] * _coord[_qp];
414 
415  _avg_grad_phi[_i][component] /= _current_elem_volume;
416  }
417  }
418 }
std::vector< std::vector< Real > > _avg_grad_phi
Gradient of phi function averaged over the element. Used in volumetric locking correction calculation...
Real component(const SymmTensor &symm_tensor, unsigned int index)

◆ computeAverageGradientTest()

void StressDivergenceTensors::computeAverageGradientTest ( )
protectedvirtualinherited

Reimplemented in StressDivergenceRZTensors.

Definition at line 386 of file StressDivergenceTensors.C.

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

387 {
388  // Calculate volume averaged value of shape function derivative
389  _avg_grad_test.resize(_test.size());
390  for (_i = 0; _i < _test.size(); ++_i)
391  {
392  _avg_grad_test[_i].resize(3);
393  _avg_grad_test[_i][_component] = 0.0;
394  for (_qp = 0; _qp < _qrule->n_points(); ++_qp)
395  _avg_grad_test[_i][_component] += _grad_test[_i][_qp](_component) * _JxW[_qp] * _coord[_qp];
396 
397  _avg_grad_test[_i][_component] /= _current_elem_volume;
398  }
399 }
std::vector< std::vector< Real > > _avg_grad_test
Gradient of test function averaged over the element. Used in volumetric locking correction calculatio...

◆ computeFiniteDeformJacobian()

void StressDivergenceTensors::computeFiniteDeformJacobian ( )
protectedvirtualinherited

Definition at line 329 of file StressDivergenceTensors.C.

Referenced by StressDivergenceTensors::computeJacobian(), and StressDivergenceTensors::computeOffDiagJacobian().

330 {
331  const RankTwoTensor I(RankTwoTensor::initIdentity);
332  const RankFourTensor II_ijkl = I.mixedProductIkJl(I);
333 
334  // Bring back to unrotated config
335  const RankTwoTensor unrotated_stress =
336  (*_rotation_increment)[_qp].transpose() * _stress[_qp] * (*_rotation_increment)[_qp];
337 
338  // Incremental deformation gradient Fhat
339  const RankTwoTensor Fhat =
340  (*_deformation_gradient)[_qp] * (*_deformation_gradient_old)[_qp].inverse();
341  const RankTwoTensor Fhatinv = Fhat.inverse();
342 
343  const RankTwoTensor rot_times_stress = (*_rotation_increment)[_qp] * unrotated_stress;
344  const RankFourTensor dstress_drot =
345  I.mixedProductIkJl(rot_times_stress) + I.mixedProductJkIl(rot_times_stress);
346  const RankFourTensor rot_rank_four =
347  (*_rotation_increment)[_qp].mixedProductIkJl((*_rotation_increment)[_qp]);
348  const RankFourTensor drot_dUhatinv = Fhat.mixedProductIkJl(I);
349 
350  const RankTwoTensor A = I - Fhatinv;
351 
352  // Ctilde = Chat^-1 - I
353  const RankTwoTensor Ctilde = A * A.transpose() - A - A.transpose();
354  const RankFourTensor dCtilde_dFhatinv =
355  -I.mixedProductIkJl(A) - I.mixedProductJkIl(A) + II_ijkl + I.mixedProductJkIl(I);
356 
357  // Second order approximation of Uhat - consistent with strain increment definition
358  // const RankTwoTensor Uhat = I - 0.5 * Ctilde - 3.0/8.0 * Ctilde * Ctilde;
359 
360  RankFourTensor dUhatinv_dCtilde =
361  0.5 * II_ijkl - 1.0 / 8.0 * (I.mixedProductIkJl(Ctilde) + Ctilde.mixedProductIkJl(I));
362  RankFourTensor drot_dFhatinv = drot_dUhatinv * dUhatinv_dCtilde * dCtilde_dFhatinv;
363 
364  drot_dFhatinv -= Fhat.mixedProductIkJl((*_rotation_increment)[_qp].transpose());
365  _finite_deform_Jacobian_mult[_qp] = dstress_drot * drot_dFhatinv;
366 
367  const RankFourTensor dstrain_increment_dCtilde =
368  -0.5 * II_ijkl + 0.25 * (I.mixedProductIkJl(Ctilde) + Ctilde.mixedProductIkJl(I));
370  rot_rank_four * _Jacobian_mult[_qp] * dstrain_increment_dCtilde * dCtilde_dFhatinv;
371  _finite_deform_Jacobian_mult[_qp] += Fhat.mixedProductJkIl(_stress[_qp]);
372 
373  const RankFourTensor dFhat_dFhatinv = -Fhat.mixedProductIkJl(Fhat.transpose());
374  const RankTwoTensor dJ_dFhatinv = dFhat_dFhatinv.innerProductTranspose(Fhat.ddet());
375 
376  // Component from Jacobian derivative
377  _finite_deform_Jacobian_mult[_qp] += _stress[_qp].outerProduct(dJ_dFhatinv);
378 
379  // Derivative of Fhatinv w.r.t. undisplaced coordinates
380  const RankTwoTensor Finv = (*_deformation_gradient)[_qp].inverse();
381  const RankFourTensor dFhatinv_dGradu = -Fhatinv.mixedProductIkJl(Finv.transpose());
382  _finite_deform_Jacobian_mult[_qp] = _finite_deform_Jacobian_mult[_qp] * dFhatinv_dGradu;
383 }
const MaterialProperty< RankTwoTensor > * _rotation_increment
std::vector< RankFourTensor > _finite_deform_Jacobian_mult
const MaterialProperty< RankFourTensor > & _Jacobian_mult
const MaterialProperty< RankTwoTensor > & _stress

◆ computeJacobian()

void StressDivergenceTensors::computeJacobian ( )
overridevirtualinherited

Reimplemented from ALEKernel.

Definition at line 154 of file StressDivergenceTensors.C.

155 {
157  {
160  }
161 
163  {
164  _finite_deform_Jacobian_mult.resize(_qrule->n_points());
165 
166  for (_qp = 0; _qp < _qrule->n_points(); ++_qp)
168 
170  }
171  else
172  Kernel::computeJacobian();
173 }
bool _volumetric_locking_correction
Flag for volumetric locking correction.
std::vector< RankFourTensor > _finite_deform_Jacobian_mult
virtual void computeFiniteDeformJacobian()
virtual void computeJacobian() override
Definition: ALEKernel.C:35

◆ computeOffDiagJacobian()

void StressDivergenceTensors::computeOffDiagJacobian ( MooseVariableFEBase &  jvar)
overridevirtualinherited

Reimplemented from ALEKernel.

Definition at line 176 of file StressDivergenceTensors.C.

177 {
179  {
182  }
183 
185  {
186  _finite_deform_Jacobian_mult.resize(_qrule->n_points());
187 
188  for (_qp = 0; _qp < _qrule->n_points(); ++_qp)
190 
192  }
193  else
194  Kernel::computeOffDiagJacobian(jvar);
195 }
bool _volumetric_locking_correction
Flag for volumetric locking correction.
virtual void computeOffDiagJacobian(MooseVariableFEBase &jvar) override
Definition: ALEKernel.C:42
std::vector< RankFourTensor > _finite_deform_Jacobian_mult
virtual void computeFiniteDeformJacobian()

◆ computeQpJacobian()

Real StressDivergenceRSphericalTensors::computeQpJacobian ( )
overrideprotectedvirtual

Reimplemented from StressDivergenceTensors.

Definition at line 58 of file StressDivergenceRSphericalTensors.C.

59 {
61 }
Real calculateJacobian(unsigned int ivar, unsigned int jvar)

◆ computeQpOffDiagJacobian()

Real StressDivergenceRSphericalTensors::computeQpOffDiagJacobian ( unsigned int  jvar)
overrideprotectedvirtual

Reimplemented from StressDivergenceTensors.

Definition at line 64 of file StressDivergenceRSphericalTensors.C.

65 {
66  for (unsigned int i = 0; i < _ndisp; ++i)
67  if (jvar == _disp_var[i])
68  return calculateJacobian(_component, i);
69 
70  if (_temp_coupled && jvar == _temp_var)
71  return 0.0;
72 
73  return 0.0;
74 }
unsigned int _ndisp
Coupled displacement variables.
std::vector< unsigned int > _disp_var
Real calculateJacobian(unsigned int ivar, unsigned int jvar)

◆ computeQpResidual()

Real StressDivergenceRSphericalTensors::computeQpResidual ( )
overrideprotectedvirtual

Reimplemented from StressDivergenceTensors.

Definition at line 50 of file StressDivergenceRSphericalTensors.C.

51 {
52  return _grad_test[_i][_qp](0) * _stress[_qp](0, 0) + // stress_{rr} part 1
53  +(_test[_i][_qp] / _q_point[_qp](0)) * _stress[_qp](1, 1) + // stress_{\theta \theta}
54  +(_test[_i][_qp] / _q_point[_qp](0)) * _stress[_qp](2, 2); // stress_{\phi \phi}
55 }
const MaterialProperty< RankTwoTensor > & _stress

◆ computeResidual()

void StressDivergenceTensors::computeResidual ( )
overrideprotectedvirtualinherited

Definition at line 117 of file StressDivergenceTensors.C.

118 {
119  DenseVector<Number> & re = _assembly.residualBlock(_var.number());
120  _local_re.resize(re.size());
121  _local_re.zero();
122 
125 
126  precalculateResidual();
127  for (_i = 0; _i < _test.size(); ++_i)
128  for (_qp = 0; _qp < _qrule->n_points(); ++_qp)
129  _local_re(_i) += _JxW[_qp] * _coord[_qp] * computeQpResidual();
130 
131  re += _local_re;
132 
133  if (_has_save_in)
134  {
135  Threads::spin_mutex::scoped_lock lock(Threads::spin_mtx);
136  for (const auto & var : _save_in)
137  var->sys().solution().add_vector(_local_re, var->dofIndices());
138  }
139 }
bool _volumetric_locking_correction
Flag for volumetric locking correction.
virtual Real computeQpResidual() override

◆ initialSetup()

void StressDivergenceRSphericalTensors::initialSetup ( )
overrideprotectedvirtual

Reimplemented from StressDivergenceTensors.

Definition at line 42 of file StressDivergenceRSphericalTensors.C.

43 {
44  if (getBlockCoordSystem() != Moose::COORD_RSPHERICAL)
45  mooseError("The coordinate system in the Problem block must be set to RSPHERICAL for 1D "
46  "spherically symmetric geometries.");
47 }

Member Data Documentation

◆ _assembly_undisplaced

Assembly& ALEKernel::_assembly_undisplaced
protectedinherited

undisplaced problem

Definition at line 33 of file ALEKernel.h.

◆ _avg_grad_phi

std::vector<std::vector<Real> > StressDivergenceTensors::_avg_grad_phi
protectedinherited

◆ _avg_grad_test

std::vector<std::vector<Real> > StressDivergenceTensors::_avg_grad_test
protectedinherited

◆ _base_name

std::string StressDivergenceTensors::_base_name
protectedinherited

◆ _component

const unsigned int StressDivergenceTensors::_component
protectedinherited

◆ _deformation_gradient

const MaterialProperty<RankTwoTensor>* StressDivergenceTensors::_deformation_gradient
protectedinherited

◆ _deformation_gradient_old

const MaterialProperty<RankTwoTensor>* StressDivergenceTensors::_deformation_gradient_old
protectedinherited

◆ _deigenstrain_dT

const MaterialProperty<RankTwoTensor>* const StressDivergenceTensors::_deigenstrain_dT
protectedinherited

d(strain)/d(temperature), if computed by ComputeThermalExpansionEigenstrain

Definition at line 73 of file StressDivergenceTensors.h.

◆ _disp_var

std::vector<unsigned int> StressDivergenceTensors::_disp_var
protectedinherited

◆ _finite_deform_Jacobian_mult

std::vector<RankFourTensor> StressDivergenceTensors::_finite_deform_Jacobian_mult
protectedinherited

◆ _grad_phi_undisplaced

const VariablePhiGradient& ALEKernel::_grad_phi_undisplaced
protectedinherited

Shape and test functions on the undisplaced mesh.

Definition at line 39 of file ALEKernel.h.

Referenced by StressDivergenceTensors::computeQpJacobian(), and StressDivergenceTensors::computeQpOffDiagJacobian().

◆ _grad_test_undisplaced

const VariableTestGradient& ALEKernel::_grad_test_undisplaced
protectedinherited

Definition at line 40 of file ALEKernel.h.

◆ _Jacobian_mult

const MaterialProperty<RankFourTensor>& StressDivergenceTensors::_Jacobian_mult
protectedinherited

◆ _ndisp

unsigned int StressDivergenceTensors::_ndisp
protectedinherited

◆ _out_of_plane_direction

const unsigned int StressDivergenceTensors::_out_of_plane_direction
protectedinherited

◆ _out_of_plane_strain_coupled

const bool StressDivergenceTensors::_out_of_plane_strain_coupled
protectedinherited

◆ _out_of_plane_strain_var

const unsigned int StressDivergenceTensors::_out_of_plane_strain_var
protectedinherited

◆ _rotation_increment

const MaterialProperty<RankTwoTensor>* StressDivergenceTensors::_rotation_increment
protectedinherited

◆ _stress

const MaterialProperty<RankTwoTensor>& StressDivergenceTensors::_stress
protectedinherited

◆ _temp_coupled

const bool StressDivergenceTensors::_temp_coupled
protectedinherited

◆ _temp_var

const unsigned int StressDivergenceTensors::_temp_var
protectedinherited

◆ _use_finite_deform_jacobian

bool StressDivergenceTensors::_use_finite_deform_jacobian
protectedinherited

◆ _var_undisplaced

MooseVariable& ALEKernel::_var_undisplaced
protectedinherited

Reference to this Kernel's undisplaced MooseVariable object.

Definition at line 36 of file ALEKernel.h.

◆ _volumetric_locking_correction

bool StressDivergenceTensors::_volumetric_locking_correction
protectedinherited

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