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

#include <Linear.h>

Inheritance diagram for SolidMechanics::Linear:
[legend]

Public Member Functions

 Linear (SolidModel &solid_model, const std::string &name, const InputParameters &parameters)
 
virtual ~Linear ()
 
virtual void init ()
 
virtual void computeDeformationGradient (unsigned int, ColumnMajorMatrix &)
 
virtual Real volumeRatioOld (unsigned) const
 
virtual void finalizeStress (std::vector< SymmTensor *> &)
 Rotate stress to current configuration. More...
 
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 Member Functions

virtual void computeStrain (const unsigned qp, const SymmTensor &total_strain_old, SymmTensor &total_strain_new, SymmTensor &strain_increment)
 

Protected Attributes

const bool _large_strain
 
const VariableGradient & _grad_disp_x
 
const VariableGradient & _grad_disp_y
 
const VariableGradient & _grad_disp_z
 
const bool _volumetric_locking_correction
 
SolidModel_solid_model
 

Detailed Description

Definition at line 21 of file Linear.h.

Constructor & Destructor Documentation

◆ Linear()

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

Definition at line 19 of file Linear.C.

22  : Element(solid_model, name, parameters),
23  _large_strain(solid_model.getParam<bool>("large_strain")),
24  _grad_disp_x(coupledGradient("disp_x")),
25  _grad_disp_y(coupledGradient("disp_y")),
26  _grad_disp_z(parameters.get<SubProblem *>("_subproblem")->mesh().dimension() == 3
27  ? coupledGradient("disp_z")
28  : _grad_zero),
29  _volumetric_locking_correction(solid_model.getParam<bool>("volumetric_locking_correction"))
30 {
31 }
const bool _volumetric_locking_correction
Definition: Linear.h:38
const VariableGradient & _grad_disp_z
Definition: Linear.h:37
Element(SolidModel &solid_model, const std::string &name, const InputParameters &parameters)
Definition: Element.C:17
const VariableGradient & _grad_disp_x
Definition: Linear.h:35
const bool _large_strain
Definition: Linear.h:33
const std::string name
Definition: Setup.h:22
const VariableGradient & _grad_disp_y
Definition: Linear.h:36

◆ ~Linear()

SolidMechanics::Linear::~Linear ( )
virtual

Definition at line 33 of file Linear.C.

33 {}

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 51 of file Element.h.

Referenced by SolidModel::computeEshelby().

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

◆ computeStrain()

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

Implements SolidMechanics::Element.

Definition at line 36 of file Linear.C.

40 {
41  strain_increment.xx(_grad_disp_x[qp](0));
42  strain_increment.yy(_grad_disp_y[qp](1));
43  strain_increment.zz(_grad_disp_z[qp](2));
44  strain_increment.xy(0.5 * (_grad_disp_x[qp](1) + _grad_disp_y[qp](0)));
45  strain_increment.yz(0.5 * (_grad_disp_y[qp](2) + _grad_disp_z[qp](1)));
46  strain_increment.zx(0.5 * (_grad_disp_z[qp](0) + _grad_disp_x[qp](2)));
47  if (_large_strain)
48  {
49  strain_increment.xx() += 0.5 * (_grad_disp_x[qp](0) * _grad_disp_x[qp](0) +
50  _grad_disp_y[qp](0) * _grad_disp_y[qp](0) +
51  _grad_disp_z[qp](0) * _grad_disp_z[qp](0));
52  strain_increment.yy() += 0.5 * (_grad_disp_x[qp](1) * _grad_disp_x[qp](1) +
53  _grad_disp_y[qp](1) * _grad_disp_y[qp](1) +
54  _grad_disp_z[qp](1) * _grad_disp_z[qp](1));
55  strain_increment.zz() += 0.5 * (_grad_disp_x[qp](2) * _grad_disp_x[qp](2) +
56  _grad_disp_y[qp](2) * _grad_disp_y[qp](2) +
57  _grad_disp_z[qp](2) * _grad_disp_z[qp](2));
58  strain_increment.xy() += 0.5 * (_grad_disp_x[qp](0) * _grad_disp_x[qp](1) +
59  _grad_disp_y[qp](0) * _grad_disp_y[qp](1) +
60  _grad_disp_z[qp](0) * _grad_disp_z[qp](1));
61  strain_increment.yz() += 0.5 * (_grad_disp_x[qp](1) * _grad_disp_x[qp](2) +
62  _grad_disp_y[qp](1) * _grad_disp_y[qp](2) +
63  _grad_disp_z[qp](1) * _grad_disp_z[qp](2));
64  strain_increment.zx() += 0.5 * (_grad_disp_x[qp](2) * _grad_disp_x[qp](0) +
65  _grad_disp_y[qp](2) * _grad_disp_y[qp](0) +
66  _grad_disp_z[qp](2) * _grad_disp_z[qp](0));
67  }
68 
70  {
71  // volumetric locking correction - averaging the volumertic strain over the element
72  Real volumetric_strain = 0.0;
73  Real volume = 0.0;
74  for (unsigned int qp_loop = 0; qp_loop < _solid_model.qrule()->n_points(); ++qp_loop)
75  {
76  volumetric_strain +=
77  (_grad_disp_x[qp_loop](0) + _grad_disp_y[qp_loop](1) + _grad_disp_z[qp_loop](2)) / 3.0 *
78  _solid_model.JxW(qp_loop);
79 
80  volume += _solid_model.JxW(qp_loop);
81 
82  if (_large_strain)
83  {
84  volumetric_strain += 0.5 * (_grad_disp_x[qp_loop](0) * _grad_disp_x[qp_loop](0) +
85  _grad_disp_y[qp_loop](0) * _grad_disp_y[qp_loop](0) +
86  _grad_disp_z[qp_loop](0) * _grad_disp_z[qp_loop](0)) /
87  3.0 * _solid_model.JxW(qp_loop);
88  volumetric_strain += 0.5 * (_grad_disp_x[qp_loop](1) * _grad_disp_x[qp_loop](1) +
89  _grad_disp_y[qp_loop](1) * _grad_disp_y[qp_loop](1) +
90  _grad_disp_z[qp_loop](1) * _grad_disp_z[qp_loop](1)) /
91  3.0 * _solid_model.JxW(qp_loop);
92  volumetric_strain += 0.5 * (_grad_disp_x[qp_loop](2) * _grad_disp_x[qp_loop](2) +
93  _grad_disp_y[qp_loop](2) * _grad_disp_y[qp_loop](2) +
94  _grad_disp_z[qp_loop](2) * _grad_disp_z[qp_loop](2)) /
95  3.0 * _solid_model.JxW(qp_loop);
96  }
97  }
98 
99  volumetric_strain /= volume; // average volumetric strain
100 
101  // strain increment at _qp
102  Real trace = strain_increment.trace();
103  strain_increment.xx() += volumetric_strain - trace / 3.0;
104  strain_increment.yy() += volumetric_strain - trace / 3.0;
105  strain_increment.zz() += volumetric_strain - trace / 3.0;
106  }
107 
108  total_strain_new = strain_increment;
109  strain_increment -= total_strain_old;
110 }
const bool _volumetric_locking_correction
Definition: Linear.h:38
const VariableGradient & _grad_disp_z
Definition: Linear.h:37
Real yz() const
Definition: SymmTensor.h:136
Real zx() const
Definition: SymmTensor.h:137
const VariableGradient & _grad_disp_x
Definition: Linear.h:35
const bool _large_strain
Definition: Linear.h:33
QBase * qrule()
Definition: SolidModel.h:56
Real yy() const
Definition: SymmTensor.h:133
Real xx() const
Definition: SymmTensor.h:132
SolidModel & _solid_model
Definition: Element.h:75
const VariableGradient & _grad_disp_y
Definition: Linear.h:36
Real JxW(unsigned i) const
Definition: SolidModel.h:58
Real trace() const
Definition: SymmTensor.h:98
Real xy() const
Definition: SymmTensor.h:135
Real zz() const
Definition: SymmTensor.h:134

◆ detMatrix()

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

Definition at line 31 of file Element.C.

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().

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 }

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

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

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 }

◆ finalizeStress()

virtual void SolidMechanics::Element::finalizeStress ( std::vector< SymmTensor *> &  )
inlinevirtualinherited

Rotate stress to current configuration.

Reimplemented in SolidMechanics::Nonlinear.

Definition at line 64 of file Element.h.

Referenced by SolidModel::finalizeStress().

64 {}

◆ getNumKnownCrackDirs()

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

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

Definition at line 66 of file Element.h.

Referenced by SolidModel::getNumKnownCrackDirs().

66 { return 0; }

◆ init()

virtual void SolidMechanics::Element::init ( )
inlinevirtualinherited

Reimplemented in SolidMechanics::Nonlinear.

Definition at line 49 of file Element.h.

Referenced by SolidModel::computeProperties().

49 {}

◆ invertMatrix()

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

Definition at line 52 of file Element.C.

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

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 }
static Real detMatrix(const ColumnMajorMatrix &A)
Definition: Element.C:31

◆ polarDecompositionEigen()

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

Definition at line 185 of file Element.C.

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

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 }
static void invertMatrix(const ColumnMajorMatrix &A, ColumnMajorMatrix &Ainv)
Definition: Element.C:52

◆ rotateSymmetricTensor() [1/2]

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

Definition at line 81 of file Element.C.

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

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 }

◆ 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 }
Real yz() const
Definition: SymmTensor.h:136
Real zx() const
Definition: SymmTensor.h:137
Real yy() const
Definition: SymmTensor.h:133
Real xx() const
Definition: SymmTensor.h:132
Real xy() const
Definition: SymmTensor.h:135
Real zz() const
Definition: SymmTensor.h:134

◆ 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 }
Real yz() const
Definition: SymmTensor.h:136
Real zx() const
Definition: SymmTensor.h:137
Real yy() const
Definition: SymmTensor.h:133
Real xx() const
Definition: SymmTensor.h:132
Real xy() const
Definition: SymmTensor.h:135
Real zz() const
Definition: SymmTensor.h:134

◆ volumeRatioOld()

virtual Real SolidMechanics::Element::volumeRatioOld ( unsigned  ) const
inlinevirtualinherited

Member Data Documentation

◆ _grad_disp_x

const VariableGradient& SolidMechanics::Linear::_grad_disp_x
protected

Definition at line 35 of file Linear.h.

Referenced by computeStrain().

◆ _grad_disp_y

const VariableGradient& SolidMechanics::Linear::_grad_disp_y
protected

Definition at line 36 of file Linear.h.

Referenced by computeStrain().

◆ _grad_disp_z

const VariableGradient& SolidMechanics::Linear::_grad_disp_z
protected

Definition at line 37 of file Linear.h.

Referenced by computeStrain().

◆ _large_strain

const bool SolidMechanics::Linear::_large_strain
protected

Definition at line 33 of file Linear.h.

Referenced by computeStrain().

◆ _solid_model

SolidModel& SolidMechanics::Element::_solid_model
protectedinherited

◆ _volumetric_locking_correction

const bool SolidMechanics::Linear::_volumetric_locking_correction
protected

Definition at line 38 of file Linear.h.

Referenced by computeStrain().


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