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

ComputePlaneFiniteStrain defines strain increment and rotation increment for finite strain under 2D planar assumptions. More...

#include <ComputePlaneFiniteStrain.h>

Inheritance diagram for ComputePlaneFiniteStrain:
[legend]

Public Member Functions

 ComputePlaneFiniteStrain (const InputParameters &parameters)
 

Static Public Member Functions

static MooseEnum decompositionType ()
 

Protected Member Functions

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

Protected Attributes

const bool _scalar_out_of_plane_strain_coupled
 
const VariableValue & _scalar_out_of_plane_strain
 
const VariableValue & _scalar_out_of_plane_strain_old
 
const bool _out_of_plane_strain_coupled
 
const VariableValue & _out_of_plane_strain
 
const VariableValue & _out_of_plane_strain_old
 
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
 
bool _volumetric_locking_correction
 
const Real & _current_elem_volume
 

Detailed Description

ComputePlaneFiniteStrain defines strain increment and rotation increment for finite strain under 2D planar assumptions.

Definition at line 16 of file ComputePlaneFiniteStrain.h.

Constructor & Destructor Documentation

ComputePlaneFiniteStrain::ComputePlaneFiniteStrain ( const InputParameters &  parameters)

Definition at line 23 of file ComputePlaneFiniteStrain.C.

24  : Compute2DFiniteStrain(parameters),
25  _scalar_out_of_plane_strain_coupled(isCoupledScalar("scalar_out_of_plane_strain")),
27  ? coupledScalarValue("scalar_out_of_plane_strain")
28  : _zero),
30  ? coupledScalarValueOld("scalar_out_of_plane_strain")
31  : _zero),
32  _out_of_plane_strain_coupled(isCoupled("out_of_plane_strain")),
33  _out_of_plane_strain(_out_of_plane_strain_coupled ? coupledValue("out_of_plane_strain")
34  : _zero),
35  _out_of_plane_strain_old(_out_of_plane_strain_coupled ? coupledValueOld("out_of_plane_strain")
36  : _zero)
37 {
39  mooseError("Must define only one of out_of_plane_strain or scalar_out_of_plane_strain");
40 }
Compute2DFiniteStrain(const InputParameters &parameters)
const VariableValue & _out_of_plane_strain
const VariableValue & _scalar_out_of_plane_strain_old
const VariableValue & _out_of_plane_strain_old
const VariableValue & _scalar_out_of_plane_strain

Member Function Documentation

Real ComputePlaneFiniteStrain::computeGradDispZZ ( )
protectedvirtual

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

This is consistent with the approximation of stretch rate tensor D = log(sqrt(Fhat^T * Fhat)) / dt

Implements Compute2DFiniteStrain.

Definition at line 43 of file ComputePlaneFiniteStrain.C.

44 {
50  return std::exp(_scalar_out_of_plane_strain[0]) - 1.0;
51  else
52  return std::exp(_out_of_plane_strain[_qp]) - 1.0;
53 }
const VariableValue & _out_of_plane_strain
const VariableValue & _scalar_out_of_plane_strain
Real ComputePlaneFiniteStrain::computeGradDispZZOld ( )
protectedvirtual

Computes the old out-of-plane 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 ComputePlaneFiniteStrain.C.

57 {
59  return std::exp(_scalar_out_of_plane_strain_old[0]) - 1.0;
60  else
61  return std::exp(_out_of_plane_strain_old[_qp]) - 1.0;
62 }
const VariableValue & _scalar_out_of_plane_strain_old
const VariableValue & _out_of_plane_strain_old
void Compute2DFiniteStrain::computeProperties ( )
protectedvirtualinherited

Reimplemented from ComputeFiniteStrain.

Definition at line 28 of file Compute2DFiniteStrain.C.

29 {
30  RankTwoTensor ave_Fhat;
31  Real ave_dfgrd_det = 0.0;
32 
33  for (_qp = 0; _qp < _qrule->n_points(); ++_qp)
34  {
35  // Deformation gradient calculation for 2D problems
36  // Note: x_disp is the radial displacement, y_disp is the axial displacement
37  RankTwoTensor A((*_grad_disp[0])[_qp],
38  (*_grad_disp[1])[_qp],
39  (*_grad_disp[2])[_qp]); // Deformation gradient
40  RankTwoTensor Fbar((*_grad_disp_old[0])[_qp],
41  (*_grad_disp_old[1])[_qp],
42  (*_grad_disp_old[2])[_qp]); // Old Deformation gradient
43 
44  // Compute the displacement gradient (2,2) value for plane strain, generalized plane strain, or
45  // axisymmetric problems
46  A(2, 2) = computeGradDispZZ();
47  Fbar(2, 2) = computeGradDispZZOld();
48 
49  // Gauss point deformation gradient
50  _deformation_gradient[_qp] = A;
51  _deformation_gradient[_qp].addIa(1.0);
52 
53  A -= Fbar; // very nearly A = gradU - gradUold, adapted to cylindrical coords
54 
55  Fbar.addIa(1.0); // Fbar = ( I + gradUold)
56 
57  // Incremental deformation gradient _Fhat = I + A Fbar^-1
58  _Fhat[_qp] = A * Fbar.inverse();
59  _Fhat[_qp].addIa(1.0);
60 
62  {
63  // Calculate average _Fhat for volumetric locking correction
64  ave_Fhat += _Fhat[_qp] * _JxW[_qp] * _coord[_qp];
65 
66  // Average deformation gradient
67  ave_dfgrd_det += _deformation_gradient[_qp].det() * _JxW[_qp] * _coord[_qp];
68  }
69  }
71  {
72  // needed for volumetric locking correction
73  ave_Fhat /= _current_elem_volume;
74  // average deformation gradient
75  ave_dfgrd_det /= _current_elem_volume;
76  }
77  for (_qp = 0; _qp < _qrule->n_points(); ++_qp)
78  {
80  {
81  // Finalize volumetric locking correction
82  _Fhat[_qp] *= std::cbrt(ave_Fhat.det() / _Fhat[_qp].det());
83  // Volumetric locking correction
84  _deformation_gradient[_qp] *= std::cbrt(ave_dfgrd_det / _deformation_gradient[_qp].det());
85  }
86 
88  }
89 }
virtual Real computeGradDispZZ()=0
Computes the current out-of-plane displacement gradient; as a virtual function, this function is over...
const Real & _current_elem_volume
MaterialProperty< RankTwoTensor > & _deformation_gradient
virtual void computeQpStrain()
std::vector< const VariableGradient * > _grad_disp_old
std::vector< RankTwoTensor > _Fhat
virtual Real computeGradDispZZOld()=0
Computes the old out-of-plane displacement gradient; as a virtual function, this function is overwrit...
std::vector< const VariableGradient * > _grad_disp
void ComputeFiniteStrain::computeQpIncrements ( RankTwoTensor &  e,
RankTwoTensor &  r 
)
protectedvirtualinherited

Definition at line 129 of file ComputeFiniteStrain.C.

Referenced by ComputeFiniteStrain::computeQpStrain().

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

Definition at line 100 of file ComputeFiniteStrain.C.

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

101 {
102  RankTwoTensor total_strain_increment;
103 
104  // two ways to calculate these increments: TaylorExpansion(default) or EigenSolution
105  computeQpIncrements(total_strain_increment, _rotation_increment[_qp]);
106 
107  _strain_increment[_qp] = total_strain_increment;
108 
109  // Remove the eigenstrain increment
111 
112  if (_dt > 0)
113  _strain_rate[_qp] = _strain_increment[_qp] / _dt;
114  else
115  _strain_rate[_qp].zero();
116 
117  // Update strain in intermediate configuration
119  _total_strain[_qp] = _total_strain_old[_qp] + total_strain_increment;
120 
121  // Rotate strain to current configuration
122  _mechanical_strain[_qp] =
123  _rotation_increment[_qp] * _mechanical_strain[_qp] * _rotation_increment[_qp].transpose();
124  _total_strain[_qp] =
125  _rotation_increment[_qp] * _total_strain[_qp] * _rotation_increment[_qp].transpose();
126 }
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
MaterialProperty< RankTwoTensor > & _rotation_increment
MaterialProperty< RankTwoTensor > & _total_strain
MooseEnum ComputeFiniteStrain::decompositionType ( )
staticinherited

Definition at line 15 of file ComputeFiniteStrain.C.

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

16 {
17  return MooseEnum("TaylorExpansion EigenSolution", "TaylorExpansion");
18 }
void ComputeIncrementalStrainBase::initQpStatefulProperties ( )
overrideprotectedvirtualinherited

Reimplemented from ComputeStrainBase.

Reimplemented in ComputeCosseratIncrementalSmallStrain.

Definition at line 44 of file ComputeIncrementalStrainBase.C.

Referenced by ComputeCosseratIncrementalSmallStrain::initQpStatefulProperties(), and ComputeIncrementalStrainBase::~ComputeIncrementalStrainBase().

45 {
46  _mechanical_strain[_qp].zero();
47  _total_strain[_qp].zero();
48  _deformation_gradient[_qp].zero();
49  _deformation_gradient[_qp].addIa(1.0);
50 
51  // Note that for some models (small strain), the rotation increment is
52  // never updated. Because we always have stateful properties, this method
53  // always gets called, so we can rely on this getting set here without
54  // setting it again when properties get computed.
55  _rotation_increment[_qp].zero();
56  _rotation_increment[_qp].addIa(1.0);
57 }
MaterialProperty< RankTwoTensor > & _deformation_gradient
MaterialProperty< RankTwoTensor > & _mechanical_strain
MaterialProperty< RankTwoTensor > & _rotation_increment
MaterialProperty< RankTwoTensor > & _total_strain
void ComputeIncrementalStrainBase::subtractEigenstrainIncrementFromStrain ( RankTwoTensor &  strain)
protectedinherited

Definition at line 60 of file ComputeIncrementalStrainBase.C.

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

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

Member Data Documentation

std::string ComputeStrainBase::_base_name
protectedinherited

Definition at line 33 of file ComputeStrainBase.h.

Referenced by ComputeStrainBase::ComputeStrainBase().

const Real& ComputeStrainBase::_current_elem_volume
protectedinherited
MaterialProperty<RankTwoTensor>& ComputeIncrementalStrainBase::_deformation_gradient
protectedinherited
std::vector<const VariableValue *> ComputeStrainBase::_disp
protectedinherited
std::vector<MaterialPropertyName> ComputeStrainBase::_eigenstrain_names
protectedinherited
std::vector<const MaterialProperty<RankTwoTensor> *> ComputeStrainBase::_eigenstrains
protectedinherited
std::vector<const MaterialProperty<RankTwoTensor> *> ComputeIncrementalStrainBase::_eigenstrains_old
protectedinherited
std::vector<RankTwoTensor> ComputeFiniteStrain::_Fhat
protectedinherited
std::vector<const VariableGradient *> ComputeStrainBase::_grad_disp
protectedinherited
std::vector<const VariableGradient *> ComputeIncrementalStrainBase::_grad_disp_old
protectedinherited
MaterialProperty<RankTwoTensor>& ComputeStrainBase::_mechanical_strain
protectedinherited
const MaterialProperty<RankTwoTensor>& ComputeIncrementalStrainBase::_mechanical_strain_old
protectedinherited
unsigned int ComputeStrainBase::_ndisp
protectedinherited
const VariableValue& ComputePlaneFiniteStrain::_out_of_plane_strain
protected

Definition at line 30 of file ComputePlaneFiniteStrain.h.

Referenced by computeGradDispZZ().

const bool ComputePlaneFiniteStrain::_out_of_plane_strain_coupled
protected

Definition at line 29 of file ComputePlaneFiniteStrain.h.

Referenced by ComputePlaneFiniteStrain().

const VariableValue& ComputePlaneFiniteStrain::_out_of_plane_strain_old
protected

Definition at line 31 of file ComputePlaneFiniteStrain.h.

Referenced by computeGradDispZZOld().

MaterialProperty<RankTwoTensor>& ComputeIncrementalStrainBase::_rotation_increment
protectedinherited
const VariableValue& ComputePlaneFiniteStrain::_scalar_out_of_plane_strain
protected

Definition at line 26 of file ComputePlaneFiniteStrain.h.

Referenced by computeGradDispZZ().

const bool ComputePlaneFiniteStrain::_scalar_out_of_plane_strain_coupled
protected
const VariableValue& ComputePlaneFiniteStrain::_scalar_out_of_plane_strain_old
protected

Definition at line 27 of file ComputePlaneFiniteStrain.h.

Referenced by computeGradDispZZOld().

MaterialProperty<RankTwoTensor>& ComputeIncrementalStrainBase::_strain_increment
protectedinherited
MaterialProperty<RankTwoTensor>& ComputeIncrementalStrainBase::_strain_rate
protectedinherited
MaterialProperty<RankTwoTensor>& ComputeStrainBase::_total_strain
protectedinherited
const MaterialProperty<RankTwoTensor>& ComputeIncrementalStrainBase::_total_strain_old
protectedinherited
bool ComputeStrainBase::_volumetric_locking_correction
protectedinherited

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