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

ComputeAxisymmetricRZFiniteStrain defines a strain increment and rotation increment for finite strains in an Axisymmetric simulation. More...

#include <ComputeAxisymmetricRZFiniteStrain.h>

Inheritance diagram for ComputeAxisymmetricRZFiniteStrain:
[legend]

Public Member Functions

 ComputeAxisymmetricRZFiniteStrain (const InputParameters &parameters)
 
void initialSetup () override
 
virtual void computeProperties () override
 

Static Public Member Functions

static MooseEnum decompositionType ()
 

Protected Member Functions

Real computeOutOfPlaneGradDisp () override
 Computes the current out-of-plane component of the displacement gradient; as a virtual function, this function is overwritten for the specific geometries defined by inheriting classes. More...
 
Real computeOutOfPlaneGradDispOld () override
 Computes the old out-of-plane component of the displacement gradient; as a virtual function, this function is overwritten for the specific geometries defined by inheriting classes. More...
 
virtual void displacementIntegrityCheck () override
 
virtual void computeQpStrain ()
 
virtual void computeQpIncrements (RankTwoTensor &e, RankTwoTensor &r)
 
virtual void initQpStatefulProperties () override
 
void subtractEigenstrainIncrementFromStrain (RankTwoTensor &strain)
 

Protected Attributes

const VariableValue & _disp_old_0
 the old value of the first component of the displacements vector More...
 
const unsigned int _out_of_plane_direction
 
std::vector< RankTwoTensor_Fhat
 
std::vector< const VariableGradient * > _grad_disp_old
 
MaterialProperty< RankTwoTensor > & _strain_rate
 
MaterialProperty< RankTwoTensor > & _strain_increment
 
MaterialProperty< RankTwoTensor > & _rotation_increment
 
MaterialProperty< RankTwoTensor > & _deformation_gradient
 
const MaterialProperty< RankTwoTensor > & _mechanical_strain_old
 
const MaterialProperty< RankTwoTensor > & _total_strain_old
 
std::vector< const MaterialProperty< RankTwoTensor > * > _eigenstrains_old
 
unsigned int _ndisp
 Coupled displacement variables. More...
 
std::vector< const VariableValue * > _disp
 
std::vector< const VariableGradient * > _grad_disp
 
std::string _base_name
 
MaterialProperty< RankTwoTensor > & _mechanical_strain
 
MaterialProperty< RankTwoTensor > & _total_strain
 
std::vector< MaterialPropertyName > _eigenstrain_names
 
std::vector< const MaterialProperty< RankTwoTensor > * > _eigenstrains
 
const MaterialProperty< RankTwoTensor > * _global_strain
 
bool _volumetric_locking_correction
 
const Real & _current_elem_volume
 

Detailed Description

ComputeAxisymmetricRZFiniteStrain defines a strain increment and rotation increment for finite strains in an Axisymmetric simulation.

The COORD_TYPE in the Problem block must be set to RZ.

Definition at line 25 of file ComputeAxisymmetricRZFiniteStrain.h.

Constructor & Destructor Documentation

◆ ComputeAxisymmetricRZFiniteStrain()

ComputeAxisymmetricRZFiniteStrain::ComputeAxisymmetricRZFiniteStrain ( const InputParameters &  parameters)

Definition at line 27 of file ComputeAxisymmetricRZFiniteStrain.C.

29  : Compute2DFiniteStrain(parameters), _disp_old_0(coupledValueOld("displacements", 0))
30 {
31 }
Compute2DFiniteStrain(const InputParameters &parameters)
const VariableValue & _disp_old_0
the old value of the first component of the displacements vector

Member Function Documentation

◆ computeOutOfPlaneGradDisp()

Real ComputeAxisymmetricRZFiniteStrain::computeOutOfPlaneGradDisp ( )
overrideprotectedvirtual

Computes the current out-of-plane component of the displacement gradient; as a virtual function, this function is overwritten for the specific geometries defined by inheriting classes.

Implements Compute2DFiniteStrain.

Definition at line 47 of file ComputeAxisymmetricRZFiniteStrain.C.

48 {
49  if (!MooseUtils::absoluteFuzzyEqual(_q_point[_qp](0), 0.0))
50  return (*_disp[0])[_qp] / _q_point[_qp](0);
51  else
52  return 0.0;
53 }
std::vector< const VariableValue * > _disp

◆ computeOutOfPlaneGradDispOld()

Real ComputeAxisymmetricRZFiniteStrain::computeOutOfPlaneGradDispOld ( )
overrideprotectedvirtual

Computes the old out-of-plane component of the displacement gradient; as a virtual function, this function is overwritten for the specific geometries defined by inheriting classes.

Implements Compute2DFiniteStrain.

Definition at line 56 of file ComputeAxisymmetricRZFiniteStrain.C.

57 {
58  if (!MooseUtils::absoluteFuzzyEqual(_q_point[_qp](0), 0.0))
59  return _disp_old_0[_qp] / _q_point[_qp](0);
60  else
61  return 0.0;
62 }
const VariableValue & _disp_old_0
the old value of the first component of the displacements vector

◆ computeProperties()

void Compute2DFiniteStrain::computeProperties ( )
overridevirtualinherited

Reimplemented from ComputeFiniteStrain.

Definition at line 58 of file Compute2DFiniteStrain.C.

59 {
60  RankTwoTensor ave_Fhat;
61  Real ave_dfgrd_det = 0.0;
62 
63  for (_qp = 0; _qp < _qrule->n_points(); ++_qp)
64  {
65 
66  // Deformation gradient calculation for 2D problems
67  RankTwoTensor A((*_grad_disp[0])[_qp],
68  (*_grad_disp[1])[_qp],
69  (*_grad_disp[2])[_qp]); // Deformation gradient
70  RankTwoTensor Fbar((*_grad_disp_old[0])[_qp],
71  (*_grad_disp_old[1])[_qp],
72  (*_grad_disp_old[2])[_qp]); // Old Deformation gradient
73 
74  // Compute the displacement gradient for the out of plane direction for plane strain,
75  // generalized plane strain, or axisymmetric problems
76 
79 
80  // Gauss point deformation gradient
81  _deformation_gradient[_qp] = A;
82  _deformation_gradient[_qp].addIa(1.0);
83 
84  A -= Fbar; // very nearly A = gradU - gradUold
85 
86  Fbar.addIa(1.0); // Fbar = ( I + gradUold)
87 
88  // Incremental deformation gradient _Fhat = I + A Fbar^-1
89  _Fhat[_qp] = A * Fbar.inverse();
90  _Fhat[_qp].addIa(1.0);
91 
93  {
94  // Calculate average _Fhat for volumetric locking correction
95  ave_Fhat += _Fhat[_qp] * _JxW[_qp] * _coord[_qp];
96 
97  // Average deformation gradient
98  ave_dfgrd_det += _deformation_gradient[_qp].det() * _JxW[_qp] * _coord[_qp];
99  }
100  }
102  {
103  // needed for volumetric locking correction
104  ave_Fhat /= _current_elem_volume;
105  // average deformation gradient
106  ave_dfgrd_det /= _current_elem_volume;
107  }
108  for (_qp = 0; _qp < _qrule->n_points(); ++_qp)
109  {
111  {
112  // Finalize volumetric locking correction
113  _Fhat[_qp] *= std::cbrt(ave_Fhat.det() / _Fhat[_qp].det());
114  // Volumetric locking correction
115  _deformation_gradient[_qp] *= std::cbrt(ave_dfgrd_det / _deformation_gradient[_qp].det());
116  }
117 
118  computeQpStrain();
119  }
120 }
const Real & _current_elem_volume
MaterialProperty< RankTwoTensor > & _deformation_gradient
virtual void computeQpStrain()
virtual Real computeOutOfPlaneGradDisp()=0
Computes the current out-of-plane component of the displacement gradient; as a virtual function...
std::vector< const VariableGradient * > _grad_disp_old
virtual Real computeOutOfPlaneGradDispOld()=0
Computes the old out-of-plane component of the displacement gradient; as a virtual function...
const unsigned int _out_of_plane_direction
std::vector< RankTwoTensor > _Fhat
std::vector< const VariableGradient * > _grad_disp

◆ computeQpIncrements()

void ComputeFiniteStrain::computeQpIncrements ( RankTwoTensor e,
RankTwoTensor r 
)
protectedvirtualinherited

Definition at line 136 of file ComputeFiniteStrain.C.

Referenced by ComputeFiniteStrain::computeQpStrain().

138 {
139  switch (_decomposition_method)
140  {
142  {
143  // inverse of _Fhat
144  RankTwoTensor invFhat;
145  static const RankTwoTensor zero;
146  if (_Fhat[_qp] == zero)
147  invFhat.zero();
148  else
149  invFhat = _Fhat[_qp].inverse();
150 
151  // A = I - _Fhat^-1
152  RankTwoTensor A(RankTwoTensor::initIdentity);
153  A -= invFhat;
154 
155  // Cinv - I = A A^T - A - A^T;
156  RankTwoTensor Cinv_I = A * A.transpose() - A - A.transpose();
157 
158  // strain rate D from Taylor expansion, Chat = (-1/2(Chat^-1 - I) + 1/4*(Chat^-1 - I)^2 + ...
159  total_strain_increment = -Cinv_I * 0.5 + Cinv_I * Cinv_I * 0.25;
160 
161  const Real a[3] = {invFhat(1, 2) - invFhat(2, 1),
162  invFhat(2, 0) - invFhat(0, 2),
163  invFhat(0, 1) - invFhat(1, 0)};
164 
165  Real q = (a[0] * a[0] + a[1] * a[1] + a[2] * a[2]) / 4.0;
166  Real trFhatinv_1 = invFhat.trace() - 1.0;
167  const Real p = trFhatinv_1 * trFhatinv_1 / 4.0;
168 
169  // cos theta_a
170  const Real C1 =
171  std::sqrt(p + 3.0 * Utility::pow<2>(p) * (1.0 - (p + q)) / Utility::pow<2>(p + q) -
172  2.0 * Utility::pow<3>(p) * (1.0 - (p + q)) / Utility::pow<3>(p + q));
173 
174  Real C2;
175  if (q > 0.01)
176  // (1-cos theta_a)/4q
177  C2 = (1.0 - C1) / (4.0 * q);
178  else
179  // alternate form for small q
180  C2 = 0.125 + q * 0.03125 * (Utility::pow<2>(p) - 12.0 * (p - 1.0)) / Utility::pow<2>(p) +
181  Utility::pow<2>(q) * (p - 2.0) * (Utility::pow<2>(p) - 10.0 * p + 32.0) /
182  Utility::pow<3>(p) +
183  Utility::pow<3>(q) * (1104.0 - 992.0 * p + 376.0 * Utility::pow<2>(p) -
184  72.0 * Utility::pow<3>(p) + 5.0 * Utility::pow<4>(p)) /
185  (512.0 * Utility::pow<4>(p));
186  const Real C3 =
187  0.5 * std::sqrt((p * q * (3.0 - q) + Utility::pow<3>(p) + Utility::pow<2>(q)) /
188  Utility::pow<3>(p + q)); // sin theta_a/(2 sqrt(q))
189 
190  // Calculate incremental rotation. Note that this value is the transpose of that from Rashid,
191  // 93, so we transpose it before storing
192  RankTwoTensor R_incr;
193  R_incr.addIa(C1);
194  for (unsigned int i = 0; i < 3; ++i)
195  for (unsigned int j = 0; j < 3; ++j)
196  R_incr(i, j) += C2 * a[i] * a[j];
197 
198  R_incr(0, 1) += C3 * a[2];
199  R_incr(0, 2) -= C3 * a[1];
200  R_incr(1, 0) -= C3 * a[2];
201  R_incr(1, 2) += C3 * a[0];
202  R_incr(2, 0) += C3 * a[1];
203  R_incr(2, 1) -= C3 * a[0];
204 
205  rotation_increment = R_incr.transpose();
206  break;
207  }
208 
210  {
211  std::vector<Real> e_value(3);
212  RankTwoTensor e_vector, N1, N2, N3;
213 
214  RankTwoTensor Chat = _Fhat[_qp].transpose() * _Fhat[_qp];
215  Chat.symmetricEigenvaluesEigenvectors(e_value, e_vector);
216 
217  const Real lambda1 = std::sqrt(e_value[0]);
218  const Real lambda2 = std::sqrt(e_value[1]);
219  const Real lambda3 = std::sqrt(e_value[2]);
220 
221  N1.vectorOuterProduct(e_vector.column(0), e_vector.column(0));
222  N2.vectorOuterProduct(e_vector.column(1), e_vector.column(1));
223  N3.vectorOuterProduct(e_vector.column(2), e_vector.column(2));
224 
225  RankTwoTensor Uhat = N1 * lambda1 + N2 * lambda2 + N3 * lambda3;
226  RankTwoTensor invUhat(Uhat.inverse());
227 
228  rotation_increment = _Fhat[_qp] * invUhat;
229 
230  total_strain_increment =
231  N1 * std::log(lambda1) + N2 * std::log(lambda2) + N3 * std::log(lambda3);
232  break;
233  }
234 
235  default:
236  mooseError("ComputeFiniteStrain Error: Pass valid decomposition type: TaylorExpansion or "
237  "EigenSolution.");
238  }
239 }
const DecompMethod _decomposition_method
std::vector< RankTwoTensor > _Fhat

◆ computeQpStrain()

void ComputeFiniteStrain::computeQpStrain ( )
protectedvirtualinherited

Definition at line 104 of file ComputeFiniteStrain.C.

Referenced by ComputeFiniteStrain::computeProperties(), Compute1DFiniteStrain::computeProperties(), Compute2DFiniteStrain::computeProperties(), and ComputeRSphericalFiniteStrain::computeProperties().

105 {
106  RankTwoTensor total_strain_increment;
107 
108  // two ways to calculate these increments: TaylorExpansion(default) or EigenSolution
109  computeQpIncrements(total_strain_increment, _rotation_increment[_qp]);
110 
111  _strain_increment[_qp] = total_strain_increment;
112 
113  // Remove the eigenstrain increment
115 
116  if (_dt > 0)
117  _strain_rate[_qp] = _strain_increment[_qp] / _dt;
118  else
119  _strain_rate[_qp].zero();
120 
121  // Update strain in intermediate configuration
123  _total_strain[_qp] = _total_strain_old[_qp] + total_strain_increment;
124 
125  // Rotate strain to current configuration
126  _mechanical_strain[_qp] =
127  _rotation_increment[_qp] * _mechanical_strain[_qp] * _rotation_increment[_qp].transpose();
128  _total_strain[_qp] =
129  _rotation_increment[_qp] * _total_strain[_qp] * _rotation_increment[_qp].transpose();
130 
131  if (_global_strain)
132  _total_strain[_qp] += (*_global_strain)[_qp];
133 }
const MaterialProperty< RankTwoTensor > & _total_strain_old
MaterialProperty< RankTwoTensor > & _strain_increment
MaterialProperty< RankTwoTensor > & _mechanical_strain
virtual void computeQpIncrements(RankTwoTensor &e, RankTwoTensor &r)
MaterialProperty< RankTwoTensor > & _strain_rate
void subtractEigenstrainIncrementFromStrain(RankTwoTensor &strain)
const MaterialProperty< RankTwoTensor > & _mechanical_strain_old
const MaterialProperty< RankTwoTensor > * _global_strain
MaterialProperty< RankTwoTensor > & _rotation_increment
MaterialProperty< RankTwoTensor > & _total_strain

◆ decompositionType()

MooseEnum ComputeFiniteStrain::decompositionType ( )
staticinherited

Definition at line 17 of file ComputeFiniteStrain.C.

Referenced by validParams< ComputeFiniteStrain >(), and validParams< TensorMechanicsActionBase >().

18 {
19  return MooseEnum("TaylorExpansion EigenSolution", "TaylorExpansion");
20 }

◆ displacementIntegrityCheck()

void Compute2DFiniteStrain::displacementIntegrityCheck ( )
overrideprotectedvirtualinherited

Reimplemented from ComputeStrainBase.

Definition at line 123 of file Compute2DFiniteStrain.C.

124 {
125  if (_out_of_plane_direction != 2 && _ndisp != 3)
126  mooseError("For 2D simulations where the out-of-plane direction is x or y the number of "
127  "supplied displacements must be three.");
128  else if (_out_of_plane_direction == 2 && _ndisp != 2)
129  mooseError("For 2D simulations where the out-of-plane direction is z the number of supplied "
130  "displacements must be two.");
131 }
unsigned int _ndisp
Coupled displacement variables.
const unsigned int _out_of_plane_direction

◆ initialSetup()

void ComputeAxisymmetricRZFiniteStrain::initialSetup ( )
override

Definition at line 34 of file ComputeAxisymmetricRZFiniteStrain.C.

35 {
37 
38  if (getBlockCoordSystem() != Moose::COORD_RZ)
39  mooseError("The coordinate system must be set to RZ for Axisymmetric geometries.");
40 
41  if (_out_of_plane_direction != 2)
42  paramError("out_of_plane_direction",
43  "The out-of-plane direction for axisymmetric systems is currently restricted to z");
44 }
const unsigned int _out_of_plane_direction

◆ initQpStatefulProperties()

void ComputeIncrementalStrainBase::initQpStatefulProperties ( )
overrideprotectedvirtualinherited

Reimplemented from ComputeStrainBase.

Reimplemented in ComputeCosseratIncrementalSmallStrain.

Definition at line 50 of file ComputeIncrementalStrainBase.C.

Referenced by ComputeCosseratIncrementalSmallStrain::initQpStatefulProperties().

51 {
52  _mechanical_strain[_qp].zero();
53  _total_strain[_qp].zero();
54  _deformation_gradient[_qp].setToIdentity();
55 }
MaterialProperty< RankTwoTensor > & _deformation_gradient
MaterialProperty< RankTwoTensor > & _mechanical_strain
MaterialProperty< RankTwoTensor > & _total_strain

◆ subtractEigenstrainIncrementFromStrain()

void ComputeIncrementalStrainBase::subtractEigenstrainIncrementFromStrain ( RankTwoTensor strain)
protectedinherited

Definition at line 58 of file ComputeIncrementalStrainBase.C.

Referenced by ComputeIncrementalSmallStrain::computeProperties(), ComputeCosseratIncrementalSmallStrain::computeQpProperties(), and ComputeFiniteStrain::computeQpStrain().

59 {
60  for (unsigned int i = 0; i < _eigenstrains.size(); ++i)
61  {
62  strain -= (*_eigenstrains[i])[_qp];
63  strain += (*_eigenstrains_old[i])[_qp];
64  }
65 }
std::vector< const MaterialProperty< RankTwoTensor > * > _eigenstrains_old
std::vector< const MaterialProperty< RankTwoTensor > * > _eigenstrains

Member Data Documentation

◆ _base_name

std::string ComputeStrainBase::_base_name
protectedinherited

Definition at line 43 of file ComputeStrainBase.h.

Referenced by ComputeStrainBase::ComputeStrainBase().

◆ _current_elem_volume

const Real& ComputeStrainBase::_current_elem_volume
protectedinherited

◆ _deformation_gradient

MaterialProperty<RankTwoTensor>& ComputeIncrementalStrainBase::_deformation_gradient
protectedinherited

◆ _disp

std::vector<const VariableValue *> ComputeStrainBase::_disp
protectedinherited

◆ _disp_old_0

const VariableValue& ComputeAxisymmetricRZFiniteStrain::_disp_old_0
protected

the old value of the first component of the displacements vector

Definition at line 38 of file ComputeAxisymmetricRZFiniteStrain.h.

Referenced by computeOutOfPlaneGradDispOld().

◆ _eigenstrain_names

std::vector<MaterialPropertyName> ComputeStrainBase::_eigenstrain_names
protectedinherited

◆ _eigenstrains

std::vector<const MaterialProperty<RankTwoTensor> *> ComputeStrainBase::_eigenstrains
protectedinherited

◆ _eigenstrains_old

std::vector<const MaterialProperty<RankTwoTensor> *> ComputeIncrementalStrainBase::_eigenstrains_old
protectedinherited

◆ _Fhat

std::vector<RankTwoTensor> ComputeFiniteStrain::_Fhat
protectedinherited

◆ _global_strain

const MaterialProperty<RankTwoTensor>* ComputeStrainBase::_global_strain
protectedinherited

◆ _grad_disp

std::vector<const VariableGradient *> ComputeStrainBase::_grad_disp
protectedinherited

◆ _grad_disp_old

std::vector<const VariableGradient *> ComputeIncrementalStrainBase::_grad_disp_old
protectedinherited

◆ _mechanical_strain

MaterialProperty<RankTwoTensor>& ComputeStrainBase::_mechanical_strain
protectedinherited

◆ _mechanical_strain_old

const MaterialProperty<RankTwoTensor>& ComputeIncrementalStrainBase::_mechanical_strain_old
protectedinherited

◆ _ndisp

unsigned int ComputeStrainBase::_ndisp
protectedinherited

◆ _out_of_plane_direction

const unsigned int Compute2DFiniteStrain::_out_of_plane_direction
protectedinherited

◆ _rotation_increment

MaterialProperty<RankTwoTensor>& ComputeIncrementalStrainBase::_rotation_increment
protectedinherited

◆ _strain_increment

MaterialProperty<RankTwoTensor>& ComputeIncrementalStrainBase::_strain_increment
protectedinherited

◆ _strain_rate

MaterialProperty<RankTwoTensor>& ComputeIncrementalStrainBase::_strain_rate
protectedinherited

◆ _total_strain

MaterialProperty<RankTwoTensor>& ComputeStrainBase::_total_strain
protectedinherited

◆ _total_strain_old

const MaterialProperty<RankTwoTensor>& ComputeIncrementalStrainBase::_total_strain_old
protectedinherited

◆ _volumetric_locking_correction

bool ComputeStrainBase::_volumetric_locking_correction
protectedinherited

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