RankFourTensorTempl< T > Class Template Reference

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

#include <MooseTypes.h>

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

Public Types
enum	InitMethod { initNone, initIdentity, initIdentityFour, initIdentitySymmetricFour }
	Initialization method. More...
enum	FillMethod {   antisymmetric, symmetric9, symmetric21, general_isotropic,   symmetric_isotropic, symmetric_isotropic_E_nu, antisymmetric_isotropic, axisymmetric_rz,   general, principal }
	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

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...
template<typename T2 >
	RankFourTensorTempl (const RankFourTensorTempl< T2 > &copy)
	Copy constructor. More...
T &	operator() (unsigned int i, unsigned int j, unsigned int k, unsigned int l)
	Gets the value for the index specified. Takes index = 0,1,2. More...
T	operator() (unsigned int i, unsigned int j, unsigned int k, unsigned int l) const
	Gets the value for the index specified. More...
void	zero ()
	Zeros out the tensor. More...
void	print (std::ostream &stm=Moose::out) const
	Print the rank four tensor. More...
RankFourTensorTempl< T > &	operator= (const RankFourTensorTempl< T > &a)
	copies values from a into this tensor More...
template<typename Scalar >
boostcopy::enable_if_c< 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< 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< 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...
void	rotate (const TypeTensor< T > &R)
	Rotate the tensor using C_ijkl = R_im R_in 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...
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...
RankTwoTensorTempl< T >	innerProductTranspose (const RankTwoTensorTempl< T > &) const
	Inner product of the major transposed tensor with a rank two tensor. More...
T	sum3x3 () const
	Calculates the sum of Ciijj for i and j varying from 0 to 2. More...
VectorValue< T >	sum3x1 () const
	Calculates the vector a[i] = sum over j Ciijj for i and j varying from 0 to 2. More...
bool	isSymmetric () const
	checks if the tensor is symmetric More...
bool	isIsotropic () const
	checks if the tensor is isotropic More...
template<>
RankFourTensorTempl< DualReal >	invSymm () const
void	fillGeneralIsotropic (T i0, T i1, T i2)
	Vector-less fill API functions. See docs of the corresponding ...FromInputVector methods. More...
void	fillAntisymmetricIsotropic (T i0)
void	fillSymmetricIsotropic (T i0, T i1)
void	fillSymmetricIsotropicEandNu (T E, T nu)

Static Public Member Functions
static RankFourTensorTempl< T >	Identity ()
static RankFourTensorTempl< T >	IdentityFour ()
static MooseEnum	fillMethodEnum ()
	Static method for use in validParams for getting the "fill_method". More...

Protected Member Functions
void	fillSymmetricFromInputVector (const std::vector< T > &input, bool all)
	fillSymmetricFromInputVector takes either 21 (all=true) or 9 (all=false) inputs to fill in the Rank-4 tensor with the appropriate crystal symmetries maintained. More...
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...

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

Static Protected Attributes
static constexpr unsigned int	N = LIBMESH_DIM
	Dimensionality of rank-four tensor. 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

Friends
template<typename T2 >
class	RankTwoTensorTempl
template<typename T2 >
class	RankFourTensorTempl
class	RankThreeTensor
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.

It is designed to allow for maximum clarity of the mathematics and ease of use. Original class authors: A. M. Jokisaari, O. Heinonen, M.R. Tonks

Since N is hard-coded to 3, RankFourTensorTempl holds 81 separate C_ijkl entries. Within the code i = 0, 1, 2, but this object provides methods to extract the entries with i = 1, 2, 3, and some of the documentation is also written in this way.

Definition at line 80 of file MooseTypes.h.

Member Typedef Documentation

index_type

template<typename T>

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

Definition at line 68 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

Definition at line 84 of file RankFourTensor.h.

  {
    antisymmetric,
    symmetric9,
    symmetric21,
    general_isotropic,
    symmetric_isotropic,
    symmetric_isotropic_E_nu,
    antisymmetric_isotropic,
    axisymmetric_rz,
    general,
    principal
  };

InitMethod

template<typename T>

enum RankFourTensorTempl::InitMethod

Initialization method.

Enumerator
initNone
initIdentity
initIdentityFour
initIdentitySymmetricFour

Definition at line 71 of file RankFourTensor.h.

  {
    initNone,
    initIdentity,
    initIdentityFour,
    initIdentitySymmetricFour
  };

Constructor & Destructor Documentation

RankFourTensorTempl() [1/4]

template<typename T >

RankFourTensorTempl< T >::RankFourTensorTempl

(

)

Default constructor; fills to zero.

Definition at line 54 of file RankFourTensor.C.

{
  mooseAssert(N == 3, "RankFourTensorTempl<T> is currently only tested for 3 dimensions.");

  unsigned int index = 0;
  for (unsigned int i = 0; i < N4; ++i)
    _vals[index++] = 0.0;
}

RankFourTensorTempl() [2/4]

template<typename T >

RankFourTensorTempl< T >::RankFourTensorTempl

(

const InitMethod

init

)

Select specific initialization pattern.

Definition at line 64 of file RankFourTensor.C.

{
  unsigned int index = 0;
  switch (init)
  {
    case initNone:
      break;

    case initIdentity:
      zero();
      for (unsigned int i = 0; i < N; ++i)
        (*this)(i, i, i, i) = 1.0;
      break;

    case initIdentityFour:
      for (unsigned int i = 0; i < N; ++i)
        for (unsigned int j = 0; j < N; ++j)
          for (unsigned int k = 0; k < N; ++k)
            for (unsigned int l = 0; l < N; ++l)
              _vals[index++] = (i == k) && (j == l);
      break;

    case initIdentitySymmetricFour:
      for (unsigned int i = 0; i < N; ++i)
        for (unsigned int j = 0; j < N; ++j)
          for (unsigned int k = 0; k < N; ++k)
            for (unsigned int l = 0; l < N; ++l)
              _vals[index++] = 0.5 * ((i == k) && (j == l)) + 0.5 * ((i == l) && (j == k));
      break;

    default:
      mooseError("Unknown RankFourTensorTempl<T> initialization pattern.");
  }
}

RankFourTensorTempl() [3/4]

template<typename T>

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

Fill from vector.

Definition at line 100 of file RankFourTensor.C.

{
  fillFromInputVector(input, fill_method);
}

RankFourTensorTempl() [4/4]

template<typename T >

template<typename T2 >

RankFourTensorTempl< T >::RankFourTensorTempl

(

const RankFourTensorTempl< T2 > &

copy

)

Copy constructor.

Definition at line 428 of file RankFourTensor.h.

{
  for (unsigned int i = 0; i < N4; ++i)
    _vals[i] = copy._vals[i];
}

Member Function Documentation

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

input

this is B1212, B1213, B1223, B1313, B1323, B2323.

Definition at line 622 of file RankFourTensor.C.

{
  if (input.size() != 6)
    mooseError(
        "To use fillAntisymmetricFromInputVector, your input must have size 6.  Yours has size ",
        input.size());

  zero();

  (*this)(0, 1, 0, 1) = input[0]; // B1212
  (*this)(0, 1, 0, 2) = input[1]; // B1213
  (*this)(0, 1, 1, 2) = input[2]; // B1223

  (*this)(0, 2, 0, 2) = input[3]; // B1313
  (*this)(0, 2, 1, 2) = input[4]; // B1323

  (*this)(1, 2, 1, 2) = input[5]; // B2323

  // symmetry on the two pairs
  (*this)(0, 2, 0, 1) = (*this)(0, 1, 0, 2);
  (*this)(1, 2, 0, 1) = (*this)(0, 1, 1, 2);
  (*this)(1, 2, 0, 2) = (*this)(0, 2, 1, 2);
  // have now got the upper parts of vals[0][1], vals[0][2] and vals[1][2]

  // fill in from antisymmetry relations
  for (unsigned int i = 0; i < N; ++i)
    for (unsigned int j = 0; j < N; ++j)
    {
      (*this)(0, 1, j, i) = -(*this)(0, 1, i, j);
      (*this)(0, 2, j, i) = -(*this)(0, 2, i, j);
      (*this)(1, 2, j, i) = -(*this)(1, 2, i, j);
    }
  // have now got all of vals[0][1], vals[0][2] and vals[1][2]

  // fill in from antisymmetry relations
  for (unsigned int i = 0; i < N; ++i)
    for (unsigned int j = 0; j < N; ++j)
    {
      (*this)(1, 0, i, j) = -(*this)(0, 1, i, j);
      (*this)(2, 0, i, j) = -(*this)(0, 2, i, j);
      (*this)(2, 1, i, j) = -(*this)(1, 2, i, j);
    }
}

fillAntisymmetricIsotropic()

template<typename T>

void RankFourTensorTempl< T >::fillAntisymmetricIsotropic

(

T

i0

)

Definition at line 708 of file RankFourTensor.C.

{
  fillGeneralIsotropic(0.0, 0.0, i0);
}

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

input

this is a in the above formula

Definition at line 697 of file RankFourTensor.C.

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

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

input

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

Definition at line 757 of file RankFourTensor.C.

{
  if (input.size() != 5)
    mooseError("To use fillAxisymmetricRZFromInputVector, your input must have size 5.  Your "
               "vector has size ",
               input.size());

  // C1111     C1122     C1133     C2222     C2233=C1133
  fillSymmetricFromInputVector({input[0],
                                input[1],
                                input[2],
                                input[0],
                                input[2],
                                // C3333     C2323     C3131=C2323   C1212
                                input[3],
                                input[4],
                                input[4],
                                (input[0] - input[1]) * 0.5},
                               false);
}

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

input

the numbers that will be placed in the tensor

fill_method

this can be: antisymmetric (use fillAntisymmetricFromInputVector) symmetric9 (use fillSymmetricFromInputVector with all=false) symmetric21 (use fillSymmetricFromInputVector with all=true) 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 519 of file RankFourTensor.C.

{
  zero();

  switch (fill_method)
  {
    case antisymmetric:
      fillAntisymmetricFromInputVector(input);
      break;
    case symmetric9:
      fillSymmetricFromInputVector(input, false);
      break;
    case symmetric21:
      fillSymmetricFromInputVector(input, true);
      break;
    case general_isotropic:
      fillGeneralIsotropicFromInputVector(input);
      break;
    case symmetric_isotropic:
      fillSymmetricIsotropicFromInputVector(input);
      break;
    case symmetric_isotropic_E_nu:
      fillSymmetricIsotropicEandNuFromInputVector(input);
      break;
    case antisymmetric_isotropic:
      fillAntisymmetricIsotropicFromInputVector(input);
      break;
    case axisymmetric_rz:
      fillAxisymmetricRZFromInputVector(input);
      break;
    case general:
      fillGeneralFromInputVector(input);
      break;
    case principal:
      fillPrincipalFromInputVector(input);
      break;
    default:
      mooseError("fillFromInputVector called with unknown fill_method of ", fill_method);
  }
}

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

input

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

Definition at line 780 of file RankFourTensor.C.

{
  if (input.size() != 81)
    mooseError("To use fillGeneralFromInputVector, your input must have size 81. Yours has size ",
               input.size());

  for (unsigned int i = 0; i < N4; ++i)
    _vals[i] = input[i];
}

fillGeneralIsotropic()

template<typename T>

void RankFourTensorTempl< T >::fillGeneralIsotropic	(	T	i0,
		T	i1,
		T	i2
	)

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

Definition at line 680 of file RankFourTensor.C.

{
  for (unsigned int i = 0; i < N; ++i)
    for (unsigned int j = 0; j < N; ++j)
      for (unsigned int k = 0; k < N; ++k)
        for (unsigned int l = 0; l < N; ++l)
        {
          (*this)(i, j, k, l) =
              i0 * (i == j) * (k == l) + i1 * (i == k) * (j == l) + i1 * (i == l) * (j == k);
          for (unsigned int m = 0; m < N; ++m)
            (*this)(i, j, k, l) +=
                i2 * PermutationTensor::eps(i, j, m) * PermutationTensor::eps(k, l, m);
        }
}

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

input

this is la, mu, a in the above formula

Definition at line 668 of file RankFourTensor.C.

{
  if (input.size() != 3)
    mooseError(
        "To use fillGeneralIsotropicFromInputVector, your input must have size 3.  Yours has size ",
        input.size());

  fillGeneralIsotropic(input[0], input[1], input[2]);
}

fillMethodEnum()

template<typename T >

MooseEnum RankFourTensorTempl< T >::fillMethodEnum ( )

static

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

Definition at line 46 of file RankFourTensor.C.

{
  return MooseEnum("antisymmetric symmetric9 symmetric21 general_isotropic symmetric_isotropic "
                   "symmetric_isotropic_E_nu antisymmetric_isotropic axisymmetric_rz general "
                   "principal");
}

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 792 of file RankFourTensor.C.

{
  if (input.size() != 9)
    mooseError("To use fillPrincipalFromInputVector, your input must have size 9. Yours has size ",
               input.size());

  zero();

  (*this)(0, 0, 0, 0) = input[0];
  (*this)(0, 0, 1, 1) = input[1];
  (*this)(0, 0, 2, 2) = input[2];
  (*this)(1, 1, 0, 0) = input[3];
  (*this)(1, 1, 1, 1) = input[4];
  (*this)(1, 1, 2, 2) = input[5];
  (*this)(2, 2, 0, 0) = input[6];
  (*this)(2, 2, 1, 1) = input[7];
  (*this)(2, 2, 2, 2) = input[8];
}

fillSymmetricFromInputVector()

template<typename T>

void RankFourTensorTempl< T >::fillSymmetricFromInputVector ( const std::vector< T > &  input, bool  all  )

protected

fillSymmetricFromInputVector takes either 21 (all=true) or 9 (all=false) inputs to fill in the Rank-4 tensor with the appropriate crystal symmetries maintained.

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

Parameters

input	If all==true then this is C1111 C1122 C1133 C2222 C2233 C3333 C2323 C1313 C1212 In the isotropic case this is (la is first Lame constant, mu is second (shear) Lame constant) la+2mu la la la+2mu la la+2mu mu mu mu If all==false then this is C1111 C1122 C1133 C1123 C1113 C1112 C2222 C2233 C2223 C2213 C2212 C3333 C3323 C3313 C3312 C2323 C2313 C2312 C1313 C1312 C1212
all	Determines the compoinents passed in vis the input parameter

Definition at line 562 of file RankFourTensor.C.

{
  if ((all == true && input.size() != 21) || (all == false && input.size() != 9))
    mooseError("Please check the number of entries in the stiffness input vector.");

  zero();

  if (all == true)
  {
    (*this)(0, 0, 0, 0) = input[0]; // C1111
    (*this)(0, 0, 1, 1) = input[1]; // C1122
    (*this)(0, 0, 2, 2) = input[2]; // C1133
    (*this)(0, 0, 1, 2) = input[3]; // C1123
    (*this)(0, 0, 0, 2) = input[4]; // C1113
    (*this)(0, 0, 0, 1) = input[5]; // C1112

    (*this)(1, 1, 1, 1) = input[6];  // C2222
    (*this)(1, 1, 2, 2) = input[7];  // C2233
    (*this)(1, 1, 1, 2) = input[8];  // C2223
    (*this)(0, 2, 1, 1) = input[9];  // C2213  //flipped for filling purposes
    (*this)(0, 1, 1, 1) = input[10]; // C2212 //flipped for filling purposes

    (*this)(2, 2, 2, 2) = input[11]; // C3333
    (*this)(1, 2, 2, 2) = input[12]; // C3323 //flipped for filling purposes
    (*this)(0, 2, 2, 2) = input[13]; // C3313 //flipped for filling purposes
    (*this)(0, 1, 2, 2) = input[14]; // C3312 //flipped for filling purposes

    (*this)(1, 2, 1, 2) = input[15]; // C2323
    (*this)(0, 2, 1, 2) = input[16]; // C2313 //flipped for filling purposes
    (*this)(0, 1, 1, 2) = input[17]; // C2312 //flipped for filling purposes

    (*this)(0, 2, 0, 2) = input[18]; // C1313
    (*this)(0, 1, 0, 2) = input[19]; // C1312 //flipped for filling purposes

    (*this)(0, 1, 0, 1) = input[20]; // C1212
  }
  else
  {
    (*this)(0, 0, 0, 0) = input[0]; // C1111
    (*this)(0, 0, 1, 1) = input[1]; // C1122
    (*this)(0, 0, 2, 2) = input[2]; // C1133
    (*this)(1, 1, 1, 1) = input[3]; // C2222
    (*this)(1, 1, 2, 2) = input[4]; // C2233
    (*this)(2, 2, 2, 2) = input[5]; // C3333
    (*this)(1, 2, 1, 2) = input[6]; // C2323
    (*this)(0, 2, 0, 2) = input[7]; // C1313
    (*this)(0, 1, 0, 1) = input[8]; // C1212
  }

  // fill in from symmetry relations
  for (unsigned int i = 0; i < N; ++i)
    for (unsigned int j = 0; j < N; ++j)
      for (unsigned int k = 0; k < N; ++k)
        for (unsigned int l = 0; l < N; ++l)
          (*this)(i, j, l, k) = (*this)(j, i, k, l) = (*this)(j, i, l, k) = (*this)(k, l, i, j) =
              (*this)(l, k, j, i) = (*this)(k, l, j, i) = (*this)(l, k, i, j) = (*this)(i, j, k, l);
}

fillSymmetricIsotropic()

template<typename T>

void RankFourTensorTempl< T >::fillSymmetricIsotropic	(	T	i0,
		T	i1
	)

Definition at line 726 of file RankFourTensor.C.

{
  fillGeneralIsotropic(i0, i1, 0.0);
}

fillSymmetricIsotropicEandNu()

template<typename T>

void RankFourTensorTempl< T >::fillSymmetricIsotropicEandNu	(	T	E,
		T	nu
	)

Definition at line 746 of file RankFourTensor.C.

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

  fillGeneralIsotropic(lambda, G, 0.0);
}

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

input

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

Definition at line 733 of file RankFourTensor.C.

{
  if (input.size() != 2)
    mooseError(
        "To use fillSymmetricIsotropicEandNuFromInputVector, your input must have size 2. Yours "
        "has size ",
        input.size());

  fillSymmetricIsotropicEandNu(input[0], input[1]);
}

fillSymmetricIsotropicFromInputVector()

template<typename T>

void 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

input

this is lambda and mu in the above formula

Definition at line 715 of file RankFourTensor.C.

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

Identity()

template<typename T>

static RankFourTensorTempl<T> RankFourTensorTempl< T >::Identity ( )

inlinestatic

Definition at line 135 of file RankFourTensor.h.

{ return RankFourTensorTempl<T>(initIdentity); }

IdentityFour()

template<typename T>

static RankFourTensorTempl<T> RankFourTensorTempl< T >::IdentityFour ( )

inlinestatic

Definition at line 136 of file RankFourTensor.h.

{ return RankFourTensorTempl<T>(initIdentityFour); };

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 813 of file RankFourTensor.C.

{
  RankTwoTensorTempl<T> result;

  unsigned int index = 0;
  for (unsigned int ij = 0; ij < N2; ++ij)
  {
    T bb = b._coords[ij];
    for (unsigned int kl = 0; kl < N2; ++kl)
      result._coords[kl] += _vals[index++] * bb;
  }

  return result;
}

invSymm() [1/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 262 of file RankFourTensor.C.

{
  unsigned int ntens = N * (N + 1) / 2;
  int nskip = N - 1;

  RankFourTensorTempl<T> result;
  std::vector<PetscScalar> mat;
  mat.assign(ntens * ntens, 0);

  // We use the LAPACK matrix inversion routine here.  Form the matrix
  //
  // mat[0]  mat[1]  mat[2]  mat[3]  mat[4]  mat[5]
  // mat[6]  mat[7]  mat[8]  mat[9]  mat[10] mat[11]
  // mat[12] mat[13] mat[14] mat[15] mat[16] mat[17]
  // mat[18] mat[19] mat[20] mat[21] mat[22] mat[23]
  // mat[24] mat[25] mat[26] mat[27] mat[28] mat[29]
  // mat[30] mat[31] mat[32] mat[33] mat[34] mat[35]
  //
  // This is filled from the indpendent components of C assuming
  // the symmetry C_ijkl = C_ijlk = C_jikl.
  //
  // If there are two rank-four tensors X and Y then the reason for
  // this filling becomes apparent if we want to calculate
  // X_ijkl*Y_klmn = Z_ijmn
  // For denote the "mat" versions of X, Y and Z by x, y and z.
  // Then
  // z_ab = x_ac*y_cb
  // Eg
  // z_00 = Z_0000 = X_0000*Y_0000 + X_0011*Y_1111 + X_0022*Y_2200 + 2*X_0001*Y_0100 +
  // 2*X_0002*Y_0200 + 2*X_0012*Y_1200   (the factors of 2 come from the assumed symmetries)
  // 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 +
  // 2*X_0002*2*Y_0201 + 2*X_0012*2*Y_1201
  // 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 +
  // 2*X_0102*2*Y_0202 + 2*X_0112*2*Y_1202
  // Finally, we use LAPACK to find x^-1, and put it back into rank-4 tensor form
  //
  // mat[0] = C(0,0,0,0)
  // mat[1] = C(0,0,1,1)
  // mat[2] = C(0,0,2,2)
  // mat[3] = C(0,0,0,1)*2
  // mat[4] = C(0,0,0,2)*2
  // mat[5] = C(0,0,1,2)*2

  // mat[6] = C(1,1,0,0)
  // mat[7] = C(1,1,1,1)
  // mat[8] = C(1,1,2,2)
  // mat[9] = C(1,1,0,1)*2
  // mat[10] = C(1,1,0,2)*2
  // mat[11] = C(1,1,1,2)*2

  // mat[12] = C(2,2,0,0)
  // mat[13] = C(2,2,1,1)
  // mat[14] = C(2,2,2,2)
  // mat[15] = C(2,2,0,1)*2
  // mat[16] = C(2,2,0,2)*2
  // mat[17] = C(2,2,1,2)*2

  // mat[18] = C(0,1,0,0)
  // mat[19] = C(0,1,1,1)
  // mat[20] = C(0,1,2,2)
  // mat[21] = C(0,1,0,1)*2
  // mat[22] = C(0,1,0,2)*2
  // mat[23] = C(0,1,1,2)*2

  // mat[24] = C(0,2,0,0)
  // mat[25] = C(0,2,1,1)
  // mat[26] = C(0,2,2,2)
  // mat[27] = C(0,2,0,1)*2
  // mat[28] = C(0,2,0,2)*2
  // mat[29] = C(0,2,1,2)*2

  // mat[30] = C(1,2,0,0)
  // mat[31] = C(1,2,1,1)
  // mat[32] = C(1,2,2,2)
  // mat[33] = C(1,2,0,1)*2
  // mat[34] = C(1,2,0,2)*2
  // mat[35] = C(1,2,1,2)*2

  unsigned int index = 0;
  for (unsigned int i = 0; i < N; ++i)
    for (unsigned int j = 0; j < N; ++j)
      for (unsigned int k = 0; k < N; ++k)
        for (unsigned int l = 0; l < N; ++l)
        {
          if (i == j)
            mat[k == l ? i * ntens + k : i * ntens + k + nskip + l] += _vals[index];
          else // i!=j
            mat[k == l ? (nskip + i + j) * ntens + k : (nskip + i + j) * ntens + k + nskip + l] +=
                _vals[index]; // note the +=, which results in double-counting and is rectified
                              // below
          index++;
        }

  for (unsigned int i = 3; i < ntens; ++i)
    for (unsigned int j = 0; j < ntens; ++j)
      mat[i * ntens + j] /= 2.0; // because of double-counting above

  // use LAPACK to find the inverse
  MatrixTools::inverse(mat, ntens);

  // build the resulting rank-four tensor
  // using the inverse of the above algorithm
  index = 0;
  for (unsigned int i = 0; i < N; ++i)
    for (unsigned int j = 0; j < N; ++j)
      for (unsigned int k = 0; k < N; ++k)
        for (unsigned int l = 0; l < N; ++l)
        {
          if (i == j)
            result._vals[index] =
                k == l ? mat[i * ntens + k] : mat[i * ntens + k + nskip + l] / 2.0;
          else // i!=j
            result._vals[index] = k == l ? mat[(nskip + i + j) * ntens + k]
                                         : mat[(nskip + i + j) * ntens + k + nskip + l] / 2.0;
          index++;
        }

  return result;
}

invSymm() [2/2]

template<>

RankFourTensorTempl< DualReal > RankFourTensorTempl< DualReal >::invSymm

(

)

const

Definition at line 384 of file RankFourTensor.C.

{
  mooseError("The invSymm operation calls to LAPACK, so AD is not supported.");
  return {};
}

isIsotropic()

template<typename T >

bool RankFourTensorTempl< T >::isIsotropic

(

)

const

checks if the tensor is isotropic

Definition at line 873 of file RankFourTensor.C.

{
  // prerequisite is symmetry
  if (!isSymmetric())
    return false;

  // inspect shear components
  const T & mu = (*this)(0, 1, 0, 1);
  // ...diagonal
  if ((*this)(1, 2, 1, 2) != mu || (*this)(2, 0, 2, 0) != mu)
    return false;
  // ...off-diagonal
  if ((*this)(2, 0, 1, 2) != 0.0 || (*this)(0, 1, 1, 2) != 0.0 || (*this)(0, 1, 2, 0) != 0.0)
    return false;

  // off diagonal blocks in Voigt
  unsigned int i1 = 0;
  for (unsigned int i = 0; i < N; ++i)
  {
    for (unsigned int j = 0; j < N; ++j)
      if (_vals[i1 + ((j + 1) % N) * N + (j + 2) % N] != 0.0)
        return false;
    i1 += N3 + N2;
  }

  // top left block
  const T & K1 = (*this)(0, 0, 0, 0);
  const T & K2 = (*this)(0, 0, 1, 1);
  if (!MooseUtils::relativeFuzzyEqual(K1 - 4.0 * mu / 3.0, K2 + 2.0 * mu / 3.0))
    return false;
  if ((*this)(1, 1, 1, 1) != K1 || (*this)(2, 2, 2, 2) != K1)
    return false;
  for (unsigned int i = 1; i < N; ++i)
    for (unsigned int j = 0; j < i; ++j)
      if ((*this)(i, i, j, j) != K2)
        return false;

  return true;
}

isSymmetric()

template<typename T >

bool RankFourTensorTempl< T >::isSymmetric

(

)

const

checks if the tensor is symmetric

Definition at line 852 of file RankFourTensor.C.

{
  for (unsigned int i = 1; i < N; ++i)
    for (unsigned int j = 0; j < i; ++j)
      for (unsigned int k = 1; k < N; ++k)
        for (unsigned int l = 0; l < k; ++l)
        {
          // minor symmetries
          if ((*this)(i, j, k, l) != (*this)(j, i, k, l) ||
              (*this)(i, j, k, l) != (*this)(i, j, l, k))
            return false;

          // major symmetry
          if ((*this)(i, j, k, l) != (*this)(k, l, i, j))
            return false;
        }
  return true;
}

L2norm()

template<typename T >

T RankFourTensorTempl< T >::L2norm

(

)

const

sqrt(C_ijkl*C_ijkl)

Definition at line 250 of file RankFourTensor.C.

{
  T l2 = 0;

  for (unsigned int i = 0; i < N4; ++i)
    l2 += Utility::pow<2>(_vals[i]);

  return std::sqrt(l2);
}

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 index specified. Takes index = 0,1,2.

Definition at line 139 of file RankFourTensor.h.

  {
    return _vals[((i * LIBMESH_DIM + j) * LIBMESH_DIM + k) * LIBMESH_DIM + l];
  }

operator()() [2/2]

template<typename T>

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

inline

Gets the value for the index specified.

Takes index = 0,1,2 used for const

Definition at line 148 of file RankFourTensor.h.

  {
    return _vals[((i * LIBMESH_DIM + j) * LIBMESH_DIM + k) * LIBMESH_DIM + l];
  }

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 124 of file RankFourTensor.C.

{
  typedef decltype(T() * T2()) ValueType;
  RankTwoTensorTempl<ValueType> result;

  unsigned int index = 0;
  for (unsigned int ij = 0; ij < N2; ++ij)
  {
    ValueType tmp = 0;
    for (unsigned int kl = 0; kl < N2; ++kl)
      tmp += _vals[index++] * b(kl / LIBMESH_DIM, kl % LIBMESH_DIM);
    result._coords[ij] = tmp;
  }

  return result;
}

operator*() [2/3]

template<typename T>

template<typename T2>

auto RankFourTensorTempl< T >::operator*

(

const T2 &

a

)

const -> typename std::enable_if<ScalarTraits<T2>::value, RankFourTensorTempl<decltype(T() * T2())>>::type

C_ijkl*a.

Definition at line 436 of file RankFourTensor.h.

{
  typedef decltype(T() * T2()) ValueType;
  RankFourTensorTempl<ValueType> result;

  for (unsigned int i = 0; i < N4; ++i)
    result._vals[i] = _vals[i] * b;

  return result;
}

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 215 of file RankFourTensor.C.

{
  typedef decltype(T() * T2()) ValueType;
  RankFourTensorTempl<ValueType> result;

  unsigned int index = 0;
  unsigned int ij1 = 0;
  for (unsigned int i = 0; i < N; ++i)
  {
    for (unsigned int j = 0; j < N; ++j)
    {
      for (unsigned int k = 0; k < N; ++k)
      {
        for (unsigned int l = 0; l < N; ++l)
        {
          ValueType sum = 0;
          for (unsigned int p = 0; p < N; ++p)
          {
            unsigned int p1 = N * p;
            for (unsigned int q = 0; q < N; ++q)
              sum += _vals[ij1 + p1 + q] * b(p, q, k, l);
          }
          result._vals[index++] = sum;
        }
      }
      ij1 += N2;
    }
  }

  return result;
}

operator*=()

template<typename T>

RankFourTensorTempl< T > & RankFourTensorTempl< T >::operator*=

(

const T &

a

)

C_ijkl *= a.

Definition at line 145 of file RankFourTensor.C.

{
  for (unsigned int i = 0; i < N4; ++i)
    _vals[i] *= a;
  return *this;
}

operator+()

template<typename T>

template<typename T2 >

template RankFourTensorTempl< DualReal > RankFourTensorTempl< T >::operator+

(

const RankFourTensorTempl< T2 > &

a

)

const -> RankFourTensorTempl< decltype(T()+T2())>

C_ijkl + a_ijkl.

Definition at line 173 of file RankFourTensor.C.

{
  RankFourTensorTempl<decltype(T() + T2())> result;
  for (unsigned int i = 0; i < N4; ++i)
    result._vals[i] = _vals[i] + b._vals[i];
  return result;
}

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 163 of file RankFourTensor.C.

{
  for (unsigned int i = 0; i < N4; ++i)
    _vals[i] += a._vals[i];
  return *this;
}

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 194 of file RankFourTensor.C.

{
  RankFourTensorTempl<decltype(T() - T2())> result;
  for (unsigned int i = 0; i < N4; ++i)
    result._vals[i] = _vals[i] - b._vals[i];
  return result;
}

operator-() [2/2]

template<typename T >

RankFourTensorTempl< T > RankFourTensorTempl< T >::operator-

(

)

const

-C_ijkl

Definition at line 205 of file RankFourTensor.C.

{
  RankFourTensorTempl<T> result;
  for (unsigned int i = 0; i < N4; ++i)
    result._vals[i] = -_vals[i];
  return result;
}

operator-=()

template<typename T>

RankFourTensorTempl< T > & RankFourTensorTempl< T >::operator-=

(

const RankFourTensorTempl< T > &

a

)

C_ijkl -= a_ijkl.

Definition at line 184 of file RankFourTensor.C.

{
  for (unsigned int i = 0; i < N4; ++i)
    _vals[i] -= a._vals[i];
  return *this;
}

operator/()

template<typename T>

template<typename T2 >

auto RankFourTensorTempl< T >::operator/

(

const T2 &

a

)

const -> typename std::enable_if<ScalarTraits<T2>::value, RankFourTensorTempl<decltype(T() / T2())>>::type

C_ijkl/a.

Definition at line 452 of file RankFourTensor.h.

{
  RankFourTensorTempl<decltype(T() / T2())> result;
  for (unsigned int i = 0; i < N4; ++i)
    result._vals[i] = _vals[i] / b;
  return result;
}

operator/=()

template<typename T>

RankFourTensorTempl< T > & RankFourTensorTempl< T >::operator/=

(

const T &

a

)

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

Definition at line 154 of file RankFourTensor.C.

{
  for (unsigned int i = 0; i < N4; ++i)
    _vals[i] /= a;
  return *this;
}

operator=() [1/2]

template<typename T>

RankFourTensorTempl< T > & RankFourTensorTempl< T >::operator=

(

const RankFourTensorTempl< T > &

a

)

copies values from a into this tensor

Definition at line 115 of file RankFourTensor.C.

{
  for (unsigned int i = 0; i < N4; ++i)
    _vals[i] = a._vals[i];
  return *this;
}

operator=() [2/2]

template<typename T>

template<typename Scalar >

boostcopy::enable_if_c<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 169 of file RankFourTensor.h.

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

print()

template<typename T >

void RankFourTensorTempl< T >::print

(

std::ostream &

stm = Moose::out

)

const

Print the rank four tensor.

Definition at line 430 of file RankFourTensor.C.

{
  for (unsigned int i = 0; i < N; ++i)
    for (unsigned int j = 0; j < N; ++j)
    {
      stm << "i = " << i << " j = " << j << '\n';
      for (unsigned int k = 0; k < N; ++k)
      {
        for (unsigned int l = 0; l < N; ++l)
          stm << std::setw(15) << (*this)(i, j, k, l) << " ";

        stm << '\n';
      }
    }
}

rotate()

template<typename T>

void RankFourTensorTempl< T >::rotate

(

const TypeTensor< T > &

R

)

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

Definition at line 392 of file RankFourTensor.C.

{
  RankFourTensorTempl<T> old = *this;

  unsigned int index = 0;
  for (unsigned int i = 0; i < N; ++i)
  {
    for (unsigned int j = 0; j < N; ++j)
    {
      for (unsigned int k = 0; k < N; ++k)
      {
        for (unsigned int l = 0; l < N; ++l)
        {
          unsigned int index2 = 0;
          T sum = 0.0;
          for (unsigned int m = 0; m < N; ++m)
          {
            const T & a = R(i, m);
            for (unsigned int n = 0; n < N; ++n)
            {
              const T & ab = a * R(j, n);
              for (unsigned int o = 0; o < N; ++o)
              {
                const T & abc = ab * R(k, o);
                for (unsigned int p = 0; p < N; ++p)
                  sum += abc * R(l, p) * old._vals[index2++];
              }
            }
          }
          _vals[index++] = sum;
        }
      }
    }
  }
}

sum3x1()

template<typename T >

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 840 of file RankFourTensor.C.

{
  // used for volumetric locking correction
  VectorValue<T> a(3);
  a(0) = (*this)(0, 0, 0, 0) + (*this)(0, 0, 1, 1) + (*this)(0, 0, 2, 2); // C0000 + C0011 + C0022
  a(1) = (*this)(1, 1, 0, 0) + (*this)(1, 1, 1, 1) + (*this)(1, 1, 2, 2); // C1100 + C1111 + C1122
  a(2) = (*this)(2, 2, 0, 0) + (*this)(2, 2, 1, 1) + (*this)(2, 2, 2, 2); // C2200 + C2211 + C2222
  return a;
}

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 830 of file RankFourTensor.C.

{
  // summation of Ciijj for i and j ranging from 0 to 2 - used in the volumetric locking correction
  return (*this)(0, 0, 0, 0) + (*this)(0, 0, 1, 1) + (*this)(0, 0, 2, 2) + (*this)(1, 1, 0, 0) +
         (*this)(1, 1, 1, 1) + (*this)(1, 1, 2, 2) + (*this)(2, 2, 0, 0) + (*this)(2, 2, 1, 1) +
         (*this)(2, 2, 2, 2);
}

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 473 of file RankFourTensor.C.

{
  zero();

  if (input.size() == 9)
  {
    // then fill from vector C_1111, C_1112, C_1122, C_1212, C_1222, C_1211, C_2211, C_2212, C_2222
    (*this)(0, 0, 0, 0) = input[0];
    (*this)(0, 0, 0, 1) = input[1];
    (*this)(0, 0, 1, 1) = input[2];
    (*this)(0, 1, 0, 1) = input[3];
    (*this)(0, 1, 1, 1) = input[4];
    (*this)(0, 1, 0, 0) = input[5];
    (*this)(1, 1, 0, 0) = input[6];
    (*this)(1, 1, 0, 1) = input[7];
    (*this)(1, 1, 1, 1) = input[8];

    // fill in remainders from C_ijkl = C_ijlk = C_jikl
    (*this)(0, 0, 1, 0) = (*this)(0, 0, 0, 1);
    (*this)(0, 1, 1, 0) = (*this)(0, 1, 0, 1);
    (*this)(1, 0, 0, 0) = (*this)(0, 1, 0, 0);
    (*this)(1, 0, 0, 1) = (*this)(0, 1, 0, 1);
    (*this)(1, 0, 1, 1) = (*this)(0, 1, 1, 1);
    (*this)(1, 0, 0, 0) = (*this)(0, 1, 0, 0);
    (*this)(1, 1, 1, 0) = (*this)(1, 1, 0, 1);
  }
  else if (input.size() == 2)
  {
    // only two independent constants, C_1111 and C_1122
    (*this)(0, 0, 0, 0) = input[0];
    (*this)(0, 0, 1, 1) = input[1];
    // use symmetries
    (*this)(1, 1, 1, 1) = (*this)(0, 0, 0, 0);
    (*this)(1, 1, 0, 0) = (*this)(0, 0, 1, 1);
    (*this)(0, 1, 0, 1) = 0.5 * ((*this)(0, 0, 0, 0) - (*this)(0, 0, 1, 1));
    (*this)(1, 0, 0, 1) = (*this)(0, 1, 0, 1);
    (*this)(0, 1, 1, 0) = (*this)(0, 1, 0, 1);
    (*this)(1, 0, 1, 0) = (*this)(0, 1, 0, 1);
  }
  else
    mooseError("Please provide correct number of inputs for surface RankFourTensorTempl<T> "
               "initialization.");
}

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 448 of file RankFourTensor.C.

{
  RankFourTensorTempl<T> result;

  unsigned int index = 0;
  unsigned int i1 = 0;
  for (unsigned int i = 0; i < N; ++i)
  {
    for (unsigned int j = 0; j < N; ++j)
    {
      for (unsigned int k = 0; k < N; ++k)
      {
        unsigned int ijk1 = k * N3 + i1 + j;
        for (unsigned int l = 0; l < N; ++l)
          result._vals[index++] = _vals[ijk1 + l * N2];
      }
    }
    i1 += N;
  }

  return result;
}

zero()

template<typename T >

void RankFourTensorTempl< T >::zero

(

)

Zeros out the tensor.

Definition at line 107 of file RankFourTensor.C.

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

{
  for (unsigned int i = 0; i < N4; ++i)
    _vals[i] = 0.0;
}

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

RankFourTensorTempl

template<typename T>

template<typename T2 >

friend class RankFourTensorTempl

friend

Definition at line 414 of file RankFourTensor.h.

RankThreeTensor

template<typename T>

friend class RankThreeTensor

friend

Definition at line 415 of file RankFourTensor.h.

RankTwoTensorTempl

template<typename T>

template<typename T2 >

friend class RankTwoTensorTempl

friend

Definition at line 412 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 310 of file RankFourTensor.h.

Referenced by RankTwoTensorTempl< Real >::d2secondInvariant(), RankTwoTensorTempl< Real >::d2thirdInvariant(), dataLoad(), dataStore(), RankTwoTensorTempl< Real >::initialContraction(), RankFourTensorTempl< Real >::invSymm(), RankTwoTensorTempl< Real >::mixedProductIkJl(), RankTwoTensorTempl< Real >::mixedProductJkIl(), RankThreeTensor::mixedProductRankFour(), RankFourTensorTempl< Real >::operator()(), RankFourTensorTempl< Real >::operator*(), RankFourTensorTempl< Real >::operator+(), RankFourTensorTempl< Real >::operator+=(), RankFourTensorTempl< Real >::operator-(), RankFourTensorTempl< Real >::operator-=(), RankFourTensorTempl< Real >::operator/(), RankFourTensorTempl< Real >::operator=(), RankTwoTensorTempl< Real >::outerProduct(), RankFourTensorTempl< Real >::RankFourTensorTempl(), RankFourTensorTempl< Real >::rotate(), and RankFourTensorTempl< Real >::transposeMajor().

N

template<typename T>

constexpr unsigned int RankFourTensorTempl< T >::N = LIBMESH_DIM

staticprotected

Dimensionality of rank-four tensor.

Definition at line 303 of file RankFourTensor.h.

N2

template<typename T>

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

staticprotected

Definition at line 304 of file RankFourTensor.h.

N3

template<typename T>

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

staticprotected

Definition at line 305 of file RankFourTensor.h.

N4

template<typename T>

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

staticprotected

Definition at line 306 of file RankFourTensor.h.

---

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

• include/utils/MooseTypes.h
• include/utils/RankFourTensor.h
• src/utils/RankFourTensor.C