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:323
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:545

◆ 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 886 of file RankFourTensorImplementation.h.

889 {
890  T val = 0;
891  for (unsigned int k = 0; k < N; k++)
892  for (unsigned int l = 0; l < N; l++)
893  val += (*this)(i, j, k, l) * M(k, l);
894 
895  return val;
896 }
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 900 of file RankFourTensorImplementation.h.

903 {
904  T val = 0;
905  for (unsigned int i = 0; i < N; i++)
906  for (unsigned int j = 0; j < N; j++)
907  val += (*this)(i, j, k, l) * M(i, j);
908 
909  return val;
910 }
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 590 of file RankFourTensorImplementation.h.

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

678 {
679  fillGeneralIsotropic(0.0, 0.0, i0);
680 }
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:648

◆ 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 665 of file RankFourTensorImplementation.h.

666 {
667  if (input.size() != 1)
668  mooseError("To use fillAntisymmetricIsotropicFromInputVector, your input must have size 1. "
669  "Yours has size ",
670  input.size());
671 
672  fillGeneralIsotropic(0.0, 0.0, input[0]);
673 }
mooseError
void mooseError(Args &&... args)
Emit an error message with the given stringified, concatenated args and terminate the application...
Definition: MooseError.h:323
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:648

◆ 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 732 of file RankFourTensorImplementation.h.

733 {
734  mooseAssert(input.size() == 5,
735  "To use fillAxisymmetricRZFromInputVector, your input must have size 5.");
736 
737  // C1111 C1122 C1133 0 0 0
738  // C2222 C2233=C1133 0 0 0
739  // C3333 0 0 0
740  // C2323 0 0
741  // C3131=C2323 0
742  // C1212
743  // clang-format off
744  fillSymmetric21FromInputVector(std::array<T,21>
745  {{input[0],input[1],input[2], 0.0, 0.0, 0.0,
746  input[0],input[2], 0.0, 0.0, 0.0,
747  input[3], 0.0, 0.0, 0.0,
748  input[4], 0.0, 0.0,
749  input[4], 0.0,
750  (input[0] - input[1]) * 0.5}});
751  // clang-format on
752 }
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 545 of file RankFourTensorImplementation.h.

546 {
547 
548  switch (fill_method)
549  {
550  case antisymmetric:
551  fillAntisymmetricFromInputVector(input);
552  break;
553  case symmetric9:
554  fillSymmetric9FromInputVector(input);
555  break;
556  case symmetric21:
557  fillSymmetric21FromInputVector(input);
558  break;
559  case general_isotropic:
560  fillGeneralIsotropicFromInputVector(input);
561  break;
562  case symmetric_isotropic:
563  fillSymmetricIsotropicFromInputVector(input);
564  break;
565  case symmetric_isotropic_E_nu:
566  fillSymmetricIsotropicEandNuFromInputVector(input);
567  break;
568  case antisymmetric_isotropic:
569  fillAntisymmetricIsotropicFromInputVector(input);
570  break;
571  case axisymmetric_rz:
572  fillAxisymmetricRZFromInputVector(input);
573  break;
574  case general:
575  fillGeneralFromInputVector(input);
576  break;
577  case principal:
578  fillPrincipalFromInputVector(input);
579  break;
580  case orthotropic:
581  fillGeneralOrthotropicFromInputVector(input);
582  break;
583  default:
584  mooseError("fillFromInputVector called with unknown fill_method of ", fill_method);
585  }
586 }
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:756
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:789
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:590
mooseError
void mooseError(Args &&... args)
Emit an error message with the given stringified, concatenated args and terminate the application...
Definition: MooseError.h:323
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:768
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:636
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:732
RankFourTensorTempl::fillSymmetricIsotropicEandNuFromInputVector
void fillSymmetricIsotropicEandNuFromInputVector(const std::vector< T > &input)
fillSymmetricIsotropicEandNuFromInputVector is a variation of the fillSymmetricIsotropicFromInputVect...
Definition: RankFourTensorImplementation.h:708
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:684
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:665

◆ 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 756 of file RankFourTensorImplementation.h.

757 {
758  if (input.size() != 81)
759  mooseError("To use fillGeneralFromInputVector, your input must have size 81. Yours has size ",
760  input.size());
761 
762  for (auto i : make_range(N4))
763  _vals[i] = input[i];
764 }
mooseError
void mooseError(Args &&... args)
Emit an error message with the given stringified, concatenated args and terminate the application...
Definition: MooseError.h:323
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 648 of file RankFourTensorImplementation.h.

649 {
650  for (auto i : make_range(N))
651  for (auto j : make_range(N))
652  for (auto k : make_range(N))
653  for (auto l : make_range(N))
654  {
655  (*this)(i, j, k, l) = i0 * Real(i == j) * Real(k == l) +
656  i1 * Real(i == k) * Real(j == l) + i1 * Real(i == l) * Real(j == k);
657  for (auto m : make_range(N))
658  (*this)(i, j, k, l) +=
659  i2 * Real(PermutationTensor::eps(i, j, m)) * Real(PermutationTensor::eps(k, l, m));
660  }
661 }
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 636 of file RankFourTensorImplementation.h.

637 {
638  if (input.size() != 3)
639  mooseError("To use fillGeneralIsotropicFromInputVector, your input must have size 3. Yours "
640  "has size ",
641  input.size());
642 
643  fillGeneralIsotropic(input[0], input[1], input[2]);
644 }
mooseError
void mooseError(Args &&... args)
Emit an error message with the given stringified, concatenated args and terminate the application...
Definition: MooseError.h:323
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:648

◆ 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 789 of file RankFourTensorImplementation.h.

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

769 {
770  if (input.size() != 9)
771  mooseError("To use fillPrincipalFromInputVector, your input must have size 9. Yours has size ",
772  input.size());
773 
774  zero();
775 
776  (*this)(0, 0, 0, 0) = input[0];
777  (*this)(0, 0, 1, 1) = input[1];
778  (*this)(0, 0, 2, 2) = input[2];
779  (*this)(1, 1, 0, 0) = input[3];
780  (*this)(1, 1, 1, 1) = input[4];
781  (*this)(1, 1, 2, 2) = input[5];
782  (*this)(2, 2, 0, 0) = input[6];
783  (*this)(2, 2, 1, 1) = input[7];
784  (*this)(2, 2, 2, 2) = input[8];
785 }
mooseError
void mooseError(Args &&... args)
Emit an error message with the given stringified, concatenated args and terminate the application...
Definition: MooseError.h:323
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 693 of file RankFourTensorImplementation.h.

694 {
695  // clang-format off
696  fillSymmetric21FromInputVector(std::array<T,21>
697  {{lambda + 2.0 * G, lambda, lambda, 0.0, 0.0, 0.0,
698  lambda + 2.0 * G, lambda, 0.0, 0.0, 0.0,
699  lambda + 2.0 * G, 0.0, 0.0, 0.0,
700  G, 0.0, 0.0,
701  G, 0.0,
702  G}});
703  // clang-format on
704 }
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 721 of file RankFourTensorImplementation.h.

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

◆ 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 708 of file RankFourTensorImplementation.h.

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

◆ 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 684 of file RankFourTensorImplementation.h.

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

◆ 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 869 of file RankFourTensorImplementation.h.

870 {
871  RankTwoTensorTempl<T> result;
872 
873  unsigned int index = 0;
874  for (unsigned int ij = 0; ij < N2; ++ij)
875  {
876  T bb = b._coords[ij];
877  for (unsigned int kl = 0; kl < N2; ++kl)
878  result._coords[kl] += _vals[index++] * bb;
879  }
880 
881  return result;
882 }
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 257 of file RankFourTensorImplementation.h.

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

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

◆ isIsotropic()

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

checks if the tensor is isotropic

Definition at line 1099 of file RankFourTensorImplementation.h.

1100 {
1101  // prerequisite is symmetry
1102  if (!isSymmetric())
1103  return false;
1104 
1105  // inspect shear components
1106  const T & mu = (*this)(0, 1, 0, 1);
1107  // ...diagonal
1108  if ((*this)(1, 2, 1, 2) != mu || (*this)(2, 0, 2, 0) != mu)
1109  return false;
1110  // ...off-diagonal
1111  if ((*this)(2, 0, 1, 2) != 0.0 || (*this)(0, 1, 1, 2) != 0.0 || (*this)(0, 1, 2, 0) != 0.0)
1112  return false;
1113 
1114  // off diagonal blocks in Voigt
1115  for (auto i : make_range(N))
1116  for (auto j : make_range(N))
1117  if (_vals[i * (N3 + N2) + ((j + 1) % N) * N + (j + 2) % N] != 0.0)
1118  return false;
1119 
1120  // top left block
1121  const T & K1 = (*this)(0, 0, 0, 0);
1122  const T & K2 = (*this)(0, 0, 1, 1);
1123  if (!MooseUtils::relativeFuzzyEqual(K1 - 4.0 * mu / 3.0, K2 + 2.0 * mu / 3.0))
1124  return false;
1125  if ((*this)(1, 1, 1, 1) != K1 || (*this)(2, 2, 2, 2) != K1)
1126  return false;
1127  for (auto i : make_range(1u, N))
1128  for (auto j : make_range(i))
1129  if ((*this)(i, i, j, j) != K2)
1130  return false;
1131 
1132  return true;
1133 }
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:1078
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

◆ isSymmetric()

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

checks if the tensor is symmetric

Definition at line 1078 of file RankFourTensorImplementation.h.

1079 {
1080  for (auto i : make_range(1u, N))
1081  for (auto j : make_range(i))
1082  for (auto k : make_range(1u, N))
1083  for (auto l : make_range(k))
1084  {
1085  // minor symmetries
1086  if ((*this)(i, j, k, l) != (*this)(j, i, k, l) ||
1087  (*this)(i, j, k, l) != (*this)(i, j, l, k))
1088  return false;
1089 
1090  // major symmetry
1091  if ((*this)(i, j, k, l) != (*this)(k, l, i, j))
1092  return false;
1093  }
1094  return true;
1095 }
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  using std::sqrt;
245  return sqrt(l2);
246 }
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:1721

◆ 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:1721

◆ 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:1721

◆ 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 413 of file RankFourTensorImplementation.h.

414 {
415  for (auto i : make_range(N))
416  for (auto j : make_range(N))
417  {
418  stm << "i = " << i << " j = " << j << '\n';
419  for (auto k : make_range(N))
420  {
421  for (auto l : make_range(N))
422  stm << std::setw(15) << (*this)(i, j, k, l) << " ";
423 
424  stm << '\n';
425  }
426  }
427 
428  stm << std::flush;
429 }
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 433 of file RankFourTensorImplementation.h.

434 {
435  for (unsigned int i = 0; i < N; ++i)
436  for (unsigned int j = 0; j < N; ++j)
437  {
438  stm << "i = " << i << " j = " << j << '\n';
439  for (unsigned int k = 0; k < N; ++k)
440  {
441  for (unsigned int l = 0; l < N; ++l)
442  stm << std::setw(15) << MetaPhysicL::raw_value((*this)(i, j, k, l)) << " ";
443 
444  stm << '\n';
445  }
446  }
447 
448  stm << std::flush;
449 }
MetaPhysicL::raw_value
auto raw_value(const Eigen::Map< T > &in)
Definition: EigenADReal.h:84
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 381 of file RankFourTensorImplementation.h.

382 {
383  RankFourTensorTempl<T> old = *this;
384 
385  unsigned int index = 0;
386  for (auto i : make_range(N))
387  for (auto j : make_range(N))
388  for (auto k : make_range(N))
389  for (auto l : make_range(N))
390  {
391  unsigned int index2 = 0;
392  T sum = 0.0;
393  for (auto m : make_range(N))
394  {
395  const T & a = R(i, m);
396  for (auto n : make_range(N))
397  {
398  const T & ab = a * R(j, n);
399  for (auto o : make_range(N))
400  {
401  const T & abc = ab * R(k, o);
402  for (auto p : make_range(N))
403  sum += abc * R(l, p) * old._vals[index2++];
404  }
405  }
406  }
407  _vals[index++] = sum;
408  }
409 }
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 1014 of file RankFourTensorImplementation.h.

1015 {
1016  RankFourTensorTempl<T> R;
1017 
1018  for (unsigned int i = 0; i < N; i++)
1019  for (unsigned int j = 0; j < N; j++)
1020  for (unsigned int k = 0; k < N; k++)
1021  for (unsigned int l = 0; l < N; l++)
1022  for (unsigned int m = 0; m < N; m++)
1023  R(i, j, k, l) += (*this)(m, j, k, l) * A(i, m);
1024 
1025  return R;
1026 }
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 1030 of file RankFourTensorImplementation.h.

1031 {
1032  RankFourTensorTempl<T> R;
1033 
1034  for (unsigned int i = 0; i < N; i++)
1035  for (unsigned int j = 0; j < N; j++)
1036  for (unsigned int k = 0; k < N; k++)
1037  for (unsigned int l = 0; l < N; l++)
1038  for (unsigned int m = 0; m < N; m++)
1039  R(i, j, k, l) += (*this)(i, m, k, l) * A(j, m);
1040 
1041  return R;
1042 }
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 1046 of file RankFourTensorImplementation.h.

1047 {
1048  RankFourTensorTempl<T> R;
1049 
1050  for (unsigned int i = 0; i < N; i++)
1051  for (unsigned int j = 0; j < N; j++)
1052  for (unsigned int k = 0; k < N; k++)
1053  for (unsigned int l = 0; l < N; l++)
1054  for (unsigned int m = 0; m < N; m++)
1055  R(i, j, k, l) += (*this)(i, j, m, l) * A(k, m);
1056 
1057  return R;
1058 }
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 1062 of file RankFourTensorImplementation.h.

1063 {
1064  RankFourTensorTempl<T> R;
1065 
1066  for (unsigned int i = 0; i < N; i++)
1067  for (unsigned int j = 0; j < N; j++)
1068  for (unsigned int k = 0; k < N; k++)
1069  for (unsigned int l = 0; l < N; l++)
1070  for (unsigned int m = 0; m < N; m++)
1071  R(i, j, k, l) += (*this)(i, j, k, m) * A(l, m);
1072 
1073  return R;
1074 }
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 926 of file RankFourTensorImplementation.h.

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

◆ 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 914 of file RankFourTensorImplementation.h.

915 {
916  // used in the volumetric locking correction
917  T sum = 0;
918  for (auto i : make_range(N))
919  for (auto j : make_range(N))
920  sum += (*this)(i, i, j, j);
921  return sum;
922 }
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 499 of file RankFourTensorImplementation.h.

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

470 {
471  RankFourTensorTempl<T> result;
472 
473  for (auto i : make_range(N))
474  for (auto j : make_range(N))
475  for (auto k : make_range(N))
476  for (auto l : make_range(N))
477  result(i, j, k, l) = (*this)(j, i, k, l);
478 
479  return result;
480 }
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 484 of file RankFourTensorImplementation.h.

485 {
486  RankFourTensorTempl<T> result;
487 
488  for (auto i : make_range(N))
489  for (auto j : make_range(N))
490  for (auto k : make_range(N))
491  for (auto l : make_range(N))
492  result(i, j, k, l) = (*this)(i, j, l, k);
493 
494  return result;
495 }
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 453 of file RankFourTensorImplementation.h.

454 {
455  RankFourTensorTempl<T> result;
456 
457  unsigned int index = 0;
458  for (auto i : make_range(N))
459  for (auto j : make_range(N))
460  for (auto k : make_range(N))
461  for (auto l : make_range(N))
462  result._vals[index++] = _vals[k * N3 + i * N + j + l * N2];
463 
464  return result;
465 }
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 995 of file RankFourTensorImplementation.h.

998 {
999  RankFourTensorTempl<T> R;
1000  for (unsigned int i = 0; i < N; i++)
1001  for (unsigned int j = 0; j < N; j++)
1002  for (unsigned int k = 0; k < N; k++)
1003  for (unsigned int l = 0; l < N; l++)
1004  for (unsigned int m = 0; m < N; m++)
1005  for (unsigned int n = 0; n < N; n++)
1006  for (unsigned int t = 0; t < N; t++)
1007  R(i, j, k, l) += (*this)(m, n, t, l) * A(i, m) * B(j, n) * C(k, t);
1008 
1009  return R;
1010 }
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 976 of file RankFourTensorImplementation.h.

979 {
980  RankFourTensorTempl<T> R;
981  for (unsigned int i = 0; i < N; i++)
982  for (unsigned int j = 0; j < N; j++)
983  for (unsigned int k = 0; k < N; k++)
984  for (unsigned int l = 0; l < N; l++)
985  for (unsigned int m = 0; m < N; m++)
986  for (unsigned int n = 0; n < N; n++)
987  for (unsigned int t = 0; t < N; t++)
988  R(i, j, k, l) += (*this)(m, n, k, t) * A(i, m) * B(j, n) * C(l, t);
989 
990  return R;
991 }
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 957 of file RankFourTensorImplementation.h.

960 {
961  RankFourTensorTempl<T> R;
962  for (unsigned int i = 0; i < N; i++)
963  for (unsigned int j = 0; j < N; j++)
964  for (unsigned int k = 0; k < N; k++)
965  for (unsigned int l = 0; l < N; l++)
966  for (unsigned int m = 0; m < N; m++)
967  for (unsigned int n = 0; n < N; n++)
968  for (unsigned int t = 0; t < N; t++)
969  R(i, j, k, l) += (*this)(m, j, n, t) * A(i, m) * B(k, n) * C(l, t);
970 
971  return R;
972 }
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 938 of file RankFourTensorImplementation.h.

941 {
942  RankFourTensorTempl<T> R;
943  for (unsigned int i = 0; i < N; i++)
944  for (unsigned int j = 0; j < N; j++)
945  for (unsigned int k = 0; k < N; k++)
946  for (unsigned int l = 0; l < N; l++)
947  for (unsigned int m = 0; m < N; m++)
948  for (unsigned int n = 0; n < N; n++)
949  for (unsigned int t = 0; t < N; t++)
950  R(i, j, k, l) += (*this)(i, m, n, t) * A(j, m) * B(k, n) * C(l, t);
951 
952  return R;
953 }
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:413

◆ 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 Sun Nov 2 2025 20:10:22 for https://mooseframework.inl.gov by   doxygen 1.8.14