https://mooseframework.inl.gov
Classes | Public Types | Public Member Functions | Static Public Member Functions | Protected Member Functions | Protected Attributes | Friends | List of all members
RankFourTensorTempl< T > Class Template Reference

RankFourTensorTempl is designed to handle any N-dimensional fourth order tensor, C. More...

#include <RankFourTensor.h>

Classes

struct  TwoTensorMultTraits
 
struct  TwoTensorMultTraits< RankTwoTensorTempl, Scalar >
 
struct  TwoTensorMultTraits< TensorValue, Scalar >
 
struct  TwoTensorMultTraits< TypeTensor, Scalar >
 

Public Types

enum  InitMethod {
  initNone, initIdentity, initIdentityFour, initIdentitySymmetricFour,
  initIdentityDeviatoric
}
 Initialization method. More...
 
enum  FillMethod {
  antisymmetric, symmetric9, symmetric21, general_isotropic,
  symmetric_isotropic, symmetric_isotropic_E_nu, antisymmetric_isotropic, axisymmetric_rz,
  general, principal, orthotropic
}
 To fill up the 81 entries in the 4th-order tensor, fillFromInputVector is called with one of the following fill_methods. More...
 
typedef tuple_of< 4, unsigned int > index_type
 
typedef T value_type
 

Public Member Functions

 RankFourTensorTempl ()
 Default constructor; fills to zero. More...
 
 RankFourTensorTempl (const InitMethod)
 Select specific initialization pattern. More...
 
 RankFourTensorTempl (const std::vector< T > &, FillMethod)
 Fill from vector. More...
 
 RankFourTensorTempl (const RankFourTensorTempl< T > &a)=default
 Copy assignment operator must be defined if used. More...
 
template<typename T2 >
 RankFourTensorTempl (const RankFourTensorTempl< T2 > &copy)
 Copy constructor. More...
 
template<typename T2 >
 RankFourTensorTempl (const SymmetricRankFourTensorTempl< T2 > &t)
 The conversion operator from a SymmetricRankFourTensorTempl More...
 
T & operator() (unsigned int i, unsigned int j, unsigned int k, unsigned int l)
 Gets the value for the indices specified. Takes indices ranging from 0-2 for i, j, k, and l. More...
 
const T & operator() (unsigned int i, unsigned int j, unsigned int k, unsigned int l) const
 Gets the value for the indices specified. More...
 
void zero ()
 Zeros out the tensor. More...
 
void print (std::ostream &stm=Moose::out) const
 Print the rank four tensor. More...
 
void printReal (std::ostream &stm=Moose::out) const
 Print the values of the rank four tensor. More...
 
RankFourTensorTempl< T > & operator= (const RankFourTensorTempl< T > &a)=default
 copies values from a into this tensor More...
 
template<typename Scalar >
libMesh::boostcopy::enable_if_c< libMesh::ScalarTraits< Scalar >::value, RankFourTensorTempl & >::type operator= (const Scalar &libmesh_dbg_var(p))
 Assignment-from-scalar operator. More...
 
template<template< typename > class Tensor, typename T2 >
auto operator* (const Tensor< T2 > &a) const -> typename std::enable_if< TwoTensorMultTraits< Tensor, T2 >::value, RankTwoTensorTempl< decltype(T() *T2())>>::type
 C_ijkl*a_kl. More...
 
template<typename T2 >
auto operator* (const T2 &a) const -> typename std::enable_if< libMesh::ScalarTraits< T2 >::value, RankFourTensorTempl< decltype(T() *T2())>>::type
 C_ijkl*a. More...
 
RankFourTensorTempl< T > & operator*= (const T &a)
 C_ijkl *= a. More...
 
template<typename T2 >
auto operator/ (const T2 &a) const -> typename std::enable_if< libMesh::ScalarTraits< T2 >::value, RankFourTensorTempl< decltype(T()/T2())>>::type
 C_ijkl/a. More...
 
RankFourTensorTempl< T > & operator/= (const T &a)
 C_ijkl /= a for all i, j, k, l. More...
 
RankFourTensorTempl< T > & operator+= (const RankFourTensorTempl< T > &a)
 C_ijkl += a_ijkl for all i, j, k, l. More...
 
template<typename T2 >
auto operator+ (const RankFourTensorTempl< T2 > &a) const -> RankFourTensorTempl< decltype(T()+T2())>
 C_ijkl + a_ijkl. More...
 
RankFourTensorTempl< T > & operator-= (const RankFourTensorTempl< T > &a)
 C_ijkl -= a_ijkl. More...
 
template<typename T2 >
auto operator- (const RankFourTensorTempl< T2 > &a) const -> RankFourTensorTempl< decltype(T() - T2())>
 C_ijkl - a_ijkl. More...
 
RankFourTensorTempl< T > operator- () const
 -C_ijkl More...
 
template<typename T2 >
auto operator* (const RankFourTensorTempl< T2 > &a) const -> RankFourTensorTempl< decltype(T() *T2())>
 C_ijpq*a_pqkl. More...
 
T L2norm () const
 sqrt(C_ijkl*C_ijkl) More...
 
RankFourTensorTempl< 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. More...
 
RankFourTensorTempl< T > inverse () const
 This returns A_ijkl such that C_ijkl*A_klmn = de_im de_jn i.e. More...
 
void rotate (const TypeTensor< T > &R)
 Rotate the tensor using C_ijkl = R_im R_jn R_ko R_lp C_mnop. More...
 
RankFourTensorTempl< T > transposeMajor () const
 Transpose the tensor by swapping the first pair with the second pair of indices. More...
 
RankFourTensorTempl< T > transposeIj () const
 Transpose the tensor by swapping the first two indeces. More...
 
RankFourTensorTempl< T > transposeKl () const
 Transpose the tensor by swapping the last two indeces. More...
 
template<int m>
RankThreeTensorTempl< T > contraction (const libMesh::VectorValue< T > &b) const
 single contraction of a RankFourTensor with a vector over index m More...
 
void surfaceFillFromInputVector (const std::vector< T > &input)
 Fills the tensor entries ignoring the last dimension (ie, C_ijkl=0 if any of i, j, k, or l = 3). More...
 
void fillFromInputVector (const std::vector< T > &input, FillMethod fill_method)
 fillFromInputVector takes some number of inputs to fill the Rank-4 tensor. More...
 
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. More...
 
template<typename T2 >
void fillSymmetric21FromInputVector (const T2 &input)
 fillSymmetric21FromInputVector takes either 21 inputs to fill in the Rank-4 tensor with the appropriate crystal symmetries maintained. More...
 
RankTwoTensorTempl< T > innerProductTranspose (const RankTwoTensorTempl< T > &) const
 Inner product of the major transposed tensor with a rank two tensor. More...
 
T contractionIj (unsigned int, unsigned int, const RankTwoTensorTempl< T > &) const
 Sum C_ijkl M_kl for a given i,j. More...
 
T contractionKl (unsigned int, unsigned int, const RankTwoTensorTempl< T > &) const
 Sum M_ij C_ijkl for a given k,l. More...
 
T sum3x3 () const
 Calculates the sum of Ciijj for i and j varying from 0 to 2. More...
 
libMesh::VectorValue< T > sum3x1 () const
 Calculates the vector a[i] = sum over j Ciijj for i and j varying from 0 to 2. More...
 
RankFourTensorTempl< T > tripleProductJkl (const RankTwoTensorTempl< T > &, const RankTwoTensorTempl< T > &, const RankTwoTensorTempl< T > &) const
 Calculates C_imnt A_jm B_kn C_lt. More...
 
RankFourTensorTempl< T > tripleProductIkl (const RankTwoTensorTempl< T > &, const RankTwoTensorTempl< T > &, const RankTwoTensorTempl< T > &) const
 Calculates C_mjnt A_im B_kn C_lt. More...
 
RankFourTensorTempl< T > tripleProductIjl (const RankTwoTensorTempl< T > &, const RankTwoTensorTempl< T > &, const RankTwoTensorTempl< T > &) const
 Calculates C_mnkt A_im B_jn C_lt. More...
 
RankFourTensorTempl< T > tripleProductIjk (const RankTwoTensorTempl< T > &, const RankTwoTensorTempl< T > &, const RankTwoTensorTempl< T > &) const
 Calculates C_mntl A_im B_jn C_kt. More...
 
RankFourTensorTempl< T > singleProductI (const RankTwoTensorTempl< T > &) const
 Calculates C_mjkl A_im. More...
 
RankFourTensorTempl< T > singleProductJ (const RankTwoTensorTempl< T > &) const
 Calculates C_imkl A_jm. More...
 
RankFourTensorTempl< T > singleProductK (const RankTwoTensorTempl< T > &) const
 Calculates C_ijml A_km. More...
 
RankFourTensorTempl< T > singleProductL (const RankTwoTensorTempl< T > &) const
 Calculates C_ijkm A_lm. More...
 
bool isSymmetric () const
 checks if the tensor is symmetric More...
 
bool isIsotropic () const
 checks if the tensor is isotropic More...
 
template<>
RankFourTensorTempl< Real > invSymm () const
 
void fillGeneralIsotropic (const T &i0, const T &i1, const T &i2)
 Vector-less fill API functions. See docs of the corresponding ...FromInputVector methods. More...
 
void fillAntisymmetricIsotropic (const T &i0)
 
void fillSymmetricIsotropic (const T &i0, const T &i1)
 
void fillSymmetricIsotropicEandNu (const T &E, const T &nu)
 

Static Public Member Functions

static RankFourTensorTempl< T > Identity ()
 
static RankFourTensorTempl< T > IdentityFour ()
 
static RankFourTensorTempl< T > IdentityDeviatoric ()
 Identity of type {ik} {jl} - {ij} {kl} / 3. More...
 
static MooseEnum fillMethodEnum ()
 Static method for use in validParams for getting the "fill_method". More...
 

Static Public Attributes

static constexpr unsigned int N = Moose::dim
 tensor dimension and powers of the dimension More...
 
static constexpr unsigned int N2 = N * N
 
static constexpr unsigned int N3 = N * N * N
 
static constexpr unsigned int N4 = N * N * N * N
 

Protected Member Functions

void fillAntisymmetricFromInputVector (const std::vector< T > &input)
 fillAntisymmetricFromInputVector takes 6 inputs to fill the the antisymmetric Rank-4 tensor with the appropriate symmetries maintained. More...
 
void fillGeneralIsotropicFromInputVector (const std::vector< T > &input)
 fillGeneralIsotropicFromInputVector takes 3 inputs to fill the Rank-4 tensor with symmetries C_ijkl = C_klij, and isotropy, ie C_ijkl = la*de_ij*de_kl + mu*(de_ik*de_jl + de_il*de_jk) + a*ep_ijm*ep_klm where la is the first Lame modulus, mu is the second (shear) Lame modulus, and a is the antisymmetric shear modulus, and ep is the permutation tensor More...
 
void fillAntisymmetricIsotropicFromInputVector (const std::vector< T > &input)
 fillAntisymmetricIsotropicFromInputVector takes 1 input to fill the the antisymmetric Rank-4 tensor with the appropriate symmetries maintained. More...
 
void fillSymmetricIsotropicFromInputVector (const std::vector< T > &input)
 fillSymmetricIsotropicFromInputVector takes 2 inputs to fill the the symmetric Rank-4 tensor with the appropriate symmetries maintained. More...
 
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. More...
 
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. More...
 
void fillGeneralFromInputVector (const std::vector< T > &input)
 fillGeneralFromInputVector takes 81 inputs to fill the Rank-4 tensor No symmetries are explicitly maintained More...
 
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 More...
 
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 More...
 

Protected Attributes

T _vals [N4]
 The values of the rank-four tensor stored by index=(((i * LIBMESH_DIM + j) * LIBMESH_DIM + k) * LIBMESH_DIM + l) More...
 

Friends

template<typename T2 >
class RankTwoTensorTempl
 
template<typename T2 >
class RankFourTensorTempl
 
template<typename T2 >
class RankThreeTensorTempl
 
std::ostream & operator<< (std::ostream &os, const RankFourTensorTempl< T > &t)
 
template<class T2 >
void dataStore (std::ostream &, RankFourTensorTempl< T2 > &, void *)
 
template<class T2 >
void dataLoad (std::istream &, RankFourTensorTempl< T2 > &, void *)
 

Detailed Description

template<typename T>
class RankFourTensorTempl< T >

RankFourTensorTempl is designed to handle any N-dimensional fourth order tensor, C.

Since N is hard-coded to 3, RankFourTensorTempl holds 81 separate C_ijkl entries, with i,j,k,l = 0, 1, 2.

Definition at line 65 of file RankFourTensor.h.

Member Typedef Documentation

◆ index_type

template<typename T>
typedef tuple_of<4, unsigned int> RankFourTensorTempl< T >::index_type

Definition at line 75 of file RankFourTensor.h.

◆ value_type

template<typename T>
typedef T RankFourTensorTempl< T >::value_type

Definition at line 76 of file RankFourTensor.h.

Member Enumeration Documentation

◆ FillMethod

template<typename T>
enum RankFourTensorTempl::FillMethod

To fill up the 81 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
antisymmetric 
symmetric9 
symmetric21 
general_isotropic 
symmetric_isotropic 
symmetric_isotropic_E_nu 
antisymmetric_isotropic 
axisymmetric_rz 
general 
principal 
orthotropic 

Definition at line 93 of file RankFourTensor.h.

94  {
95  antisymmetric,
96  symmetric9,
97  symmetric21,
98  general_isotropic,
99  symmetric_isotropic,
100  symmetric_isotropic_E_nu,
101  antisymmetric_isotropic,
102  axisymmetric_rz,
103  general,
104  principal,
105  orthotropic
106  };

◆ InitMethod

template<typename T>
enum RankFourTensorTempl::InitMethod

Initialization method.

Enumerator
initNone 
initIdentity 
initIdentityFour 
initIdentitySymmetricFour 
initIdentityDeviatoric 

Definition at line 79 of file RankFourTensor.h.

80  {
81  initNone,
82  initIdentity,
83  initIdentityFour,
84  initIdentitySymmetricFour,
85  initIdentityDeviatoric
86  };

Constructor & Destructor Documentation

◆ RankFourTensorTempl() [1/6]

template<typename T >
RankFourTensorTempl< T >::RankFourTensorTempl ( )

Default constructor; fills to zero.

Definition at line 52 of file RankFourTensorImplementation.h.

53 {
54  mooseAssert(N == 3, "RankFourTensorTempl<T> is currently only tested for 3 dimensions.");
55 
56  for (auto i : make_range(N4))
57  _vals[i] = 0.0;
58 }
RankFourTensorTempl::N4
static constexpr unsigned int N4
Definition: RankFourTensor.h:72
RankFourTensorTempl::_vals
T _vals[N4]
The values of the rank-four tensor stored by index=(((i * LIBMESH_DIM + j) * LIBMESH_DIM + k) * LIBME...
Definition: RankFourTensor.h:436
make_range
IntRange< T > make_range(T beg, T end)
RankFourTensorTempl::N
static constexpr unsigned int N
tensor dimension and powers of the dimension
Definition: RankFourTensor.h:69

◆ RankFourTensorTempl() [2/6]

template<typename T >
RankFourTensorTempl< T >::RankFourTensorTempl ( const InitMethod  init)

Select specific initialization pattern.

Definition at line 61 of file RankFourTensorImplementation.h.

62 {
63  unsigned int index = 0;
64  switch (init)
65  {
66  case initNone:
67  break;
68 
69  case initIdentity:
70  zero();
71  for (auto i : make_range(N))
72  (*this)(i, i, i, i) = 1.0;
73  break;
74 
75  case initIdentityFour:
76  for (auto i : make_range(N))
77  for (auto j : make_range(N))
78  for (auto k : make_range(N))
79  for (auto l : make_range(N))
80  _vals[index++] = Real(i == k && j == l);
81  break;
82 
83  case initIdentitySymmetricFour:
84  for (auto i : make_range(N))
85  for (auto j : make_range(N))
86  for (auto k : make_range(N))
87  for (auto l : make_range(N))
88  _vals[index++] = 0.5 * Real(i == k && j == l) + 0.5 * Real(i == l && j == k);
89  break;
90 
91  case initIdentityDeviatoric:
92  for (unsigned int i = 0; i < N; ++i)
93  for (unsigned int j = 0; j < N; ++j)
94  for (unsigned int k = 0; k < N; ++k)
95  for (unsigned int l = 0; l < N; ++l)
96  {
97  _vals[index] = Real(i == k && j == l);
98  if ((i == j) && (k == l))
99  _vals[index] -= 1.0 / 3.0;
100  index++;
101  }
102  break;
103 
104  default:
105  mooseError("Unknown RankFourTensorTempl<T> initialization pattern.");
106  }
107 }
mooseError
void mooseError(Args &&... args)
Emit an error message with the given stringified, concatenated args and terminate the application...
Definition: MooseError.h:302
RankFourTensorTempl::zero
void zero()
Zeros out the tensor.
Definition: RankFourTensorImplementation.h:117
RankFourTensorTempl::_vals
T _vals[N4]
The values of the rank-four tensor stored by index=(((i * LIBMESH_DIM + j) * LIBMESH_DIM + k) * LIBME...
Definition: RankFourTensor.h:436
Real
DIE A HORRIBLE DEATH HERE typedef LIBMESH_DEFAULT_SCALAR_TYPE Real
make_range
IntRange< T > make_range(T beg, T end)
RankFourTensorTempl::N
static constexpr unsigned int N
tensor dimension and powers of the dimension
Definition: RankFourTensor.h:69

◆ RankFourTensorTempl() [3/6]

template<typename T >
RankFourTensorTempl< T >::RankFourTensorTempl ( const std::vector< T > &  input,
FillMethod  fill_method 
)

Fill from vector.

Definition at line 110 of file RankFourTensorImplementation.h.

111 {
112  fillFromInputVector(input, fill_method);
113 }
RankFourTensorTempl::fillFromInputVector
void fillFromInputVector(const std::vector< T > &input, FillMethod fill_method)
fillFromInputVector takes some number of inputs to fill the Rank-4 tensor.
Definition: RankFourTensorImplementation.h:544

◆ RankFourTensorTempl() [4/6]

template<typename T>
RankFourTensorTempl< T >::RankFourTensorTempl ( const RankFourTensorTempl< T > &  a)
default

Copy assignment operator must be defined if used.

◆ RankFourTensorTempl() [5/6]

template<typename T >
template<typename T2 >
RankFourTensorTempl< T >::RankFourTensorTempl ( const RankFourTensorTempl< T2 > &  copy)

Copy constructor.

Definition at line 571 of file RankFourTensor.h.

572 {
573  for (auto i : libMesh::make_range(N4))
574  _vals[i] = copy._vals[i];
575 }
RankFourTensorTempl::N4
static constexpr unsigned int N4
Definition: RankFourTensor.h:72
RankFourTensorTempl::_vals
T _vals[N4]
The values of the rank-four tensor stored by index=(((i * LIBMESH_DIM + j) * LIBMESH_DIM + k) * LIBME...
Definition: RankFourTensor.h:436
libMesh::make_range
IntRange< T > make_range(T beg, T end)

◆ RankFourTensorTempl() [6/6]

template<typename T>
template<typename T2 >
RankFourTensorTempl< T >::RankFourTensorTempl ( const SymmetricRankFourTensorTempl< T2 > &  t)
inline

The conversion operator from a SymmetricRankFourTensorTempl

Definition at line 151 of file RankFourTensor.h.

152  {
153  for (const auto a : make_range(SymmetricRankFourTensorTempl<T2>::N))
154  for (const auto b : make_range(SymmetricRankFourTensorTempl<T2>::N))
155  {
156  const auto & idx = SymmetricRankFourTensorTempl<T2>::full_index[a][b];
157  const auto i = idx[0];
158  const auto j = idx[1];
159  const auto k = idx[2];
160  const auto l = idx[3];
161 
162  // Rijkl = Rjikl = Rijlk = Rjilk
163  (*this)(i, j, k, l) = t(a, b) / SymmetricRankFourTensorTempl<T2>::mandelFactor(a, b);
164  (*this)(j, i, k, l) = t(a, b) / SymmetricRankFourTensorTempl<T2>::mandelFactor(a, b);
165  (*this)(i, j, l, k) = t(a, b) / SymmetricRankFourTensorTempl<T2>::mandelFactor(a, b);
166  (*this)(j, i, l, k) = t(a, b) / SymmetricRankFourTensorTempl<T2>::mandelFactor(a, b);
167  }
168  }
SymmetricRankFourTensorTempl::mandelFactor
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...
Definition: SymmetricRankFourTensor.h:88
SymmetricRankFourTensorTempl
SymmetricRankFourTensorTempl is designed to handle an N-dimensional fourth order tensor with minor sy...
Definition: SymmetricRankFourTensor.h:69
make_range
IntRange< T > make_range(T beg, T end)
idx
unsigned int idx(const ElemType type, const unsigned int nx, const unsigned int i, const unsigned int j)

Member Function Documentation

◆ contraction()

template<typename T >
template<int m>
RankThreeTensorTempl< T > RankFourTensorTempl< T >::contraction ( const libMesh::VectorValue< T > &  b) const

single contraction of a RankFourTensor with a vector over index m

Returns
C_xxx = a_ijkl*b_m where m={i,j,k,l} and xxx the remaining indices

Definition at line 790 of file RankFourTensor.h.

791 {
792  RankThreeTensorTempl<T> result;
793  static constexpr std::size_t z[4][3] = {{1, 2, 3}, {0, 2, 3}, {0, 1, 3}, {0, 1, 2}};
794  std::size_t x[4];
795  for (x[0] = 0; x[0] < N; ++x[0])
796  for (x[1] = 0; x[1] < N; ++x[1])
797  for (x[2] = 0; x[2] < N; ++x[2])
798  for (x[3] = 0; x[3] < N; ++x[3])
799  result(x[z[m][0]], x[z[m][1]], x[z[m][2]]) += (*this)(x[0], x[1], x[2], x[3]) * b(x[m]);
800 
801  return result;
802 }
RankThreeTensorTempl
RankThreeTensor is designed to handle any N-dimensional third order tensor, r.
Definition: RankThreeTensor.h:55
RankFourTensorTempl::N
static constexpr unsigned int N
tensor dimension and powers of the dimension
Definition: RankFourTensor.h:69

◆ contractionIj()

template<typename T >
T RankFourTensorTempl< T >::contractionIj ( unsigned int  i,
unsigned int  j,
const RankTwoTensorTempl< T > &  M 
) const

Sum C_ijkl M_kl for a given i,j.

Definition at line 885 of file RankFourTensorImplementation.h.

888 {
889  T val = 0;
890  for (unsigned int k = 0; k < N; k++)
891  for (unsigned int l = 0; l < N; l++)
892  val += (*this)(i, j, k, l) * M(k, l);
893 
894  return val;
895 }
RankFourTensorTempl::N
static constexpr unsigned int N
tensor dimension and powers of the dimension
Definition: RankFourTensor.h:69

◆ contractionKl()

template<typename T >
T RankFourTensorTempl< T >::contractionKl ( unsigned int  k,
unsigned int  l,
const RankTwoTensorTempl< T > &  M 
) const

Sum M_ij C_ijkl for a given k,l.

Definition at line 899 of file RankFourTensorImplementation.h.

902 {
903  T val = 0;
904  for (unsigned int i = 0; i < N; i++)
905  for (unsigned int j = 0; j < N; j++)
906  val += (*this)(i, j, k, l) * M(i, j);
907 
908  return val;
909 }
RankFourTensorTempl::N
static constexpr unsigned int N
tensor dimension and powers of the dimension
Definition: RankFourTensor.h:69

◆ fillAntisymmetricFromInputVector()

template<typename T >
void RankFourTensorTempl< T >::fillAntisymmetricFromInputVector ( const std::vector< T > &  input)
protected

fillAntisymmetricFromInputVector takes 6 inputs to fill the the antisymmetric Rank-4 tensor with the appropriate symmetries maintained.

I.e., B_ijkl = -B_jikl = -B_ijlk = B_klij

Parameters
inputthis is B1212, B1213, B1223, B1313, B1323, B2323.

Definition at line 589 of file RankFourTensorImplementation.h.

590 {
591  if (input.size() != 6)
592  mooseError(
593  "To use fillAntisymmetricFromInputVector, your input must have size 6. Yours has size ",
594  input.size());
595 
596  zero();
597 
598  (*this)(0, 1, 0, 1) = input[0]; // B1212
599  (*this)(0, 1, 0, 2) = input[1]; // B1213
600  (*this)(0, 1, 1, 2) = input[2]; // B1223
601 
602  (*this)(0, 2, 0, 2) = input[3]; // B1313
603  (*this)(0, 2, 1, 2) = input[4]; // B1323
604 
605  (*this)(1, 2, 1, 2) = input[5]; // B2323
606 
607  // symmetry on the two pairs
608  (*this)(0, 2, 0, 1) = (*this)(0, 1, 0, 2);
609  (*this)(1, 2, 0, 1) = (*this)(0, 1, 1, 2);
610  (*this)(1, 2, 0, 2) = (*this)(0, 2, 1, 2);
611  // have now got the upper parts of vals[0][1], vals[0][2] and vals[1][2]
612 
613  // fill in from antisymmetry relations
614  for (auto i : make_range(N))
615  for (auto j : make_range(N))
616  {
617  (*this)(0, 1, j, i) = -(*this)(0, 1, i, j);
618  (*this)(0, 2, j, i) = -(*this)(0, 2, i, j);
619  (*this)(1, 2, j, i) = -(*this)(1, 2, i, j);
620  }
621  // have now got all of vals[0][1], vals[0][2] and vals[1][2]
622 
623  // fill in from antisymmetry relations
624  for (auto i : make_range(N))
625  for (auto j : make_range(N))
626  {
627  (*this)(1, 0, i, j) = -(*this)(0, 1, i, j);
628  (*this)(2, 0, i, j) = -(*this)(0, 2, i, j);
629  (*this)(2, 1, i, j) = -(*this)(1, 2, i, j);
630  }
631 }
mooseError
void mooseError(Args &&... args)
Emit an error message with the given stringified, concatenated args and terminate the application...
Definition: MooseError.h:302
RankFourTensorTempl::zero
void zero()
Zeros out the tensor.
Definition: RankFourTensorImplementation.h:117
make_range
IntRange< T > make_range(T beg, T end)
RankFourTensorTempl::N
static constexpr unsigned int N
tensor dimension and powers of the dimension
Definition: RankFourTensor.h:69

◆ fillAntisymmetricIsotropic()

template<typename T >
void RankFourTensorTempl< T >::fillAntisymmetricIsotropic ( const T &  i0)

Definition at line 676 of file RankFourTensorImplementation.h.

677 {
678  fillGeneralIsotropic(0.0, 0.0, i0);
679 }
RankFourTensorTempl::fillGeneralIsotropic
void fillGeneralIsotropic(const T &i0, const T &i1, const T &i2)
Vector-less fill API functions. See docs of the corresponding ...FromInputVector methods.
Definition: RankFourTensorImplementation.h:647

◆ fillAntisymmetricIsotropicFromInputVector()

template<typename T >
void RankFourTensorTempl< T >::fillAntisymmetricIsotropicFromInputVector ( const std::vector< T > &  input)
protected

fillAntisymmetricIsotropicFromInputVector takes 1 input to fill the the antisymmetric Rank-4 tensor with the appropriate symmetries maintained.

I.e., C_ijkl = a * ep_ijm * ep_klm, where epsilon is the permutation tensor (and sum on m)

Parameters
inputthis is a in the above formula

Definition at line 664 of file RankFourTensorImplementation.h.

665 {
666  if (input.size() != 1)
667  mooseError("To use fillAntisymmetricIsotropicFromInputVector, your input must have size 1. "
668  "Yours has size ",
669  input.size());
670 
671  fillGeneralIsotropic(0.0, 0.0, input[0]);
672 }
mooseError
void mooseError(Args &&... args)
Emit an error message with the given stringified, concatenated args and terminate the application...
Definition: MooseError.h:302
RankFourTensorTempl::fillGeneralIsotropic
void fillGeneralIsotropic(const T &i0, const T &i1, const T &i2)
Vector-less fill API functions. See docs of the corresponding ...FromInputVector methods.
Definition: RankFourTensorImplementation.h:647

◆ fillAxisymmetricRZFromInputVector()

template<typename T >
void RankFourTensorTempl< 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
inputthis is C1111, C1122, C1133, C3333, C2323.

Definition at line 731 of file RankFourTensorImplementation.h.

732 {
733  mooseAssert(input.size() == 5,
734  "To use fillAxisymmetricRZFromInputVector, your input must have size 5.");
735 
736  // C1111 C1122 C1133 0 0 0
737  // C2222 C2233=C1133 0 0 0
738  // C3333 0 0 0
739  // C2323 0 0
740  // C3131=C2323 0
741  // C1212
742  // clang-format off
743  fillSymmetric21FromInputVector(std::array<T,21>
744  {{input[0],input[1],input[2], 0.0, 0.0, 0.0,
745  input[0],input[2], 0.0, 0.0, 0.0,
746  input[3], 0.0, 0.0, 0.0,
747  input[4], 0.0, 0.0,
748  input[4], 0.0,
749  (input[0] - input[1]) * 0.5}});
750  // clang-format on
751 }
RankFourTensorTempl::fillSymmetric21FromInputVector
void fillSymmetric21FromInputVector(const T2 &input)
fillSymmetric21FromInputVector takes either 21 inputs to fill in the Rank-4 tensor with the appropria...
Definition: RankFourTensor.h:646

◆ fillFromInputVector()

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

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

Parameters
inputthe numbers that will be placed in the tensor
fill_methodthis can be: antisymmetric (use fillAntisymmetricFromInputVector) symmetric9 (use fillSymmetric9FromInputVector) symmetric21 (use fillSymmetric21FromInputVector) general_isotropic (use fillGeneralIsotropicFrominputVector) symmetric_isotropic (use fillSymmetricIsotropicFromInputVector) antisymmetric_isotropic (use fillAntisymmetricIsotropicFromInputVector) axisymmetric_rz (use fillAxisymmetricRZFromInputVector) general (use fillGeneralFromInputVector) principal (use fillPrincipalFromInputVector)

Definition at line 544 of file RankFourTensorImplementation.h.

545 {
546 
547  switch (fill_method)
548  {
549  case antisymmetric:
550  fillAntisymmetricFromInputVector(input);
551  break;
552  case symmetric9:
553  fillSymmetric9FromInputVector(input);
554  break;
555  case symmetric21:
556  fillSymmetric21FromInputVector(input);
557  break;
558  case general_isotropic:
559  fillGeneralIsotropicFromInputVector(input);
560  break;
561  case symmetric_isotropic:
562  fillSymmetricIsotropicFromInputVector(input);
563  break;
564  case symmetric_isotropic_E_nu:
565  fillSymmetricIsotropicEandNuFromInputVector(input);
566  break;
567  case antisymmetric_isotropic:
568  fillAntisymmetricIsotropicFromInputVector(input);
569  break;
570  case axisymmetric_rz:
571  fillAxisymmetricRZFromInputVector(input);
572  break;
573  case general:
574  fillGeneralFromInputVector(input);
575  break;
576  case principal:
577  fillPrincipalFromInputVector(input);
578  break;
579  case orthotropic:
580  fillGeneralOrthotropicFromInputVector(input);
581  break;
582  default:
583  mooseError("fillFromInputVector called with unknown fill_method of ", fill_method);
584  }
585 }
RankFourTensorTempl::fillSymmetric9FromInputVector
void fillSymmetric9FromInputVector(const T2 &input)
fillSymmetric9FromInputVector takes 9 inputs to fill in the Rank-4 tensor with the appropriate crysta...
Definition: RankFourTensor.h:609
RankFourTensorTempl::fillGeneralFromInputVector
void fillGeneralFromInputVector(const std::vector< T > &input)
fillGeneralFromInputVector takes 81 inputs to fill the Rank-4 tensor No symmetries are explicitly mai...
Definition: RankFourTensorImplementation.h:755
RankFourTensorTempl::fillGeneralOrthotropicFromInputVector
void fillGeneralOrthotropicFromInputVector(const std::vector< T > &input)
fillGeneralOrhotropicFromInputVector takes 10 inputs to fill the Rank-4 tensor It defines a general o...
Definition: RankFourTensorImplementation.h:788
RankFourTensorTempl::fillAntisymmetricFromInputVector
void fillAntisymmetricFromInputVector(const std::vector< T > &input)
fillAntisymmetricFromInputVector takes 6 inputs to fill the the antisymmetric Rank-4 tensor with the ...
Definition: RankFourTensorImplementation.h:589
mooseError
void mooseError(Args &&... args)
Emit an error message with the given stringified, concatenated args and terminate the application...
Definition: MooseError.h:302
RankFourTensorTempl::fillSymmetric21FromInputVector
void fillSymmetric21FromInputVector(const T2 &input)
fillSymmetric21FromInputVector takes either 21 inputs to fill in the Rank-4 tensor with the appropria...
Definition: RankFourTensor.h:646
RankFourTensorTempl::fillPrincipalFromInputVector
void fillPrincipalFromInputVector(const std::vector< T > &input)
fillPrincipalFromInputVector takes 9 inputs to fill a Rank-4 tensor C1111 = input0 C1122 = input1 C11...
Definition: RankFourTensorImplementation.h:767
RankFourTensorTempl::fillGeneralIsotropicFromInputVector
void fillGeneralIsotropicFromInputVector(const std::vector< T > &input)
fillGeneralIsotropicFromInputVector takes 3 inputs to fill the Rank-4 tensor with symmetries C_ijkl =...
Definition: RankFourTensorImplementation.h:635
RankFourTensorTempl::fillAxisymmetricRZFromInputVector
void fillAxisymmetricRZFromInputVector(const std::vector< T > &input)
fillAxisymmetricRZFromInputVector takes 5 inputs to fill the axisymmetric Rank-4 tensor with the appr...
Definition: RankFourTensorImplementation.h:731
RankFourTensorTempl::fillSymmetricIsotropicEandNuFromInputVector
void fillSymmetricIsotropicEandNuFromInputVector(const std::vector< T > &input)
fillSymmetricIsotropicEandNuFromInputVector is a variation of the fillSymmetricIsotropicFromInputVect...
Definition: RankFourTensorImplementation.h:707
RankFourTensorTempl::fillSymmetricIsotropicFromInputVector
void fillSymmetricIsotropicFromInputVector(const std::vector< T > &input)
fillSymmetricIsotropicFromInputVector takes 2 inputs to fill the the symmetric Rank-4 tensor with the...
Definition: RankFourTensorImplementation.h:683
RankFourTensorTempl::fillAntisymmetricIsotropicFromInputVector
void fillAntisymmetricIsotropicFromInputVector(const std::vector< T > &input)
fillAntisymmetricIsotropicFromInputVector takes 1 input to fill the the antisymmetric Rank-4 tensor w...
Definition: RankFourTensorImplementation.h:664

◆ fillGeneralFromInputVector()

template<typename T >
void RankFourTensorTempl< T >::fillGeneralFromInputVector ( const std::vector< T > &  input)
protected

fillGeneralFromInputVector takes 81 inputs to fill the Rank-4 tensor No symmetries are explicitly maintained

Parameters
inputC(i,j,k,l) = input[i*N*N*N + j*N*N + k*N + l]

Definition at line 755 of file RankFourTensorImplementation.h.

756 {
757  if (input.size() != 81)
758  mooseError("To use fillGeneralFromInputVector, your input must have size 81. Yours has size ",
759  input.size());
760 
761  for (auto i : make_range(N4))
762  _vals[i] = input[i];
763 }
mooseError
void mooseError(Args &&... args)
Emit an error message with the given stringified, concatenated args and terminate the application...
Definition: MooseError.h:302
RankFourTensorTempl::N4
static constexpr unsigned int N4
Definition: RankFourTensor.h:72
RankFourTensorTempl::_vals
T _vals[N4]
The values of the rank-four tensor stored by index=(((i * LIBMESH_DIM + j) * LIBMESH_DIM + k) * LIBME...
Definition: RankFourTensor.h:436
make_range
IntRange< T > make_range(T beg, T end)

◆ fillGeneralIsotropic()

template<typename T >
void RankFourTensorTempl< T >::fillGeneralIsotropic ( const T &  i0,
const T &  i1,
const T &  i2 
)

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

Definition at line 647 of file RankFourTensorImplementation.h.

648 {
649  for (auto i : make_range(N))
650  for (auto j : make_range(N))
651  for (auto k : make_range(N))
652  for (auto l : make_range(N))
653  {
654  (*this)(i, j, k, l) = i0 * Real(i == j) * Real(k == l) +
655  i1 * Real(i == k) * Real(j == l) + i1 * Real(i == l) * Real(j == k);
656  for (auto m : make_range(N))
657  (*this)(i, j, k, l) +=
658  i2 * Real(PermutationTensor::eps(i, j, m)) * Real(PermutationTensor::eps(k, l, m));
659  }
660 }
PermutationTensor::eps
int eps(unsigned int i, unsigned int j)
2D version
Definition: PermutationTensor.C:13
Real
DIE A HORRIBLE DEATH HERE typedef LIBMESH_DEFAULT_SCALAR_TYPE Real
make_range
IntRange< T > make_range(T beg, T end)
RankFourTensorTempl::N
static constexpr unsigned int N
tensor dimension and powers of the dimension
Definition: RankFourTensor.h:69

◆ fillGeneralIsotropicFromInputVector()

template<typename T >
void RankFourTensorTempl< T >::fillGeneralIsotropicFromInputVector ( const std::vector< T > &  input)
protected

fillGeneralIsotropicFromInputVector takes 3 inputs to fill the Rank-4 tensor with symmetries C_ijkl = C_klij, and isotropy, ie C_ijkl = la*de_ij*de_kl + mu*(de_ik*de_jl + de_il*de_jk) + a*ep_ijm*ep_klm where la is the first Lame modulus, mu is the second (shear) Lame modulus, and a is the antisymmetric shear modulus, and ep is the permutation tensor

Parameters
inputthis is la, mu, a in the above formula

Definition at line 635 of file RankFourTensorImplementation.h.

636 {
637  if (input.size() != 3)
638  mooseError("To use fillGeneralIsotropicFromInputVector, your input must have size 3. Yours "
639  "has size ",
640  input.size());
641 
642  fillGeneralIsotropic(input[0], input[1], input[2]);
643 }
mooseError
void mooseError(Args &&... args)
Emit an error message with the given stringified, concatenated args and terminate the application...
Definition: MooseError.h:302
RankFourTensorTempl::fillGeneralIsotropic
void fillGeneralIsotropic(const T &i0, const T &i1, const T &i2)
Vector-less fill API functions. See docs of the corresponding ...FromInputVector methods.
Definition: RankFourTensorImplementation.h:647

◆ fillGeneralOrthotropicFromInputVector()

template<typename T >
void RankFourTensorTempl< 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
inputEa, Eb, Ec, Gab, Gbc, Gca, nuba, nuca, nucb, nuab, nuac, nubc

Definition at line 788 of file RankFourTensorImplementation.h.

789 {
790  if (input.size() != 12)
791  mooseError("To use fillGeneralOrhotropicFromInputVector, your input must have size 12. Yours "
792  "has size ",
793  input.size());
794 
795  const T & Ea = input[0];
796  const T & Eb = input[1];
797  const T & Ec = input[2];
798  const T & Gab = input[3];
799  const T & Gbc = input[4];
800  const T & Gca = input[5];
801  const T & nuba = input[6];
802  const T & nuca = input[7];
803  const T & nucb = input[8];
804  const T & nuab = input[9];
805  const T & nuac = input[10];
806  const T & nubc = input[11];
807 
808  // Input must satisfy constraints.
809  bool preserve_symmetry = MooseUtils::absoluteFuzzyEqual(nuab * Eb, nuba * Ea) &&
810  MooseUtils::absoluteFuzzyEqual(nuca * Ea, nuac * Ec) &&
811  MooseUtils::absoluteFuzzyEqual(nubc * Ec, nucb * Eb);
812 
813  if (!preserve_symmetry)
814  mooseError("Orthotropic elasticity tensor input is not consistent with symmetry requirements. "
815  "Check input for accuracy");
816 
817  unsigned int ntens = N * (N + 1) / 2;
818 
819  std::vector<T> mat;
820  mat.assign(ntens * ntens, 0);
821 
822  T k = 1 - nuab * nuba - nubc * nucb - nuca * nuac - nuab * nubc * nuca - nuba * nucb * nuac;
823 
824  bool is_positive_definite =
825  (k > 0) && (1 - nubc * nucb) > 0 && (1 - nuac * nuca) > 0 && (1 - nuab * nuba) > 0;
826  if (!is_positive_definite)
827  mooseError("Orthotropic elasticity tensor input is not positive definite. Check input for "
828  "accuracy");
829 
830  mat[0] = Ea * (1 - nubc * nucb) / k;
831  mat[1] = Ea * (nubc * nuca + nuba) / k;
832  mat[2] = Ea * (nuba * nucb + nuca) / k;
833 
834  mat[6] = Eb * (nuac * nucb + nuab) / k;
835  mat[7] = Eb * (1 - nuac * nuca) / k;
836  mat[8] = Eb * (nuab * nuca + nucb) / k;
837 
838  mat[12] = Ec * (nuab * nubc + nuac) / k;
839  mat[13] = Ec * (nuac * nuba + nubc) / k;
840  mat[14] = Ec * (1 - nuab * nuba) / k;
841 
842  mat[21] = 2 * Gab;
843  mat[28] = 2 * Gca;
844  mat[35] = 2 * Gbc;
845 
846  // Switching from Voigt to fourth order tensor
847  // Copied from existing code (invSymm)
848  int nskip = N - 1;
849 
850  unsigned int index = 0;
851  for (auto i : make_range(N))
852  for (auto j : make_range(N))
853  for (auto k : make_range(N))
854  for (auto l : make_range(N))
855  {
856  if (i == j)
857  (*this)._vals[index] =
858  k == l ? mat[i * ntens + k] : mat[i * ntens + k + nskip + l] / 2.0;
859  else
860  (*this)._vals[index] = k == l ? mat[(nskip + i + j) * ntens + k]
861  : mat[(nskip + i + j) * ntens + k + nskip + l] / 2.0;
862  index++;
863  }
864 }
MooseUtils::absoluteFuzzyEqual
bool absoluteFuzzyEqual(const T &var1, const T2 &var2, const T3 &tol=libMesh::TOLERANCE *libMesh::TOLERANCE)
Function to check whether two variables are equal within an absolute tolerance.
Definition: MooseUtils.h:380
mooseError
void mooseError(Args &&... args)
Emit an error message with the given stringified, concatenated args and terminate the application...
Definition: MooseError.h:302
make_range
IntRange< T > make_range(T beg, T end)
RankFourTensorTempl::N
static constexpr unsigned int N
tensor dimension and powers of the dimension
Definition: RankFourTensor.h:69

◆ fillMethodEnum()

template<typename T >
MooseEnum RankFourTensorTempl< T >::fillMethodEnum ( )
static

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

Definition at line 44 of file RankFourTensorImplementation.h.

45 {
46  return MooseEnum("antisymmetric symmetric9 symmetric21 general_isotropic symmetric_isotropic "
47  "symmetric_isotropic_E_nu antisymmetric_isotropic axisymmetric_rz general "
48  "principal orthotropic");
49 }
MooseEnum
This is a "smart" enum class intended to replace many of the shortcomings in the C++ enum type It sho...
Definition: MooseEnum.h:33

◆ fillPrincipalFromInputVector()

template<typename T >
void RankFourTensorTempl< 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 767 of file RankFourTensorImplementation.h.

768 {
769  if (input.size() != 9)
770  mooseError("To use fillPrincipalFromInputVector, your input must have size 9. Yours has size ",
771  input.size());
772 
773  zero();
774 
775  (*this)(0, 0, 0, 0) = input[0];
776  (*this)(0, 0, 1, 1) = input[1];
777  (*this)(0, 0, 2, 2) = input[2];
778  (*this)(1, 1, 0, 0) = input[3];
779  (*this)(1, 1, 1, 1) = input[4];
780  (*this)(1, 1, 2, 2) = input[5];
781  (*this)(2, 2, 0, 0) = input[6];
782  (*this)(2, 2, 1, 1) = input[7];
783  (*this)(2, 2, 2, 2) = input[8];
784 }
mooseError
void mooseError(Args &&... args)
Emit an error message with the given stringified, concatenated args and terminate the application...
Definition: MooseError.h:302
RankFourTensorTempl::zero
void zero()
Zeros out the tensor.
Definition: RankFourTensorImplementation.h:117

◆ fillSymmetric21FromInputVector()

template<typename T >
template<typename T2 >
void RankFourTensorTempl< T >::fillSymmetric21FromInputVector ( const T2 &  input)

fillSymmetric21FromInputVector takes either 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
inputis C1111 C1122 C1133 C1123 C1113 C1112 C2222 C2233 C2223 C2213 C2212 C3333 C3323 C3313 C3312 C2323 C2313 C2312 C1313 C1312 C1212

Definition at line 646 of file RankFourTensor.h.

647 {
648  mooseAssert(input.size() == 21,
649  "To use fillSymmetric21FromInputVector, your input must have size 21.");
650 
651  (*this)(0, 0, 0, 0) = input[0]; // C1111
652  (*this)(1, 1, 1, 1) = input[6]; // C2222
653  (*this)(2, 2, 2, 2) = input[11]; // C3333
654 
655  (*this)(0, 0, 1, 1) = input[1]; // C1122
656  (*this)(1, 1, 0, 0) = input[1];
657 
658  (*this)(0, 0, 2, 2) = input[2]; // C1133
659  (*this)(2, 2, 0, 0) = input[2];
660 
661  (*this)(1, 1, 2, 2) = input[7]; // C2233
662  (*this)(2, 2, 1, 1) = input[7];
663 
664  (*this)(0, 0, 0, 2) = input[4]; // C1113
665  (*this)(0, 0, 2, 0) = input[4];
666  (*this)(0, 2, 0, 0) = input[4];
667  (*this)(2, 0, 0, 0) = input[4];
668 
669  (*this)(0, 0, 0, 1) = input[5]; // C1112
670  (*this)(0, 0, 1, 0) = input[5];
671  (*this)(0, 1, 0, 0) = input[5];
672  (*this)(1, 0, 0, 0) = input[5];
673 
674  (*this)(1, 1, 1, 2) = input[8]; // C2223
675  (*this)(1, 1, 2, 1) = input[8];
676  (*this)(1, 2, 1, 1) = input[8];
677  (*this)(2, 1, 1, 1) = input[8];
678 
679  (*this)(1, 1, 1, 0) = input[10];
680  (*this)(1, 1, 0, 1) = input[10];
681  (*this)(1, 0, 1, 1) = input[10];
682  (*this)(0, 1, 1, 1) = input[10]; // C2212 //flipped for filling purposes
683 
684  (*this)(2, 2, 2, 1) = input[12];
685  (*this)(2, 2, 1, 2) = input[12];
686  (*this)(2, 1, 2, 2) = input[12];
687  (*this)(1, 2, 2, 2) = input[12]; // C3323 //flipped for filling purposes
688 
689  (*this)(2, 2, 2, 0) = input[13];
690  (*this)(2, 2, 0, 2) = input[13];
691  (*this)(2, 0, 2, 2) = input[13];
692  (*this)(0, 2, 2, 2) = input[13]; // C3313 //flipped for filling purposes
693 
694  (*this)(0, 0, 1, 2) = input[3]; // C1123
695  (*this)(0, 0, 2, 1) = input[3];
696  (*this)(1, 2, 0, 0) = input[3];
697  (*this)(2, 1, 0, 0) = input[3];
698 
699  (*this)(1, 1, 0, 2) = input[9];
700  (*this)(1, 1, 2, 0) = input[9];
701  (*this)(0, 2, 1, 1) = input[9]; // C2213 //flipped for filling purposes
702  (*this)(2, 0, 1, 1) = input[9];
703 
704  (*this)(2, 2, 0, 1) = input[14];
705  (*this)(2, 2, 1, 0) = input[14];
706  (*this)(0, 1, 2, 2) = input[14]; // C3312 //flipped for filling purposes
707  (*this)(1, 0, 2, 2) = input[14];
708 
709  (*this)(1, 2, 1, 2) = input[15]; // C2323
710  (*this)(2, 1, 2, 1) = input[15];
711  (*this)(2, 1, 1, 2) = input[15];
712  (*this)(1, 2, 2, 1) = input[15];
713 
714  (*this)(0, 2, 0, 2) = input[18]; // C1313
715  (*this)(2, 0, 2, 0) = input[18];
716  (*this)(2, 0, 0, 2) = input[18];
717  (*this)(0, 2, 2, 0) = input[18];
718 
719  (*this)(0, 1, 0, 1) = input[20]; // C1212
720  (*this)(1, 0, 1, 0) = input[20];
721  (*this)(1, 0, 0, 1) = input[20];
722  (*this)(0, 1, 1, 0) = input[20];
723 
724  (*this)(1, 2, 0, 2) = input[16];
725  (*this)(0, 2, 1, 2) = input[16]; // C2313 //flipped for filling purposes
726  (*this)(2, 1, 0, 2) = input[16];
727  (*this)(1, 2, 2, 0) = input[16];
728  (*this)(2, 0, 1, 2) = input[16];
729  (*this)(0, 2, 2, 1) = input[16];
730  (*this)(2, 1, 2, 0) = input[16];
731  (*this)(2, 0, 2, 1) = input[16];
732 
733  (*this)(1, 2, 0, 1) = input[17];
734  (*this)(0, 1, 1, 2) = input[17]; // C2312 //flipped for filling purposes
735  (*this)(2, 1, 0, 1) = input[17];
736  (*this)(1, 2, 1, 0) = input[17];
737  (*this)(1, 0, 1, 2) = input[17];
738  (*this)(0, 1, 2, 1) = input[17];
739  (*this)(2, 1, 1, 0) = input[17];
740  (*this)(1, 0, 2, 1) = input[17];
741 
742  (*this)(0, 2, 0, 1) = input[19];
743  (*this)(0, 1, 0, 2) = input[19]; // C1312 //flipped for filling purposes
744  (*this)(2, 0, 0, 1) = input[19];
745  (*this)(0, 2, 1, 0) = input[19];
746  (*this)(1, 0, 0, 2) = input[19];
747  (*this)(0, 1, 2, 0) = input[19];
748  (*this)(2, 0, 1, 0) = input[19];
749  (*this)(1, 0, 2, 0) = input[19];
750 }

◆ fillSymmetric9FromInputVector()

template<typename T >
template<typename T2 >
void RankFourTensorTempl< 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
inputis: 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 609 of file RankFourTensor.h.

610 {
611  mooseAssert(input.size() == 9,
612  "To use fillSymmetric9FromInputVector, your input must have size 9.");
613  zero();
614 
615  (*this)(0, 0, 0, 0) = input[0]; // C1111
616  (*this)(1, 1, 1, 1) = input[3]; // C2222
617  (*this)(2, 2, 2, 2) = input[5]; // C3333
618 
619  (*this)(0, 0, 1, 1) = input[1]; // C1122
620  (*this)(1, 1, 0, 0) = input[1];
621 
622  (*this)(0, 0, 2, 2) = input[2]; // C1133
623  (*this)(2, 2, 0, 0) = input[2];
624 
625  (*this)(1, 1, 2, 2) = input[4]; // C2233
626  (*this)(2, 2, 1, 1) = input[4];
627 
628  (*this)(1, 2, 1, 2) = input[6]; // C2323
629  (*this)(2, 1, 2, 1) = input[6];
630  (*this)(2, 1, 1, 2) = input[6];
631  (*this)(1, 2, 2, 1) = input[6];
632 
633  (*this)(0, 2, 0, 2) = input[7]; // C1313
634  (*this)(2, 0, 2, 0) = input[7];
635  (*this)(2, 0, 0, 2) = input[7];
636  (*this)(0, 2, 2, 0) = input[7];
637 
638  (*this)(0, 1, 0, 1) = input[8]; // C1212
639  (*this)(1, 0, 1, 0) = input[8];
640  (*this)(1, 0, 0, 1) = input[8];
641  (*this)(0, 1, 1, 0) = input[8];
642 }
RankFourTensorTempl::zero
void zero()
Zeros out the tensor.
Definition: RankFourTensorImplementation.h:117

◆ fillSymmetricIsotropic()

template<typename T >
void RankFourTensorTempl< T >::fillSymmetricIsotropic ( const T &  i0,
const T &  i1 
)

Definition at line 692 of file RankFourTensorImplementation.h.

693 {
694  // clang-format off
695  fillSymmetric21FromInputVector(std::array<T,21>
696  {{lambda + 2.0 * G, lambda, lambda, 0.0, 0.0, 0.0,
697  lambda + 2.0 * G, lambda, 0.0, 0.0, 0.0,
698  lambda + 2.0 * G, 0.0, 0.0, 0.0,
699  G, 0.0, 0.0,
700  G, 0.0,
701  G}});
702  // clang-format on
703 }
RankFourTensorTempl::fillSymmetric21FromInputVector
void fillSymmetric21FromInputVector(const T2 &input)
fillSymmetric21FromInputVector takes either 21 inputs to fill in the Rank-4 tensor with the appropria...
Definition: RankFourTensor.h:646

◆ fillSymmetricIsotropicEandNu()

template<typename T >
void RankFourTensorTempl< T >::fillSymmetricIsotropicEandNu ( const T &  E,
const T &  nu 
)

Definition at line 720 of file RankFourTensorImplementation.h.

721 {
722  // Calculate lambda and the shear modulus from the given young's modulus and poisson's ratio
723  const T & lambda = E * nu / ((1.0 + nu) * (1.0 - 2.0 * nu));
724  const T & G = E / (2.0 * (1.0 + nu));
725 
726  fillSymmetricIsotropic(lambda, G);
727 }
RankFourTensorTempl::fillSymmetricIsotropic
void fillSymmetricIsotropic(const T &i0, const T &i1)
Definition: RankFourTensorImplementation.h:692

◆ fillSymmetricIsotropicEandNuFromInputVector()

template<typename T >
void RankFourTensorTempl< 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
inputYoung's modulus (E) and Poisson's ratio (nu)

Definition at line 707 of file RankFourTensorImplementation.h.

708 {
709  if (input.size() != 2)
710  mooseError(
711  "To use fillSymmetricIsotropicEandNuFromInputVector, your input must have size 2. Yours "
712  "has size ",
713  input.size());
714 
715  fillSymmetricIsotropicEandNu(input[0], input[1]);
716 }
mooseError
void mooseError(Args &&... args)
Emit an error message with the given stringified, concatenated args and terminate the application...
Definition: MooseError.h:302
RankFourTensorTempl::fillSymmetricIsotropicEandNu
void fillSymmetricIsotropicEandNu(const T &E, const T &nu)
Definition: RankFourTensorImplementation.h:720

◆ fillSymmetricIsotropicFromInputVector()

template<typename T >
void RankFourTensorTempl< 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
inputthis is lambda and mu in the above formula

Definition at line 683 of file RankFourTensorImplementation.h.

684 {
685  mooseAssert(input.size() == 2,
686  "To use fillSymmetricIsotropicFromInputVector, your input must have size 2.");
687  fillSymmetricIsotropic(input[0], input[1]);
688 }
RankFourTensorTempl::fillSymmetricIsotropic
void fillSymmetricIsotropic(const T &i0, const T &i1)
Definition: RankFourTensorImplementation.h:692

◆ Identity()

template<typename T>
static RankFourTensorTempl<T> RankFourTensorTempl< T >::Identity ( )
inlinestatic

Definition at line 171 of file RankFourTensor.h.

171 { return RankFourTensorTempl<T>(initIdentity); }
RankFourTensorTempl
RankFourTensorTempl is designed to handle any N-dimensional fourth order tensor, C.
Definition: RankFourTensor.h:65

◆ IdentityDeviatoric()

template<typename T>
static RankFourTensorTempl<T> RankFourTensorTempl< T >::IdentityDeviatoric ( )
inlinestatic

Identity of type {ik} {jl} - {ij} {kl} / 3.

Definition at line 174 of file RankFourTensor.h.

175  {
176  return RankFourTensorTempl<T>(initIdentityDeviatoric);
177  };
RankFourTensorTempl
RankFourTensorTempl is designed to handle any N-dimensional fourth order tensor, C.
Definition: RankFourTensor.h:65

◆ IdentityFour()

template<typename T>
static RankFourTensorTempl<T> RankFourTensorTempl< T >::IdentityFour ( )
inlinestatic

Definition at line 172 of file RankFourTensor.h.

172 { return RankFourTensorTempl<T>(initIdentityFour); };
RankFourTensorTempl
RankFourTensorTempl is designed to handle any N-dimensional fourth order tensor, C.
Definition: RankFourTensor.h:65

◆ innerProductTranspose()

template<typename T >
RankTwoTensorTempl< T > RankFourTensorTempl< T >::innerProductTranspose ( const RankTwoTensorTempl< T > &  b) const

Inner product of the major transposed tensor with a rank two tensor.

Definition at line 868 of file RankFourTensorImplementation.h.

869 {
870  RankTwoTensorTempl<T> result;
871 
872  unsigned int index = 0;
873  for (unsigned int ij = 0; ij < N2; ++ij)
874  {
875  T bb = b._coords[ij];
876  for (unsigned int kl = 0; kl < N2; ++kl)
877  result._coords[kl] += _vals[index++] * bb;
878  }
879 
880  return result;
881 }
libMesh::TensorValue::_coords
T _coords[LIBMESH_DIM *LIBMESH_DIM]
RankFourTensorTempl::N2
static constexpr unsigned int N2
Definition: RankFourTensor.h:70
RankFourTensorTempl::_vals
T _vals[N4]
The values of the rank-four tensor stored by index=(((i * LIBMESH_DIM + j) * LIBMESH_DIM + k) * LIBME...
Definition: RankFourTensor.h:436
RankTwoTensorTempl
RankTwoTensorTempl is designed to handle the Stress or Strain Tensor for a fully anisotropic material...
Definition: RankTwoTensor.h:87

◆ inverse()

template<typename T >
RankFourTensorTempl< T > RankFourTensorTempl< T >::inverse ( ) const

This returns A_ijkl such that C_ijkl*A_klmn = de_im de_jn i.e.

the general rank four inverse

Definition at line 754 of file RankFourTensor.h.

755 {
756 
757  // The inverse of a 3x3x3x3 in the C_ijkl*A_klmn = de_im de_jn sense is
758  // simply the inverse of the 9x9 matrix of the tensor entries.
759  // So all we need to do is inverse _vals (with the appropriate row-major
760  // storage)
761 
762  RankFourTensorTempl<T> result;
763 
764  if constexpr (RankFourTensorTempl<T>::N4 * sizeof(T) > EIGEN_STACK_ALLOCATION_LIMIT)
765  {
766  // Allocate on the heap if you're going to exceed the stack size limit
767  Eigen::Matrix<T, Eigen::Dynamic, Eigen::Dynamic, Eigen::RowMajor> mat(9, 9);
768  for (auto i : libMesh::make_range(9 * 9))
769  mat(i) = _vals[i];
770 
771  mat = mat.inverse();
772 
773  for (auto i : libMesh::make_range(9 * 9))
774  result._vals[i] = mat(i);
775  }
776  else
777  {
778  // Allocate on the stack if small enough
779  const Eigen::Map<const Eigen::Matrix<T, 9, 9, Eigen::RowMajor>> mat(&_vals[0]);
780  Eigen::Map<Eigen::Matrix<T, 9, 9, Eigen::RowMajor>> res(&result._vals[0]);
781  res = mat.inverse();
782  }
783 
784  return result;
785 }
RankFourTensorTempl
RankFourTensorTempl is designed to handle any N-dimensional fourth order tensor, C.
Definition: RankFourTensor.h:65
RankFourTensorTempl::_vals
T _vals[N4]
The values of the rank-four tensor stored by index=(((i * LIBMESH_DIM + j) * LIBMESH_DIM + k) * LIBME...
Definition: RankFourTensor.h:436
libMesh::make_range
IntRange< T > make_range(T beg, T end)

◆ invSymm() [1/2]

template<>
RankFourTensorTempl< Real > RankFourTensorTempl< Real >::invSymm ( ) const

Definition at line 256 of file RankFourTensorImplementation.h.

257 {
258  unsigned int ntens = N * (N + 1) / 2;
259  int nskip = N - 1;
260 
261  RankFourTensorTempl<Real> result;
262  std::vector<PetscScalar> mat;
263  mat.assign(ntens * ntens, 0);
264 
265  // We use the LAPACK matrix inversion routine here. Form the matrix
266  //
267  // mat[0] mat[1] mat[2] mat[3] mat[4] mat[5]
268  // mat[6] mat[7] mat[8] mat[9] mat[10] mat[11]
269  // mat[12] mat[13] mat[14] mat[15] mat[16] mat[17]
270  // mat[18] mat[19] mat[20] mat[21] mat[22] mat[23]
271  // mat[24] mat[25] mat[26] mat[27] mat[28] mat[29]
272  // mat[30] mat[31] mat[32] mat[33] mat[34] mat[35]
273  //
274  // This is filled from the indpendent components of C assuming
275  // the symmetry C_ijkl = C_ijlk = C_jikl.
276  //
277  // If there are two rank-four tensors X and Y then the reason for
278  // this filling becomes apparent if we want to calculate
279  // X_ijkl*Y_klmn = Z_ijmn
280  // For denote the "mat" versions of X, Y and Z by x, y and z.
281  // Then
282  // z_ab = x_ac*y_cb
283  // Eg
284  // z_00 = Z_0000 = X_0000*Y_0000 + X_0011*Y_1111 + X_0022*Y_2200 + 2*X_0001*Y_0100 +
285  // 2*X_0002*Y_0200 + 2*X_0012*Y_1200 (the factors of 2 come from the assumed symmetries)
286  // z_03 = 2*Z_0001 = X_0000*2*Y_0001 + X_0011*2*Y_1101 + X_0022*2*Y_2201 + 2*X_0001*2*Y_0101 +
287  // 2*X_0002*2*Y_0201 + 2*X_0012*2*Y_1201
288  // z_22 = 2*Z_0102 = X_0100*2*Y_0002 + X_0111*2*X_1102 + X_0122*2*Y_2202 + 2*X_0101*2*Y_0102 +
289  // 2*X_0102*2*Y_0202 + 2*X_0112*2*Y_1202
290  // Finally, we use LAPACK to find x^-1, and put it back into rank-4 tensor form
291  //
292  // mat[0] = C(0,0,0,0)
293  // mat[1] = C(0,0,1,1)
294  // mat[2] = C(0,0,2,2)
295  // mat[3] = C(0,0,0,1)*2
296  // mat[4] = C(0,0,0,2)*2
297  // mat[5] = C(0,0,1,2)*2
298 
299  // mat[6] = C(1,1,0,0)
300  // mat[7] = C(1,1,1,1)
301  // mat[8] = C(1,1,2,2)
302  // mat[9] = C(1,1,0,1)*2
303  // mat[10] = C(1,1,0,2)*2
304  // mat[11] = C(1,1,1,2)*2
305 
306  // mat[12] = C(2,2,0,0)
307  // mat[13] = C(2,2,1,1)
308  // mat[14] = C(2,2,2,2)
309  // mat[15] = C(2,2,0,1)*2
310  // mat[16] = C(2,2,0,2)*2
311  // mat[17] = C(2,2,1,2)*2
312 
313  // mat[18] = C(0,1,0,0)
314  // mat[19] = C(0,1,1,1)
315  // mat[20] = C(0,1,2,2)
316  // mat[21] = C(0,1,0,1)*2
317  // mat[22] = C(0,1,0,2)*2
318  // mat[23] = C(0,1,1,2)*2
319 
320  // mat[24] = C(0,2,0,0)
321  // mat[25] = C(0,2,1,1)
322  // mat[26] = C(0,2,2,2)
323  // mat[27] = C(0,2,0,1)*2
324  // mat[28] = C(0,2,0,2)*2
325  // mat[29] = C(0,2,1,2)*2
326 
327  // mat[30] = C(1,2,0,0)
328  // mat[31] = C(1,2,1,1)
329  // mat[32] = C(1,2,2,2)
330  // mat[33] = C(1,2,0,1)*2
331  // mat[34] = C(1,2,0,2)*2
332  // mat[35] = C(1,2,1,2)*2
333 
334  unsigned int index = 0;
335  for (auto i : make_range(N))
336  for (auto j : make_range(N))
337  for (auto k : make_range(N))
338  for (auto l : make_range(N))
339  {
340  if (i == j)
341  mat[k == l ? i * ntens + k : i * ntens + k + nskip + l] += _vals[index];
342  else
343  // i!=j
344  mat[k == l ? (nskip + i + j) * ntens + k : (nskip + i + j) * ntens + k + nskip + l] +=
345  _vals[index]; // note the +=, which results in double-counting and is rectified
346  // below
347  index++;
348  }
349 
350  for (unsigned int i = 3; i < ntens; ++i)
351  for (auto j : make_range(ntens))
352  mat[i * ntens + j] /= 2.0; // because of double-counting above
353 
354  // use LAPACK to find the inverse
355  MatrixTools::inverse(mat, ntens);
356 
357  // build the resulting rank-four tensor
358  // using the inverse of the above algorithm
359  index = 0;
360  for (auto i : make_range(N))
361  for (auto j : make_range(N))
362  for (auto k : make_range(N))
363  for (auto l : make_range(N))
364  {
365  if (i == j)
366  result._vals[index] =
367  k == l ? mat[i * ntens + k] : mat[i * ntens + k + nskip + l] / 2.0;
368  else
369  // i!=j
370  result._vals[index] = k == l ? mat[(nskip + i + j) * ntens + k]
371  : mat[(nskip + i + j) * ntens + k + nskip + l] / 2.0;
372  index++;
373  }
374 
375  return result;
376 }
RankFourTensorTempl
RankFourTensorTempl is designed to handle any N-dimensional fourth order tensor, C.
Definition: RankFourTensor.h:65
MatrixTools::inverse
void inverse(const std::vector< std::vector< Real >> &m, std::vector< std::vector< Real >> &m_inv)
Inverse the dense square matrix m using LAPACK routines.
Definition: MatrixTools.C:23
RankFourTensorTempl::_vals
T _vals[N4]
The values of the rank-four tensor stored by index=(((i * LIBMESH_DIM + j) * LIBMESH_DIM + k) * LIBME...
Definition: RankFourTensor.h:436
make_range
IntRange< T > make_range(T beg, T end)
RankFourTensorTempl::N
static constexpr unsigned int N
tensor dimension and powers of the dimension
Definition: RankFourTensor.h:69

◆ invSymm() [2/2]

template<typename T >
RankFourTensorTempl< T > RankFourTensorTempl< 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 249 of file RankFourTensorImplementation.h.

250 {
251  mooseError("The invSymm operation calls to LAPACK and only supports plain Real type tensors.");
252 }
mooseError
void mooseError(Args &&... args)
Emit an error message with the given stringified, concatenated args and terminate the application...
Definition: MooseError.h:302

◆ isIsotropic()

template<typename T >
bool RankFourTensorTempl< T >::isIsotropic ( ) const

checks if the tensor is isotropic

Definition at line 1098 of file RankFourTensorImplementation.h.

1099 {
1100  // prerequisite is symmetry
1101  if (!isSymmetric())
1102  return false;
1103 
1104  // inspect shear components
1105  const T & mu = (*this)(0, 1, 0, 1);
1106  // ...diagonal
1107  if ((*this)(1, 2, 1, 2) != mu || (*this)(2, 0, 2, 0) != mu)
1108  return false;
1109  // ...off-diagonal
1110  if ((*this)(2, 0, 1, 2) != 0.0 || (*this)(0, 1, 1, 2) != 0.0 || (*this)(0, 1, 2, 0) != 0.0)
1111  return false;
1112 
1113  // off diagonal blocks in Voigt
1114  for (auto i : make_range(N))
1115  for (auto j : make_range(N))
1116  if (_vals[i * (N3 + N2) + ((j + 1) % N) * N + (j + 2) % N] != 0.0)
1117  return false;
1118 
1119  // top left block
1120  const T & K1 = (*this)(0, 0, 0, 0);
1121  const T & K2 = (*this)(0, 0, 1, 1);
1122  if (!MooseUtils::relativeFuzzyEqual(K1 - 4.0 * mu / 3.0, K2 + 2.0 * mu / 3.0))
1123  return false;
1124  if ((*this)(1, 1, 1, 1) != K1 || (*this)(2, 2, 2, 2) != K1)
1125  return false;
1126  for (auto i : make_range(1u, N))
1127  for (auto j : make_range(i))
1128  if ((*this)(i, i, j, j) != K2)
1129  return false;
1130 
1131  return true;
1132 }
RankFourTensorTempl::N3
static constexpr unsigned int N3
Definition: RankFourTensor.h:71
RankFourTensorTempl::N2
static constexpr unsigned int N2
Definition: RankFourTensor.h:70
RankFourTensorTempl::isSymmetric
bool isSymmetric() const
checks if the tensor is symmetric
Definition: RankFourTensorImplementation.h:1077
RankFourTensorTempl::_vals
T _vals[N4]
The values of the rank-four tensor stored by index=(((i * LIBMESH_DIM + j) * LIBMESH_DIM + k) * LIBME...
Definition: RankFourTensor.h:436
MooseUtils::relativeFuzzyEqual
bool relativeFuzzyEqual(const T &var1, const T2 &var2, const T3 &tol=libMesh::TOLERANCE *libMesh::TOLERANCE)
Function to check whether two variables are equal within a relative tolerance.
Definition: MooseUtils.h:492
make_range
IntRange< T > make_range(T beg, T end)
RankFourTensorTempl::N
static constexpr unsigned int N
tensor dimension and powers of the dimension
Definition: RankFourTensor.h:69

◆ isSymmetric()

template<typename T >
bool RankFourTensorTempl< T >::isSymmetric ( ) const

checks if the tensor is symmetric

Definition at line 1077 of file RankFourTensorImplementation.h.

1078 {
1079  for (auto i : make_range(1u, N))
1080  for (auto j : make_range(i))
1081  for (auto k : make_range(1u, N))
1082  for (auto l : make_range(k))
1083  {
1084  // minor symmetries
1085  if ((*this)(i, j, k, l) != (*this)(j, i, k, l) ||
1086  (*this)(i, j, k, l) != (*this)(i, j, l, k))
1087  return false;
1088 
1089  // major symmetry
1090  if ((*this)(i, j, k, l) != (*this)(k, l, i, j))
1091  return false;
1092  }
1093  return true;
1094 }
make_range
IntRange< T > make_range(T beg, T end)
RankFourTensorTempl::N
static constexpr unsigned int N
tensor dimension and powers of the dimension
Definition: RankFourTensor.h:69

◆ L2norm()

template<typename T >
T RankFourTensorTempl< T >::L2norm ( ) const

sqrt(C_ijkl*C_ijkl)

Definition at line 237 of file RankFourTensorImplementation.h.

238 {
239  T l2 = 0;
240 
241  for (auto i : make_range(N4))
242  l2 += Utility::pow<2>(_vals[i]);
243 
244  return std::sqrt(l2);
245 }
RankFourTensorTempl::N4
static constexpr unsigned int N4
Definition: RankFourTensor.h:72
RankFourTensorTempl::_vals
T _vals[N4]
The values of the rank-four tensor stored by index=(((i * LIBMESH_DIM + j) * LIBMESH_DIM + k) * LIBME...
Definition: RankFourTensor.h:436
CompileTimeDerivatives::sqrt
CTSub CT_OPERATOR_BINARY CTMul CTCompareLess CTCompareGreater CTCompareEqual _arg template * sqrt(_arg)) *_arg.template D< dtag >()) CT_SIMPLE_UNARY_FUNCTION(tanh
make_range
IntRange< T > make_range(T beg, T end)
CompileTimeDerivatives::pow< 2 >
CTSub CT_OPERATOR_BINARY CTMul CTCompareLess CTCompareGreater CTCompareEqual _arg template pow< 2 >(tan(_arg))+1.0) *_arg.template D< dtag >()) CT_SIMPLE_UNARY_FUNCTION(sqrt

◆ operator()() [1/2]

template<typename T>
T& RankFourTensorTempl< T >::operator() ( unsigned int  i,
unsigned int  j,
unsigned int  k,
unsigned int  l 
)
inline

Gets the value for the indices specified. Takes indices ranging from 0-2 for i, j, k, and l.

Definition at line 180 of file RankFourTensor.h.

181  {
182  return _vals[i * N3 + j * N2 + k * N + l];
183  }
RankFourTensorTempl::N3
static constexpr unsigned int N3
Definition: RankFourTensor.h:71
RankFourTensorTempl::N2
static constexpr unsigned int N2
Definition: RankFourTensor.h:70
RankFourTensorTempl::_vals
T _vals[N4]
The values of the rank-four tensor stored by index=(((i * LIBMESH_DIM + j) * LIBMESH_DIM + k) * LIBME...
Definition: RankFourTensor.h:436
RankFourTensorTempl::N
static constexpr unsigned int N
tensor dimension and powers of the dimension
Definition: RankFourTensor.h:69

◆ operator()() [2/2]

template<typename T>
const T& RankFourTensorTempl< T >::operator() ( unsigned int  i,
unsigned int  j,
unsigned int  k,
unsigned int  l 
) const
inline

Gets the value for the indices specified.

Takes indices ranging from 0-2 for i, j, k, and l. used for const

Definition at line 189 of file RankFourTensor.h.

190  {
191  return _vals[i * N3 + j * N2 + k * N + l];
192  }
RankFourTensorTempl::N3
static constexpr unsigned int N3
Definition: RankFourTensor.h:71
RankFourTensorTempl::N2
static constexpr unsigned int N2
Definition: RankFourTensor.h:70
RankFourTensorTempl::_vals
T _vals[N4]
The values of the rank-four tensor stored by index=(((i * LIBMESH_DIM + j) * LIBMESH_DIM + k) * LIBME...
Definition: RankFourTensor.h:436
RankFourTensorTempl::N
static constexpr unsigned int N
tensor dimension and powers of the dimension
Definition: RankFourTensor.h:69

◆ operator*() [1/3]

template<typename T >
template<template< typename > class Tensor, typename T2 >
auto RankFourTensorTempl< T >::operator* ( const Tensor< T2 > &  a) const -> typename std::enable_if<TwoTensorMultTraits<Tensor, T2>::value, RankTwoTensorTempl<decltype(T() * T2())>>::type

C_ijkl*a_kl.

Definition at line 126 of file RankFourTensorImplementation.h.

129 {
130  typedef decltype(T() * T2()) ValueType;
131  RankTwoTensorTempl<ValueType> result;
132 
133  unsigned int index = 0;
134  for (unsigned int ij = 0; ij < N2; ++ij)
135  {
136  ValueType tmp = 0;
137  for (unsigned int kl = 0; kl < N2; ++kl)
138  tmp += _vals[index++] * b(kl / LIBMESH_DIM, kl % LIBMESH_DIM);
139  result._coords[ij] = tmp;
140  }
141 
142  return result;
143 }
RankFourTensorTempl::N2
static constexpr unsigned int N2
Definition: RankFourTensor.h:70
RankFourTensorTempl::_vals
T _vals[N4]
The values of the rank-four tensor stored by index=(((i * LIBMESH_DIM + j) * LIBMESH_DIM + k) * LIBME...
Definition: RankFourTensor.h:436
RankTwoTensorTempl
RankTwoTensorTempl is designed to handle the Stress or Strain Tensor for a fully anisotropic material...
Definition: RankTwoTensor.h:87
for
for(PetscInt i=0;i< nvars;++i)
Definition: PetscDMMoose.C:1703

◆ operator*() [2/3]

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

C_ijkl*a.

Definition at line 580 of file RankFourTensor.h.

583 {
584  typedef decltype(T() * T2()) ValueType;
585  RankFourTensorTempl<ValueType> result;
586 
587  for (auto i : libMesh::make_range(N4))
588  result._vals[i] = _vals[i] * b;
589 
590  return result;
591 }
RankFourTensorTempl
RankFourTensorTempl is designed to handle any N-dimensional fourth order tensor, C.
Definition: RankFourTensor.h:65
libMesh
The following methods are specializations for using the libMesh::Parallel::packed_range_* routines fo...
RankFourTensorTempl::N4
static constexpr unsigned int N4
Definition: RankFourTensor.h:72
RankFourTensorTempl::_vals
T _vals[N4]
The values of the rank-four tensor stored by index=(((i * LIBMESH_DIM + j) * LIBMESH_DIM + k) * LIBME...
Definition: RankFourTensor.h:436
for
for(PetscInt i=0;i< nvars;++i)
Definition: PetscDMMoose.C:1703

◆ operator*() [3/3]

template<typename T >
template<typename T2>
auto RankFourTensorTempl< T >::operator* ( const RankFourTensorTempl< T2 > &  a) const -> RankFourTensorTempl<decltype(T() * T2())>

C_ijpq*a_pqkl.

Definition at line 218 of file RankFourTensorImplementation.h.

220 {
221  typedef decltype(T() * T2()) ValueType;
222  RankFourTensorTempl<ValueType> result;
223 
224  for (auto i : make_range(N))
225  for (auto j : make_range(N))
226  for (auto k : make_range(N))
227  for (auto l : make_range(N))
228  for (auto p : make_range(N))
229  for (auto q : make_range(N))
230  result(i, j, k, l) += (*this)(i, j, p, q) * b(p, q, k, l);
231 
232  return result;
233 }
RankFourTensorTempl
RankFourTensorTempl is designed to handle any N-dimensional fourth order tensor, C.
Definition: RankFourTensor.h:65
RankFourTensorTempl::N
static constexpr unsigned int N
tensor dimension and powers of the dimension
Definition: RankFourTensor.h:69
for
for(PetscInt i=0;i< nvars;++i)
Definition: PetscDMMoose.C:1703

◆ operator*=()

template<typename T >
RankFourTensorTempl< T > & RankFourTensorTempl< T >::operator*= ( const T &  a)

C_ijkl *= a.

Definition at line 147 of file RankFourTensorImplementation.h.

148 {
149  for (auto i : make_range(N4))
150  _vals[i] *= a;
151  return *this;
152 }
RankFourTensorTempl::N4
static constexpr unsigned int N4
Definition: RankFourTensor.h:72
RankFourTensorTempl::_vals
T _vals[N4]
The values of the rank-four tensor stored by index=(((i * LIBMESH_DIM + j) * LIBMESH_DIM + k) * LIBME...
Definition: RankFourTensor.h:436
make_range
IntRange< T > make_range(T beg, T end)

◆ operator+()

template<typename T >
template<typename T2 >
auto RankFourTensorTempl< T >::operator+ ( const RankFourTensorTempl< T2 > &  a) const -> RankFourTensorTempl<decltype(T() + T2())>

C_ijkl + a_ijkl.

Definition at line 175 of file RankFourTensorImplementation.h.

177 {
178  RankFourTensorTempl<decltype(T() + T2())> result;
179  for (auto i : make_range(N4))
180  result._vals[i] = _vals[i] + b._vals[i];
181  return result;
182 }
RankFourTensorTempl
RankFourTensorTempl is designed to handle any N-dimensional fourth order tensor, C.
Definition: RankFourTensor.h:65
RankFourTensorTempl::N4
static constexpr unsigned int N4
Definition: RankFourTensor.h:72
RankFourTensorTempl::_vals
T _vals[N4]
The values of the rank-four tensor stored by index=(((i * LIBMESH_DIM + j) * LIBMESH_DIM + k) * LIBME...
Definition: RankFourTensor.h:436
make_range
IntRange< T > make_range(T beg, T end)

◆ operator+=()

template<typename T >
RankFourTensorTempl< T > & RankFourTensorTempl< T >::operator+= ( const RankFourTensorTempl< T > &  a)

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

Definition at line 165 of file RankFourTensorImplementation.h.

166 {
167  for (auto i : make_range(N4))
168  _vals[i] += a._vals[i];
169  return *this;
170 }
RankFourTensorTempl::N4
static constexpr unsigned int N4
Definition: RankFourTensor.h:72
RankFourTensorTempl::_vals
T _vals[N4]
The values of the rank-four tensor stored by index=(((i * LIBMESH_DIM + j) * LIBMESH_DIM + k) * LIBME...
Definition: RankFourTensor.h:436
make_range
IntRange< T > make_range(T beg, T end)

◆ operator-() [1/2]

template<typename T >
template<typename T2 >
auto RankFourTensorTempl< T >::operator- ( const RankFourTensorTempl< T2 > &  a) const -> RankFourTensorTempl<decltype(T() - T2())>

C_ijkl - a_ijkl.

Definition at line 196 of file RankFourTensorImplementation.h.

198 {
199  RankFourTensorTempl<decltype(T() - T2())> result;
200  for (auto i : make_range(N4))
201  result._vals[i] = _vals[i] - b._vals[i];
202  return result;
203 }
RankFourTensorTempl
RankFourTensorTempl is designed to handle any N-dimensional fourth order tensor, C.
Definition: RankFourTensor.h:65
RankFourTensorTempl::N4
static constexpr unsigned int N4
Definition: RankFourTensor.h:72
RankFourTensorTempl::_vals
T _vals[N4]
The values of the rank-four tensor stored by index=(((i * LIBMESH_DIM + j) * LIBMESH_DIM + k) * LIBME...
Definition: RankFourTensor.h:436
make_range
IntRange< T > make_range(T beg, T end)

◆ operator-() [2/2]

template<typename T >
RankFourTensorTempl< T > RankFourTensorTempl< T >::operator- ( ) const

-C_ijkl

Definition at line 207 of file RankFourTensorImplementation.h.

208 {
209  RankFourTensorTempl<T> result;
210  for (auto i : make_range(N4))
211  result._vals[i] = -_vals[i];
212  return result;
213 }
RankFourTensorTempl
RankFourTensorTempl is designed to handle any N-dimensional fourth order tensor, C.
Definition: RankFourTensor.h:65
RankFourTensorTempl::N4
static constexpr unsigned int N4
Definition: RankFourTensor.h:72
RankFourTensorTempl::_vals
T _vals[N4]
The values of the rank-four tensor stored by index=(((i * LIBMESH_DIM + j) * LIBMESH_DIM + k) * LIBME...
Definition: RankFourTensor.h:436
make_range
IntRange< T > make_range(T beg, T end)

◆ operator-=()

template<typename T >
RankFourTensorTempl< T > & RankFourTensorTempl< T >::operator-= ( const RankFourTensorTempl< T > &  a)

C_ijkl -= a_ijkl.

Definition at line 186 of file RankFourTensorImplementation.h.

187 {
188  for (auto i : make_range(N4))
189  _vals[i] -= a._vals[i];
190  return *this;
191 }
RankFourTensorTempl::N4
static constexpr unsigned int N4
Definition: RankFourTensor.h:72
RankFourTensorTempl::_vals
T _vals[N4]
The values of the rank-four tensor stored by index=(((i * LIBMESH_DIM + j) * LIBMESH_DIM + k) * LIBME...
Definition: RankFourTensor.h:436
make_range
IntRange< T > make_range(T beg, T end)

◆ operator/()

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

C_ijkl/a.

Definition at line 596 of file RankFourTensor.h.

599 {
600  RankFourTensorTempl<decltype(T() / T2())> result;
601  for (auto i : libMesh::make_range(N4))
602  result._vals[i] = _vals[i] / b;
603  return result;
604 }
RankFourTensorTempl
RankFourTensorTempl is designed to handle any N-dimensional fourth order tensor, C.
Definition: RankFourTensor.h:65
RankFourTensorTempl::N4
static constexpr unsigned int N4
Definition: RankFourTensor.h:72
RankFourTensorTempl::_vals
T _vals[N4]
The values of the rank-four tensor stored by index=(((i * LIBMESH_DIM + j) * LIBMESH_DIM + k) * LIBME...
Definition: RankFourTensor.h:436
libMesh::make_range
IntRange< T > make_range(T beg, T end)

◆ operator/=()

template<typename T >
RankFourTensorTempl< T > & RankFourTensorTempl< T >::operator/= ( const T &  a)

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

Definition at line 156 of file RankFourTensorImplementation.h.

157 {
158  for (auto i : make_range(N4))
159  _vals[i] /= a;
160  return *this;
161 }
RankFourTensorTempl::N4
static constexpr unsigned int N4
Definition: RankFourTensor.h:72
RankFourTensorTempl::_vals
T _vals[N4]
The values of the rank-four tensor stored by index=(((i * LIBMESH_DIM + j) * LIBMESH_DIM + k) * LIBME...
Definition: RankFourTensor.h:436
make_range
IntRange< T > make_range(T beg, T end)

◆ operator=() [1/2]

template<typename T>
RankFourTensorTempl<T>& RankFourTensorTempl< T >::operator= ( const RankFourTensorTempl< T > &  a)
default

copies values from a into this tensor

◆ operator=() [2/2]

template<typename T>
template<typename Scalar >
libMesh::boostcopy::enable_if_c<libMesh::ScalarTraits<Scalar>::value, RankFourTensorTempl &>::type RankFourTensorTempl< 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 220 of file RankFourTensor.h.

221  {
222  libmesh_assert_equal_to(p, Scalar(0));
223  this->zero();
224  return *this;
225  }
RankFourTensorTempl::zero
void zero()
Zeros out the tensor.
Definition: RankFourTensorImplementation.h:117

◆ print()

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

Print the rank four tensor.

Definition at line 412 of file RankFourTensorImplementation.h.

413 {
414  for (auto i : make_range(N))
415  for (auto j : make_range(N))
416  {
417  stm << "i = " << i << " j = " << j << '\n';
418  for (auto k : make_range(N))
419  {
420  for (auto l : make_range(N))
421  stm << std::setw(15) << (*this)(i, j, k, l) << " ";
422 
423  stm << '\n';
424  }
425  }
426 
427  stm << std::flush;
428 }
make_range
IntRange< T > make_range(T beg, T end)
RankFourTensorTempl::N
static constexpr unsigned int N
tensor dimension and powers of the dimension
Definition: RankFourTensor.h:69

◆ printReal()

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

Print the values of the rank four tensor.

Definition at line 432 of file RankFourTensorImplementation.h.

433 {
434  for (unsigned int i = 0; i < N; ++i)
435  for (unsigned int j = 0; j < N; ++j)
436  {
437  stm << "i = " << i << " j = " << j << '\n';
438  for (unsigned int k = 0; k < N; ++k)
439  {
440  for (unsigned int l = 0; l < N; ++l)
441  stm << std::setw(15) << MetaPhysicL::raw_value((*this)(i, j, k, l)) << " ";
442 
443  stm << '\n';
444  }
445  }
446 
447  stm << std::flush;
448 }
MetaPhysicL::raw_value
auto raw_value(const Eigen::Map< T > &in)
Definition: EigenADReal.h:73
RankFourTensorTempl::N
static constexpr unsigned int N
tensor dimension and powers of the dimension
Definition: RankFourTensor.h:69

◆ rotate()

template<typename T >
void RankFourTensorTempl< 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 380 of file RankFourTensorImplementation.h.

381 {
382  RankFourTensorTempl<T> old = *this;
383 
384  unsigned int index = 0;
385  for (auto i : make_range(N))
386  for (auto j : make_range(N))
387  for (auto k : make_range(N))
388  for (auto l : make_range(N))
389  {
390  unsigned int index2 = 0;
391  T sum = 0.0;
392  for (auto m : make_range(N))
393  {
394  const T & a = R(i, m);
395  for (auto n : make_range(N))
396  {
397  const T & ab = a * R(j, n);
398  for (auto o : make_range(N))
399  {
400  const T & abc = ab * R(k, o);
401  for (auto p : make_range(N))
402  sum += abc * R(l, p) * old._vals[index2++];
403  }
404  }
405  }
406  _vals[index++] = sum;
407  }
408 }
RankFourTensorTempl
RankFourTensorTempl is designed to handle any N-dimensional fourth order tensor, C.
Definition: RankFourTensor.h:65
RankFourTensorTempl::_vals
T _vals[N4]
The values of the rank-four tensor stored by index=(((i * LIBMESH_DIM + j) * LIBMESH_DIM + k) * LIBME...
Definition: RankFourTensor.h:436
make_range
IntRange< T > make_range(T beg, T end)
RankFourTensorTempl::N
static constexpr unsigned int N
tensor dimension and powers of the dimension
Definition: RankFourTensor.h:69

◆ singleProductI()

template<typename T >
RankFourTensorTempl< T > RankFourTensorTempl< T >::singleProductI ( const RankTwoTensorTempl< T > &  A) const

Calculates C_mjkl A_im.

Definition at line 1013 of file RankFourTensorImplementation.h.

1014 {
1015  RankFourTensorTempl<T> R;
1016 
1017  for (unsigned int i = 0; i < N; i++)
1018  for (unsigned int j = 0; j < N; j++)
1019  for (unsigned int k = 0; k < N; k++)
1020  for (unsigned int l = 0; l < N; l++)
1021  for (unsigned int m = 0; m < N; m++)
1022  R(i, j, k, l) += (*this)(m, j, k, l) * A(i, m);
1023 
1024  return R;
1025 }
RankFourTensorTempl
RankFourTensorTempl is designed to handle any N-dimensional fourth order tensor, C.
Definition: RankFourTensor.h:65
RankFourTensorTempl::N
static constexpr unsigned int N
tensor dimension and powers of the dimension
Definition: RankFourTensor.h:69

◆ singleProductJ()

template<typename T >
RankFourTensorTempl< T > RankFourTensorTempl< T >::singleProductJ ( const RankTwoTensorTempl< T > &  A) const

Calculates C_imkl A_jm.

Definition at line 1029 of file RankFourTensorImplementation.h.

1030 {
1031  RankFourTensorTempl<T> R;
1032 
1033  for (unsigned int i = 0; i < N; i++)
1034  for (unsigned int j = 0; j < N; j++)
1035  for (unsigned int k = 0; k < N; k++)
1036  for (unsigned int l = 0; l < N; l++)
1037  for (unsigned int m = 0; m < N; m++)
1038  R(i, j, k, l) += (*this)(i, m, k, l) * A(j, m);
1039 
1040  return R;
1041 }
RankFourTensorTempl
RankFourTensorTempl is designed to handle any N-dimensional fourth order tensor, C.
Definition: RankFourTensor.h:65
RankFourTensorTempl::N
static constexpr unsigned int N
tensor dimension and powers of the dimension
Definition: RankFourTensor.h:69

◆ singleProductK()

template<typename T >
RankFourTensorTempl< T > RankFourTensorTempl< T >::singleProductK ( const RankTwoTensorTempl< T > &  A) const

Calculates C_ijml A_km.

Definition at line 1045 of file RankFourTensorImplementation.h.

1046 {
1047  RankFourTensorTempl<T> R;
1048 
1049  for (unsigned int i = 0; i < N; i++)
1050  for (unsigned int j = 0; j < N; j++)
1051  for (unsigned int k = 0; k < N; k++)
1052  for (unsigned int l = 0; l < N; l++)
1053  for (unsigned int m = 0; m < N; m++)
1054  R(i, j, k, l) += (*this)(i, j, m, l) * A(k, m);
1055 
1056  return R;
1057 }
RankFourTensorTempl
RankFourTensorTempl is designed to handle any N-dimensional fourth order tensor, C.
Definition: RankFourTensor.h:65
RankFourTensorTempl::N
static constexpr unsigned int N
tensor dimension and powers of the dimension
Definition: RankFourTensor.h:69

◆ singleProductL()

template<typename T >
RankFourTensorTempl< T > RankFourTensorTempl< T >::singleProductL ( const RankTwoTensorTempl< T > &  A) const

Calculates C_ijkm A_lm.

Definition at line 1061 of file RankFourTensorImplementation.h.

1062 {
1063  RankFourTensorTempl<T> R;
1064 
1065  for (unsigned int i = 0; i < N; i++)
1066  for (unsigned int j = 0; j < N; j++)
1067  for (unsigned int k = 0; k < N; k++)
1068  for (unsigned int l = 0; l < N; l++)
1069  for (unsigned int m = 0; m < N; m++)
1070  R(i, j, k, l) += (*this)(i, j, k, m) * A(l, m);
1071 
1072  return R;
1073 }
RankFourTensorTempl
RankFourTensorTempl is designed to handle any N-dimensional fourth order tensor, C.
Definition: RankFourTensor.h:65
RankFourTensorTempl::N
static constexpr unsigned int N
tensor dimension and powers of the dimension
Definition: RankFourTensor.h:69

◆ sum3x1()

template<typename T >
libMesh::VectorValue< T > RankFourTensorTempl< T >::sum3x1 ( ) const

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

Definition at line 925 of file RankFourTensorImplementation.h.

926 {
927  // used for volumetric locking correction
928  libMesh::VectorValue<T> a(3);
929  a(0) = (*this)(0, 0, 0, 0) + (*this)(0, 0, 1, 1) + (*this)(0, 0, 2, 2); // C0000 + C0011 + C0022
930  a(1) = (*this)(1, 1, 0, 0) + (*this)(1, 1, 1, 1) + (*this)(1, 1, 2, 2); // C1100 + C1111 + C1122
931  a(2) = (*this)(2, 2, 0, 0) + (*this)(2, 2, 1, 1) + (*this)(2, 2, 2, 2); // C2200 + C2211 + C2222
932  return a;
933 }

◆ sum3x3()

template<typename T >
T RankFourTensorTempl< T >::sum3x3 ( ) const

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

Definition at line 913 of file RankFourTensorImplementation.h.

914 {
915  // used in the volumetric locking correction
916  T sum = 0;
917  for (auto i : make_range(N))
918  for (auto j : make_range(N))
919  sum += (*this)(i, i, j, j);
920  return sum;
921 }
make_range
IntRange< T > make_range(T beg, T end)
RankFourTensorTempl::N
static constexpr unsigned int N
tensor dimension and powers of the dimension
Definition: RankFourTensor.h:69

◆ surfaceFillFromInputVector()

template<typename T >
void RankFourTensorTempl< T >::surfaceFillFromInputVector ( const std::vector< T > &  input)

Fills the tensor entries ignoring the last dimension (ie, C_ijkl=0 if any of i, j, k, or l = 3).

Fill method depends on size of input Input size = 2. Then C_1111 = C_2222 = input[0], and C_1122 = input[1], and C_1212 = (input[0]

  • input[1])/2, and C_ijkl = C_jikl = C_ijlk = C_klij, and C_1211 = C_1222 = 0. Input size = 9. Then C_1111 = input[0], C_1112 = input[1], C_1122 = input[3], C_1212 = input[4], C_1222 = input[5], C_1211 = input[6] C_2211 = input[7], C_2212 = input[8], C_2222 = input[9] and C_ijkl = C_jikl = C_ijlk

Definition at line 498 of file RankFourTensorImplementation.h.

499 {
500  zero();
501 
502  if (input.size() == 9)
503  {
504  // then fill from vector C_1111, C_1112, C_1122, C_1212, C_1222, C_1211, C_2211, C_2212, C_2222
505  (*this)(0, 0, 0, 0) = input[0];
506  (*this)(0, 0, 0, 1) = input[1];
507  (*this)(0, 0, 1, 1) = input[2];
508  (*this)(0, 1, 0, 1) = input[3];
509  (*this)(0, 1, 1, 1) = input[4];
510  (*this)(0, 1, 0, 0) = input[5];
511  (*this)(1, 1, 0, 0) = input[6];
512  (*this)(1, 1, 0, 1) = input[7];
513  (*this)(1, 1, 1, 1) = input[8];
514 
515  // fill in remainders from C_ijkl = C_ijlk = C_jikl
516  (*this)(0, 0, 1, 0) = (*this)(0, 0, 0, 1);
517  (*this)(0, 1, 1, 0) = (*this)(0, 1, 0, 1);
518  (*this)(1, 0, 0, 0) = (*this)(0, 1, 0, 0);
519  (*this)(1, 0, 0, 1) = (*this)(0, 1, 0, 1);
520  (*this)(1, 0, 1, 1) = (*this)(0, 1, 1, 1);
521  (*this)(1, 0, 0, 0) = (*this)(0, 1, 0, 0);
522  (*this)(1, 1, 1, 0) = (*this)(1, 1, 0, 1);
523  }
524  else if (input.size() == 2)
525  {
526  // only two independent constants, C_1111 and C_1122
527  (*this)(0, 0, 0, 0) = input[0];
528  (*this)(0, 0, 1, 1) = input[1];
529  // use symmetries
530  (*this)(1, 1, 1, 1) = (*this)(0, 0, 0, 0);
531  (*this)(1, 1, 0, 0) = (*this)(0, 0, 1, 1);
532  (*this)(0, 1, 0, 1) = 0.5 * ((*this)(0, 0, 0, 0) - (*this)(0, 0, 1, 1));
533  (*this)(1, 0, 0, 1) = (*this)(0, 1, 0, 1);
534  (*this)(0, 1, 1, 0) = (*this)(0, 1, 0, 1);
535  (*this)(1, 0, 1, 0) = (*this)(0, 1, 0, 1);
536  }
537  else
538  mooseError("Please provide correct number of inputs for surface RankFourTensorTempl<T> "
539  "initialization.");
540 }
mooseError
void mooseError(Args &&... args)
Emit an error message with the given stringified, concatenated args and terminate the application...
Definition: MooseError.h:302
RankFourTensorTempl::zero
void zero()
Zeros out the tensor.
Definition: RankFourTensorImplementation.h:117

◆ transposeIj()

template<typename T >
RankFourTensorTempl< T > RankFourTensorTempl< T >::transposeIj ( ) const

Transpose the tensor by swapping the first two indeces.

Returns
C_jikl

Definition at line 468 of file RankFourTensorImplementation.h.

469 {
470  RankFourTensorTempl<T> result;
471 
472  for (auto i : make_range(N))
473  for (auto j : make_range(N))
474  for (auto k : make_range(N))
475  for (auto l : make_range(N))
476  result(i, j, k, l) = (*this)(j, i, k, l);
477 
478  return result;
479 }
RankFourTensorTempl
RankFourTensorTempl is designed to handle any N-dimensional fourth order tensor, C.
Definition: RankFourTensor.h:65
make_range
IntRange< T > make_range(T beg, T end)
RankFourTensorTempl::N
static constexpr unsigned int N
tensor dimension and powers of the dimension
Definition: RankFourTensor.h:69

◆ transposeKl()

template<typename T >
RankFourTensorTempl< T > RankFourTensorTempl< T >::transposeKl ( ) const

Transpose the tensor by swapping the last two indeces.

Returns
C_ijlk

Definition at line 483 of file RankFourTensorImplementation.h.

484 {
485  RankFourTensorTempl<T> result;
486 
487  for (auto i : make_range(N))
488  for (auto j : make_range(N))
489  for (auto k : make_range(N))
490  for (auto l : make_range(N))
491  result(i, j, k, l) = (*this)(i, j, l, k);
492 
493  return result;
494 }
RankFourTensorTempl
RankFourTensorTempl is designed to handle any N-dimensional fourth order tensor, C.
Definition: RankFourTensor.h:65
make_range
IntRange< T > make_range(T beg, T end)
RankFourTensorTempl::N
static constexpr unsigned int N
tensor dimension and powers of the dimension
Definition: RankFourTensor.h:69

◆ transposeMajor()

template<typename T >
RankFourTensorTempl< T > RankFourTensorTempl< T >::transposeMajor ( ) const

Transpose the tensor by swapping the first pair with the second pair of indices.

Returns
C_klji

Definition at line 452 of file RankFourTensorImplementation.h.

453 {
454  RankFourTensorTempl<T> result;
455 
456  unsigned int index = 0;
457  for (auto i : make_range(N))
458  for (auto j : make_range(N))
459  for (auto k : make_range(N))
460  for (auto l : make_range(N))
461  result._vals[index++] = _vals[k * N3 + i * N + j + l * N2];
462 
463  return result;
464 }
RankFourTensorTempl
RankFourTensorTempl is designed to handle any N-dimensional fourth order tensor, C.
Definition: RankFourTensor.h:65
RankFourTensorTempl::N3
static constexpr unsigned int N3
Definition: RankFourTensor.h:71
RankFourTensorTempl::N2
static constexpr unsigned int N2
Definition: RankFourTensor.h:70
RankFourTensorTempl::_vals
T _vals[N4]
The values of the rank-four tensor stored by index=(((i * LIBMESH_DIM + j) * LIBMESH_DIM + k) * LIBME...
Definition: RankFourTensor.h:436
make_range
IntRange< T > make_range(T beg, T end)
RankFourTensorTempl::N
static constexpr unsigned int N
tensor dimension and powers of the dimension
Definition: RankFourTensor.h:69

◆ tripleProductIjk()

template<typename T >
RankFourTensorTempl< T > RankFourTensorTempl< T >::tripleProductIjk ( const RankTwoTensorTempl< T > &  A,
const RankTwoTensorTempl< T > &  B,
const RankTwoTensorTempl< T > &  C 
) const

Calculates C_mntl A_im B_jn C_kt.

Definition at line 994 of file RankFourTensorImplementation.h.

997 {
998  RankFourTensorTempl<T> R;
999  for (unsigned int i = 0; i < N; i++)
1000  for (unsigned int j = 0; j < N; j++)
1001  for (unsigned int k = 0; k < N; k++)
1002  for (unsigned int l = 0; l < N; l++)
1003  for (unsigned int m = 0; m < N; m++)
1004  for (unsigned int n = 0; n < N; n++)
1005  for (unsigned int t = 0; t < N; t++)
1006  R(i, j, k, l) += (*this)(m, n, t, l) * A(i, m) * B(j, n) * C(k, t);
1007 
1008  return R;
1009 }
RankFourTensorTempl
RankFourTensorTempl is designed to handle any N-dimensional fourth order tensor, C.
Definition: RankFourTensor.h:65
RankFourTensorTempl::N
static constexpr unsigned int N
tensor dimension and powers of the dimension
Definition: RankFourTensor.h:69

◆ tripleProductIjl()

template<typename T >
RankFourTensorTempl< T > RankFourTensorTempl< T >::tripleProductIjl ( const RankTwoTensorTempl< T > &  A,
const RankTwoTensorTempl< T > &  B,
const RankTwoTensorTempl< T > &  C 
) const

Calculates C_mnkt A_im B_jn C_lt.

Definition at line 975 of file RankFourTensorImplementation.h.

978 {
979  RankFourTensorTempl<T> R;
980  for (unsigned int i = 0; i < N; i++)
981  for (unsigned int j = 0; j < N; j++)
982  for (unsigned int k = 0; k < N; k++)
983  for (unsigned int l = 0; l < N; l++)
984  for (unsigned int m = 0; m < N; m++)
985  for (unsigned int n = 0; n < N; n++)
986  for (unsigned int t = 0; t < N; t++)
987  R(i, j, k, l) += (*this)(m, n, k, t) * A(i, m) * B(j, n) * C(l, t);
988 
989  return R;
990 }
RankFourTensorTempl
RankFourTensorTempl is designed to handle any N-dimensional fourth order tensor, C.
Definition: RankFourTensor.h:65
RankFourTensorTempl::N
static constexpr unsigned int N
tensor dimension and powers of the dimension
Definition: RankFourTensor.h:69

◆ tripleProductIkl()

template<typename T >
RankFourTensorTempl< T > RankFourTensorTempl< T >::tripleProductIkl ( const RankTwoTensorTempl< T > &  A,
const RankTwoTensorTempl< T > &  B,
const RankTwoTensorTempl< T > &  C 
) const

Calculates C_mjnt A_im B_kn C_lt.

Definition at line 956 of file RankFourTensorImplementation.h.

959 {
960  RankFourTensorTempl<T> R;
961  for (unsigned int i = 0; i < N; i++)
962  for (unsigned int j = 0; j < N; j++)
963  for (unsigned int k = 0; k < N; k++)
964  for (unsigned int l = 0; l < N; l++)
965  for (unsigned int m = 0; m < N; m++)
966  for (unsigned int n = 0; n < N; n++)
967  for (unsigned int t = 0; t < N; t++)
968  R(i, j, k, l) += (*this)(m, j, n, t) * A(i, m) * B(k, n) * C(l, t);
969 
970  return R;
971 }
RankFourTensorTempl
RankFourTensorTempl is designed to handle any N-dimensional fourth order tensor, C.
Definition: RankFourTensor.h:65
RankFourTensorTempl::N
static constexpr unsigned int N
tensor dimension and powers of the dimension
Definition: RankFourTensor.h:69

◆ tripleProductJkl()

template<typename T >
RankFourTensorTempl< T > RankFourTensorTempl< T >::tripleProductJkl ( const RankTwoTensorTempl< T > &  A,
const RankTwoTensorTempl< T > &  B,
const RankTwoTensorTempl< T > &  C 
) const

Calculates C_imnt A_jm B_kn C_lt.

Definition at line 937 of file RankFourTensorImplementation.h.

940 {
941  RankFourTensorTempl<T> R;
942  for (unsigned int i = 0; i < N; i++)
943  for (unsigned int j = 0; j < N; j++)
944  for (unsigned int k = 0; k < N; k++)
945  for (unsigned int l = 0; l < N; l++)
946  for (unsigned int m = 0; m < N; m++)
947  for (unsigned int n = 0; n < N; n++)
948  for (unsigned int t = 0; t < N; t++)
949  R(i, j, k, l) += (*this)(i, m, n, t) * A(j, m) * B(k, n) * C(l, t);
950 
951  return R;
952 }
RankFourTensorTempl
RankFourTensorTempl is designed to handle any N-dimensional fourth order tensor, C.
Definition: RankFourTensor.h:65
RankFourTensorTempl::N
static constexpr unsigned int N
tensor dimension and powers of the dimension
Definition: RankFourTensor.h:69

◆ zero()

template<typename T >
void RankFourTensorTempl< T >::zero ( )

Zeros out the tensor.

Definition at line 117 of file RankFourTensorImplementation.h.

Referenced by RankFourTensorTempl< T >::operator=().

118 {
119  for (auto i : make_range(N4))
120  _vals[i] = 0.0;
121 }
RankFourTensorTempl::N4
static constexpr unsigned int N4
Definition: RankFourTensor.h:72
RankFourTensorTempl::_vals
T _vals[N4]
The values of the rank-four tensor stored by index=(((i * LIBMESH_DIM + j) * LIBMESH_DIM + k) * LIBME...
Definition: RankFourTensor.h:436
make_range
IntRange< T > make_range(T beg, T end)

Friends And Related Function Documentation

◆ dataLoad

template<typename T>
template<class T2 >
void dataLoad ( std::istream &  ,
RankFourTensorTempl< T2 > &  ,
void *   
)
friend

◆ dataStore

template<typename T>
template<class T2 >
void dataStore ( std::ostream &  ,
RankFourTensorTempl< T2 > &  ,
void *   
)
friend

◆ operator<<

template<typename T>
std::ostream& operator<< ( std::ostream &  os,
const RankFourTensorTempl< T > &  t 
)
friend

Definition at line 200 of file RankFourTensor.h.

201  {
202  t.print(os);
203  return os;
204  }
os
std::basic_ostream< charT, traits > * os
Definition: InfixIterator.h:33
RankFourTensorTempl::print
void print(std::ostream &stm=Moose::out) const
Print the rank four tensor.
Definition: RankFourTensorImplementation.h:412

◆ RankFourTensorTempl

template<typename T>
template<typename T2 >
friend class RankFourTensorTempl
friend

Definition at line 533 of file RankFourTensor.h.

◆ RankThreeTensorTempl

template<typename T>
template<typename T2 >
friend class RankThreeTensorTempl
friend

Definition at line 535 of file RankFourTensor.h.

◆ RankTwoTensorTempl

template<typename T>
template<typename T2 >
friend class RankTwoTensorTempl
friend

Definition at line 531 of file RankFourTensor.h.

Member Data Documentation

◆ _vals

template<typename T>
T RankFourTensorTempl< T >::_vals[N4]
protected

The values of the rank-four tensor stored by index=(((i * LIBMESH_DIM + j) * LIBMESH_DIM + k) * LIBMESH_DIM + l)

Definition at line 436 of file RankFourTensor.h.

Referenced by dataLoad(), dataStore(), RankFourTensorTempl< T >::inverse(), RankFourTensorTempl< T >::invSymm(), RankThreeTensorTempl< T >::mixedProductRankFour(), RankFourTensorTempl< T >::operator()(), RankFourTensorTempl< T >::operator*(), RankFourTensorTempl< T >::operator+(), RankFourTensorTempl< T >::operator+=(), RankFourTensorTempl< T >::operator-(), RankFourTensorTempl< T >::operator-=(), RankFourTensorTempl< T >::operator/(), RankFourTensorTempl< T >::RankFourTensorTempl(), RankFourTensorTempl< T >::rotate(), and RankFourTensorTempl< T >::transposeMajor().

◆ N

template<typename T>
constexpr unsigned int RankFourTensorTempl< T >::N = Moose::dim
static

tensor dimension and powers of the dimension

Definition at line 69 of file RankFourTensor.h.

Referenced by RankFourTensorTempl< T >::operator()().

◆ N2

template<typename T>
constexpr unsigned int RankFourTensorTempl< T >::N2 = N * N
static

Definition at line 70 of file RankFourTensor.h.

Referenced by RankFourTensorTempl< T >::operator()().

◆ N3

template<typename T>
constexpr unsigned int RankFourTensorTempl< T >::N3 = N * N * N
static

Definition at line 71 of file RankFourTensor.h.

Referenced by RankFourTensorTempl< T >::operator()().

◆ N4

template<typename T>
constexpr unsigned int RankFourTensorTempl< T >::N4 = N * N * N * N
static

Definition at line 72 of file RankFourTensor.h.

The documentation for this class was generated from the following files:
Generated on Wed Jul 23 2025 20:11:20 for https://mooseframework.inl.gov by   doxygen 1.8.14