SymmetricRankFourTensorTempl is designed to handle an N-dimensional fourth order tensor with minor symmetry, C. More...

#include <SymmetricRankFourTensor.h>

Classes
struct	TwoTensorMultTraits

struct	TwoTensorMultTraits< SymmetricRankTwoTensorTempl, Scalar >

struct	TwoTensorMultTraits< TensorValue, Scalar >

struct	TwoTensorMultTraits< TypeTensor, Scalar >

Public Types
enum	InitMethod { initNone , initIdentity , initIdentitySymmetricFour }
	Initialization method. More...

enum	FillMethod { symmetric9 , symmetric21 , symmetric_isotropic , symmetric_isotropic_E_nu , axisymmetric_rz , principal , orthotropic }
	To fill up the 36 entries in the 4th-order tensor, fillFromInputVector is called with one of the following fill_methods. More...

Public Member Functions
	SymmetricRankFourTensorTempl ()
	Default constructor; fills to zero.

	SymmetricRankFourTensorTempl (const InitMethod)
	Select specific initialization pattern.

	SymmetricRankFourTensorTempl (const std::vector< T > &, FillMethod)
	Fill from vector.

	SymmetricRankFourTensorTempl (const SymmetricRankFourTensorTempl< T > &a)=default
	Copy assignment operator must be defined if used.

template<typename T2 >
	SymmetricRankFourTensorTempl (const SymmetricRankFourTensorTempl< T2 > &copy)
	Copy constructor.

	SymmetricRankFourTensorTempl (const RankFourTensorTempl< T > &a)
	Copy constructor from RankFourTensorTempl<T>

	operator RankFourTensorTempl< T > ()
	The conversion operator to `RankFourTensorTempl`

T &	operator() (unsigned int i, unsigned int j)
	Gets the value for the indices specified. Takes indices ranging from 0-5 for i and j.

const T &	operator() (unsigned int i, unsigned int j) const
	Gets the value for the indices specified.

void	zero ()
	Zeros out the tensor.

void	print (std::ostream &stm=Moose::out) const
	Print the rank four tensor.

void	printReal (std::ostream &stm=Moose::out) const
	Print the values of the rank four tensor.

SymmetricRankFourTensorTempl< T > &	operator= (const SymmetricRankFourTensorTempl< T > &a)=default
	copies values from a into this tensor

template<typename Scalar >
std::enable_if< libMesh::ScalarTraits< Scalar >::value, SymmetricRankFourTensorTempl & >::type	operator= (const Scalar &libmesh_dbg_var(p))
	Assignment-from-scalar operator.

template<typename T2 >
auto	operator* (const SymmetricRankTwoTensorTempl< T2 > &b) const -> SymmetricRankTwoTensorTempl< decltype(T() *T2())>
	C_ijkl*a_kl.

template<typename T2 >
auto	operator* (const T2 &a) const -> typename std::enable_if< libMesh::ScalarTraits< T2 >::value, SymmetricRankFourTensorTempl< decltype(T() *T2())> >::type
	C_ijkl*a.

SymmetricRankFourTensorTempl< T > &	operator*= (const T &a)
	C_ijkl *= a.

template<typename T2 >
auto	operator/ (const T2 &a) const -> typename std::enable_if< libMesh::ScalarTraits< T2 >::value, SymmetricRankFourTensorTempl< decltype(T()/T2())> >::type
	C_ijkl/a.

SymmetricRankFourTensorTempl< T > &	operator/= (const T &a)
	C_ijkl /= a for all i, j, k, l.

SymmetricRankFourTensorTempl< T > &	operator+= (const SymmetricRankFourTensorTempl< T > &a)
	C_ijkl += a_ijkl for all i, j, k, l.

template<typename T2 >
auto	operator+ (const SymmetricRankFourTensorTempl< T2 > &a) const -> SymmetricRankFourTensorTempl< decltype(T()+T2())>
	C_ijkl + a_ijkl.

SymmetricRankFourTensorTempl< T > &	operator-= (const SymmetricRankFourTensorTempl< T > &a)
	C_ijkl -= a_ijkl.

template<typename T2 >
auto	operator- (const SymmetricRankFourTensorTempl< T2 > &a) const -> SymmetricRankFourTensorTempl< decltype(T() - T2())>
	C_ijkl - a_ijkl.

SymmetricRankFourTensorTempl< T >	operator- () const
	-C_ijkl

template<typename T2 >
auto	operator* (const SymmetricRankFourTensorTempl< T2 > &a) const -> SymmetricRankFourTensorTempl< decltype(T() *T2())>
	C_ijpq*a_pqkl.

T	L2norm () const
	sqrt(C_ijkl*C_ijkl)

SymmetricRankFourTensorTempl< T >	invSymm () const
	This returns A_ijkl such that C_ijklA_klmn = 0.5(de_im de_jn + de_in de_jm) This routine assumes that C_ijkl = C_jikl = C_ijlk.

void	rotate (const TypeTensor< T > &R)
	Rotate the tensor using C_ijkl = R_im R_jn R_ko R_lp C_mnop.

SymmetricRankFourTensorTempl< T >	transposeMajor () const
	Transpose the tensor by swapping the first pair with the second pair of indices This amounts to a regular transpose of the 6x6 matrix.

SymmetricRankFourTensorTempl< T >	transposeIj () const
	Transpose the tensor by swapping the first two indices - a no-op.

void	fillFromInputVector (const std::vector< T > &input, FillMethod fill_method)
	fillFromInputVector takes some number of inputs to fill the Rank-4 tensor.

template<typename T2 >
void	fillSymmetric9FromInputVector (const T2 &input)
	fillSymmetric9FromInputVector takes 9 inputs to fill in the Rank-4 tensor with the appropriate crystal symmetries maintained.

template<typename T2 >
void	fillSymmetric21FromInputVector (const T2 &input)
	fillSymmetric21FromInputVector takes 21 inputs to fill in the Rank-4 tensor with the appropriate crystal symmetries maintained.

T	sum3x3 () const
	Calculates the sum of Ciijj for i and j varying from 0 to 2.

libMesh::VectorValue< T >	sum3x1 () const
	Calculates the vector a[i] = sum over j Ciijj for i and j varying from 0 to 2.

bool	isSymmetric () const
	checks if the tensor is symmetric

bool	isIsotropic () const
	checks if the tensor is isotropic


void	fillSymmetricIsotropic (const T &i0, const T &i1)
	Vector-less fill API functions. See docs of the corresponding ...FromInputVector methods.

void	fillSymmetricIsotropicEandNu (const T &E, const T &nu)

Static Public Member Functions
static constexpr Real	mandelFactor (unsigned int i, unsigned int j)
	returns the 1, sqrt(2), or 2 prefactor in the Mandel notation for the indices i,j ranging from 0-5.

static SymmetricRankFourTensorTempl< T >	identity ()

static SymmetricRankFourTensorTempl< T >	identitySymmetricFour ()

static SymmetricRankFourTensorTempl< T >	rotationMatrix (const TypeTensor< T > &R)
	Build a 6x6 rotation matrix MEHRABADI, MORTEZA M.; COWIN, STEPHEN C.

static MooseEnum	fillMethodEnum ()
	Static method for use in validParams for getting the "fill_method".

Static Public Attributes
static constexpr unsigned int	full_index [6][6][4]


static constexpr unsigned int	Ndim = LIBMESH_DIM
	tensor dimension, Mandel matrix dimension, and Mandel matrix size

static constexpr unsigned int	N = Ndim + Ndim * (Ndim - 1) / 2

static constexpr unsigned int	N2 = N * N

Protected Member Functions
void	fillSymmetricIsotropicFromInputVector (const std::vector< T > &input)
	fillSymmetricIsotropicFromInputVector takes 2 inputs to fill the the symmetric Rank-4 tensor with the appropriate symmetries maintained.

void	fillSymmetricIsotropicEandNuFromInputVector (const std::vector< T > &input)
	fillSymmetricIsotropicEandNuFromInputVector is a variation of the fillSymmetricIsotropicFromInputVector which takes as inputs the more commonly used Young's modulus (E) and Poisson's ratio (nu) constants to fill the isotropic elasticity tensor.

void	fillAxisymmetricRZFromInputVector (const std::vector< T > &input)
	fillAxisymmetricRZFromInputVector takes 5 inputs to fill the axisymmetric Rank-4 tensor with the appropriate symmetries maintatined for use with axisymmetric problems using coord_type = RZ.

void	fillPrincipalFromInputVector (const std::vector< T > &input)
	fillPrincipalFromInputVector takes 9 inputs to fill a Rank-4 tensor C1111 = input0 C1122 = input1 C1133 = input2 C2211 = input3 C2222 = input4 C2233 = input5 C3311 = input6 C3322 = input7 C3333 = input8 with all other components being zero

void	fillGeneralOrthotropicFromInputVector (const std::vector< T > &input)
	fillGeneralOrhotropicFromInputVector takes 10 inputs to fill the Rank-4 tensor It defines a general orthotropic tensor for which some constraints among elastic parameters exist

Protected Attributes
std::array< T, N2 >	_vals
	The values of the rank-four tensor.

Friends
template<typename T2 >
class	SymmetricRankTwoTensorTempl

template<typename T2 >
class	SymmetricRankFourTensorTempl

template<typename T2 >
class	RankThreeTensorTempl

std::ostream &	operator<< (std::ostream &os, const SymmetricRankFourTensorTempl< T > &t)

template<class T2 >
void	dataStore (std::ostream &, SymmetricRankFourTensorTempl< T2 > &, void *)

template<class T2 >
void	dataLoad (std::istream &, SymmetricRankFourTensorTempl< T2 > &, void *)

Detailed Description

template<typename T>
class SymmetricRankFourTensorTempl< T >

SymmetricRankFourTensorTempl is designed to handle an N-dimensional fourth order tensor with minor symmetry, C.

Since N is hard-coded to 3, SymmetricRankFourTensorTempl holds 36 separate C_ij entries. Within the code i,j = 0, .., 5.

Definition at line 66 of file SymmetricRankFourTensor.h.

Member Enumeration Documentation

◆ FillMethod

template<typename T >

enum SymmetricRankFourTensorTempl::FillMethod

To fill up the 36 entries in the 4th-order tensor, fillFromInputVector is called with one of the following fill_methods.

See the fill*FromInputVector functions for more details

Enumerator
symmetric9
symmetric21
symmetric_isotropic
symmetric_isotropic_E_nu
axisymmetric_rz
principal
orthotropic

Definition at line 104 of file SymmetricRankFourTensor.h.

  {
    symmetric9,               // fillSymmetric9FromInputVector
    symmetric21,              // fillSymmetric21FromInputVector
    symmetric_isotropic,      // fillSymmetricIsotropicFromInputVector
    symmetric_isotropic_E_nu, // fillSymmetricIsotropicEandNu
    axisymmetric_rz,          // fillAxisymmetricRZFromInputVector
    principal,                // fillPrincipalFromInputVector
    orthotropic               // fillGeneralOrthotropicFromInputVector
  };

◆ InitMethod

template<typename T >

enum SymmetricRankFourTensorTempl::InitMethod

Initialization method.

Enumerator
initNone
initIdentity
initIdentitySymmetricFour

Definition at line 92 of file SymmetricRankFourTensor.h.

  {
    initNone,
    initIdentity,
    initIdentitySymmetricFour
  };

Constructor & Destructor Documentation

◆ SymmetricRankFourTensorTempl() [1/6]

template<typename T >

SymmetricRankFourTensorTempl< T >::SymmetricRankFourTensorTempl ( )

Default constructor; fills to zero.

Definition at line 48 of file SymmetricRankFourTensorImplementation.h.

{
  mooseAssert(Ndim == 3,
              "SymmetricRankFourTensorTempl<T> is designed to only work in 3 dimensions.");
  zero();
}

◆ SymmetricRankFourTensorTempl() [2/6]

template<typename T >

SymmetricRankFourTensorTempl< T >::SymmetricRankFourTensorTempl ( const InitMethod init )

Select specific initialization pattern.

Definition at line 56 of file SymmetricRankFourTensorImplementation.h.

{
  switch (init)
  {
    case initNone:
      break;
 
    case initIdentity:
      zero();
      for (const auto i : make_range(Ndim))
        (*this)(i, i) = 1.0;
      break;
 
    case initIdentitySymmetricFour:
      zero();
      for (const auto i : make_range(N))
        (*this)(i, i) = 1.0;
      break;
 
    default:
      mooseError("Unknown SymmetricRankFourTensorTempl<T> initialization pattern.");
  }
}

◆ SymmetricRankFourTensorTempl() [3/6]

template<typename T >

SymmetricRankFourTensorTempl< T >::SymmetricRankFourTensorTempl	(	const std::vector< T > &	input,
		FillMethod	fill_method
	)

Fill from vector.

Definition at line 120 of file SymmetricRankFourTensorImplementation.h.

{
  fillFromInputVector(input, fill_method);
}

◆ SymmetricRankFourTensorTempl() [4/6]

template<typename T >

SymmetricRankFourTensorTempl< T >::SymmetricRankFourTensorTempl ( const SymmetricRankFourTensorTempl< T > & a )

default

Copy assignment operator must be defined if used.

◆ SymmetricRankFourTensorTempl() [5/6]

template<typename T >

template<typename T2 >

SymmetricRankFourTensorTempl< T >::SymmetricRankFourTensorTempl ( const SymmetricRankFourTensorTempl< T2 > & copy )

Copy constructor.

Definition at line 447 of file SymmetricRankFourTensor.h.

{
  for (const auto i : make_range(N2))
    _vals[i] = copy._vals[i];
}

◆ SymmetricRankFourTensorTempl() [6/6]

template<typename T >

SymmetricRankFourTensorTempl< T >::SymmetricRankFourTensorTempl ( const RankFourTensorTempl< T > & a )

explicit

Copy constructor from RankFourTensorTempl<T>

Definition at line 81 of file SymmetricRankFourTensorImplementation.h.

{
  for (const auto a : make_range(N))
    for (const auto b : make_range(N))
    {
      const auto & idx = full_index[a][b];
      auto i = idx[0];
      auto j = idx[1];
      auto k = idx[2];
      auto l = idx[3];
      (*this)(a, b) =
          (t(i, j, k, l) + t(j, i, l, k) + t(j, i, k, l) + t(i, j, l, k)) / 4 * mandelFactor(a, b);
    }
}

Member Function Documentation

◆ fillAxisymmetricRZFromInputVector()

template<typename T >

void SymmetricRankFourTensorTempl< T >::fillAxisymmetricRZFromInputVector ( const std::vector< T > & input )

protected

fillAxisymmetricRZFromInputVector takes 5 inputs to fill the axisymmetric Rank-4 tensor with the appropriate symmetries maintatined for use with axisymmetric problems using coord_type = RZ.

I.e. C1111 = C2222, C1133 = C2233, C2323 = C3131 and C1212 = 0.5*(C1111-C1122)

Parameters

input this is C1111, C1122, C1133, C3333, C2323.

Definition at line 383 of file SymmetricRankFourTensorImplementation.h.

{
  mooseAssert(input.size() == 5,
              "To use fillAxisymmetricRZFromInputVector, your input must have size 5.");
 
  // C1111  C1122     C1133       0         0         0
  //        C2222  C2233=C1133    0         0         0
  //                  C3333       0         0         0
  //                            C2323       0         0
  //                                   C3131=C2323    0
  //                                                C1212
  // clang-format off
  fillSymmetric21FromInputVector(std::array<T,21>
  {{input[0],input[1],input[2],      0.0,      0.0, 0.0,
             input[0],input[2],      0.0,      0.0, 0.0,
                      input[3],      0.0,      0.0, 0.0,
                                input[4],      0.0, 0.0,
                                          input[4], 0.0,
                                                    (input[0] - input[1]) * 0.5}});
  // clang-format on
}

◆ fillFromInputVector()

template<typename T >

void SymmetricRankFourTensorTempl< T >::fillFromInputVector	(	const std::vector< T > &	input,
		FillMethod	fill_method
	)

fillFromInputVector takes some number of inputs to fill the Rank-4 tensor.

Parameters

input	the numbers that will be placed in the tensor
fill_method	See FillMethod

Definition at line 300 of file SymmetricRankFourTensorImplementation.h.

{
 
  switch (fill_method)
  {
    case symmetric9:
      fillSymmetric9FromInputVector(input);
      break;
    case symmetric21:
      fillSymmetric21FromInputVector(input);
      break;
    case symmetric_isotropic:
      fillSymmetricIsotropicFromInputVector(input);
      break;
    case symmetric_isotropic_E_nu:
      fillSymmetricIsotropicEandNuFromInputVector(input);
      break;
    case axisymmetric_rz:
      fillAxisymmetricRZFromInputVector(input);
      break;
    case principal:
      fillPrincipalFromInputVector(input);
      break;
    case orthotropic:
      fillGeneralOrthotropicFromInputVector(input);
      break;
    default:
      mooseError("fillFromInputVector called with unknown fill_method of ", fill_method);
  }
}

◆ fillGeneralOrthotropicFromInputVector()

template<typename T >

void SymmetricRankFourTensorTempl< T >::fillGeneralOrthotropicFromInputVector ( const std::vector< T > & input )

protected

fillGeneralOrhotropicFromInputVector takes 10 inputs to fill the Rank-4 tensor It defines a general orthotropic tensor for which some constraints among elastic parameters exist

Parameters

input Ea, Eb, Ec, Gab, Gbc, Gca, nuba, nuca, nucb, nuab, nuac, nubc

Definition at line 429 of file SymmetricRankFourTensorImplementation.h.

{
  mooseAssert(LIBMESH_DIM == 3, "This method assumes LIBMESH_DIM == 3");
  if (input.size() != 12)
    mooseError("To use fillGeneralOrhotropicFromInputVector, your input must have size 12. Yours "
               "has size ",
               input.size());
 
  const T & Ea = input[0];
  const T & Eb = input[1];
  const T & Ec = input[2];
  const T & Gab = input[3];
  const T & Gbc = input[4];
  const T & Gca = input[5];
  const T & nuba = input[6];
  const T & nuca = input[7];
  const T & nucb = input[8];
  const T & nuab = input[9];
  const T & nuac = input[10];
  const T & nubc = input[11];
 
  // Input must satisfy constraints.
  bool preserve_symmetry = MooseUtils::relativeFuzzyEqual(nuab * Eb, nuba * Ea) &&
                           MooseUtils::relativeFuzzyEqual(nuca * Ea, nuac * Ec) &&
                           MooseUtils::relativeFuzzyEqual(nubc * Ec, nucb * Eb);
 
  if (!preserve_symmetry)
    mooseError("Orthotropic elasticity tensor input is not consistent with symmetry requirements. "
               "Check input for accuracy");
 
  zero();
  T k = 1 - nuab * nuba - nubc * nucb - nuca * nuac - nuab * nubc * nuca - nuba * nucb * nuac;
 
  bool is_positive_definite =
      (k > 0) && (1 - nubc * nucb) > 0 && (1 - nuac * nuca) > 0 && (1 - nuab * nuba) > 0;
  if (!is_positive_definite)
    mooseError("Orthotropic elasticity tensor input is not positive definite. Check input for "
               "accuracy");
 
  _vals[0] = Ea * (1 - nubc * nucb) / k;
  _vals[1] = Ea * (nubc * nuca + nuba) / k;
  _vals[2] = Ea * (nuba * nucb + nuca) / k;
 
  _vals[6] = Eb * (nuac * nucb + nuab) / k;
  _vals[7] = Eb * (1 - nuac * nuca) / k;
  _vals[8] = Eb * (nuab * nuca + nucb) / k;
 
  _vals[12] = Ec * (nuab * nubc + nuac) / k;
  _vals[13] = Ec * (nuac * nuba + nubc) / k;
  _vals[14] = Ec * (1 - nuab * nuba) / k;
 
  _vals[21] = 2 * Gbc;
  _vals[28] = 2 * Gca;
  _vals[35] = 2 * Gab;
}

◆ fillMethodEnum()

template<typename T >

MooseEnum SymmetricRankFourTensorTempl< T >::fillMethodEnum ( )

static

Static method for use in validParams for getting the "fill_method".

Definition at line 41 of file SymmetricRankFourTensorImplementation.h.

{
  return MooseEnum("symmetric9 symmetric21  symmetric_isotropic symmetric_isotropic_E_nu  "
                   "axisymmetric_rz principal orthotropic");
}

◆ fillPrincipalFromInputVector()

template<typename T >

void SymmetricRankFourTensorTempl< T >::fillPrincipalFromInputVector ( const std::vector< T > & input )

protected

fillPrincipalFromInputVector takes 9 inputs to fill a Rank-4 tensor C1111 = input0 C1122 = input1 C1133 = input2 C2211 = input3 C2222 = input4 C2233 = input5 C3311 = input6 C3322 = input7 C3333 = input8 with all other components being zero

Definition at line 407 of file SymmetricRankFourTensorImplementation.h.

{
  if (input.size() != 9)
    mooseError("To use fillPrincipalFromInputVector, your input must have size 9. Yours has size ",
               input.size());
 
  zero();
 
  // top left block
  _vals[0] = input[0];
  _vals[1] = input[1];
  _vals[2] = input[2];
  _vals[6] = input[3];
  _vals[7] = input[4];
  _vals[8] = input[5];
  _vals[12] = input[6];
  _vals[13] = input[7];
  _vals[14] = input[8];
}

◆ fillSymmetric21FromInputVector()

template<typename T >

template<typename T2 >

void SymmetricRankFourTensorTempl< T >::fillSymmetric21FromInputVector ( const T2 & input )

fillSymmetric21FromInputVector takes 21 inputs to fill in the Rank-4 tensor with the appropriate crystal symmetries maintained.

I.e., C_ijkl = C_klij, C_ijkl = C_ijlk, C_ijkl = C_jikl

Parameters

input is C1111 C1122 C1133 C1123 C1113 C1112 C2222 C2233 C2223 C2213 C2212 C3333 C3323 C3313 C3312 C2323 C2313 C2312 C1313 C1312 C1212

Definition at line 534 of file SymmetricRankFourTensor.h.

{
  // C1111 C1122 C1133 C1123 C1113 C1112
  //       C2222 C2233 C2223 C2213 C2212
  //             C3333 C3323 C3313 C3312
  //                   C2323 C2313 C2312
  //                         C1313 C1312
  //                               C1212
 
  mooseAssert(LIBMESH_DIM == 3, "This method assumes LIBMESH_DIM == 3");
  mooseAssert(input.size() == 21,
              "To use fillSymmetric21FromInputVector, your input must have size 21.");
  std::size_t index = 0;
  for (const auto i : make_range(N))
    for (const auto j : make_range(i, N))
    {
      _vals[i + N * j] = mandelFactor(i, j) * input[index];
      _vals[j + N * i] = mandelFactor(j, i) * input[index];
      index++;
    }
}

◆ fillSymmetric9FromInputVector()

template<typename T >

template<typename T2 >

void SymmetricRankFourTensorTempl< T >::fillSymmetric9FromInputVector ( const T2 & input )

fillSymmetric9FromInputVector takes 9 inputs to fill in the Rank-4 tensor with the appropriate crystal symmetries maintained.

I.e., C_ijkl = C_klij, C_ijkl = C_ijlk, C_ijkl = C_jikl

Parameters

input is: C1111 C1122 C1133 C2222 C2233 C3333 C2323 C1313 C1212 In the isotropic case this is (la is first Lame constant, mu is second (shear) Lame constant) la+2mu la la la+2mu la la+2mu mu mu mu

Definition at line 507 of file SymmetricRankFourTensor.h.

{
  mooseAssert(LIBMESH_DIM == 3, "This method assumes LIBMESH_DIM == 3");
  mooseAssert(input.size() == 9,
              "To use fillSymmetric9FromInputVector, your input must have size 9.");
  zero();
 
  _vals[0] = input[0];  // C1111
  _vals[7] = input[3];  // C2222
  _vals[14] = input[5]; // C3333
 
  _vals[1] = _vals[6] = input[1];  // C1122
  _vals[2] = _vals[12] = input[2]; // C1133
  _vals[8] = _vals[13] = input[4]; // C2233
 
  static constexpr std::size_t C2323 = 21;
  static constexpr std::size_t C1313 = 28;
  static constexpr std::size_t C1212 = 35;
 
  _vals[C2323] = 2.0 * input[6];
  _vals[C1313] = 2.0 * input[7];
  _vals[C1212] = 2.0 * input[8];
}

◆ fillSymmetricIsotropic()

template<typename T >

void SymmetricRankFourTensorTempl< T >::fillSymmetricIsotropic	(	const T &	i0,
		const T &	i1
	)

Vector-less fill API functions. See docs of the corresponding ...FromInputVector methods.

Definition at line 343 of file SymmetricRankFourTensorImplementation.h.

{
  // clang-format off
  fillSymmetric21FromInputVector(std::array<T,21>
  {{lambda + 2.0 * G, lambda,           lambda,           0.0, 0.0, 0.0,
                      lambda + 2.0 * G, lambda,           0.0, 0.0, 0.0,
                                        lambda + 2.0 * G, 0.0, 0.0, 0.0,
                                                            G, 0.0, 0.0,
                                                                 G, 0.0,
                                                                      G}});
  // clang-format on
}

◆ fillSymmetricIsotropicEandNu()

template<typename T >

void SymmetricRankFourTensorTempl< T >::fillSymmetricIsotropicEandNu	(	const T &	E,
		const T &	nu
	)

Definition at line 372 of file SymmetricRankFourTensorImplementation.h.

{
  // Calculate lambda and the shear modulus from the given young's modulus and poisson's ratio
  const T & lambda = E * nu / ((1.0 + nu) * (1.0 - 2.0 * nu));
  const T & G = E / (2.0 * (1.0 + nu));
 
  fillSymmetricIsotropic(lambda, G);
}

◆ fillSymmetricIsotropicEandNuFromInputVector()

template<typename T >

void SymmetricRankFourTensorTempl< T >::fillSymmetricIsotropicEandNuFromInputVector ( const std::vector< T > & input )

protected

fillSymmetricIsotropicEandNuFromInputVector is a variation of the fillSymmetricIsotropicFromInputVector which takes as inputs the more commonly used Young's modulus (E) and Poisson's ratio (nu) constants to fill the isotropic elasticity tensor.

Using well-known formulas, E and nu are used to calculate lambda and mu and then the vector is passed to fillSymmetricIsotropicFromInputVector.

Parameters

input Young's modulus (E) and Poisson's ratio (nu)

Definition at line 358 of file SymmetricRankFourTensorImplementation.h.

{
  if (input.size() != 2)
    mooseError(
        "To use fillSymmetricIsotropicEandNuFromInputVector, your input must have size 2. Yours "
        "has size ",
        input.size());
 
  fillSymmetricIsotropicEandNu(input[0], input[1]);
}

◆ fillSymmetricIsotropicFromInputVector()

template<typename T >

void SymmetricRankFourTensorTempl< T >::fillSymmetricIsotropicFromInputVector ( const std::vector< T > & input )

protected

fillSymmetricIsotropicFromInputVector takes 2 inputs to fill the the symmetric Rank-4 tensor with the appropriate symmetries maintained.

C_ijkl = lambda*de_ij*de_kl + mu*(de_ik*de_jl + de_il*de_jk) where lambda is the first Lame modulus, mu is the second (shear) Lame modulus,

Parameters

input this is lambda and mu in the above formula

Definition at line 334 of file SymmetricRankFourTensorImplementation.h.

{
  mooseAssert(input.size() == 2,
              "To use fillSymmetricIsotropicFromInputVector, your input must have size 2.");
  fillSymmetricIsotropic(input[0], input[1]);
}

◆ identity()

template<typename T >

static SymmetricRankFourTensorTempl< T > SymmetricRankFourTensorTempl< T >::identity ( )

inlinestatic

Definition at line 161 of file SymmetricRankFourTensor.h.

  {
    return SymmetricRankFourTensorTempl<T>(initIdentity);
  }

◆ identitySymmetricFour()

template<typename T >

static SymmetricRankFourTensorTempl< T > SymmetricRankFourTensorTempl< T >::identitySymmetricFour ( )

inlinestatic

Definition at line 165 of file SymmetricRankFourTensor.h.

  {
    return SymmetricRankFourTensorTempl<T>(initIdentitySymmetricFour);
  };

◆ invSymm()

template<typename T >

SymmetricRankFourTensorTempl< T > SymmetricRankFourTensorTempl< T >::invSymm ( ) const

This returns A_ijkl such that C_ijkl*A_klmn = 0.5*(de_im de_jn + de_in de_jm) This routine assumes that C_ijkl = C_jikl = C_ijlk.

Definition at line 558 of file SymmetricRankFourTensor.h.

{
  SymmetricRankFourTensorTempl<T> result(initNone);
 
  if constexpr (SymmetricRankFourTensorTempl<T>::N2 * sizeof(T) > EIGEN_STACK_ALLOCATION_LIMIT)
  {
    Eigen::Matrix<T, Eigen::Dynamic, Eigen::Dynamic> mat(N, N);
    for (const auto i : make_range(N))
      for (const auto j : make_range(N))
        mat(i, j) = (*this)(i, j);
    mat = mat.inverse();
    for (const auto i : make_range(N))
      for (const auto j : make_range(N))
        result(i, j) = mat(i, j);
  }
  else
  {
    const Eigen::Map<const Eigen::Matrix<T, N, N, Eigen::RowMajor>> mat(&_vals[0]);
    Eigen::Map<Eigen::Matrix<T, N, N, Eigen::RowMajor>> res(&result._vals[0]);
    res = mat.inverse();
  }
 
  return result;
}

◆ isIsotropic()

template<typename T >

bool SymmetricRankFourTensorTempl< T >::isIsotropic ( ) const

checks if the tensor is isotropic

Definition at line 523 of file SymmetricRankFourTensorImplementation.h.

{
  // prerequisite is symmetry
  if (!isSymmetric())
    return false;
 
  // inspect shear components
  const T & mu = _vals[35];
 
  // ...diagonal
  if (_vals[28] != mu || _vals[21] != mu)
    return false;
 
  // ...off-diagonal
  if (_vals[22] != 0.0 || _vals[23] != 0.0 || _vals[29] != 0.0)
    return false;
 
  // off diagonal blocks in Voigt
  for (const auto i : make_range(3))
    for (const auto j : make_range(3))
      if (_vals[3 + i + N * j] != 0.0)
        return false;
 
  // top left block
  const T & K1 = _vals[0];
  const T & K2 = _vals[1];
  if (!MooseUtils::relativeFuzzyEqual(K1 - 2.0 * mu / 3.0, K2 + mu / 3.0))
    return false;
  if (_vals[7] != K1 || _vals[14] != K1)
    return false;
 
  for (const auto i : make_range(1, 3))
    for (const auto j : make_range(i))
      if (_vals[i + N * j] != K2)
        return false;
 
  return true;
}

◆ isSymmetric()

template<typename T >

bool SymmetricRankFourTensorTempl< T >::isSymmetric ( ) const

checks if the tensor is symmetric

Definition at line 511 of file SymmetricRankFourTensorImplementation.h.

{
  for (unsigned int i = 0; i < N; ++i)
    for (unsigned int j = 0; j < N; ++j)
      // major symmetry
      if (_vals[i + N * j] != _vals[N * i + j])
        return false;
  return true;
}

◆ L2norm()

template<typename T >

T SymmetricRankFourTensorTempl< T >::L2norm ( ) const

sqrt(C_ijkl*C_ijkl)

Definition at line 251 of file SymmetricRankFourTensorImplementation.h.

{
  T l2 = Utility::pow<2>(_vals[0]);
  for (const auto i : make_range(1u, N2))
    l2 += Utility::pow<2>(_vals[i]);
  using std::sqrt;
  return sqrt(l2);
}

◆ mandelFactor()

template<typename T >

static constexpr Real SymmetricRankFourTensorTempl< T >::mandelFactor	(	unsigned int	i,
		unsigned int	j
	)

inlinestaticconstexpr

returns the 1, sqrt(2), or 2 prefactor in the Mandel notation for the indices i,j ranging from 0-5.

Definition at line 85 of file SymmetricRankFourTensor.h.

  {
    return SymmetricRankTwoTensorTempl<T>::mandelFactor(i) *
           SymmetricRankTwoTensorTempl<T>::mandelFactor(j);
  }

Referenced by SymmetricRankTwoTensorTempl< T >::d2thirdInvariant(), and RankFourTensorTempl< T >::RankFourTensorTempl().

◆ operator RankFourTensorTempl< T >()

template<typename T >

SymmetricRankFourTensorTempl< T >::operator RankFourTensorTempl< T > ( )

explicit

The conversion operator to RankFourTensorTempl

Definition at line 97 of file SymmetricRankFourTensorImplementation.h.

{
  auto & q = *this;
  RankFourTensorTempl<T> r;
  for (const auto a : make_range(N))
    for (const auto b : make_range(N))
    {
      const auto i = full_index[a][b][0];
      const auto j = full_index[a][b][1];
      const auto k = full_index[a][b][2];
      const auto l = full_index[a][b][3];
 
      // Rijkl = Rjikl = Rijlk = Rjilk
      r(i, j, k, l) = q(a, b) / mandelFactor(a, b);
      r(j, i, k, l) = q(a, b) / mandelFactor(a, b);
      r(i, j, l, k) = q(a, b) / mandelFactor(a, b);
      r(j, i, l, k) = q(a, b) / mandelFactor(a, b);
    }
 
  return r;
}

◆ operator()() [1/2]

template<typename T >

T & SymmetricRankFourTensorTempl< T >::operator()	(	unsigned int	i,
		unsigned int	j
	)

inline

Gets the value for the indices specified. Takes indices ranging from 0-5 for i and j.

Definition at line 171 of file SymmetricRankFourTensor.h.

171{ return _vals[i * N + j]; }

◆ operator()() [2/2]

template<typename T >

const T & SymmetricRankFourTensorTempl< T >::operator()	(	unsigned int	i,
		unsigned int	j
	)		const

inline

Gets the value for the indices specified.

Takes indices ranging from 0-5 for i and j. used for const

Definition at line 177 of file SymmetricRankFourTensor.h.

177{ return _vals[i * N + j]; }

◆ operator*() [1/3]

template<typename T >

template<typename T2 >

auto SymmetricRankFourTensorTempl< T >::operator* ( const SymmetricRankFourTensorTempl< T2 > & a ) const -> SymmetricRankFourTensorTempl<decltype(T() * T2())>

C_ijpq*a_pqkl.

Definition at line 235 of file SymmetricRankFourTensorImplementation.h.

{
  typedef decltype(T() * T2()) ValueType;
  SymmetricRankFourTensorTempl<ValueType> result;
 
  for (const auto i : make_range(N))
    for (const auto j : make_range(N))
      for (const auto p : make_range(N))
        result(i, j) += (*this)(i, p) * b(p, j);
 
  return result;
}

◆ operator*() [2/3]

template<typename T >

template<typename T2 >

auto SymmetricRankFourTensorTempl< T >::operator* ( const SymmetricRankTwoTensorTempl< T2 > & b ) const -> SymmetricRankTwoTensorTempl<decltype(T() * T2())>

C_ijkl*a_kl.

Definition at line 473 of file SymmetricRankFourTensor.h.

{
  typedef decltype(T() * T2()) ValueType;
  SymmetricRankTwoTensorTempl<ValueType> result;
 
  std::size_t index = 0;
  for (const auto i : make_range(N))
  {
    ValueType tmp = 0.0;
    for (const auto j : make_range(N))
      tmp += _vals[index++] * b._vals[j];
    result._vals[i] = tmp;
  }
 
  return result;
}

◆ operator*() [3/3]

template<typename T >

template<typename T2 >

auto SymmetricRankFourTensorTempl< T >::operator* ( const T2 & a ) const -> typename std::enable_if<libMesh::ScalarTraits<T2>::value, SymmetricRankFourTensorTempl<decltype(T() * T2())>>::type

C_ijkl*a.

Definition at line 457 of file SymmetricRankFourTensor.h.

{
  typedef decltype(T() * T2()) ValueType;
  SymmetricRankFourTensorTempl<ValueType> result;
 
  for (const auto i : make_range(N2))
    result._vals[i] = _vals[i] * b;
 
  return result;
}

◆ operator*=()

template<typename T >

SymmetricRankFourTensorTempl< T > & SymmetricRankFourTensorTempl< T >::operator*= ( const T & a )

C_ijkl *= a.

Definition at line 164 of file SymmetricRankFourTensorImplementation.h.

{
  for (const auto i : make_range(N2))
    _vals[i] *= a;
  return *this;
}

◆ operator+()

template<typename T >

template<typename T2 >

auto SymmetricRankFourTensorTempl< T >::operator+ ( const SymmetricRankFourTensorTempl< T2 > & a ) const -> SymmetricRankFourTensorTempl<decltype(T() + T2())>

C_ijkl + a_ijkl.

Definition at line 192 of file SymmetricRankFourTensorImplementation.h.

{
  SymmetricRankFourTensorTempl<decltype(T() + T2())> result;
  for (const auto i : make_range(N2))
    result._vals[i] = _vals[i] + b._vals[i];
  return result;
}

◆ operator+=()

template<typename T >

SymmetricRankFourTensorTempl< T > & SymmetricRankFourTensorTempl< T >::operator+= ( const SymmetricRankFourTensorTempl< T > & a )

C_ijkl += a_ijkl for all i, j, k, l.

Definition at line 182 of file SymmetricRankFourTensorImplementation.h.

{
  for (const auto i : make_range(N2))
    _vals[i] += a._vals[i];
  return *this;
}

◆ operator-() [1/2]

template<typename T >

SymmetricRankFourTensorTempl< T > SymmetricRankFourTensorTempl< T >::operator- ( ) const

-C_ijkl

Definition at line 224 of file SymmetricRankFourTensorImplementation.h.

{
  SymmetricRankFourTensorTempl<T> result;
  for (const auto i : make_range(N2))
    result._vals[i] = -_vals[i];
  return result;
}

◆ operator-() [2/2]

template<typename T >

template<typename T2 >

auto SymmetricRankFourTensorTempl< T >::operator- ( const SymmetricRankFourTensorTempl< T2 > & a ) const -> SymmetricRankFourTensorTempl<decltype(T() - T2())>

C_ijkl - a_ijkl.

Definition at line 213 of file SymmetricRankFourTensorImplementation.h.

{
  SymmetricRankFourTensorTempl<decltype(T() - T2())> result;
  for (const auto i : make_range(N2))
    result._vals[i] = _vals[i] - b._vals[i];
  return result;
}

◆ operator-=()

template<typename T >

SymmetricRankFourTensorTempl< T > & SymmetricRankFourTensorTempl< T >::operator-= ( const SymmetricRankFourTensorTempl< T > & a )

C_ijkl -= a_ijkl.

Definition at line 203 of file SymmetricRankFourTensorImplementation.h.

{
  for (const auto i : make_range(N2))
    _vals[i] -= a._vals[i];
  return *this;
}

◆ operator/()

template<typename T >

template<typename T2 >

auto SymmetricRankFourTensorTempl< T >::operator/ ( const T2 & a ) const -> typename std::enable_if<libMesh::ScalarTraits<T2>::value, SymmetricRankFourTensorTempl<decltype(T() / T2())>>::type

C_ijkl/a.

Definition at line 494 of file SymmetricRankFourTensor.h.

{
  SymmetricRankFourTensorTempl<decltype(T() / T2())> result;
  for (const auto i : make_range(N2))
    result._vals[i] = _vals[i] / b;
  return result;
}

◆ operator/=()

template<typename T >

SymmetricRankFourTensorTempl< T > & SymmetricRankFourTensorTempl< T >::operator/= ( const T & a )

C_ijkl /= a for all i, j, k, l.

Definition at line 173 of file SymmetricRankFourTensorImplementation.h.

{
  for (const auto i : make_range(N2))
    _vals[i] /= a;
  return *this;
}

◆ operator=() [1/2]

template<typename T >

template<typename Scalar >

std::enable_if< libMesh::ScalarTraits< Scalar >::value, SymmetricRankFourTensorTempl & >::type SymmetricRankFourTensorTempl< T >::operator= ( const Scalar & libmesh_dbg_varp )

inline

Assignment-from-scalar operator.

Used only to zero out the tensor.

Returns: A reference to *this.

Definition at line 205 of file SymmetricRankFourTensor.h.

  {
    libmesh_assert_equal_to(p, Scalar(0));
    this->zero();
    return *this;
  }

◆ operator=() [2/2]

template<typename T >

SymmetricRankFourTensorTempl< T > & SymmetricRankFourTensorTempl< T >::operator= ( const SymmetricRankFourTensorTempl< T > & a )

default

copies values from a into this tensor

◆ print()

template<typename T >

void SymmetricRankFourTensorTempl< T >::print ( std::ostream & stm = Moose::out ) const

Print the rank four tensor.

Definition at line 262 of file SymmetricRankFourTensorImplementation.h.

{
  for (const auto i : make_range(N))
  {
    for (const auto j : make_range(N))
      stm << std::setw(15) << _vals[i * N + j] << " ";
    stm << '\n';
  }
  stm << std::flush;
}

◆ printReal()

template<typename T >

void SymmetricRankFourTensorTempl< T >::printReal ( std::ostream & stm = Moose::out ) const

Print the values of the rank four tensor.

Definition at line 275 of file SymmetricRankFourTensorImplementation.h.

{
  for (const auto i : make_range(N))
  {
    for (const auto j : make_range(N))
      stm << std::setw(15) << MetaPhysicL::raw_value(_vals[i * N + j]) << " ";
    stm << '\n';
  }
  stm << std::flush;
}

◆ rotate()

template<typename T >

void SymmetricRankFourTensorTempl< T >::rotate ( const TypeTensor< T > & R )

Rotate the tensor using C_ijkl = R_im R_jn R_ko R_lp C_mnop.

Definition at line 153 of file SymmetricRankFourTensorImplementation.h.

{
  // build 6x6 rotation matrix
  auto M = SymmetricRankFourTensorTempl<T>::rotationMatrix(R);
 
  // rotate tensor
  (*this) = M * (*this) * M.transposeMajor();
}

◆ rotationMatrix()

template<typename T >

SymmetricRankFourTensorTempl< T > SymmetricRankFourTensorTempl< T >::rotationMatrix ( const TypeTensor< T > & R )

static

Build a 6x6 rotation matrix MEHRABADI, MORTEZA M.; COWIN, STEPHEN C.

(1990). EIGENTENSORS OF LINEAR ANISOTROPIC ELASTIC MATERIALS. The Quarterly Journal of Mechanics and Applied Mathematics, 43(1), 15-41. doi:10.1093/qjmam/43.1.15

Definition at line 135 of file SymmetricRankFourTensorImplementation.h.

{
  SymmetricRankFourTensorTempl<T> M(initNone);
  const static std::array<std::size_t, 3> a = {{1, 0, 0}};
  const static std::array<std::size_t, 3> b = {{2, 2, 1}};
  for (std::size_t i = 0; i < 3; ++i)
    for (std::size_t j = 0; j < 3; ++j)
    {
      M(i, j) = R(i, j) * R(i, j);
      M(i + 3, j) = MathUtils::sqrt2 * R((i + 1) % 3, j) * R((i + 2) % 3, j);
      M(j, i + 3) = MathUtils::sqrt2 * R(j, (i + 1) % 3) * R(j, (i + 2) % 3);
      M(i + 3, j + 3) = R(a[i], a[j]) * R(b[i], b[j]) + R(a[i], b[j]) * R(b[i], a[j]);
    }
  return M;
}

Referenced by SymmetricRankFourTensorTempl< T >::rotate(), and SymmetricRankTwoTensorTempl< T >::rotate().

◆ sum3x1()

template<typename T >

libMesh::VectorValue< T > SymmetricRankFourTensorTempl< T >::sum3x1 ( ) const

Calculates the vector a[i] = sum over j Ciijj for i and j varying from 0 to 2.

Definition at line 500 of file SymmetricRankFourTensorImplementation.h.

{
  mooseAssert(LIBMESH_DIM == 3, "This method assumes LIBMESH_DIM == 3");
  // used for volumetric locking correction
  return libMesh::VectorValue<T>(_vals[0] + _vals[1] + _vals[2],
                                 _vals[6] + _vals[7] + _vals[8],
                                 _vals[12] + _vals[13] + _vals[14]);
}

◆ sum3x3()

template<typename T >

T SymmetricRankFourTensorTempl< T >::sum3x3 ( ) const

Calculates the sum of Ciijj for i and j varying from 0 to 2.

Definition at line 487 of file SymmetricRankFourTensorImplementation.h.

{
  mooseAssert(LIBMESH_DIM == 3, "This method assumes LIBMESH_DIM == 3");
  // summation of Ciijj used in the volumetric locking correction
  T sum = 0;
  for (const auto i : make_range(3))
    for (const auto j : make_range(3))
      sum += (*this)(i, j);
  return sum;
}

◆ transposeIj()

template<typename T >

SymmetricRankFourTensorTempl< T > SymmetricRankFourTensorTempl< T >::transposeIj ( ) const

inline

Transpose the tensor by swapping the first two indices - a no-op.

Definition at line 292 of file SymmetricRankFourTensor.h.

292{ return *this; }

◆ transposeMajor()

template<typename T >

SymmetricRankFourTensorTempl< T > SymmetricRankFourTensorTempl< T >::transposeMajor ( ) const

Transpose the tensor by swapping the first pair with the second pair of indices This amounts to a regular transpose of the 6x6 matrix.

Returns: C_klji

Definition at line 288 of file SymmetricRankFourTensorImplementation.h.

{
  std::size_t index = 0;
  SymmetricRankFourTensorTempl<T> ret;
  for (const auto i : make_range(N))
    for (const auto j : make_range(N))
      ret._vals[index++] = _vals[i + N * j];
  return ret;
}

◆ zero()

template<typename T >

void SymmetricRankFourTensorTempl< T >::zero ( )

Zeros out the tensor.

Definition at line 128 of file SymmetricRankFourTensorImplementation.h.

{
  std::fill(_vals.begin(), _vals.end(), 0.0);
}

Referenced by MathUtils::mooseSetToZero< ADSymmetricRankFourTensor >(), MathUtils::mooseSetToZero< SymmetricRankFourTensor >(), and SymmetricRankFourTensorTempl< T >::operator=().

Friends And Related Symbol Documentation

◆ dataLoad

template<typename T >

template<class T2 >

void dataLoad	(	std::istream &	,
		SymmetricRankFourTensorTempl< T2 > &	,
		void *
	)

friend

◆ dataStore

template<typename T >

template<class T2 >

void dataStore	(	std::ostream &	,
		SymmetricRankFourTensorTempl< T2 > &	,
		void *
	)

friend

◆ operator<<

template<typename T >

std::ostream & operator<<	(	std::ostream &	os,
		const SymmetricRankFourTensorTempl< T > &	t
	)

friend

Definition at line 188 of file SymmetricRankFourTensor.h.

  {
    t.print(os);
    return os;
  }

◆ RankThreeTensorTempl

template<typename T >

template<typename T2 >

friend class RankThreeTensorTempl

friend

Definition at line 414 of file SymmetricRankFourTensor.h.

◆ SymmetricRankFourTensorTempl

template<typename T >

template<typename T2 >

friend class SymmetricRankFourTensorTempl

friend

Definition at line 412 of file SymmetricRankFourTensor.h.

◆ SymmetricRankTwoTensorTempl

template<typename T >

template<typename T2 >

friend class SymmetricRankTwoTensorTempl

friend

Definition at line 410 of file SymmetricRankFourTensor.h.

Member Data Documentation

◆ _vals

template<typename T >

std::array<T, N2> SymmetricRankFourTensorTempl< T >::_vals

protected

The values of the rank-four tensor.

Definition at line 348 of file SymmetricRankFourTensor.h.

◆ full_index

template<typename T >

constexpr unsigned int SymmetricRankFourTensorTempl< T >::full_index[6][6][4]

staticconstexpr

Initial value:

= {
      {{0, 0, 0, 0}, {0, 0, 1, 1}, {0, 0, 2, 2}, {0, 0, 1, 2}, {0, 0, 0, 2}, {0, 0, 0, 1}},
      {{1, 1, 0, 0}, {1, 1, 1, 1}, {1, 1, 2, 2}, {1, 1, 1, 2}, {1, 1, 0, 2}, {1, 1, 0, 1}},
      {{2, 2, 0, 0}, {2, 2, 1, 1}, {2, 2, 2, 2}, {2, 2, 1, 2}, {2, 2, 0, 2}, {2, 2, 0, 1}},
      {{1, 2, 0, 0}, {1, 2, 1, 1}, {1, 2, 2, 2}, {1, 2, 1, 2}, {1, 2, 0, 2}, {1, 2, 0, 1}},
      {{0, 2, 0, 0}, {0, 2, 1, 1}, {0, 2, 2, 2}, {0, 2, 1, 2}, {0, 2, 0, 2}, {0, 2, 0, 1}},
      {{0, 1, 0, 0}, {0, 1, 1, 1}, {0, 1, 2, 2}, {0, 1, 1, 2}, {0, 1, 0, 2}, {0, 1, 0, 1}}}

Definition at line 76 of file SymmetricRankFourTensor.h.

                                                      {
      {{0, 0, 0, 0}, {0, 0, 1, 1}, {0, 0, 2, 2}, {0, 0, 1, 2}, {0, 0, 0, 2}, {0, 0, 0, 1}},
      {{1, 1, 0, 0}, {1, 1, 1, 1}, {1, 1, 2, 2}, {1, 1, 1, 2}, {1, 1, 0, 2}, {1, 1, 0, 1}},
      {{2, 2, 0, 0}, {2, 2, 1, 1}, {2, 2, 2, 2}, {2, 2, 1, 2}, {2, 2, 0, 2}, {2, 2, 0, 1}},
      {{1, 2, 0, 0}, {1, 2, 1, 1}, {1, 2, 2, 2}, {1, 2, 1, 2}, {1, 2, 0, 2}, {1, 2, 0, 1}},
      {{0, 2, 0, 0}, {0, 2, 1, 1}, {0, 2, 2, 2}, {0, 2, 1, 2}, {0, 2, 0, 2}, {0, 2, 0, 1}},
      {{0, 1, 0, 0}, {0, 1, 1, 1}, {0, 1, 2, 2}, {0, 1, 1, 2}, {0, 1, 0, 2}, {0, 1, 0, 1}}};

◆ N

template<typename T >

constexpr unsigned int SymmetricRankFourTensorTempl< T >::N = Ndim + Ndim * (Ndim - 1) / 2

staticconstexpr

Definition at line 71 of file SymmetricRankFourTensor.h.

Referenced by SymmetricRankFourTensorTempl< T >::operator()(), and SymmetricRankFourTensorTempl< T >::operator()().

◆ N2

template<typename T >

constexpr unsigned int SymmetricRankFourTensorTempl< T >::N2 = N * N

staticconstexpr

Definition at line 72 of file SymmetricRankFourTensor.h.

◆ Ndim

template<typename T >

constexpr unsigned int SymmetricRankFourTensorTempl< T >::Ndim = LIBMESH_DIM

staticconstexpr

tensor dimension, Mandel matrix dimension, and Mandel matrix size

Definition at line 70 of file SymmetricRankFourTensor.h.

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

include/utils/SymmetricRankFourTensor.h
include/utils/SymmetricRankFourTensorImplementation.h

Classes

Public Types

Public Member Functions

Static Public Member Functions

Static Public Attributes

Protected Member Functions

Protected Attributes

Friends

Detailed Description

Member Enumeration Documentation

◆ FillMethod

◆ InitMethod

Constructor & Destructor Documentation

◆ SymmetricRankFourTensorTempl() [1/6]

◆ SymmetricRankFourTensorTempl() [2/6]

◆ SymmetricRankFourTensorTempl() [3/6]

◆ SymmetricRankFourTensorTempl() [4/6]

◆ SymmetricRankFourTensorTempl() [5/6]

◆ SymmetricRankFourTensorTempl() [6/6]

Member Function Documentation

◆ fillAxisymmetricRZFromInputVector()

◆ fillFromInputVector()

◆ fillGeneralOrthotropicFromInputVector()

◆ fillMethodEnum()

◆ fillPrincipalFromInputVector()

◆ fillSymmetric21FromInputVector()

◆ fillSymmetric9FromInputVector()

◆ fillSymmetricIsotropic()

◆ fillSymmetricIsotropicEandNu()

◆ fillSymmetricIsotropicEandNuFromInputVector()

◆ fillSymmetricIsotropicFromInputVector()

◆ identity()

◆ identitySymmetricFour()

◆ invSymm()

◆ isIsotropic()

◆ isSymmetric()

◆ L2norm()

◆ mandelFactor()

◆ operator RankFourTensorTempl< T >()

◆ operator()() [1/2]

◆ operator()() [2/2]

◆ operator*() [1/3]

◆ operator*() [2/3]

◆ operator*() [3/3]

◆ operator*=()

◆ operator+()

◆ operator+=()

◆ operator-() [1/2]

◆ operator-() [2/2]

◆ operator-=()

◆ operator/()

◆ operator/=()

◆ operator=() [1/2]

◆ operator=() [2/2]

◆ print()

◆ printReal()

◆ rotate()

◆ rotationMatrix()

◆ sum3x1()

◆ sum3x3()

◆ transposeIj()

◆ transposeMajor()

◆ zero()

Friends And Related Symbol Documentation

◆ dataLoad

◆ dataStore

◆ operator<<

◆ RankThreeTensorTempl

◆ SymmetricRankFourTensorTempl

◆ SymmetricRankTwoTensorTempl

Member Data Documentation

◆ _vals

◆ full_index

◆ N

◆ N2

◆ Ndim