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

NonlinearPlaneStrain is a class for large deformation plane strain. More...

#include <NonlinearPlaneStrain.h>

Inheritance diagram for SolidMechanics::NonlinearPlaneStrain:
[legend]

Public Member Functions

 NonlinearPlaneStrain (SolidModel &solid_model, const std::string &name, const InputParameters &parameters)
 
virtual ~NonlinearPlaneStrain ()
 
const ColumnMajorMatrix & incrementalRotation () const
 
const std::vector< ColumnMajorMatrix > & Fhat () const
 
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)
 

Public Attributes

const VariableGradient & _grad_disp_x
 
const VariableGradient & _grad_disp_y
 
bool _have_strain_zz
 
const VariableValue & _strain_zz
 
bool _have_scalar_strain_zz
 
const VariableValue & _scalar_strain_zz
 
const VariableGradient & _grad_disp_x_old
 
const VariableGradient & _grad_disp_y_old
 
const VariableValue & _strain_zz_old
 
const VariableValue & _scalar_strain_zz_old
 

Protected Types

enum  DecompMethod { RashidApprox = 0, Eigen = 1 }
 

Protected Member Functions

virtual void computeDeformationGradient (unsigned int qp, ColumnMajorMatrix &F)
 
virtual void fillMatrix (unsigned int qp, const VariableGradient &grad_x, const VariableGradient &grad_y, const Real &strain_zz, ColumnMajorMatrix &A) const
 
virtual Real volumeRatioOld (unsigned qp) const
 
virtual void computeIncrementalDeformationGradient (std::vector< ColumnMajorMatrix > &Fhat)
 
virtual void init ()
 
virtual void computeStrain (const unsigned qp, const SymmTensor &total_strain_old, SymmTensor &total_strain_new, SymmTensor &strain_increment)
 
virtual void finalizeStress (std::vector< SymmTensor * > &t)
 Rotate stress to current configuration. More...
 
void computeStrainIncrement (const ColumnMajorMatrix &Fhat, SymmTensor &strain_increment)
 
void computePolarDecomposition (const ColumnMajorMatrix &Fhat)
 
void computeStrainAndRotationIncrement (const ColumnMajorMatrix &Fhat, SymmTensor &strain_increment)
 

Protected Attributes

const bool _volumetric_locking_correction
 
DecompMethod _decomp_method
 
ColumnMajorMatrix _incremental_rotation
 
ColumnMajorMatrix _Uhat
 
std::vector< ColumnMajorMatrix > _Fhat
 
std::vector< ColumnMajorMatrix > _Fbar
 
ColumnMajorMatrix _F
 
SolidModel_solid_model
 

Detailed Description

NonlinearPlaneStrain is a class for large deformation plane strain.

Definition at line 19 of file NonlinearPlaneStrain.h.

Member Enumeration Documentation

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

Definition at line 34 of file Nonlinear.h.

Constructor & Destructor Documentation

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

Definition at line 18 of file NonlinearPlaneStrain.C.

21  : Nonlinear(solid_model, name, parameters),
22  ScalarCoupleable(&solid_model),
23  _grad_disp_x(coupledGradient("disp_x")),
24  _grad_disp_y(coupledGradient("disp_y")),
25  _have_strain_zz(isCoupled("strain_zz")),
26  _strain_zz(_have_strain_zz ? coupledValue("strain_zz") : _zero),
27  _have_scalar_strain_zz(isCoupledScalar("scalar_strain_zz")),
28  _scalar_strain_zz(_have_scalar_strain_zz ? coupledScalarValue("scalar_strain_zz") : _zero),
29  _grad_disp_x_old(coupledGradientOld("disp_x")),
30  _grad_disp_y_old(coupledGradientOld("disp_y")),
31  _strain_zz_old(_have_strain_zz ? coupledValueOld("strain_zz") : _zero),
32  _scalar_strain_zz_old(_have_scalar_strain_zz ? coupledScalarValueOld("scalar_strain_zz")
33  : _zero),
34  _volumetric_locking_correction(_solid_model.getParam<bool>("volumetric_locking_correction"))
35 {
36 }
Nonlinear(SolidModel &solid_model, const std::string &name, const InputParameters &parameters)
Definition: Nonlinear.C:18
SolidModel & _solid_model
Definition: Element.h:72
const VariableGradient & _grad_disp_y_old
const VariableGradient & _grad_disp_x_old
SolidMechanics::NonlinearPlaneStrain::~NonlinearPlaneStrain ( )
virtual

Definition at line 40 of file NonlinearPlaneStrain.C.

40 {}

Member Function Documentation

void SolidMechanics::NonlinearPlaneStrain::computeDeformationGradient ( unsigned int  qp,
ColumnMajorMatrix &  F 
)
protectedvirtual

Reimplemented from SolidMechanics::Element.

Definition at line 125 of file NonlinearPlaneStrain.C.

126 {
127  mooseAssert(F.n() == 3 && F.m() == 3, "computeDefGrad requires 3x3 matrix");
128 
129  F(0, 0) = _grad_disp_x[qp](0) + 1;
130  F(0, 1) = _grad_disp_x[qp](1);
131  F(0, 2) = 0;
132  F(1, 0) = _grad_disp_y[qp](0);
133  F(1, 1) = _grad_disp_y[qp](1) + 1;
134  F(1, 2) = 0;
135  F(2, 0) = 0;
136  F(2, 1) = 0;
137  if (_have_strain_zz)
138  F(2, 2) = _strain_zz[qp] + 1;
139  else if (_have_scalar_strain_zz && _scalar_strain_zz.size() > 0)
140  F(2, 2) = _scalar_strain_zz[qp] + 1;
141  else
142  F(2, 2) = 1;
143 }
void SolidMechanics::NonlinearPlaneStrain::computeIncrementalDeformationGradient ( std::vector< ColumnMajorMatrix > &  Fhat)
protectedvirtual

Implements SolidMechanics::Nonlinear.

Definition at line 45 of file NonlinearPlaneStrain.C.

46 {
47  // A = grad(u(k+1) - u(k))
48  // Fbar = 1 + grad(u(k))
49  // Fhat = 1 + A*(Fbar^-1)
50  ColumnMajorMatrix A;
51  ColumnMajorMatrix Fbar;
52  ColumnMajorMatrix Fbar_inverse;
53  ColumnMajorMatrix Fhat_average;
54  Real volume(0);
55 
56  _Fbar.resize(_solid_model.qrule()->n_points());
57 
58  for (unsigned qp = 0; qp < _solid_model.qrule()->n_points(); ++qp)
59  {
60  Real strain_zz, strain_zz_old;
61  if (_have_strain_zz)
62  {
63  strain_zz = _strain_zz[qp];
64  strain_zz_old = _strain_zz_old[qp];
65  }
66  else if (_have_scalar_strain_zz && _scalar_strain_zz.size() > 0)
67  {
68  strain_zz = _scalar_strain_zz[qp];
69  strain_zz_old = _scalar_strain_zz_old[qp];
70  }
71  else
72  {
73  strain_zz = 0.0;
74  strain_zz_old = 0.0;
75  }
76 
77  fillMatrix(qp, _grad_disp_x, _grad_disp_y, strain_zz, A);
78  fillMatrix(qp, _grad_disp_x_old, _grad_disp_y_old, strain_zz_old, Fbar);
79 
80  A -= Fbar;
81 
82  Fbar.addDiag(1);
83 
84  _Fbar[qp] = Fbar;
85 
86  // Get Fbar^(-1)
87  // Computing the inverse is generally a bad idea.
88  // It's better to compute LU factors. For now at least, we'll take
89  // a direct route.
90 
91  invertMatrix(Fbar, Fbar_inverse);
92 
93  Fhat[qp] = A * Fbar_inverse;
94  Fhat[qp].addDiag(1);
95 
97  {
98  // Now include the contribution for the integration of Fhat over the element
99  Fhat_average += Fhat[qp] * _solid_model.JxW(qp);
100 
101  volume += _solid_model.JxW(qp); // Accumulate original configuration volume
102  }
103  }
104 
106  {
107  Fhat_average /= volume;
108  const Real det_Fhat_average(detMatrix(Fhat_average));
109 
110  // Finalize volumetric locking correction
111  for (unsigned qp = 0; qp < _solid_model.qrule()->n_points(); ++qp)
112  {
113  const Real det_Fhat(detMatrix(Fhat[qp]));
114  const Real factor(std::cbrt(det_Fhat_average / det_Fhat));
115 
116  Fhat[qp] *= factor;
117  }
118  }
119  // Moose::out << "Fhat(0,0)" << Fhat[0](0,0) << std::endl;
120 }
std::vector< ColumnMajorMatrix > _Fbar
Definition: Nonlinear.h:46
QBase * qrule()
Definition: SolidModel.h:53
virtual void fillMatrix(unsigned int qp, const VariableGradient &grad_x, const VariableGradient &grad_y, const Real &strain_zz, ColumnMajorMatrix &A) const
static Real detMatrix(const ColumnMajorMatrix &A)
Definition: Element.C:28
Real JxW(unsigned i) const
Definition: SolidModel.h:55
const std::vector< ColumnMajorMatrix > & Fhat() const
Definition: Nonlinear.h:31
SolidModel & _solid_model
Definition: Element.h:72
const VariableGradient & _grad_disp_y_old
static void invertMatrix(const ColumnMajorMatrix &A, ColumnMajorMatrix &Ainv)
Definition: Element.C:49
const VariableGradient & _grad_disp_x_old
void SolidMechanics::Nonlinear::computePolarDecomposition ( const ColumnMajorMatrix &  Fhat)
protectedinherited

Definition at line 137 of file Nonlinear.C.

Referenced by SolidMechanics::Nonlinear::computeStrainAndRotationIncrement(), and SolidMechanics::Nonlinear::volumeRatioOld().

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

Implements SolidMechanics::Element.

Definition at line 193 of file Nonlinear.C.

197 {
198  computeStrainAndRotationIncrement(_Fhat[qp], strain_increment);
199 
200  total_strain_new = strain_increment;
201  total_strain_new += total_strain_old;
202 }
void computeStrainAndRotationIncrement(const ColumnMajorMatrix &Fhat, SymmTensor &strain_increment)
Definition: Nonlinear.C:53
std::vector< ColumnMajorMatrix > _Fhat
Definition: Nonlinear.h:45
void SolidMechanics::Nonlinear::computeStrainAndRotationIncrement ( const ColumnMajorMatrix &  Fhat,
SymmTensor strain_increment 
)
protectedinherited

Definition at line 53 of file Nonlinear.C.

Referenced by SolidMechanics::Nonlinear::computeStrain(), and SolidMechanics::Nonlinear::volumeRatioOld().

55 {
57  {
58  computeStrainIncrement(Fhat, strain_increment);
60  }
61 
62  else if (_decomp_method == Eigen)
63  {
65  }
66 
67  else
68  {
69  mooseError("Unknown polar decomposition type!");
70  }
71 }
DecompMethod _decomp_method
Definition: Nonlinear.h:40
static void polarDecompositionEigen(const ColumnMajorMatrix &Fhat, ColumnMajorMatrix &Rhat, SymmTensor &strain_increment)
Definition: Element.C:182
void computeStrainIncrement(const ColumnMajorMatrix &Fhat, SymmTensor &strain_increment)
Definition: Nonlinear.C:76
void computePolarDecomposition(const ColumnMajorMatrix &Fhat)
Definition: Nonlinear.C:137
ColumnMajorMatrix _incremental_rotation
Definition: Nonlinear.h:42
const std::vector< ColumnMajorMatrix > & Fhat() const
Definition: Nonlinear.h:31
void SolidMechanics::Nonlinear::computeStrainIncrement ( const ColumnMajorMatrix &  Fhat,
SymmTensor strain_increment 
)
protectedinherited

Definition at line 76 of file Nonlinear.C.

Referenced by SolidMechanics::Nonlinear::computeStrainAndRotationIncrement(), and SolidMechanics::Nonlinear::volumeRatioOld().

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

Definition at line 28 of file Element.C.

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

29 {
30  mooseAssert(A.n() == 3 && A.m() == 3, "detMatrix requires 3x3 matrix");
31 
32  Real Axx = A(0, 0);
33  Real Axy = A(0, 1);
34  Real Axz = A(0, 2);
35  Real Ayx = A(1, 0);
36  Real Ayy = A(1, 1);
37  Real Ayz = A(1, 2);
38  Real Azx = A(2, 0);
39  Real Azy = A(2, 1);
40  Real Azz = A(2, 2);
41 
42  return Axx * Ayy * Azz + Axy * Ayz * Azx + Axz * Ayx * Azy - Azx * Ayy * Axz - Azy * Ayz * Axx -
43  Azz * Ayx * Axy;
44 }
const std::vector<ColumnMajorMatrix>& SolidMechanics::Nonlinear::Fhat ( ) const
inlineinherited
void SolidMechanics::NonlinearPlaneStrain::fillMatrix ( unsigned int  qp,
const VariableGradient &  grad_x,
const VariableGradient &  grad_y,
const Real &  strain_zz,
ColumnMajorMatrix &  A 
) const
protectedvirtual

Definition at line 148 of file NonlinearPlaneStrain.C.

Referenced by computeIncrementalDeformationGradient(), and volumeRatioOld().

153 {
154  mooseAssert(A.n() == 3 && A.m() == 3, "computeDefGrad requires 3x3 matrix");
155 
156  A(0, 0) = grad_x[qp](0);
157  A(0, 1) = grad_x[qp](1);
158  A(0, 2) = 0;
159  A(1, 0) = grad_y[qp](0);
160  A(1, 1) = grad_y[qp](1);
161  A(1, 2) = 0;
162  A(2, 0) = 0;
163  A(2, 1) = 0;
164  A(2, 2) = strain_zz;
165 }
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 225 of file Element.C.

Referenced by SolidMechanics::Nonlinear3D::computeIncrementalDeformationGradient(), and SolidMechanics::Element::getNumKnownCrackDirs().

230 {
231  A(0, 0) = grad_x[qp](0);
232  A(0, 1) = grad_x[qp](1);
233  A(0, 2) = grad_x[qp](2);
234  A(1, 0) = grad_y[qp](0);
235  A(1, 1) = grad_y[qp](1);
236  A(1, 2) = grad_y[qp](2);
237  A(2, 0) = grad_z[qp](0);
238  A(2, 1) = grad_z[qp](1);
239  A(2, 2) = grad_z[qp](2);
240 }
void SolidMechanics::Nonlinear::finalizeStress ( std::vector< SymmTensor * > &  t)
protectedvirtualinherited

Rotate stress to current configuration.

Reimplemented from SolidMechanics::Element.

Definition at line 181 of file Nonlinear.C.

Referenced by SolidMechanics::Nonlinear::volumeRatioOld().

182 {
183  // Using the incremental rotation, update the stress to the current configuration (R*T*R^T)
184  for (unsigned i = 0; i < t.size(); ++i)
185  {
187  }
188 }
static void rotateSymmetricTensor(const ColumnMajorMatrix &R, const RealTensorValue &T, RealTensorValue &result)
Definition: Element.C:78
ColumnMajorMatrix _incremental_rotation
Definition: Nonlinear.h:42
virtual unsigned int SolidMechanics::Element::getNumKnownCrackDirs ( ) const
inlinevirtualinherited

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

Definition at line 63 of file Element.h.

Referenced by SolidModel::getNumKnownCrackDirs().

63 { return 0; }
const ColumnMajorMatrix& SolidMechanics::Nonlinear::incrementalRotation ( ) const
inlineinherited

Definition at line 29 of file Nonlinear.h.

29 { return _incremental_rotation; }
ColumnMajorMatrix _incremental_rotation
Definition: Nonlinear.h:42
void SolidMechanics::Nonlinear::init ( )
protectedvirtualinherited

Reimplemented from SolidMechanics::Element.

Definition at line 207 of file Nonlinear.C.

208 {
209  _Fhat.resize(_solid_model.qrule()->n_points());
210 
212 }
QBase * qrule()
Definition: SolidModel.h:53
virtual void computeIncrementalDeformationGradient(std::vector< ColumnMajorMatrix > &Fhat)=0
SolidModel & _solid_model
Definition: Element.h:72
std::vector< ColumnMajorMatrix > _Fhat
Definition: Nonlinear.h:45
void SolidMechanics::Element::invertMatrix ( const ColumnMajorMatrix &  A,
ColumnMajorMatrix &  Ainv 
)
staticinherited

Definition at line 49 of file Element.C.

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

50 {
51  Real Axx = A(0, 0);
52  Real Axy = A(0, 1);
53  Real Axz = A(0, 2);
54  Real Ayx = A(1, 0);
55  Real Ayy = A(1, 1);
56  Real Ayz = A(1, 2);
57  Real Azx = A(2, 0);
58  Real Azy = A(2, 1);
59  Real Azz = A(2, 2);
60 
61  mooseAssert(detMatrix(A) > 0, "Matrix is not positive definite!");
62  Real detInv = 1 / detMatrix(A);
63 
64  Ainv(0, 0) = +(Ayy * Azz - Azy * Ayz) * detInv;
65  Ainv(0, 1) = -(Axy * Azz - Azy * Axz) * detInv;
66  Ainv(0, 2) = +(Axy * Ayz - Ayy * Axz) * detInv;
67  Ainv(1, 0) = -(Ayx * Azz - Azx * Ayz) * detInv;
68  Ainv(1, 1) = +(Axx * Azz - Azx * Axz) * detInv;
69  Ainv(1, 2) = -(Axx * Ayz - Ayx * Axz) * detInv;
70  Ainv(2, 0) = +(Ayx * Azy - Azx * Ayy) * detInv;
71  Ainv(2, 1) = -(Axx * Azy - Azx * Axy) * detInv;
72  Ainv(2, 2) = +(Axx * Ayy - Ayx * Axy) * detInv;
73 }
static Real detMatrix(const ColumnMajorMatrix &A)
Definition: Element.C:28
void SolidMechanics::Element::polarDecompositionEigen ( const ColumnMajorMatrix &  Fhat,
ColumnMajorMatrix &  Rhat,
SymmTensor strain_increment 
)
staticinherited

Definition at line 182 of file Element.C.

Referenced by SolidMechanics::Nonlinear::computeStrainAndRotationIncrement().

185 {
186  const int ND = 3;
187 
188  ColumnMajorMatrix eigen_value(ND, 1), eigen_vector(ND, ND);
189  ColumnMajorMatrix n1(ND, 1), n2(ND, 1), n3(ND, 1), N1(ND, 1), N2(ND, 1), N3(ND, 1);
190 
191  ColumnMajorMatrix Chat = Fhat.transpose() * Fhat;
192 
193  Chat.eigen(eigen_value, eigen_vector);
194 
195  for (int i = 0; i < ND; i++)
196  {
197  N1(i) = eigen_vector(i, 0);
198  N2(i) = eigen_vector(i, 1);
199  N3(i) = eigen_vector(i, 2);
200  }
201 
202  const Real lamda1 = std::sqrt(eigen_value(0));
203  const Real lamda2 = std::sqrt(eigen_value(1));
204  const Real lamda3 = std::sqrt(eigen_value(2));
205 
206  const Real log1 = std::log(lamda1);
207  const Real log2 = std::log(lamda2);
208  const Real log3 = std::log(lamda3);
209 
210  ColumnMajorMatrix Uhat =
211  N1 * N1.transpose() * lamda1 + N2 * N2.transpose() * lamda2 + N3 * N3.transpose() * lamda3;
212 
213  ColumnMajorMatrix invUhat(ND, ND);
214  invertMatrix(Uhat, invUhat);
215 
216  Rhat = Fhat * invUhat;
217 
218  strain_increment =
219  N1 * N1.transpose() * log1 + N2 * N2.transpose() * log2 + N3 * N3.transpose() * log3;
220 }
static void invertMatrix(const ColumnMajorMatrix &A, ColumnMajorMatrix &Ainv)
Definition: Element.C:49
void SolidMechanics::Element::rotateSymmetricTensor ( const ColumnMajorMatrix &  R,
const RealTensorValue &  T,
RealTensorValue &  result 
)
staticinherited

Definition at line 78 of file Element.C.

Referenced by SolidMechanics::Nonlinear::finalizeStress().

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

Definition at line 116 of file Element.C.

119 {
120 
121  // R T Rt
122  // 00 01 02 00 01 02 00 10 20
123  // 10 11 12 * 10 11 12 * 01 11 21
124  // 20 21 22 20 21 22 02 12 22
125  //
126  const Real T00 = R(0, 0) * T.xx() + R(0, 1) * T.xy() + R(0, 2) * T.zx();
127  const Real T01 = R(0, 0) * T.xy() + R(0, 1) * T.yy() + R(0, 2) * T.yz();
128  const Real T02 = R(0, 0) * T.zx() + R(0, 1) * T.yz() + R(0, 2) * T.zz();
129 
130  const Real T10 = R(1, 0) * T.xx() + R(1, 1) * T.xy() + R(1, 2) * T.zx();
131  const Real T11 = R(1, 0) * T.xy() + R(1, 1) * T.yy() + R(1, 2) * T.yz();
132  const Real T12 = R(1, 0) * T.zx() + R(1, 1) * T.yz() + R(1, 2) * T.zz();
133 
134  const Real T20 = R(2, 0) * T.xx() + R(2, 1) * T.xy() + R(2, 2) * T.zx();
135  const Real T21 = R(2, 0) * T.xy() + R(2, 1) * T.yy() + R(2, 2) * T.yz();
136  const Real T22 = R(2, 0) * T.zx() + R(2, 1) * T.yz() + R(2, 2) * T.zz();
137 
138  result.xx(T00 * R(0, 0) + T01 * R(0, 1) + T02 * R(0, 2));
139  result.yy(T10 * R(1, 0) + T11 * R(1, 1) + T12 * R(1, 2));
140  result.zz(T20 * R(2, 0) + T21 * R(2, 1) + T22 * R(2, 2));
141  result.xy(T00 * R(1, 0) + T01 * R(1, 1) + T02 * R(1, 2));
142  result.yz(T10 * R(2, 0) + T11 * R(2, 1) + T12 * R(2, 2));
143  result.zx(T00 * R(2, 0) + T01 * R(2, 1) + T02 * R(2, 2));
144 }
Real yy() const
Definition: SymmTensor.h:130
Real xx() const
Definition: SymmTensor.h:129
Real zz() const
Definition: SymmTensor.h:131
Real xy() const
Definition: SymmTensor.h:132
Real yz() const
Definition: SymmTensor.h:133
Real zx() const
Definition: SymmTensor.h:134
void SolidMechanics::Element::unrotateSymmetricTensor ( const ColumnMajorMatrix &  R,
const SymmTensor T,
SymmTensor result 
)
staticinherited

Definition at line 149 of file Element.C.

152 {
153 
154  // Rt T R
155  // 00 10 20 00 01 02 00 01 02
156  // 01 11 21 * 10 11 12 * 10 11 12
157  // 02 12 22 20 21 22 20 21 22
158  //
159  const Real T00 = R(0, 0) * T.xx() + R(1, 0) * T.xy() + R(2, 0) * T.zx();
160  const Real T01 = R(0, 0) * T.xy() + R(1, 0) * T.yy() + R(2, 0) * T.yz();
161  const Real T02 = R(0, 0) * T.zx() + R(1, 0) * T.yz() + R(2, 0) * T.zz();
162 
163  const Real T10 = R(0, 1) * T.xx() + R(1, 1) * T.xy() + R(2, 1) * T.zx();
164  const Real T11 = R(0, 1) * T.xy() + R(1, 1) * T.yy() + R(2, 1) * T.yz();
165  const Real T12 = R(0, 1) * T.zx() + R(1, 1) * T.yz() + R(2, 1) * T.zz();
166 
167  const Real T20 = R(0, 2) * T.xx() + R(1, 2) * T.xy() + R(2, 2) * T.zx();
168  const Real T21 = R(0, 2) * T.xy() + R(1, 2) * T.yy() + R(2, 2) * T.yz();
169  const Real T22 = R(0, 2) * T.zx() + R(1, 2) * T.yz() + R(2, 2) * T.zz();
170 
171  result.xx(T00 * R(0, 0) + T01 * R(1, 0) + T02 * R(2, 0));
172  result.yy(T10 * R(0, 1) + T11 * R(1, 1) + T12 * R(2, 1));
173  result.zz(T20 * R(0, 2) + T21 * R(1, 2) + T22 * R(2, 2));
174  result.xy(T00 * R(0, 1) + T01 * R(1, 1) + T02 * R(2, 1));
175  result.yz(T10 * R(0, 2) + T11 * R(1, 2) + T12 * R(2, 2));
176  result.zx(T00 * R(0, 2) + T01 * R(1, 2) + T02 * R(2, 2));
177 }
Real yy() const
Definition: SymmTensor.h:130
Real xx() const
Definition: SymmTensor.h:129
Real zz() const
Definition: SymmTensor.h:131
Real xy() const
Definition: SymmTensor.h:132
Real yz() const
Definition: SymmTensor.h:133
Real zx() const
Definition: SymmTensor.h:134
Real SolidMechanics::NonlinearPlaneStrain::volumeRatioOld ( unsigned  qp) const
protectedvirtual

Reimplemented from SolidMechanics::Nonlinear.

Definition at line 170 of file NonlinearPlaneStrain.C.

171 {
172  Real strain_zz_old;
173  if (_have_strain_zz)
174  strain_zz_old = _strain_zz_old[qp];
175  else if (_have_scalar_strain_zz && _scalar_strain_zz.size() > 0)
176  strain_zz_old = _scalar_strain_zz_old[qp];
177  else
178  strain_zz_old = 0.0;
179 
180  ColumnMajorMatrix Fnm1T;
181  fillMatrix(qp, _grad_disp_x_old, _grad_disp_y_old, strain_zz_old, Fnm1T);
182  Fnm1T.addDiag(1);
183 
184  return detMatrix(Fnm1T);
185 }
virtual void fillMatrix(unsigned int qp, const VariableGradient &grad_x, const VariableGradient &grad_y, const Real &strain_zz, ColumnMajorMatrix &A) const
static Real detMatrix(const ColumnMajorMatrix &A)
Definition: Element.C:28
const VariableGradient & _grad_disp_y_old
const VariableGradient & _grad_disp_x_old

Member Data Documentation

DecompMethod SolidMechanics::Nonlinear::_decomp_method
protectedinherited
ColumnMajorMatrix SolidMechanics::Nonlinear::_F
protectedinherited

Definition at line 47 of file Nonlinear.h.

std::vector<ColumnMajorMatrix> SolidMechanics::Nonlinear::_Fbar
protectedinherited
std::vector<ColumnMajorMatrix> SolidMechanics::Nonlinear::_Fhat
protectedinherited
const VariableGradient& SolidMechanics::NonlinearPlaneStrain::_grad_disp_x
const VariableGradient& SolidMechanics::NonlinearPlaneStrain::_grad_disp_x_old

Definition at line 35 of file NonlinearPlaneStrain.h.

Referenced by computeIncrementalDeformationGradient(), and volumeRatioOld().

const VariableGradient& SolidMechanics::NonlinearPlaneStrain::_grad_disp_y
const VariableGradient& SolidMechanics::NonlinearPlaneStrain::_grad_disp_y_old

Definition at line 36 of file NonlinearPlaneStrain.h.

Referenced by computeIncrementalDeformationGradient(), and volumeRatioOld().

bool SolidMechanics::NonlinearPlaneStrain::_have_scalar_strain_zz
bool SolidMechanics::NonlinearPlaneStrain::_have_strain_zz
ColumnMajorMatrix SolidMechanics::Nonlinear::_incremental_rotation
protectedinherited
const VariableValue& SolidMechanics::NonlinearPlaneStrain::_scalar_strain_zz
const VariableValue& SolidMechanics::NonlinearPlaneStrain::_scalar_strain_zz_old

Definition at line 38 of file NonlinearPlaneStrain.h.

Referenced by computeIncrementalDeformationGradient(), and volumeRatioOld().

SolidModel& SolidMechanics::Element::_solid_model
protectedinherited
const VariableValue& SolidMechanics::NonlinearPlaneStrain::_strain_zz
const VariableValue& SolidMechanics::NonlinearPlaneStrain::_strain_zz_old

Definition at line 37 of file NonlinearPlaneStrain.h.

Referenced by computeIncrementalDeformationGradient(), and volumeRatioOld().

ColumnMajorMatrix SolidMechanics::Nonlinear::_Uhat
protectedinherited

Definition at line 43 of file Nonlinear.h.

const bool SolidMechanics::NonlinearPlaneStrain::_volumetric_locking_correction
protected

Definition at line 51 of file NonlinearPlaneStrain.h.

Referenced by computeIncrementalDeformationGradient().


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