www.mooseframework.org
Public Member Functions | Static Public Member Functions | Protected Types | Protected Member Functions | Protected Attributes | List of all members
SolidMechanics::Nonlinear Class Referenceabstract

Nonlinear is the base class for all large strain/rotation models. More...

#include <Nonlinear.h>

Inheritance diagram for SolidMechanics::Nonlinear:
[legend]

Public Member Functions

 Nonlinear (SolidModel &solid_model, const std::string &name, const InputParameters &parameters)
 
virtual ~Nonlinear ()
 
const ColumnMajorMatrix & incrementalRotation () const
 
const std::vector< ColumnMajorMatrix > & Fhat () const
 
virtual void computeDeformationGradient (unsigned int, ColumnMajorMatrix &)
 
virtual unsigned int getNumKnownCrackDirs () const
 
void fillMatrix (unsigned int qp, const VariableGradient &grad_x, const VariableGradient &grad_y, const VariableGradient &grad_z, ColumnMajorMatrix &A)
 

Static Public Member Functions

static Real detMatrix (const ColumnMajorMatrix &A)
 
static void invertMatrix (const ColumnMajorMatrix &A, ColumnMajorMatrix &Ainv)
 
static void rotateSymmetricTensor (const ColumnMajorMatrix &R, const RealTensorValue &T, RealTensorValue &result)
 
static void rotateSymmetricTensor (const ColumnMajorMatrix &R, const SymmTensor &T, SymmTensor &result)
 
static void unrotateSymmetricTensor (const ColumnMajorMatrix &R, const SymmTensor &T, SymmTensor &result)
 
static void polarDecompositionEigen (const ColumnMajorMatrix &Fhat, ColumnMajorMatrix &Rhat, SymmTensor &strain_increment)
 

Protected Types

enum  DecompMethod { RashidApprox = 0, Eigen = 1 }
 

Protected Member Functions

virtual void init ()
 
virtual void computeStrain (const unsigned qp, const SymmTensor &total_strain_old, SymmTensor &total_strain_new, SymmTensor &strain_increment)
 
virtual Real volumeRatioOld (unsigned) const
 
virtual void finalizeStress (std::vector< SymmTensor * > &t)
 Rotate stress to current configuration. More...
 
virtual void computeIncrementalDeformationGradient (std::vector< ColumnMajorMatrix > &Fhat)=0
 
void computeStrainIncrement (const ColumnMajorMatrix &Fhat, SymmTensor &strain_increment)
 
void computePolarDecomposition (const ColumnMajorMatrix &Fhat)
 
void computeStrainAndRotationIncrement (const ColumnMajorMatrix &Fhat, SymmTensor &strain_increment)
 

Protected Attributes

DecompMethod _decomp_method
 
ColumnMajorMatrix _incremental_rotation
 
ColumnMajorMatrix _Uhat
 
std::vector< ColumnMajorMatrix > _Fhat
 
std::vector< ColumnMajorMatrix > _Fbar
 
ColumnMajorMatrix _F
 
SolidModel & _solid_model
 

Detailed Description

Nonlinear is the base class for all large strain/rotation models.

Definition at line 24 of file Nonlinear.h.

Member Enumeration Documentation

◆ DecompMethod

enum SolidMechanics::Nonlinear::DecompMethod
protected
Enumerator
RashidApprox 
Eigen 

Definition at line 36 of file Nonlinear.h.

37  {
38  RashidApprox = 0,
39  Eigen = 1
40  };

Constructor & Destructor Documentation

◆ Nonlinear()

SolidMechanics::Nonlinear::Nonlinear ( SolidModel &  solid_model,
const std::string &  name,
const InputParameters &  parameters 
)

Definition at line 20 of file Nonlinear.C.

23  : Element(solid_model, name, parameters),
24  _decomp_method(RashidApprox),
25  _incremental_rotation(3, 3),
26  _Uhat(3, 3)
27 {
28 
29  std::string increment_calculation =
30  solid_model.getParamTempl<std::string>("increment_calculation");
31  std::transform(increment_calculation.begin(),
32  increment_calculation.end(),
33  increment_calculation.begin(),
34  ::tolower);
35  if (increment_calculation == "rashidapprox")
36  {
37  _decomp_method = RashidApprox;
38  }
39  else if (increment_calculation == "eigen")
40  {
41  _decomp_method = Eigen;
42  }
43  else
44  {
45  mooseError("The options for the increment calculation are RashidApprox and Eigen.");
46  }
47 }

◆ ~Nonlinear()

SolidMechanics::Nonlinear::~Nonlinear ( )
virtual

Definition at line 51 of file Nonlinear.C.

51 {}

Member Function Documentation

◆ computeDeformationGradient()

virtual void SolidMechanics::Element::computeDeformationGradient ( unsigned int  ,
ColumnMajorMatrix &   
)
inlinevirtualinherited

Reimplemented in SolidMechanics::NonlinearPlaneStrain, SolidMechanics::Nonlinear3D, SolidMechanics::NonlinearRZ, and SolidMechanics::PlaneStrain.

Definition at line 50 of file Element.h.

51  {
52  mooseError("computeDeformationGradient not defined for element type used");
53  }

Referenced by SolidModel::computeEshelby().

◆ computeIncrementalDeformationGradient()

virtual void SolidMechanics::Nonlinear::computeIncrementalDeformationGradient ( std::vector< ColumnMajorMatrix > &  Fhat)
protectedpure virtual

Implemented in SolidMechanics::NonlinearPlaneStrain, SolidMechanics::NonlinearRZ, and SolidMechanics::Nonlinear3D.

Referenced by init().

◆ computePolarDecomposition()

void SolidMechanics::Nonlinear::computePolarDecomposition ( const ColumnMajorMatrix &  Fhat)
protected

Definition at line 140 of file Nonlinear.C.

141 {
142 
143  // From Rashid, 1993.
144 
145  const Real Uxx = Fhat(0, 0);
146  const Real Uxy = Fhat(0, 1);
147  const Real Uxz = Fhat(0, 2);
148  const Real Uyx = Fhat(1, 0);
149  const Real Uyy = Fhat(1, 1);
150  const Real Uyz = Fhat(1, 2);
151  const Real Uzx = Fhat(2, 0);
152  const Real Uzy = Fhat(2, 1);
153  const Real Uzz = Fhat(2, 2);
154 
155  const Real Ax = Uyz - Uzy;
156  const Real Ay = Uzx - Uxz;
157  const Real Az = Uxy - Uyx;
158  const Real Q = 0.25 * (Ax * Ax + Ay * Ay + Az * Az);
159  const Real traceF = Uxx + Uyy + Uzz;
160  const Real P = 0.25 * (traceF - 1) * (traceF - 1);
161  const Real Y = 1 / ((Q + P) * (Q + P) * (Q + P));
162 
163  const Real C1 = std::sqrt(P * (1 + (P * (Q + Q + (Q + P))) * (1 - (Q + P)) * Y));
164  const Real C2 = 0.125 + Q * 0.03125 * (P * P - 12 * (P - 1)) / (P * P);
165  const Real C3 = 0.5 * std::sqrt((P * Q * (3 - Q) + P * P * P + Q * Q) * Y);
166 
167  // Since the input to this routine is the incremental deformation gradient
168  // and not the inverse incremental gradient, this result is the transpose
169  // of the one in Rashid's paper.
170  _incremental_rotation(0, 0) = C1 + (C2 * Ax) * Ax;
171  _incremental_rotation(0, 1) = (C2 * Ay) * Ax + (C3 * Az);
172  _incremental_rotation(0, 2) = (C2 * Az) * Ax - (C3 * Ay);
173  _incremental_rotation(1, 0) = (C2 * Ax) * Ay - (C3 * Az);
174  _incremental_rotation(1, 1) = C1 + (C2 * Ay) * Ay;
175  _incremental_rotation(1, 2) = (C2 * Az) * Ay + (C3 * Ax);
176  _incremental_rotation(2, 0) = (C2 * Ax) * Az + (C3 * Ay);
177  _incremental_rotation(2, 1) = (C2 * Ay) * Az - (C3 * Ax);
178  _incremental_rotation(2, 2) = C1 + (C2 * Az) * Az;
179 }

Referenced by computeStrainAndRotationIncrement().

◆ computeStrain()

void SolidMechanics::Nonlinear::computeStrain ( const unsigned  qp,
const SymmTensor &  total_strain_old,
SymmTensor &  total_strain_new,
SymmTensor &  strain_increment 
)
protectedvirtual

Implements SolidMechanics::Element.

Definition at line 196 of file Nonlinear.C.

200 {
201  computeStrainAndRotationIncrement(_Fhat[qp], strain_increment);
202 
203  total_strain_new = strain_increment;
204  total_strain_new += total_strain_old;
205 }

◆ computeStrainAndRotationIncrement()

void SolidMechanics::Nonlinear::computeStrainAndRotationIncrement ( const ColumnMajorMatrix &  Fhat,
SymmTensor &  strain_increment 
)
protected

Definition at line 56 of file Nonlinear.C.

58 {
59  if (_decomp_method == RashidApprox)
60  {
61  computeStrainIncrement(Fhat, strain_increment);
62  computePolarDecomposition(Fhat);
63  }
64 
65  else if (_decomp_method == Eigen)
66  {
67  Element::polarDecompositionEigen(Fhat, _incremental_rotation, strain_increment);
68  }
69 
70  else
71  {
72  mooseError("Unknown polar decomposition type!");
73  }
74 }

Referenced by computeStrain().

◆ computeStrainIncrement()

void SolidMechanics::Nonlinear::computeStrainIncrement ( const ColumnMajorMatrix &  Fhat,
SymmTensor &  strain_increment 
)
protected

Definition at line 79 of file Nonlinear.C.

80 {
81 
82  //
83  // A calculation of the strain at the mid-interval is probably more
84  // accurate (second vs. first order). This would require the
85  // incremental deformation gradient at the mid-step, which we
86  // currently don't have. We would then have to calculate the
87  // rotation for the whole step.
88  //
89  //
90  // We are looking for:
91  // log( Uhat )
92  // = log( sqrt( Fhat^T*Fhat ) )
93  // = log( sqrt( Chat ) )
94  // A Taylor series expansion gives:
95  // ( Chat - 0.25 * Chat^T*Chat - 0.75 * I )
96  // = ( - 0.25 * Chat^T*Chat + Chat - 0.75 * I )
97  // = ( (0.25*Chat - 0.75*I) * (Chat - I) )
98  // = ( B * A )
99  // B
100  // = 0.25*Chat - 0.75*I
101  // = 0.25*(Chat - I) - 0.5*I
102  // = 0.25*A - 0.5*I
103  //
104 
105  const Real Uxx = Fhat(0, 0);
106  const Real Uxy = Fhat(0, 1);
107  const Real Uxz = Fhat(0, 2);
108  const Real Uyx = Fhat(1, 0);
109  const Real Uyy = Fhat(1, 1);
110  const Real Uyz = Fhat(1, 2);
111  const Real Uzx = Fhat(2, 0);
112  const Real Uzy = Fhat(2, 1);
113  const Real Uzz = Fhat(2, 2);
114 
115  const Real Axx = Uxx * Uxx + Uyx * Uyx + Uzx * Uzx - 1.0;
116  const Real Axy = Uxx * Uxy + Uyx * Uyy + Uzx * Uzy;
117  const Real Axz = Uxx * Uxz + Uyx * Uyz + Uzx * Uzz;
118  const Real Ayy = Uxy * Uxy + Uyy * Uyy + Uzy * Uzy - 1.0;
119  const Real Ayz = Uxy * Uxz + Uyy * Uyz + Uzy * Uzz;
120  const Real Azz = Uxz * Uxz + Uyz * Uyz + Uzz * Uzz - 1.0;
121 
122  const Real Bxx = 0.25 * Axx - 0.5;
123  const Real Bxy = 0.25 * Axy;
124  const Real Bxz = 0.25 * Axz;
125  const Real Byy = 0.25 * Ayy - 0.5;
126  const Real Byz = 0.25 * Ayz;
127  const Real Bzz = 0.25 * Azz - 0.5;
128 
129  strain_increment.xx(-(Bxx * Axx + Bxy * Axy + Bxz * Axz));
130  strain_increment.xy(-(Bxx * Axy + Bxy * Ayy + Bxz * Ayz));
131  strain_increment.zx(-(Bxx * Axz + Bxy * Ayz + Bxz * Azz));
132  strain_increment.yy(-(Bxy * Axy + Byy * Ayy + Byz * Ayz));
133  strain_increment.yz(-(Bxy * Axz + Byy * Ayz + Byz * Azz));
134  strain_increment.zz(-(Bxz * Axz + Byz * Ayz + Bzz * Azz));
135 }

Referenced by computeStrainAndRotationIncrement().

◆ detMatrix()

Real SolidMechanics::Element::detMatrix ( const ColumnMajorMatrix &  A)
staticinherited

Definition at line 31 of file Element.C.

32 {
33  mooseAssert(A.n() == 3 && A.m() == 3, "detMatrix requires 3x3 matrix");
34 
35  Real Axx = A(0, 0);
36  Real Axy = A(0, 1);
37  Real Axz = A(0, 2);
38  Real Ayx = A(1, 0);
39  Real Ayy = A(1, 1);
40  Real Ayz = A(1, 2);
41  Real Azx = A(2, 0);
42  Real Azy = A(2, 1);
43  Real Azz = A(2, 2);
44 
45  return Axx * Ayy * Azz + Axy * Ayz * Azx + Axz * Ayx * Azy - Azx * Ayy * Axz - Azy * Ayz * Axx -
46  Azz * Ayx * Axy;
47 }

Referenced by SolidModel::computeEshelby(), SolidMechanics::Nonlinear3D::computeIncrementalDeformationGradient(), SolidMechanics::NonlinearRZ::computeIncrementalDeformationGradient(), SolidMechanics::NonlinearPlaneStrain::computeIncrementalDeformationGradient(), SolidMechanics::Element::invertMatrix(), SolidMechanics::Nonlinear3D::volumeRatioOld(), SolidMechanics::NonlinearRZ::volumeRatioOld(), and SolidMechanics::NonlinearPlaneStrain::volumeRatioOld().

◆ Fhat()

const std::vector<ColumnMajorMatrix>& SolidMechanics::Nonlinear::Fhat ( ) const
inline

Definition at line 33 of file Nonlinear.h.

33 { return _Fhat; }

Referenced by SolidMechanics::Nonlinear3D::computeIncrementalDeformationGradient(), SolidMechanics::NonlinearRZ::computeIncrementalDeformationGradient(), SolidMechanics::NonlinearPlaneStrain::computeIncrementalDeformationGradient(), computePolarDecomposition(), computeStrainAndRotationIncrement(), and computeStrainIncrement().

◆ fillMatrix()

void SolidMechanics::Element::fillMatrix ( unsigned int  qp,
const VariableGradient &  grad_x,
const VariableGradient &  grad_y,
const VariableGradient &  grad_z,
ColumnMajorMatrix &  A 
)
inherited

Definition at line 228 of file Element.C.

233 {
234  A(0, 0) = grad_x[qp](0);
235  A(0, 1) = grad_x[qp](1);
236  A(0, 2) = grad_x[qp](2);
237  A(1, 0) = grad_y[qp](0);
238  A(1, 1) = grad_y[qp](1);
239  A(1, 2) = grad_y[qp](2);
240  A(2, 0) = grad_z[qp](0);
241  A(2, 1) = grad_z[qp](1);
242  A(2, 2) = grad_z[qp](2);
243 }

Referenced by SolidMechanics::Nonlinear3D::computeIncrementalDeformationGradient().

◆ finalizeStress()

void SolidMechanics::Nonlinear::finalizeStress ( std::vector< SymmTensor * > &  t)
protectedvirtual

Rotate stress to current configuration.

Reimplemented from SolidMechanics::Element.

Definition at line 184 of file Nonlinear.C.

185 {
186  // Using the incremental rotation, update the stress to the current configuration (R*T*R^T)
187  for (unsigned i = 0; i < t.size(); ++i)
188  {
189  Element::rotateSymmetricTensor(_incremental_rotation, *t[i], *t[i]);
190  }
191 }

◆ getNumKnownCrackDirs()

virtual unsigned int SolidMechanics::Element::getNumKnownCrackDirs ( ) const
inlinevirtualinherited

Reimplemented in SolidMechanics::PlaneStrain, SolidMechanics::SphericalR, and SolidMechanics::AxisymmetricRZ.

Definition at line 65 of file Element.h.

65 { return 0; }

Referenced by SolidModel::getNumKnownCrackDirs().

◆ incrementalRotation()

const ColumnMajorMatrix& SolidMechanics::Nonlinear::incrementalRotation ( ) const
inline

Definition at line 31 of file Nonlinear.h.

31 { return _incremental_rotation; }

◆ init()

void SolidMechanics::Nonlinear::init ( )
protectedvirtual

Reimplemented from SolidMechanics::Element.

Definition at line 210 of file Nonlinear.C.

211 {
212  _Fhat.resize(_solid_model.qrule()->n_points());
213 
214  computeIncrementalDeformationGradient(_Fhat);
215 }

◆ invertMatrix()

void SolidMechanics::Element::invertMatrix ( const ColumnMajorMatrix &  A,
ColumnMajorMatrix &  Ainv 
)
staticinherited

Definition at line 52 of file Element.C.

53 {
54  Real Axx = A(0, 0);
55  Real Axy = A(0, 1);
56  Real Axz = A(0, 2);
57  Real Ayx = A(1, 0);
58  Real Ayy = A(1, 1);
59  Real Ayz = A(1, 2);
60  Real Azx = A(2, 0);
61  Real Azy = A(2, 1);
62  Real Azz = A(2, 2);
63 
64  mooseAssert(detMatrix(A) > 0, "Matrix is not positive definite!");
65  Real detInv = 1 / detMatrix(A);
66 
67  Ainv(0, 0) = +(Ayy * Azz - Azy * Ayz) * detInv;
68  Ainv(0, 1) = -(Axy * Azz - Azy * Axz) * detInv;
69  Ainv(0, 2) = +(Axy * Ayz - Ayy * Axz) * detInv;
70  Ainv(1, 0) = -(Ayx * Azz - Azx * Ayz) * detInv;
71  Ainv(1, 1) = +(Axx * Azz - Azx * Axz) * detInv;
72  Ainv(1, 2) = -(Axx * Ayz - Ayx * Axz) * detInv;
73  Ainv(2, 0) = +(Ayx * Azy - Azx * Ayy) * detInv;
74  Ainv(2, 1) = -(Axx * Azy - Azx * Axy) * detInv;
75  Ainv(2, 2) = +(Axx * Ayy - Ayx * Axy) * detInv;
76 }

Referenced by SolidModel::computeEshelby(), SolidMechanics::Nonlinear3D::computeIncrementalDeformationGradient(), SolidMechanics::NonlinearRZ::computeIncrementalDeformationGradient(), SolidMechanics::NonlinearPlaneStrain::computeIncrementalDeformationGradient(), and SolidMechanics::Element::polarDecompositionEigen().

◆ polarDecompositionEigen()

void SolidMechanics::Element::polarDecompositionEigen ( const ColumnMajorMatrix &  Fhat,
ColumnMajorMatrix &  Rhat,
SymmTensor &  strain_increment 
)
staticinherited

Definition at line 185 of file Element.C.

188 {
189  const int ND = 3;
190 
191  ColumnMajorMatrix eigen_value(ND, 1), eigen_vector(ND, ND);
192  ColumnMajorMatrix n1(ND, 1), n2(ND, 1), n3(ND, 1), N1(ND, 1), N2(ND, 1), N3(ND, 1);
193 
194  ColumnMajorMatrix Chat = Fhat.transpose() * Fhat;
195 
196  Chat.eigen(eigen_value, eigen_vector);
197 
198  for (int i = 0; i < ND; i++)
199  {
200  N1(i) = eigen_vector(i, 0);
201  N2(i) = eigen_vector(i, 1);
202  N3(i) = eigen_vector(i, 2);
203  }
204 
205  const Real lamda1 = std::sqrt(eigen_value(0));
206  const Real lamda2 = std::sqrt(eigen_value(1));
207  const Real lamda3 = std::sqrt(eigen_value(2));
208 
209  const Real log1 = std::log(lamda1);
210  const Real log2 = std::log(lamda2);
211  const Real log3 = std::log(lamda3);
212 
213  ColumnMajorMatrix Uhat =
214  N1 * N1.transpose() * lamda1 + N2 * N2.transpose() * lamda2 + N3 * N3.transpose() * lamda3;
215 
216  ColumnMajorMatrix invUhat(ND, ND);
217  invertMatrix(Uhat, invUhat);
218 
219  Rhat = Fhat * invUhat;
220 
221  strain_increment =
222  N1 * N1.transpose() * log1 + N2 * N2.transpose() * log2 + N3 * N3.transpose() * log3;
223 }

Referenced by computeStrainAndRotationIncrement().

◆ rotateSymmetricTensor() [1/2]

void SolidMechanics::Element::rotateSymmetricTensor ( const ColumnMajorMatrix &  R,
const RealTensorValue &  T,
RealTensorValue &  result 
)
staticinherited

Definition at line 81 of file Element.C.

84 {
85 
86  // R T Rt
87  // 00 01 02 00 01 02 00 10 20
88  // 10 11 12 * 10 11 12 * 01 11 21
89  // 20 21 22 20 21 22 02 12 22
90  //
91  const Real T00 = R(0, 0) * T(0, 0) + R(0, 1) * T(1, 0) + R(0, 2) * T(2, 0);
92  const Real T01 = R(0, 0) * T(0, 1) + R(0, 1) * T(1, 1) + R(0, 2) * T(2, 1);
93  const Real T02 = R(0, 0) * T(0, 2) + R(0, 1) * T(1, 2) + R(0, 2) * T(2, 2);
94 
95  const Real T10 = R(1, 0) * T(0, 0) + R(1, 1) * T(1, 0) + R(1, 2) * T(2, 0);
96  const Real T11 = R(1, 0) * T(0, 1) + R(1, 1) * T(1, 1) + R(1, 2) * T(2, 1);
97  const Real T12 = R(1, 0) * T(0, 2) + R(1, 1) * T(1, 2) + R(1, 2) * T(2, 2);
98 
99  const Real T20 = R(2, 0) * T(0, 0) + R(2, 1) * T(1, 0) + R(2, 2) * T(2, 0);
100  const Real T21 = R(2, 0) * T(0, 1) + R(2, 1) * T(1, 1) + R(2, 2) * T(2, 1);
101  const Real T22 = R(2, 0) * T(0, 2) + R(2, 1) * T(1, 2) + R(2, 2) * T(2, 2);
102 
103  result = RealTensorValue(T00 * R(0, 0) + T01 * R(0, 1) + T02 * R(0, 2),
104  T00 * R(1, 0) + T01 * R(1, 1) + T02 * R(1, 2),
105  T00 * R(2, 0) + T01 * R(2, 1) + T02 * R(2, 2),
106 
107  T10 * R(0, 0) + T11 * R(0, 1) + T12 * R(0, 2),
108  T10 * R(1, 0) + T11 * R(1, 1) + T12 * R(1, 2),
109  T10 * R(2, 0) + T11 * R(2, 1) + T12 * R(2, 2),
110 
111  T20 * R(0, 0) + T21 * R(0, 1) + T22 * R(0, 2),
112  T20 * R(1, 0) + T21 * R(1, 1) + T22 * R(1, 2),
113  T20 * R(2, 0) + T21 * R(2, 1) + T22 * R(2, 2));
114 }

Referenced by finalizeStress().

◆ rotateSymmetricTensor() [2/2]

void SolidMechanics::Element::rotateSymmetricTensor ( const ColumnMajorMatrix &  R,
const SymmTensor &  T,
SymmTensor &  result 
)
staticinherited

Definition at line 119 of file Element.C.

122 {
123 
124  // R T Rt
125  // 00 01 02 00 01 02 00 10 20
126  // 10 11 12 * 10 11 12 * 01 11 21
127  // 20 21 22 20 21 22 02 12 22
128  //
129  const Real T00 = R(0, 0) * T.xx() + R(0, 1) * T.xy() + R(0, 2) * T.zx();
130  const Real T01 = R(0, 0) * T.xy() + R(0, 1) * T.yy() + R(0, 2) * T.yz();
131  const Real T02 = R(0, 0) * T.zx() + R(0, 1) * T.yz() + R(0, 2) * T.zz();
132 
133  const Real T10 = R(1, 0) * T.xx() + R(1, 1) * T.xy() + R(1, 2) * T.zx();
134  const Real T11 = R(1, 0) * T.xy() + R(1, 1) * T.yy() + R(1, 2) * T.yz();
135  const Real T12 = R(1, 0) * T.zx() + R(1, 1) * T.yz() + R(1, 2) * T.zz();
136 
137  const Real T20 = R(2, 0) * T.xx() + R(2, 1) * T.xy() + R(2, 2) * T.zx();
138  const Real T21 = R(2, 0) * T.xy() + R(2, 1) * T.yy() + R(2, 2) * T.yz();
139  const Real T22 = R(2, 0) * T.zx() + R(2, 1) * T.yz() + R(2, 2) * T.zz();
140 
141  result.xx(T00 * R(0, 0) + T01 * R(0, 1) + T02 * R(0, 2));
142  result.yy(T10 * R(1, 0) + T11 * R(1, 1) + T12 * R(1, 2));
143  result.zz(T20 * R(2, 0) + T21 * R(2, 1) + T22 * R(2, 2));
144  result.xy(T00 * R(1, 0) + T01 * R(1, 1) + T02 * R(1, 2));
145  result.yz(T10 * R(2, 0) + T11 * R(2, 1) + T12 * R(2, 2));
146  result.zx(T00 * R(2, 0) + T01 * R(2, 1) + T02 * R(2, 2));
147 }

◆ unrotateSymmetricTensor()

void SolidMechanics::Element::unrotateSymmetricTensor ( const ColumnMajorMatrix &  R,
const SymmTensor &  T,
SymmTensor &  result 
)
staticinherited

Definition at line 152 of file Element.C.

155 {
156 
157  // Rt T R
158  // 00 10 20 00 01 02 00 01 02
159  // 01 11 21 * 10 11 12 * 10 11 12
160  // 02 12 22 20 21 22 20 21 22
161  //
162  const Real T00 = R(0, 0) * T.xx() + R(1, 0) * T.xy() + R(2, 0) * T.zx();
163  const Real T01 = R(0, 0) * T.xy() + R(1, 0) * T.yy() + R(2, 0) * T.yz();
164  const Real T02 = R(0, 0) * T.zx() + R(1, 0) * T.yz() + R(2, 0) * T.zz();
165 
166  const Real T10 = R(0, 1) * T.xx() + R(1, 1) * T.xy() + R(2, 1) * T.zx();
167  const Real T11 = R(0, 1) * T.xy() + R(1, 1) * T.yy() + R(2, 1) * T.yz();
168  const Real T12 = R(0, 1) * T.zx() + R(1, 1) * T.yz() + R(2, 1) * T.zz();
169 
170  const Real T20 = R(0, 2) * T.xx() + R(1, 2) * T.xy() + R(2, 2) * T.zx();
171  const Real T21 = R(0, 2) * T.xy() + R(1, 2) * T.yy() + R(2, 2) * T.yz();
172  const Real T22 = R(0, 2) * T.zx() + R(1, 2) * T.yz() + R(2, 2) * T.zz();
173 
174  result.xx(T00 * R(0, 0) + T01 * R(1, 0) + T02 * R(2, 0));
175  result.yy(T10 * R(0, 1) + T11 * R(1, 1) + T12 * R(2, 1));
176  result.zz(T20 * R(0, 2) + T21 * R(1, 2) + T22 * R(2, 2));
177  result.xy(T00 * R(0, 1) + T01 * R(1, 1) + T02 * R(2, 1));
178  result.yz(T10 * R(0, 2) + T11 * R(1, 2) + T12 * R(2, 2));
179  result.zx(T00 * R(0, 2) + T01 * R(1, 2) + T02 * R(2, 2));
180 }

◆ volumeRatioOld()

virtual Real SolidMechanics::Nonlinear::volumeRatioOld ( unsigned  ) const
inlineprotectedvirtual

Reimplemented from SolidMechanics::Element.

Reimplemented in SolidMechanics::NonlinearPlaneStrain, SolidMechanics::NonlinearRZ, and SolidMechanics::Nonlinear3D.

Definition at line 58 of file Nonlinear.h.

58 { mooseError("volumeRatioOld not defined"); }

Member Data Documentation

◆ _decomp_method

DecompMethod SolidMechanics::Nonlinear::_decomp_method
protected

Definition at line 42 of file Nonlinear.h.

Referenced by computeStrainAndRotationIncrement(), and Nonlinear().

◆ _F

ColumnMajorMatrix SolidMechanics::Nonlinear::_F
protected

Definition at line 49 of file Nonlinear.h.

◆ _Fbar

std::vector<ColumnMajorMatrix> SolidMechanics::Nonlinear::_Fbar
protected

Definition at line 48 of file Nonlinear.h.

Referenced by SolidMechanics::Nonlinear3D::computeIncrementalDeformationGradient(), SolidMechanics::NonlinearRZ::computeIncrementalDeformationGradient(), and SolidMechanics::NonlinearPlaneStrain::computeIncrementalDeformationGradient().

◆ _Fhat

std::vector<ColumnMajorMatrix> SolidMechanics::Nonlinear::_Fhat
protected

Definition at line 47 of file Nonlinear.h.

Referenced by computeStrain(), Fhat(), and init().

◆ _incremental_rotation

ColumnMajorMatrix SolidMechanics::Nonlinear::_incremental_rotation
protected

Definition at line 44 of file Nonlinear.h.

Referenced by computePolarDecomposition(), computeStrainAndRotationIncrement(), finalizeStress(), and incrementalRotation().

◆ _solid_model

SolidModel& SolidMechanics::Element::_solid_model
protectedinherited

Definition at line 74 of file Element.h.

Referenced by SolidMechanics::NonlinearRZ::computeDeformationGradient(), SolidMechanics::Nonlinear3D::computeIncrementalDeformationGradient(), SolidMechanics::NonlinearRZ::computeIncrementalDeformationGradient(), SolidMechanics::NonlinearPlaneStrain::computeIncrementalDeformationGradient(), SolidMechanics::PlaneStrain::computeStrain(), SolidMechanics::Linear::computeStrain(), SolidMechanics::AxisymmetricRZ::computeStrain(), SolidMechanics::SphericalR::computeStrain(), SolidMechanics::NonlinearRZ::fillMatrix(), and init().

◆ _Uhat

ColumnMajorMatrix SolidMechanics::Nonlinear::_Uhat
protected

Definition at line 45 of file Nonlinear.h.

The documentation for this class was generated from the following files:
SymmTensor::xx
Real xx() const
Definition: SymmTensor.h:131
SymmTensor::zx
Real zx() const
Definition: SymmTensor.h:136
SolidMechanics::Nonlinear::Eigen
Definition: Nonlinear.h:39
SolidMechanics::Nonlinear::_Fhat
std::vector< ColumnMajorMatrix > _Fhat
Definition: Nonlinear.h:47
SymmTensor::zz
Real zz() const
Definition: SymmTensor.h:133
SolidMechanics::Element::rotateSymmetricTensor
static void rotateSymmetricTensor(const ColumnMajorMatrix &R, const RealTensorValue &T, RealTensorValue &result)
Definition: Element.C:81
SolidMechanics::Element::polarDecompositionEigen
static void polarDecompositionEigen(const ColumnMajorMatrix &Fhat, ColumnMajorMatrix &Rhat, SymmTensor &strain_increment)
Definition: Element.C:185
SolidMechanics::Element::Element
Element(SolidModel &solid_model, const std::string &name, const InputParameters &parameters)
Definition: Element.C:17
SolidMechanics::Nonlinear::computePolarDecomposition
void computePolarDecomposition(const ColumnMajorMatrix &Fhat)
Definition: Nonlinear.C:140
SolidMechanics::Nonlinear::_decomp_method
DecompMethod _decomp_method
Definition: Nonlinear.h:42
SolidMechanics::Nonlinear::computeStrainAndRotationIncrement
void computeStrainAndRotationIncrement(const ColumnMajorMatrix &Fhat, SymmTensor &strain_increment)
Definition: Nonlinear.C:56
SolidMechanics::Nonlinear::Fhat
const std::vector< ColumnMajorMatrix > & Fhat() const
Definition: Nonlinear.h:33
SymmTensor::xy
Real xy() const
Definition: SymmTensor.h:134
name
const std::string name
Definition: Setup.h:21
SymmTensor::yz
Real yz() const
Definition: SymmTensor.h:135
SolidMechanics::Nonlinear::_Uhat
ColumnMajorMatrix _Uhat
Definition: Nonlinear.h:45
SolidMechanics::Nonlinear::computeStrainIncrement
void computeStrainIncrement(const ColumnMajorMatrix &Fhat, SymmTensor &strain_increment)
Definition: Nonlinear.C:79
SolidMechanics::Nonlinear::RashidApprox
Definition: Nonlinear.h:38
SolidMechanics::Element::_solid_model
SolidModel & _solid_model
Definition: Element.h:74
SolidMechanics::Element::detMatrix
static Real detMatrix(const ColumnMajorMatrix &A)
Definition: Element.C:31
SolidMechanics::Nonlinear::computeIncrementalDeformationGradient
virtual void computeIncrementalDeformationGradient(std::vector< ColumnMajorMatrix > &Fhat)=0
SymmTensor::yy
Real yy() const
Definition: SymmTensor.h:132
SolidModel::qrule
const QBase * qrule()
Definition: SolidModel.h:55
SolidMechanics::Element::invertMatrix
static void invertMatrix(const ColumnMajorMatrix &A, ColumnMajorMatrix &Ainv)
Definition: Element.C:52
SolidMechanics::Nonlinear::_incremental_rotation
ColumnMajorMatrix _incremental_rotation
Definition: Nonlinear.h:44
Generated on Sat Jan 25 2020 12:05:22 for www.mooseframework.org by   doxygen 1.8.16