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

ComputeRSphericalFiniteStrain defines a strain increment and a rotation increment for finite strains in 1D spherical symmetry geometries. More...

#include <ComputeRSphericalFiniteStrain.h>

Inheritance diagram for ComputeRSphericalFiniteStrain:
[legend]

Public Member Functions

 ComputeRSphericalFiniteStrain (const InputParameters &parameters)
 

Static Public Member Functions

static MooseEnum decompositionType ()
 

Protected Member Functions

virtual void initialSetup ()
 
virtual void computeProperties ()
 Computes the current and old deformation gradients with the assumptions for 1D spherical symmetry geometries: \( \epsilon_{\theta} = \epsilon_{\phi} = \frac{u_r}{r} \). More...
 
virtual void computeQpStrain ()
 
virtual void computeQpIncrements (RankTwoTensor &e, RankTwoTensor &r)
 
virtual void initQpStatefulProperties () override
 
void subtractEigenstrainIncrementFromStrain (RankTwoTensor &strain)
 
virtual void displacementIntegrityCheck ()
 

Protected Attributes

const VariableValue & _disp_old_0
 the old value of the first component of the displacements vector More...
 
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

ComputeRSphericalFiniteStrain defines a strain increment and a rotation increment for finite strains in 1D spherical symmetry geometries.

The strains in the polar and azimuthal directions are functions of the radial displacement.

Definition at line 26 of file ComputeRSphericalFiniteStrain.h.

Constructor & Destructor Documentation

◆ ComputeRSphericalFiniteStrain()

ComputeRSphericalFiniteStrain::ComputeRSphericalFiniteStrain ( const InputParameters &  parameters)

Definition at line 29 of file ComputeRSphericalFiniteStrain.C.

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

Member Function Documentation

◆ computeProperties()

void ComputeRSphericalFiniteStrain::computeProperties ( )
protectedvirtual

Computes the current and old deformation gradients with the assumptions for 1D spherical symmetry geometries: \( \epsilon_{\theta} = \epsilon_{\phi} = \frac{u_r}{r} \).

Reimplemented from ComputeFiniteStrain.

Definition at line 46 of file ComputeRSphericalFiniteStrain.C.

47 {
48  // Method from Rashid, 1993
49  RankTwoTensor ave_Fhat;
50 
51  for (_qp = 0; _qp < _qrule->n_points(); ++_qp)
52  {
53  // Deformation gradient calculation in cylindrical coordinates
54  RankTwoTensor A; // Deformation gradient
55  RankTwoTensor Fbar; // Old Deformation gradient
56 
57  // Step through calculating the current and old deformation gradients
58  // Only diagonal components are nonzero because this is a 1D material
59  // Note: x_disp is the radial displacement
60  A(0, 0) = (*_grad_disp[0])[_qp](0);
61  Fbar(0, 0) = (*_grad_disp_old[0])[_qp](0);
62 
63  // The polar and azimuthal strains are functions of radial displacement
64  if (!MooseUtils::relativeFuzzyEqual(_q_point[_qp](0), 0.0))
65  {
66  A(1, 1) = (*_disp[0])[_qp] / _q_point[_qp](0);
67  Fbar(1, 1) = _disp_old_0[_qp] / _q_point[_qp](0);
68  }
69 
70  // The polar and azimuthal strains are equalivalent in this 1D problem
71  A(2, 2) = A(1, 1);
72  Fbar(2, 2) = Fbar(1, 1);
73 
74  // Gauss point deformation gradient
75  _deformation_gradient[_qp] = A;
76  _deformation_gradient[_qp].addIa(1.0);
77 
78  // very nearly A = gradU - gradUold, adapted to cylindrical coords
79  A -= Fbar;
80 
81  // Fbar = ( I + gradUold)
82  Fbar.addIa(1.0);
83 
84  // Incremental deformation gradient _Fhat = I + A Fbar^-1
85  _Fhat[_qp] = A * Fbar.inverse();
86  _Fhat[_qp].addIa(1.0);
87 
89  }
90 }
MaterialProperty< RankTwoTensor > & _deformation_gradient
std::vector< const VariableValue * > _disp
virtual void computeQpStrain()
const VariableValue & _disp_old_0
the old value of the first component of the displacements vector
std::vector< const VariableGradient * > _grad_disp_old
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 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 ComputeStrainBase::displacementIntegrityCheck ( )
protectedvirtualinherited

Reimplemented in Compute2DFiniteStrain, Compute2DIncrementalStrain, and Compute2DSmallStrain.

Definition at line 86 of file ComputeStrainBase.C.

Referenced by ComputeStrainBase::initialSetup().

87 {
88  // Checking for consistency between mesh size and length of the provided displacements vector
89  if (_ndisp != _mesh.dimension())
90  paramError(
91  "displacements",
92  "The number of variables supplied in 'displacements' must match the mesh dimension.");
93 }
unsigned int _ndisp
Coupled displacement variables.

◆ initialSetup()

void ComputeRSphericalFiniteStrain::initialSetup ( )
protectedvirtual

Definition at line 35 of file ComputeRSphericalFiniteStrain.C.

36 {
38 
39  const auto & subdomainIDs = _mesh.meshSubdomains();
40  for (auto subdomainID : subdomainIDs)
41  if (_fe_problem.getCoordSystem(subdomainID) != Moose::COORD_RSPHERICAL)
42  mooseError("The coordinate system must be set to RSPHERICAL for 1D R spherical simulations.");
43 }

◆ 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].zero();
55  _deformation_gradient[_qp].addIa(1.0);
56 
57  // Note that for some models (small strain), the rotation increment is
58  // never updated. Because we always have stateful properties, this method
59  // always gets called, so we can rely on this getting set here without
60  // setting it again when properties get computed.
61  _rotation_increment[_qp].zero();
62  _rotation_increment[_qp].addIa(1.0);
63 }
MaterialProperty< RankTwoTensor > & _deformation_gradient
MaterialProperty< RankTwoTensor > & _mechanical_strain
MaterialProperty< RankTwoTensor > & _rotation_increment
MaterialProperty< RankTwoTensor > & _total_strain

◆ subtractEigenstrainIncrementFromStrain()

void ComputeIncrementalStrainBase::subtractEigenstrainIncrementFromStrain ( RankTwoTensor &  strain)
protectedinherited

Definition at line 66 of file ComputeIncrementalStrainBase.C.

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

67 {
68  for (unsigned int i = 0; i < _eigenstrains.size(); ++i)
69  {
70  strain -= (*_eigenstrains[i])[_qp];
71  strain += (*_eigenstrains_old[i])[_qp];
72  }
73 }
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& ComputeRSphericalFiniteStrain::_disp_old_0
protected

the old value of the first component of the displacements vector

Definition at line 39 of file ComputeRSphericalFiniteStrain.h.

Referenced by computeProperties().

◆ _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

◆ _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: