RankTwoTensorTempl is designed to handle the Stress or Strain Tensor for a fully anisotropic material. More...

#include <RankTwoTensor.h>

Inheritance diagram for RankTwoTensorTempl< T >:

Public Types
typedef T	value_type

typedef std::tuple< unsigned int, unsigned int >	index_type

Public Member Functions
void	assign (const TypeTensor< T2 > &)

const T &	operator() (const unsigned int i, const unsigned int j) const

T &	operator() (const unsigned int i, const unsigned int j)

ConstTypeTensorColumn< T >	slice (const unsigned int i) const

TypeTensorColumn< T >	slice (const unsigned int i)

TypeVector< T >	row (const unsigned int r) const

const TypeTensor< T > &	operator+= (const TypeTensor< T2 > &)

void	add (const TypeTensor< T2 > &)

void	add_scaled (const TypeTensor< T2 > &, const T &)

const TypeTensor< T > &	operator-= (const TypeTensor< T2 > &)

void	subtract (const TypeTensor< T2 > &)

void	subtract_scaled (const TypeTensor< T2 > &, const T &)

auto	operator* (const Scalar &scalar) const -> typename std::enable_if< ScalarTraits< Scalar >::value, TypeTensor< decltype(T() *scalar)> >::type

const TypeTensor< T > &	operator*= (const Scalar &factor)

const TypeTensor< T > &	operator*= (const TypeTensor< T2 > &)

std::enable_if< ScalarTraits< Scalar >::value, TypeTensor< typenameCompareTypes< T, Scalar >::supertype > >::type	operator/ (const Scalar &) const

CompareTypes< T, T2 >::supertype	contract (const TypeTensor< T2 > &) const

TypeVector< typename CompareTypes< T, T2 >::supertype >	left_multiply (const TypeVector< T2 > &p) const

void	solve (const TypeVector< T > &b, TypeVector< T > &x) const

auto	norm () const

auto	norm_sq () const

bool	is_zero () const

T	det () const

T	tr () const

void	zero ()

bool	operator== (const TypeTensor< T > &rhs) const

bool	operator< (const TypeTensor< T > &rhs) const

bool	operator< (const TypeTensor< Real > &rhs) const

bool	operator< (const TypeTensor< Complex > &rhs) const

bool	operator> (const TypeTensor< T > &rhs) const

bool	operator> (const TypeTensor< Real > &rhs) const

bool	operator> (const TypeTensor< Complex > &rhs) const

void	write_unformatted (std::ostream &out_stream, const bool newline=true) const

bool	is_hpd (Real rel_tol=TOLERANCE *TOLERANCE) const


	RankTwoTensorTempl (const InitMethod)
	Select specific initialization pattern.

	RankTwoTensorTempl (const libMesh::TypeVector< T > &row1, const libMesh::TypeVector< T > &row2, const libMesh::TypeVector< T > &row3)
	Initialize from row vectors.

	RankTwoTensorTempl (const std::vector< T > &input)
	Constructor that proxies the fillFromInputVector() method.

	RankTwoTensorTempl (const T &S11, const T &S22, const T &S33, const T &S23, const T &S13, const T &S12)
	Initialize a symmetric second order tensor using the 6 arguments.

	RankTwoTensorTempl (const T &S11, const T &S21, const T &S31, const T &S12, const T &S22, const T &S32, const T &S13, const T &S23, const T &S33)
	Initialize a second order tensor using the 9 arguments in a column-major fashion.

	RankTwoTensorTempl (const RankTwoTensorTempl< T > &a)=default
	The copy constructor.

	RankTwoTensorTempl (const libMesh::TensorValue< T > &a)
	The conversion operator from a `libMesh::TensorValue`

	RankTwoTensorTempl (const libMesh::TypeTensor< T > &a)
	The conversion operator from a `libMesh::TypeTensor`

template<typename T2 >
	RankTwoTensorTempl (const SymmetricRankTwoTensorTempl< T2 > &a)
	The conversion operator from a `SymmetricRankTwoTensorTempl`

template<typename T2 >
	RankTwoTensorTempl (const RankTwoTensorTempl< T2 > &a)
	The conversion operator from `RankTwoTensorTempl<T2>` to `RankTwoTensorTempl<T>` where `T2` is convertible to `T`.


libMesh::VectorValue< T >	column (const unsigned int i) const
	Get the i-th column of the second order tensor.


RankTwoTensorTempl< T > &	operator= (const RankTwoTensorTempl< T > &a)=default
	Assignment operator.

RankTwoTensorTempl< T > &	operator= (const ColumnMajorMatrixTempl< T > &a)
	Assignment operator (from a ColumnMajorMatrixTempl<T>)

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

RankTwoTensorTempl< T > &	operator+= (const RankTwoTensorTempl< T > &a)
	Add another second order tensor to this one.

RankTwoTensorTempl< T > &	operator-= (const RankTwoTensorTempl< T > &a)
	Subtract another second order tensor from this one.

RankTwoTensorTempl< T > &	operator*= (const T &a)
	Multiply this tensor by a scalar (component-wise)

RankTwoTensorTempl< T > &	operator/= (const T &a)
	Divide this tensor by a scalar (component-wise)

RankTwoTensorTempl< T > &	operator*= (const libMesh::TypeTensor< T > &a)
	Multiplication with another second order tensor.

void	fillFromInputVector (const std::vector< T > &input, FillMethod fill_method=autodetect)
	The smart mutator that determines how to fill the second order tensor based on the size of the input vector.

void	fillFromScalarVariable (const VariableValue &scalar_variable)
	The smart mutator that determines how to fill the second order tensor based on the order of the scalar_variable.

void	surfaceFillFromInputVector (const std::vector< T > &input)
	sets _coords[0][0], _coords[0][1], _coords[1][0], _coords[1][1] to input, and the remainder to zero

void	vectorOuterProduct (const libMesh::TypeVector< T > &, const libMesh::TypeVector< T > &)
	Set the values of the second order tensor to be the outer product of two vectors, i.e.

void	fillRow (unsigned int r, const libMesh::TypeVector< T > &v)
	Assign values to a specific row of the second order tensor.

void	fillColumn (unsigned int c, const libMesh::TypeVector< T > &v)
	Assign values to a specific column of the second order tensor.

void	setToIdentity ()
	Set the tensor to identity.

void	addIa (const T &a)
	Add identity times a to _coords.

void	rotate (const RankTwoTensorTempl< T > &R)
	Rotate the tensor in-place given a rotation tensor \( A_{ij} \leftarrow R_{ij} A_{jk} R_{jk} \).


RankTwoTensorTempl< T >	square () const
	Return \( A_{ij} = A_{ik}A_{kj} \).

RankTwoTensorTempl< T >	rotated (const RankTwoTensorTempl< T > &R) const
	Return the rotated tensor given a rotation tensor \( A'_{ij} = R_{ij} A_{jk} R_{jk} \).

RankTwoTensorTempl< T >	rotateXyPlane (T a)
	Rotate the tensor about the z-axis.

RankTwoTensorTempl< T >	transpose () const
	Return the tensor transposed.

template<typename T2 >
RankTwoTensorTempl< typename libMesh::CompareTypes< T, T2 >::supertype >	operator+ (const libMesh::TypeTensor< T2 > &a) const
	Return the sum of two second order tensors.

template<typename T2 >
RankTwoTensorTempl< typename libMesh::CompareTypes< T, T2 >::supertype >	operator- (const libMesh::TypeTensor< T2 > &a) const
	Return the subtraction of two second order tensors.

RankTwoTensorTempl< T >	operator- () const
	Return the negation of this tensor.

template<typename T2 , typename std::enable_if< libMesh::ScalarTraits< T2 >::value, int >::type = 0>
RankTwoTensorTempl< typename libMesh::CompareTypes< T, T2 >::supertype >	operator* (const T2 &a) const
	Return this tensor multiplied by a scalar (component-wise)

template<typename T2 , typename std::enable_if< libMesh::ScalarTraits< T2 >::value, int >::type = 0>
RankTwoTensorTempl< typename libMesh::CompareTypes< T, T2 >::supertype >	operator/ (const T2 &a) const
	Return this tensor divided by a scalar (component-wise)

template<typename T2 >
libMesh::TypeVector< typename libMesh::CompareTypes< T, T2 >::supertype >	operator* (const libMesh::TypeVector< T2 > &a) const
	Return this tensor multiplied by a vector.

template<typename T2 >
RankTwoTensorTempl< typename libMesh::CompareTypes< T, T2 >::supertype >	operator* (const libMesh::TypeTensor< T2 > &a) const
	Multiplication with another second order tensor.

T	doubleContraction (const RankTwoTensorTempl< T > &a) const
	Return the double contraction with another second order tensor \( A_{ij} B_{ij} \).

template<int n, int o, int p, int q>
RankFourTensorTempl< T >	times (const RankTwoTensorTempl< T > &b) const
	Return the general tensor product of this second order tensor and another second order tensor defined as \( C_{ijkl} = A_{\mathcal{M}(n)\mathcal{M}(o)} B_{\mathcal{M}(p)\mathcal{M}(q)} \) where the multiplication order is defined by the index map \( \mathcal{M}: \{n,o,p,q\} \to \{i,j,k,l\} \).

template<int n, int o, int p, int q, int r, int s>
RankFourTensorTempl< T >	times (const RankFourTensorTempl< T > &b) const
	Return the single contraction of this second order tensor with a fourth order tensor defined as \( C_{ijkl} = A_{\mathcal{M}(m)\mathcal{M}(n)} B_{\mathcal{M}(p)\mathcal{M}(q)\mathcal{M}(r)\mathcal{M}(s)} \) where the multiplication order is defined by the index map \( \mathcal{M}: \{m,n,p,q,r,s\} \to \{i,j,k,l\} \).

RankFourTensorTempl< T >	outerProduct (const RankTwoTensorTempl< T > &b) const
	Return the outer product \( C_{ijkl} = A_{ij} B_{kl} \).

RankThreeTensorTempl< T >	contraction (const RankThreeTensorTempl< T > &b) const
	Return the single contraction of this second order tensor with a third order tensor \( C_{ikl} = A_{ij} B_{jkl} \).

RankThreeTensorTempl< T >	mixedProductJkI (const libMesh::VectorValue< T > &b) const
	Return the tensor product of this second order tensor with a vector \( C_{ijk} = A_{jk} b_{i} \).

RankFourTensorTempl< T >	positiveProjectionEigenDecomposition (std::vector< T > &, RankTwoTensorTempl< T > &) const
	Return the positive projection tensor.

RankTwoTensorTempl< T >	deviatoric () const
	Return the deviatoric part of this tensor \( A_{ij} - \frac{1}{3} A_{kk} \delta_{ij} \).

T	trace () const
	A wrapper for tr()

RankTwoTensorTempl< T >	dtrace () const
	Return the derivative of the trace w.r.t.

RankTwoTensorTempl< T >	inverse () const
	Return the inverse of this second order tensor.

T	generalSecondInvariant () const
	Return the principal second invariant of this second order tensor.

T	secondInvariant () const
	Return the main second invariant of this second order tensor.

RankTwoTensorTempl< T >	dsecondInvariant () const
	Return the derivative of the main second invariant w.r.t.

RankFourTensorTempl< T >	d2secondInvariant () const
	Return the second derivative of the main second invariant w.r.t.

T	sin3Lode (const T &r0, const T &r0_value) const
	Sin(3*Lode_angle)

RankTwoTensorTempl< T >	dsin3Lode (const T &r0) const
	d(sin3Lode)/dA_ij If secondInvariant() <= r0 then return zero This is to gaurd against precision-loss errors.

RankFourTensorTempl< T >	d2sin3Lode (const T &r0) const
	d^2(sin3Lode)/dA_ij/dA_kl If secondInvariant() <= r0 then return zero This is to gaurd against precision-loss errors.

T	thirdInvariant () const
	Denote the _coords[i][j] by A_ij, then S_ij = A_ij - de_ij*tr(A)/3 Then this returns det(S + S.transpose())/2 Note the explicit symmeterisation.

RankTwoTensorTempl< T >	dthirdInvariant () const
	Denote the _coords[i][j] by A_ij, then this returns d(thirdInvariant()/dA_ij.

RankFourTensorTempl< T >	d2thirdInvariant () const
	Denote the _coords[i][j] by A_ij, then this returns d^2(thirdInvariant)/dA_ij/dA_kl.

RankTwoTensorTempl< T >	ddet () const
	Denote the _coords[i][j] by A_ij, then this returns d(det)/dA_ij.

T	L2norm () const
	Sqrt(_coords[i][j]*_coords[i][j])

void	symmetricEigenvalues (std::vector< T > &eigvals) const
	computes eigenvalues, assuming tens is symmetric, and places them in ascending order in eigvals

void	symmetricEigenvaluesEigenvectors (std::vector< T > &eigvals, RankTwoTensorTempl< T > &eigvecs) const
	computes eigenvalues and eigenvectors, assuming tens is symmetric, and places them in ascending order in eigvals.

void	dsymmetricEigenvalues (std::vector< T > &eigvals, std::vector< RankTwoTensorTempl< T > > &deigvals) const
	computes eigenvalues, and their symmetric derivatives wrt vals, assuming tens is symmetric

void	d2symmetricEigenvalues (std::vector< RankFourTensorTempl< T > > &deriv) const
	Computes second derivatives of Eigenvalues of a rank two tensor.

void	getRUDecompositionRotation (RankTwoTensorTempl< T > &rot) const
	Uses the petscblaslapack.h LAPACKsyev_ routine to perform RU decomposition and obtain the rotation tensor.

RankTwoTensorTempl< T >	initialContraction (const RankFourTensorTempl< T > &b) const
	returns this_ij * b_ijkl


bool	operator== (const RankTwoTensorTempl< T > &a) const
	Defines logical equality with another RankTwoTensorTempl<T>

bool	isSymmetric () const
	Test for symmetry.

Static Public Member Functions
static TensorValue< Real >	intrinsic_rotation_matrix (Real phi, Real theta, Real psi)

static TensorValue< Real >	inverse_intrinsic_rotation_matrix (Real phi, Real theta, Real psi)

static TensorValue< Real >	extrinsic_rotation_matrix (Real angle1_deg, Real angle2_deg, Real angle3_deg)

static TensorValue< Real >	inverse_extrinsic_rotation_matrix (Real angle1_deg, Real angle2_deg, Real angle3_deg)


static RankTwoTensorTempl	initializeSymmetric (const libMesh::TypeVector< T > &v0, const libMesh::TypeVector< T > &v1, const libMesh::TypeVector< T > &v2)
	Named constructor for initializing symmetrically.

static RankTwoTensorTempl	initializeFromRows (const libMesh::TypeVector< T > &row0, const libMesh::TypeVector< T > &row1, const libMesh::TypeVector< T > &row2)
	Named constructor for initializing from row vectors.

static RankTwoTensorTempl	initializeFromColumns (const libMesh::TypeVector< T > &col0, const libMesh::TypeVector< T > &col1, const libMesh::TypeVector< T > &col2)
	Named constructor for initializing from row vectors.

static RankTwoTensorTempl	Identity ()
	Initialize a second order identity tensor.

static RankTwoTensorTempl< T >	timesTranspose (const RankTwoTensorTempl< T > &)
	Initialize a second order tensor with expression \( B_{ij} = F_{ij} F_{ji} \).

static RankTwoTensorTempl< T >	transposeTimes (const RankTwoTensorTempl< T > &)
	Initialize a second order tensor with expression \( C_{ij} = F_{ji} F_{ij} \).

static RankTwoTensorTempl< T >	plusTranspose (const RankTwoTensorTempl< T > &)
	Initialize a second order tensor with expression \( E_{ij} = C_{ij} + C_{ji} \).

static RankTwoTensorTempl< T >	outerProduct (const libMesh::TypeVector< T > &, const libMesh::TypeVector< T > &)
	Initialize a second order tensor as the outer product of two vectors, i.e.

static RankTwoTensorTempl< T >	selfOuterProduct (const libMesh::TypeVector< T > &)
	Initialize a second order tensor as the outer product of a vector with itself, i.e.

static RankTwoTensorTempl< T >	genRandomTensor (T stddev, T mean)
	Generate a random second order tensor with all 9 components treated as independent random variables following a Gaussian distribution.

static RankTwoTensorTempl< T >	genRandomSymmTensor (T stddev, T mean)
	Generate a random symmetric second order tensor with the 6 upper-triangular components treated as independent random variables following a Gaussian distribution.

Protected Member Functions
void	syev (const char *calculation_type, std::vector< T > &eigvals, std::vector< T > &a) const
	Uses the petscblaslapack.h LAPACKsyev_ routine to find, for symmetric _coords: (1) the eigenvalues (if calculation_type == "N") (2) the eigenvalues and eigenvectors (if calculation_type == "V")

Protected Attributes
T	_coords [LIBMESH_DIM *LIBMESH_DIM]

Static Private Attributes
static constexpr Real	identityCoords [N2] = {1, 0, 0, 0, 1, 0, 0, 0, 1}

Friends
template<class T2 >
class	RankFourTensorTempl

template<class T2 >
class	RankThreeTensorTempl

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

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

enum	InitMethod { initNone , initIdentity }
	The initialization method. More...

enum	FillMethod { autodetect = 0 , isotropic1 = 1 , diagonal3 = 3 , symmetric6 = 6 , general = 9 }
	To fill up the 9 entries in the 2nd-order tensor, fillFromInputVector is called with one of the following fill_methods. More...

static constexpr unsigned int	N = Moose::dim
	Tensor dimension, i.e.

static constexpr unsigned int	N2 = N * N
	The square of the tensor dimension.

static void	initRandom (unsigned int)
	Initialize the random seed based on an unsigned integer.

static MooseEnum	fillMethodEnum ()
	Get the available `FillMethod` options.

void	fillRealTensor (libMesh::TensorValue< T > &)
	Fill a `libMesh::TensorValue<T>` from this second order tensor.

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

void	printReal (std::ostream &stm=Moose::out) const
	Print the Real part of the RankTwoTensorTempl<ADReal>

void	printADReal (unsigned int nDual, std::ostream &stm=Moose::out) const
	Print the Real part of the RankTwoTensorTempl<ADReal> along with its first nDual dual numbers.

Detailed Description

template<typename T>
class RankTwoTensorTempl< T >

RankTwoTensorTempl is designed to handle the Stress or Strain Tensor for a fully anisotropic material.

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

RankTwoTensorTempl holds the 9 separate Sigma_ij or Epsilon_ij entries. The entries are accessed by index, with i, j equal to 1, 2, or 3, or internally i, j = 0, 1, 2.

Definition at line 87 of file RankTwoTensor.h.

Member Enumeration Documentation

◆ FillMethod

template<typename T >

enum RankTwoTensorTempl::FillMethod

To fill up the 9 entries in the 2nd-order tensor, fillFromInputVector is called with one of the following fill_methods.

See the fill*FromInputVector functions for more details

Enumerator
autodetect
isotropic1
diagonal3
symmetric6
general

Definition at line 118 of file RankTwoTensor.h.

  {
    autodetect = 0,
    isotropic1 = 1,
    diagonal3 = 3,
    symmetric6 = 6,
    general = 9
  };

◆ InitMethod

template<typename T >

enum RankTwoTensorTempl::InitMethod

The initialization method.

See also: fillFromInputVector(); RankTwoTensorTempl(const std::vector<T> &)

Enumerator
initNone
initIdentity

Definition at line 107 of file RankTwoTensor.h.

  {
    initNone,
    initIdentity
  };

Constructor & Destructor Documentation

◆ RankTwoTensorTempl() [1/11]

template<typename T >

RankTwoTensorTempl< T >::RankTwoTensorTempl ( )

Empty constructor; fills to zero.

\( A_{ij} = 0 \)

RankTwoTensor A;
// A = [ 0 0 0
//       0 0 0
//       0 0 0 ]

Definition at line 72 of file RankTwoTensorImplementation.h.

{
  mooseAssert(N == 3, "RankTwoTensorTempl is currently only tested for 3 dimensions.");
 
  for (unsigned int i = 0; i < N2; i++)
    _coords[i] = 0.0;
}

Referenced by RankTwoTensorTempl< T >::Identity().

◆ RankTwoTensorTempl() [2/11]

template<typename T >

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

Select specific initialization pattern.

initNone initializes an empty second order tensor.

RankTwoTensor A(RankTwoTensor::initNone);
// A = [ 0 0 0
//       0 0 0
//       0 0 0 ]

initIdentity initializes a second order identity tensor.

RankTwoTensor A(RankTwoTensor::initIdentity);
// A = [ 1 0 0
//       0 1 0
//       0 0 1 ]

Definition at line 81 of file RankTwoTensorImplementation.h.

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

◆ RankTwoTensorTempl() [3/11]

template<typename T >

RankTwoTensorTempl< T >::RankTwoTensorTempl	(	const libMesh::TypeVector< T > &	row1,
		const libMesh::TypeVector< T > &	row2,
		const libMesh::TypeVector< T > &	row3
	)

Initialize from row vectors.

See also: initializeFromRows()

Deprecated in favor of initializeFromRows()

RealVectorValue row1(1, 2, 3);
RealVectorValue row2(4, 5, 6);
RealVectorValue row3(7, 8, 9);
RankTwoTensor A(row1, row2, row3);
// A = [ 1 2 3
//       4 5 6
//       7 8 9 ]

Definition at line 100 of file RankTwoTensorImplementation.h.

{
  mooseDeprecated(
      "This constructor is deprecated in favor of RankTwoTensorTempl<T>::initializeFromRows");
 
  // Initialize the Tensor matrix from the passed in vectors
  for (const auto i : make_range(N))
    _coords[i] = row1(i);
 
  for (const auto i : make_range(N))
    _coords[N + i] = row2(i);
 
  for (const auto i : make_range(N))
    _coords[2 * N + i] = row3(i);
}

◆ RankTwoTensorTempl() [4/11]

template<typename T >

RankTwoTensorTempl< T >::RankTwoTensorTempl ( const std::vector< T > & input )

inline

Constructor that proxies the fillFromInputVector() method.

See also: fillFromInputVector()

Definition at line 219 of file RankTwoTensor.h.

219{ this->fillFromInputVector(input); };

RankTwoTensorTempl::fillFromInputVector

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

The smart mutator that determines how to fill the second order tensor based on the size of the input ...

Definition RankTwoTensorImplementation.h:191

◆ RankTwoTensorTempl() [5/11]

template<typename T >

RankTwoTensorTempl< T >::RankTwoTensorTempl	(	const T &	S11,
		const T &	S22,
		const T &	S33,
		const T &	S23,
		const T &	S13,
		const T &	S12
	)

Initialize a symmetric second order tensor using the 6 arguments.

RankTwoTensor A(1, 2, 3, 4, 5, 6);
// A = [ 1 6 5
//       6 2 4
//       5 4 3 ]

Definition at line 156 of file RankTwoTensorImplementation.h.

{
  (*this)(0, 0) = S11;
  (*this)(1, 1) = S22;
  (*this)(2, 2) = S33;
  (*this)(1, 2) = (*this)(2, 1) = S23;
  (*this)(0, 2) = (*this)(2, 0) = S13;
  (*this)(0, 1) = (*this)(1, 0) = S12;
}

◆ RankTwoTensorTempl() [6/11]

template<typename T >

RankTwoTensorTempl< T >::RankTwoTensorTempl	(	const T &	S11,
		const T &	S21,
		const T &	S31,
		const T &	S12,
		const T &	S22,
		const T &	S32,
		const T &	S13,
		const T &	S23,
		const T &	S33
	)

Initialize a second order tensor using the 9 arguments in a column-major fashion.

RankTwoTensor A(1, 2, 3, 4, 5, 6, 7, 8, 9);
// A = [ 1 4 7
//       2 5 8
//       3 6 9 ]

Definition at line 168 of file RankTwoTensorImplementation.h.

{
  (*this)(0, 0) = S11;
  (*this)(1, 0) = S21;
  (*this)(2, 0) = S31;
  (*this)(0, 1) = S12;
  (*this)(1, 1) = S22;
  (*this)(2, 1) = S32;
  (*this)(0, 2) = S13;
  (*this)(1, 2) = S23;
  (*this)(2, 2) = S33;
}

◆ RankTwoTensorTempl() [7/11]

template<typename T >

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

default

The copy constructor.

RankTwoTensor A(1, 2, 3, 4, 5, 6, 7, 8, 9);
RankTwoTensor B = A;
// A = B = [ 1 4 7
//           2 5 8
//           3 6 9 ]

◆ RankTwoTensorTempl() [8/11]

template<typename T >

RankTwoTensorTempl< T >::RankTwoTensorTempl ( const libMesh::TensorValue< T > & a )

inline

The conversion operator from a libMesh::TensorValue

Definition at line 270 of file RankTwoTensor.h.

270: libMesh::TensorValue<T>(a) {}

libMesh::TensorValue

◆ RankTwoTensorTempl() [9/11]

template<typename T >

RankTwoTensorTempl< T >::RankTwoTensorTempl ( const libMesh::TypeTensor< T > & a )

inline

The conversion operator from a libMesh::TypeTensor

Definition at line 275 of file RankTwoTensor.h.

275: libMesh::TensorValue<T>(a) {}

◆ RankTwoTensorTempl() [10/11]

template<typename T >

template<typename T2 >

RankTwoTensorTempl< T >::RankTwoTensorTempl ( const SymmetricRankTwoTensorTempl< T2 > & a )

inline

The conversion operator from a SymmetricRankTwoTensorTempl

Definition at line 281 of file RankTwoTensor.h.

    : RankTwoTensorTempl<T>(a(0),
                            a(1),
                            a(2),
                            a(3) / MathUtils::sqrt2,
                            a(4) / MathUtils::sqrt2,
                            a(5) / MathUtils::sqrt2)
  {
  }

◆ RankTwoTensorTempl() [11/11]

template<typename T >

template<typename T2 >

RankTwoTensorTempl< T >::RankTwoTensorTempl ( const RankTwoTensorTempl< T2 > & a )

inline

The conversion operator from RankTwoTensorTempl<T2> to RankTwoTensorTempl<T> where T2 is convertible to T.

Definition at line 296 of file RankTwoTensor.h.

                                                       : libMesh::TensorValue<T>(a)
  {
  }

Member Function Documentation

◆ addIa()

template<typename T >

void RankTwoTensorTempl< T >::addIa ( const T & a )

Add identity times a to _coords.

Add a scalar to diagonal components \( A_{ij} + a\delta_{ij} \)

RankTwoTensor A;
// A = [ 0 0 0
//       0 0 0
//       0 0 0 ]
A.addIa(1.5);
// A = [ 1.5 0   0
//       0   1.5 0
//       0   0   1.5 ]

Definition at line 736 of file RankTwoTensorImplementation.h.

{
  for (const auto i : make_range(N))
    (*this)(i, i) += a;
}

Referenced by RankTwoTensorTempl< T >::deviatoric().

◆ column()

template<typename T >

libMesh::VectorValue< T > RankTwoTensorTempl< T >::column ( const unsigned int i ) const

Get the i-th column of the second order tensor.

Parameters

i	The column number, i = 0, 1, 2

Returns: The i-th column of the second order tensor.

RankTwoTensor A(1, 2, 3, 4, 5, 6, 7, 8, 9);
RealVectorValue col = A.column(1);
// col = [ 4
//         5
//         6 ]

Definition at line 274 of file RankTwoTensorImplementation.h.

{
  return libMesh::VectorValue<T>((*this)(0, c), (*this)(1, c), (*this)(2, c));
}

Referenced by FactorizedRankTwoTensorTempl< T >::assemble(), RankTwoTensorTempl< T >::positiveProjectionEigenDecomposition(), and SymmetricRankTwoTensorTempl< T >::positiveProjectionEigenDecomposition().

◆ contraction()

template<typename T >

RankThreeTensorTempl< T > RankTwoTensorTempl< T >::contraction ( const RankThreeTensorTempl< T > & b ) const

Return the single contraction of this second order tensor with a third order tensor \( C_{ikl} = A_{ij} B_{jkl} \).

Definition at line 465 of file RankTwoTensorImplementation.h.

{
  RankThreeTensorTempl<T> result;
 
  for (const auto i : make_range(N))
    for (const auto j : make_range(N))
      for (const auto k : make_range(N))
        for (const auto l : make_range(N))
          result(i, k, l) += (*this)(i, j) * b(j, k, l);
 
  return result;
}

◆ d2secondInvariant()

template<typename T >

RankFourTensorTempl< T > RankTwoTensorTempl< T >::d2secondInvariant ( ) const

Return the second derivative of the main second invariant w.r.t.

this second order tensor itself \( \frac{\partial^2 J_2}{\partial A_{ij}A_{kl}} = \delta_{ik}\delta_{jl} - \frac{1}{3}\delta_{ij}\delta_{kl} \)

Definition at line 539 of file RankTwoTensorImplementation.h.

{
  RankFourTensorTempl<T> result;
  for (const auto i : make_range(N))
    for (const auto j : make_range(N))
      for (const auto k : make_range(N))
        for (const auto l : make_range(N))
          result(i, j, k, l) = 0.5 * (i == k) * (j == l) + 0.5 * (i == l) * (j == k) -
                               (1.0 / 3.0) * (i == j) * (k == l);
  return result;
}

◆ d2sin3Lode()

template<typename T >

RankFourTensorTempl< T > RankTwoTensorTempl< T >::d2sin3Lode ( const T & r0 ) const

d^2(sin3Lode)/dA_ij/dA_kl If secondInvariant() <= r0 then return zero This is to gaurd against precision-loss errors.

Note that sin(3*Lode_angle) is not defined for secondInvariant() = 0

Definition at line 1548 of file RankTwoTensor.h.

{
  using std::pow, std::sqrt;
  if constexpr (MooseUtils::IsLikeReal<T>::value)
  {
    T bar = secondInvariant();
    if (bar <= r0)
      return RankFourTensorTempl<T>();
 
    T J3 = thirdInvariant();
    RankTwoTensorTempl<T> dII = dsecondInvariant();
    RankTwoTensorTempl<T> dIII = dthirdInvariant();
    RankFourTensorTempl<T> deriv =
        d2thirdInvariant() / pow(bar, 1.5) - 1.5 * d2secondInvariant() * J3 / pow(bar, 2.5);
 
    for (unsigned i = 0; i < N; ++i)
      for (unsigned j = 0; j < N; ++j)
        for (unsigned k = 0; k < N; ++k)
          for (unsigned l = 0; l < N; ++l)
            deriv(i, j, k, l) +=
                (-1.5 * dII(i, j) * dIII(k, l) - 1.5 * dIII(i, j) * dII(k, l)) / pow(bar, 2.5) +
                1.5 * 2.5 * dII(i, j) * dII(k, l) * J3 / pow(bar, 3.5);
 
    deriv *= -1.5 * sqrt(3.0);
    return deriv;
  }
  else
    mooseError("d2sin3Lode is only available for ordered tensor component types");
}

◆ d2symmetricEigenvalues()

template<typename T >

void RankTwoTensorTempl< T >::d2symmetricEigenvalues ( std::vector< RankFourTensorTempl< T > > & deriv ) const

Computes second derivatives of Eigenvalues of a rank two tensor.

Parameters

deriv store second derivative of the current tensor in here

Definition at line 855 of file RankTwoTensorImplementation.h.

{
  std::vector<T> eigvec;
  std::vector<T> eigvals;
  T ev[N][N];
 
  // reset rank four tensor
  deriv.assign(N, RankFourTensorTempl<T>());
 
  // get eigen values and eigen vectors
  syev("V", eigvals, eigvec);
 
  for (const auto i : make_range(N))
    for (const auto j : make_range(N))
      ev[i][j] = eigvec[i * N + j];
 
  for (unsigned int alpha = 0; alpha < N; ++alpha)
    for (unsigned int beta = 0; beta < N; ++beta)
    {
      if (eigvals[alpha] == eigvals[beta])
        continue;
 
      for (const auto i : make_range(N))
        for (const auto j : make_range(N))
          for (const auto k : make_range(N))
            for (const auto l : make_range(N))
            {
              deriv[alpha](i, j, k, l) +=
                  0.5 * (ev[beta][i] * ev[alpha][j] + ev[alpha][i] * ev[beta][j]) *
                  (ev[beta][k] * ev[alpha][l] + ev[beta][l] * ev[alpha][k]) /
                  (eigvals[alpha] - eigvals[beta]);
            }
    }
}

◆ d2thirdInvariant()

template<typename T >

RankFourTensorTempl< T > RankTwoTensorTempl< T >::d2thirdInvariant ( ) const

Denote the _coords[i][j] by A_ij, then this returns d^2(thirdInvariant)/dA_ij/dA_kl.

Definition at line 605 of file RankTwoTensorImplementation.h.

{
  const auto s = RankTwoTensorTempl<T>::plusTranspose(deviatoric()) * 0.5;
 
  RankFourTensorTempl<T> d2;
  for (const auto i : make_range(N))
    for (const auto j : make_range(N))
      for (const auto k : make_range(N))
        for (const auto l : make_range(N))
        {
          d2(i, j, k, l) = Real(i == j) * s(k, l) / 3.0 + Real(k == l) * s(i, j) / 3.0;
          // for (const auto a: make_range(N))
          //  for (const auto b: make_range(N))
          //    d2(i, j, k, l) += 0.5*(PermutationTensor::eps(i, k, a)*PermutationTensor::eps(j, l,
          //    b) + PermutationTensor::eps(i, l, a)*PermutationTensor::eps(j, k, b))*s(a, b);
        }
 
  // I'm not sure which is more readable: the above
  // PermutationTensor stuff, or the stuff below.
  // Anyway, they yield the same result, and so i leave
  // both of them here to enlighten you!
 
  d2(0, 0, 1, 1) += s(2, 2);
  d2(0, 0, 1, 2) -= s(2, 1);
  d2(0, 0, 2, 1) -= s(1, 2);
  d2(0, 0, 2, 2) += s(1, 1);
 
  d2(0, 1, 0, 1) -= s(2, 2) / 2.0;
  d2(0, 1, 1, 0) -= s(2, 2) / 2.0;
  d2(0, 1, 0, 2) += s(1, 2) / 2.0;
  d2(0, 1, 2, 0) += s(1, 2) / 2.0;
  d2(0, 1, 1, 2) += s(2, 0) / 2.0;
  d2(0, 1, 2, 1) += s(2, 0) / 2.0;
  d2(0, 1, 2, 2) -= s(1, 0);
 
  d2(0, 2, 0, 1) += s(2, 1) / 2.0;
  d2(0, 2, 1, 0) += s(2, 1) / 2.0;
  d2(0, 2, 0, 2) -= s(1, 1) / 2.0;
  d2(0, 2, 2, 0) -= s(1, 1) / 2.0;
  d2(0, 2, 1, 1) -= s(2, 0);
  d2(0, 2, 1, 2) += s(1, 0) / 2.0;
  d2(0, 2, 2, 1) += s(1, 0) / 2.0;
 
  d2(1, 0, 0, 1) -= s(2, 2) / 2.0;
  d2(1, 0, 1, 0) -= s(2, 2) / 2.0;
  d2(1, 0, 0, 2) += s(1, 2) / 2.0;
  d2(1, 0, 2, 0) += s(1, 2) / 2.0;
  d2(1, 0, 1, 2) += s(2, 0) / 2.0;
  d2(1, 0, 2, 1) += s(2, 0) / 2.0;
  d2(1, 0, 2, 2) -= s(1, 0);
 
  d2(1, 1, 0, 0) += s(2, 2);
  d2(1, 1, 0, 2) -= s(2, 0);
  d2(1, 1, 2, 0) -= s(2, 0);
  d2(1, 1, 2, 2) += s(0, 0);
 
  d2(1, 2, 0, 0) -= s(2, 1);
  d2(1, 2, 0, 1) += s(2, 0) / 2.0;
  d2(1, 2, 1, 0) += s(2, 0) / 2.0;
  d2(1, 2, 0, 2) += s(0, 1) / 2.0;
  d2(1, 2, 2, 0) += s(0, 1) / 2.0;
  d2(1, 2, 1, 2) -= s(0, 0) / 2.0;
  d2(1, 2, 2, 1) -= s(0, 0) / 2.0;
 
  d2(2, 0, 0, 1) += s(2, 1) / 2.0;
  d2(2, 0, 1, 0) += s(2, 1) / 2.0;
  d2(2, 0, 0, 2) -= s(1, 1) / 2.0;
  d2(2, 0, 2, 0) -= s(1, 1) / 2.0;
  d2(2, 0, 1, 1) -= s(2, 0);
  d2(2, 0, 1, 2) += s(1, 0) / 2.0;
  d2(2, 0, 2, 1) += s(1, 0) / 2.0;
 
  d2(2, 1, 0, 0) -= s(2, 1);
  d2(2, 1, 0, 1) += s(2, 0) / 2.0;
  d2(2, 1, 1, 0) += s(2, 0) / 2.0;
  d2(2, 1, 0, 2) += s(0, 1) / 2.0;
  d2(2, 1, 2, 0) += s(0, 1) / 2.0;
  d2(2, 1, 1, 2) -= s(0, 0) / 2.0;
  d2(2, 1, 2, 1) -= s(0, 0) / 2.0;
 
  d2(2, 2, 0, 0) += s(1, 1);
  d2(2, 2, 0, 1) -= s(1, 0);
  d2(2, 2, 1, 0) -= s(1, 0);
  d2(2, 2, 1, 1) += s(0, 0);
 
  return d2;
}

◆ ddet()

template<typename T >

RankTwoTensorTempl< T > RankTwoTensorTempl< T >::ddet ( ) const

Denote the _coords[i][j] by A_ij, then this returns d(det)/dA_ij.

Definition at line 695 of file RankTwoTensorImplementation.h.

{
  RankTwoTensorTempl<T> d;
 
  d(0, 0) = (*this)(1, 1) * (*this)(2, 2) - (*this)(2, 1) * (*this)(1, 2);
  d(0, 1) = (*this)(2, 0) * (*this)(1, 2) - (*this)(1, 0) * (*this)(2, 2);
  d(0, 2) = (*this)(1, 0) * (*this)(2, 1) - (*this)(2, 0) * (*this)(1, 1);
  d(1, 0) = (*this)(2, 1) * (*this)(0, 2) - (*this)(0, 1) * (*this)(2, 2);
  d(1, 1) = (*this)(0, 0) * (*this)(2, 2) - (*this)(2, 0) * (*this)(0, 2);
  d(1, 2) = (*this)(2, 0) * (*this)(0, 1) - (*this)(0, 0) * (*this)(2, 1);
  d(2, 0) = (*this)(0, 1) * (*this)(1, 2) - (*this)(1, 1) * (*this)(0, 2);
  d(2, 1) = (*this)(1, 0) * (*this)(0, 2) - (*this)(0, 0) * (*this)(1, 2);
  d(2, 2) = (*this)(0, 0) * (*this)(1, 1) - (*this)(1, 0) * (*this)(0, 1);
 
  return d;
}

◆ deviatoric()

template<typename T >

RankTwoTensorTempl< T > RankTwoTensorTempl< T >::deviatoric ( ) const

Return the deviatoric part of this tensor \( A_{ij} - \frac{1}{3} A_{kk} \delta_{ij} \).

Definition at line 494 of file RankTwoTensorImplementation.h.

{
  RankTwoTensorTempl<T> deviatoric(*this);
  // actually construct deviatoric part
  deviatoric.addIa(-1.0 / 3.0 * this->tr());
  return deviatoric;
}

◆ doubleContraction()

template<typename T >

T RankTwoTensorTempl< T >::doubleContraction ( const RankTwoTensorTempl< T > & a ) const

Return the double contraction with another second order tensor \( A_{ij} B_{ij} \).

RankTwoTensor A(1, 2, 3, 4, 5, 6, 7, 8, 9);
// A = [ 1 2 3
//       2 4 6
//       3 6 9 ]
RankTwoTensor B(9, 8, 7, 6, 5, 4, 3, 2, 1);
// B = [ 9 6 3
//       8 5 2
//       7 4 1 ]
Real result = A.doubleContraction(B);
// result = 143

Definition at line 457 of file RankTwoTensorImplementation.h.

{
  // deprecate this!
  return libMesh::TensorValue<T>::contract(b);
}

◆ dsecondInvariant()

template<typename T >

RankTwoTensorTempl< T > RankTwoTensorTempl< T >::dsecondInvariant ( ) const

Return the derivative of the main second invariant w.r.t.

this second order tensor itself \( \frac{\partial J_2}{\partial A_{ij}} = S_{ij} = A_{ij} - \frac{1}{3}A_{kk}\delta_{ij} \)

Definition at line 532 of file RankTwoTensorImplementation.h.

{
  return RankTwoTensorTempl<T>::plusTranspose(deviatoric()) * 0.5;
}

◆ dsin3Lode()

template<typename T >

RankTwoTensorTempl< T > RankTwoTensorTempl< T >::dsin3Lode ( const T & r0 ) const

d(sin3Lode)/dA_ij If secondInvariant() <= r0 then return zero This is to gaurd against precision-loss errors.

Note that sin(3*Lode_angle) is not defined for secondInvariant() = 0

Definition at line 1529 of file RankTwoTensor.h.

{
  using std::sqrt, std::pow;
  if constexpr (MooseUtils::IsLikeReal<T>::value)
  {
    T bar = secondInvariant();
    if (bar <= r0)
      return RankTwoTensorTempl<T>();
    else
      return -1.5 * sqrt(3.0) *
             (dthirdInvariant() / pow(bar, 1.5) -
              1.5 * dsecondInvariant() * thirdInvariant() / pow(bar, 2.5));
  }
  else
    mooseError("dsin3Lode is only available for ordered tensor component types");
}

◆ dsymmetricEigenvalues()

template<typename T >

void RankTwoTensorTempl< T >::dsymmetricEigenvalues	(	std::vector< T > &	eigvals,
		std::vector< RankTwoTensorTempl< T > > &	deigvals
	)		const

computes eigenvalues, and their symmetric derivatives wrt vals, assuming tens is symmetric

Parameters

eigvals	are the eigenvalues of the matrix, in ascending order
deigvals	Here digvals[i](j,k) = (1/2)*(d(eigvals[i])/dA_jk + d(eigvals[i]/dA_kj)) Note the explicit symmeterisation here. For equal eigenvalues, these derivatives are not gauranteed to be the ones you expect, since the derivatives in this case are often defined by continuation from the un-equal case, and that is too sophisticated for this routine.

Definition at line 816 of file RankTwoTensorImplementation.h.

{
  deigvals.resize(N);
 
  std::vector<T> a;
  syev("V", eigvals, a);
 
  // now a contains the eigenvetors
  // extract these and place appropriately in deigvals
  std::vector<T> eig_vec;
  eig_vec.resize(N);
 
  for (const auto i : make_range(N))
  {
    for (const auto j : make_range(N))
      eig_vec[j] = a[i * N + j];
    for (const auto j : make_range(N))
      for (const auto k : make_range(N))
        deigvals[i](j, k) = eig_vec[j] * eig_vec[k];
  }
 
  // There are discontinuities in the derivative
  // for equal eigenvalues.  The following is
  // an attempt to make a sensible choice for
  // the derivative.  This agrees with a central-difference
  // approximation to the derivative.
  if (eigvals[0] == eigvals[1] && eigvals[0] == eigvals[2])
    deigvals[0] = deigvals[1] = deigvals[2] = (deigvals[0] + deigvals[1] + deigvals[2]) / 3.0;
  else if (eigvals[0] == eigvals[1])
    deigvals[0] = deigvals[1] = (deigvals[0] + deigvals[1]) / 2.0;
  else if (eigvals[0] == eigvals[2])
    deigvals[0] = deigvals[2] = (deigvals[0] + deigvals[2]) / 2.0;
  else if (eigvals[1] == eigvals[2])
    deigvals[1] = deigvals[2] = (deigvals[1] + deigvals[2]) / 2.0;
}

◆ dthirdInvariant()

template<typename T >

RankTwoTensorTempl< T > RankTwoTensorTempl< T >::dthirdInvariant ( ) const

Denote the _coords[i][j] by A_ij, then this returns d(thirdInvariant()/dA_ij.

Definition at line 585 of file RankTwoTensorImplementation.h.

{
  const auto s = RankTwoTensorTempl<T>::plusTranspose(deviatoric()) * 0.5;
  const T s3 = secondInvariant() / 3.0;
 
  RankTwoTensorTempl<T> d;
  d(0, 0) = s(1, 1) * s(2, 2) - s(2, 1) * s(1, 2) + s3;
  d(0, 1) = s(2, 0) * s(1, 2) - s(1, 0) * s(2, 2);
  d(0, 2) = s(1, 0) * s(2, 1) - s(2, 0) * s(1, 1);
  d(1, 0) = s(2, 1) * s(0, 2) - s(0, 1) * s(2, 2);
  d(1, 1) = s(0, 0) * s(2, 2) - s(2, 0) * s(0, 2) + s3;
  d(1, 2) = s(2, 0) * s(0, 1) - s(0, 0) * s(2, 1);
  d(2, 0) = s(0, 1) * s(1, 2) - s(1, 1) * s(0, 2);
  d(2, 1) = s(1, 0) * s(0, 2) - s(0, 0) * s(1, 2);
  d(2, 2) = s(0, 0) * s(1, 1) - s(1, 0) * s(0, 1) + s3;
  return d;
}

◆ dtrace()

template<typename T >

RankTwoTensorTempl< T > RankTwoTensorTempl< T >::dtrace ( ) const

Return the derivative of the trace w.r.t.

this second order tensor itself \( \frac{\partial A_{kk}}{\partial A_{ij}} = \delta_{ij} \)

Definition at line 561 of file RankTwoTensorImplementation.h.

{
  return RankTwoTensorTempl<T>(1, 0, 0, 0, 1, 0, 0, 0, 1);
}

◆ fillColumn()

template<typename T >

void RankTwoTensorTempl< T >::fillColumn	(	unsigned int	c,
		const libMesh::TypeVector< T > &	v
	)

Assign values to a specific column of the second order tensor.

Parameters

c	The column number, c = 0, 1, 2
v	The values to be set

RealVectorValue a(1, 2, 3);
RankTwoTensor A;
// A = [ 0 0 0
//       0 0 0
//       0 0 0 ]
A.fillColumn(1, a);
// A = [ 0 1 0
//       0 2 0
//       0 3 0 ]

Definition at line 979 of file RankTwoTensorImplementation.h.

{
  for (const auto i : make_range(N))
    (*this)(i, c) = v(i);
}

◆ fillFromInputVector()

template<typename T >

void RankTwoTensorTempl< T >::fillFromInputVector	(	const std::vector< T > &	input,
		FillMethod	fill_method = `autodetect`
	)

The smart mutator that determines how to fill the second order tensor based on the size of the input vector.

Parameters

input	The input vector, can be of size 1, 3, 6, or 9
fill_method	The fill method, default to autodetect.

When input.size() == 1, the vector value is used to fill the diagonal components of the second order tensor:

RankTwoTensor A;
A.fillFromInputVector({1.5});
// A = [ 1.5 0   0
//       0   1.5 0
//       0   0   1.5 ]

When input.size() == 3, the vector values are used to fill the diagonal components of the second order tensor:

RankTwoTensor A;
A.fillFromInputVector({1, 2, 3});
// A = [ 1 0 0
//       0 2 0
//       0 0 3 ]

When input.size() == 6, the second order tensor is filled symmetrically using the Voigt notation:

RankTwoTensor A;
A.fillFromInputVector({1, 2, 3, 4, 5, 6});
// A = [ 1 6 5
//       6 2 4
//       5 4 3 ]

When input.size() == 9, all components of the second order tensor are filled in a column-major fashion:

RankTwoTensor A;
A.fillFromInputVector({1, 2, 3, 4, 5, 6, 7, 8, 9});
// A = [ 1 4 7
//       2 5 8
//       3 6 9 ]

Definition at line 191 of file RankTwoTensorImplementation.h.

{
  if (fill_method != autodetect && fill_method != input.size())
    mooseError("Expected an input vector size of ", fill_method, " to fill the RankTwoTensorTempl");
 
  switch (input.size())
  {
    case 1:
      this->zero();
      (*this)(0, 0) = input[0]; // S11
      (*this)(1, 1) = input[0]; // S22
      (*this)(2, 2) = input[0]; // S33
      break;
 
    case 3:
      this->zero();
      (*this)(0, 0) = input[0]; // S11
      (*this)(1, 1) = input[1]; // S22
      (*this)(2, 2) = input[2]; // S33
      break;
 
    case 6:
      (*this)(0, 0) = input[0];                 // S11
      (*this)(1, 1) = input[1];                 // S22
      (*this)(2, 2) = input[2];                 // S33
      (*this)(1, 2) = (*this)(2, 1) = input[3]; // S23
      (*this)(0, 2) = (*this)(2, 0) = input[4]; // S13
      (*this)(0, 1) = (*this)(1, 0) = input[5]; // S12
      break;
 
    case 9:
      (*this)(0, 0) = input[0]; // S11
      (*this)(1, 0) = input[1]; // S21
      (*this)(2, 0) = input[2]; // S31
      (*this)(0, 1) = input[3]; // S12
      (*this)(1, 1) = input[4]; // S22
      (*this)(2, 1) = input[5]; // S32
      (*this)(0, 2) = input[6]; // S13
      (*this)(1, 2) = input[7]; // S23
      (*this)(2, 2) = input[8]; // S33
      break;
 
    default:
      mooseError("Please check the number of entries in the input vector for building "
                 "a RankTwoTensorTempl. It must be 1, 3, 6, or 9");
  }
}

Referenced by GenericConstantRankTwoTensorTempl< is_ad >::GenericConstantRankTwoTensorTempl(), and RankTwoTensorTempl< T >::RankTwoTensorTempl().

◆ fillFromScalarVariable()

template<typename T >

void RankTwoTensorTempl< T >::fillFromScalarVariable ( const VariableValue & scalar_variable )

The smart mutator that determines how to fill the second order tensor based on the order of the scalar_variable.

Parameters

scalar_variable The input scalar variable. Supported orders are FIRST, THIRD, and SIXTH.

When scalar_variable.size() == 1, the scalar value is used to fill the very first component of the second order tensor:

& // Suppose v[0] = 1
  RankTwoTensor A;
  A.fillFromScalarVariable(v);
  // A = [ 1 0 0
  //       0 0 0
  //       0 0 0 ]

When scalar_variable.size() == 3, the scalar values are used to fill the in-plane components of the second order tensor using the Voigt notation:

// Suppose v[0] = 1
//         v[1] = 2
//         v[2] = 3
RankTwoTensor A;
A.fillFromScalarVariable(v);
// A = [ 1 3 0
//       3 2 0
//       0 0 0 ]

When scalar_variable.size() == 6, the second order tensor is filled symmetrically using the Voigt notation:

// Suppose v[0] = 1
//         v[1] = 2
//         v[2] = 3
//         v[3] = 4
//         v[4] = 5
//         v[5] = 6
RankTwoTensor A;
A.fillFromScalarVariable(v);
// A = [ 1 6 5
//       6 2 4
//       5 4 3 ]

Definition at line 241 of file RankTwoTensorImplementation.h.

{
  switch (scalar_variable.size())
  {
    case 1:
      this->zero();
      (*this)(0, 0) = scalar_variable[0]; // S11
      break;
 
    case 3:
      this->zero();
      (*this)(0, 0) = scalar_variable[0];                 // S11
      (*this)(1, 1) = scalar_variable[1];                 // S22
      (*this)(0, 1) = (*this)(1, 0) = scalar_variable[2]; // S12
      break;
 
    case 6:
      (*this)(0, 0) = scalar_variable[0];                 // S11
      (*this)(1, 1) = scalar_variable[1];                 // S22
      (*this)(2, 2) = scalar_variable[2];                 // S33
      (*this)(1, 2) = (*this)(2, 1) = scalar_variable[3]; // S23
      (*this)(0, 2) = (*this)(2, 0) = scalar_variable[4]; // S13
      (*this)(0, 1) = (*this)(1, 0) = scalar_variable[5]; // S12
      break;
 
    default:
      mooseError("Only FIRST, THIRD, or SIXTH order scalar variable can be used to build "
                 "a RankTwoTensorTempl.");
  }
}

◆ fillMethodEnum()

template<typename T >

MooseEnum RankTwoTensorTempl< T >::fillMethodEnum ( )

static

Get the available FillMethod options.

This method is useful in validParams().

Definition at line 66 of file RankTwoTensorImplementation.h.

{
  return MooseEnum("autodetect=0 isotropic1=1 diagonal3=3 symmetric6=6 general=9", "autodetect");
}

◆ fillRealTensor()

template<typename T >

void RankTwoTensorTempl< T >::fillRealTensor ( libMesh::TensorValue< T > & tensor )

Fill a libMesh::TensorValue<T> from this second order tensor.

Definition at line 962 of file RankTwoTensorImplementation.h.

{
  for (const auto i : make_range(N))
    for (const auto j : make_range(N))
      tensor(i, j) = (*this)(i, j);
}

◆ fillRow()

template<typename T >

void RankTwoTensorTempl< T >::fillRow	(	unsigned int	r,
		const libMesh::TypeVector< T > &	v
	)

Assign values to a specific row of the second order tensor.

Parameters

r	The row number, r = 0, 1, 2
v	The values to be set

RealVectorValue a(1, 2, 3);
RankTwoTensor A;
// A = [ 0 0 0
//       0 0 0
//       0 0 0 ]
A.fillRow(1, a);
// A = [ 0 0 0
//       1 2 3
//       0 0 0 ]

Definition at line 971 of file RankTwoTensorImplementation.h.

{
  for (const auto i : make_range(N))
    (*this)(r, i) = v(i);
}

◆ generalSecondInvariant()

template<typename T >

T RankTwoTensorTempl< T >::generalSecondInvariant ( ) const

Return the principal second invariant of this second order tensor.

\( I_2 = \frac{1}{2} \left( A_{kk}^2 - A_{ij}A_{ij} \right) \)

Definition at line 504 of file RankTwoTensorImplementation.h.

{
  return (*this)(0, 0) * (*this)(1, 1) + (*this)(0, 0) * (*this)(2, 2) +
         (*this)(1, 1) * (*this)(2, 2) - (*this)(0, 1) * (*this)(1, 0) -
         (*this)(0, 2) * (*this)(2, 0) - (*this)(1, 2) * (*this)(2, 1);
}

◆ genRandomSymmTensor()

template<typename T >

RankTwoTensorTempl< T > RankTwoTensorTempl< T >::genRandomSymmTensor	(	T	stddev,
		T	mean
	)

static

Generate a random symmetric second order tensor with the 6 upper-triangular components treated as independent random variables following a Gaussian distribution.

Parameters

stddev	The standard deviation of the Gaussian distribution
mean	The mean of the Gaussian distribution

Definition at line 920 of file RankTwoTensorImplementation.h.

{
  auto r = [&]() { return (MooseRandom::rand() + mean) * stddev; };
  return RankTwoTensorTempl<T>(r(), r(), r(), r(), r(), r());
}

◆ genRandomTensor()

template<typename T >

RankTwoTensorTempl< T > RankTwoTensorTempl< T >::genRandomTensor	(	T	stddev,
		T	mean
	)

static

Generate a random second order tensor with all 9 components treated as independent random variables following a Gaussian distribution.

Parameters

stddev	The standard deviation of the Gaussian distribution
mean	The mean of the Gaussian distribution

Definition at line 909 of file RankTwoTensorImplementation.h.

{
  RankTwoTensorTempl<T> result;
  for (const auto i : make_range(N))
    for (const auto j : make_range(N))
      result(i, j) = (MooseRandom::rand() + mean) * stddev;
  return result;
}

◆ getRUDecompositionRotation()

template<typename T >

void RankTwoTensorTempl< T >::getRUDecompositionRotation ( RankTwoTensorTempl< T > & rot ) const

Uses the petscblaslapack.h LAPACKsyev_ routine to perform RU decomposition and obtain the rotation tensor.

Definition at line 892 of file RankTwoTensorImplementation.h.

{
  mooseError("getRUDecompositionRotation is only supported for Real valued tensors");
}

◆ Identity()

template<typename T >

static RankTwoTensorTempl RankTwoTensorTempl< T >::Identity ( )

inlinestatic

Initialize a second order identity tensor.

auto A = RankTwoTensor::Identity();
// A = [ 1 0 0
//       0 1 0
//       0 0 1 ]

Definition at line 368 of file RankTwoTensor.h.

368{ return RankTwoTensorTempl(initIdentity); }

RankTwoTensorTempl::RankTwoTensorTempl

RankTwoTensorTempl()

Empty constructor; fills to zero.

Definition RankTwoTensorImplementation.h:72

◆ initialContraction()

template<typename T >

RankTwoTensorTempl< T > RankTwoTensorTempl< T >::initialContraction ( const RankFourTensorTempl< T > & b ) const

returns this_ij * b_ijkl

Definition at line 987 of file RankTwoTensorImplementation.h.

{
  RankTwoTensorTempl<T> result;
  for (const auto i : make_range(N))
    for (const auto j : make_range(N))
      for (const auto k : make_range(N))
        for (const auto l : make_range(N))
          result(k, l) += (*this)(i, j) * b(i, j, k, l);
  return result;
}

◆ initializeFromColumns()

template<typename T >

RankTwoTensorTempl< T > RankTwoTensorTempl< T >::initializeFromColumns	(	const libMesh::TypeVector< T > &	col0,
		const libMesh::TypeVector< T > &	col1,
		const libMesh::TypeVector< T > &	col2
	)

static

Named constructor for initializing from row vectors.

RealVectorValue col1(1, 2, 3);
RealVectorValue col2(4, 5, 6);
RealVectorValue col3(7, 8, 9);
auto A = RankTwoTensor::initializeFromColumns(col1, col2, col3);
// A = [ 1 4 7
//       2 5 8
//       3 6 9 ]

Definition at line 147 of file RankTwoTensorImplementation.h.

{
  return RankTwoTensorTempl<T>(
      col0(0), col0(1), col0(2), col1(0), col1(1), col1(2), col2(0), col2(1), col2(2));
}

◆ initializeFromRows()

template<typename T >

RankTwoTensorTempl< T > RankTwoTensorTempl< T >::initializeFromRows	(	const libMesh::TypeVector< T > &	row0,
		const libMesh::TypeVector< T > &	row1,
		const libMesh::TypeVector< T > &	row2
	)

static

Named constructor for initializing from row vectors.

RealVectorValue row1(1, 2, 3);
RealVectorValue row2(4, 5, 6);
RealVectorValue row3(7, 8, 9);
auto A = RankTwoTensor::initializeFromRows(row1, row2, row3);
// A = [ 1 2 3
//       4 5 6
//       7 8 9 ]

Definition at line 137 of file RankTwoTensorImplementation.h.

{
  return RankTwoTensorTempl<T>(
      row0(0), row1(0), row2(0), row0(1), row1(1), row2(1), row0(2), row1(2), row2(2));
}

◆ initializeSymmetric()

template<typename T >

RankTwoTensorTempl< T > RankTwoTensorTempl< T >::initializeSymmetric	(	const libMesh::TypeVector< T > &	v0,
		const libMesh::TypeVector< T > &	v1,
		const libMesh::TypeVector< T > &	v2
	)

static

Named constructor for initializing symmetrically.

The supplied vectors are used as row and column vectors to construct two tensors respectively, that are averaged to create a symmetric tensor.

RealVectorValue row1(1, 2, 3);
RealVectorValue row2(4, 5, 6);
RealVectorValue row3(7, 8, 9);
auto A = RankTwoTensor::initializeSymmetric(row1, row2, row3);
// A = [ 1 3 5
//       3 5 7
//       5 7 9 ]

Definition at line 120 of file RankTwoTensorImplementation.h.

{
  return RankTwoTensorTempl<T>(v0(0),
                               (v1(0) + v0(1)) / 2.0,
                               (v2(0) + v0(2)) / 2.0,
                               (v1(0) + v0(1)) / 2.0,
                               v1(1),
                               (v2(1) + v1(2)) / 2.0,
                               (v2(0) + v0(2)) / 2.0,
                               (v2(1) + v1(2)) / 2.0,
                               v2(2));
}

◆ initRandom()

template<typename T >

void RankTwoTensorTempl< T >::initRandom ( unsigned int rand_seed )

static

Initialize the random seed based on an unsigned integer.

Deprecated in favor of MooseRandom::seed().

Definition at line 902 of file RankTwoTensorImplementation.h.

{
  MooseRandom::seed(rand_seed);
}

◆ inverse()

template<typename T >

RankTwoTensorTempl< T > RankTwoTensorTempl< T >::inverse ( ) const

Return the inverse of this second order tensor.

Definition at line 568 of file RankTwoTensorImplementation.h.

{
  return libMesh::TensorValue<T>::inverse();
}

◆ isSymmetric()

template<typename T >

bool RankTwoTensorTempl< T >::isSymmetric ( ) const

Test for symmetry.

Definition at line 434 of file RankTwoTensorImplementation.h.

{
  auto test = MetaPhysicL::raw_value(*this - transpose());
  return MooseUtils::absoluteFuzzyEqual(test.norm_sq(), 0);
}

◆ L2norm()

template<typename T >

T RankTwoTensorTempl< T >::L2norm ( ) const

Sqrt(_coords[i][j]*_coords[i][j])

Definition at line 744 of file RankTwoTensorImplementation.h.

{
  T norm = 0.0;
  for (const auto i : make_range(N2))
  {
    T v = _coords[i];
    norm += v * v;
  }
  using std::sqrt;
  return norm == 0.0 ? 0.0 : sqrt(norm);
}

◆ mixedProductJkI()

template<typename T >

RankThreeTensorTempl< T > RankTwoTensorTempl< T >::mixedProductJkI ( const libMesh::VectorValue< T > & b ) const

Return the tensor product of this second order tensor with a vector \( C_{ijk} = A_{jk} b_{i} \).

Definition at line 480 of file RankTwoTensorImplementation.h.

{
  RankThreeTensorTempl<T> result;
 
  for (const auto i : make_range(N))
    for (const auto j : make_range(N))
      for (const auto k : make_range(N))
        result(i, j, k) += (*this)(j, k) * b(i);
 
  return result;
}

◆ operator*() [1/3]

template<typename T >

template<typename T2 >

RankTwoTensorTempl< typename libMesh::CompareTypes< T, T2 >::supertype > RankTwoTensorTempl< T >::operator* ( const libMesh::TypeTensor< T2 > & a ) const

Multiplication with another second order tensor.

RankTwoTensor A(1, 2, 3, 4, 5, 6, 7, 8, 9);
// A = [ 1 2 3
//       2 4 6
//       3 6 9 ]
RankTwoTensor B(9, 8, 7, 6, 5, 4, 3, 2, 1);
// B = [ 9 6 3
//       8 5 2
//       7 4 1 ]
RankTwoTensor C = A * B;
// C = [ 90  54 18
//       114 69 24
//       138 84 30 ]

Definition at line 1440 of file RankTwoTensor.h.

{
  return libMesh::TensorValue<T>::operator*(b);
}

◆ operator*() [2/3]

template<typename T >

template<typename T2 >

libMesh::TypeVector< typename libMesh::CompareTypes< T, T2 >::supertype > RankTwoTensorTempl< T >::operator* ( const libMesh::TypeVector< T2 > & a ) const

Return this tensor multiplied by a vector.

\( b_i = A_{ij} a_j \)

RankTwoTensor A(1, 2, 3, 4, 5, 6, 7, 8, 9);
// A = [ 1 2 3
//       2 4 6
//       3 6 9 ]
RealVectorValue a(1, 2, 3);
// a = [ 1
//       2
//       3 ]
RealVectorValue b = A * a;
// b = [ 30
//       36
//       42 ]

Definition at line 1432 of file RankTwoTensor.h.

{
  return libMesh::TensorValue<T>::operator*(b);
}

◆ operator*() [3/3]

template<typename T >

template<typename T2 , typename std::enable_if< libMesh::ScalarTraits< T2 >::value, int >::type >

RankTwoTensorTempl< typename libMesh::CompareTypes< T, T2 >::supertype > RankTwoTensorTempl< T >::operator* ( const T2 & a ) const

Return this tensor multiplied by a scalar (component-wise)

RankTwoTensor A(1, 2, 3, 4, 5, 6, 7, 8, 9);
// A = [ 1 2 3
//       2 4 6
//       3 6 9 ]
RankTwoTensor B = A * 2;
// B = [ 2 4  6
//       4 8  12
//       6 12 18 ]

Definition at line 1424 of file RankTwoTensor.h.

{
  return libMesh::TensorValue<T>::operator*(b);
}

◆ operator*=() [1/2]

template<typename T >

RankTwoTensorTempl< T > & RankTwoTensorTempl< T >::operator*= ( const libMesh::TypeTensor< T > & a )

Multiplication with another second order tensor.

RankTwoTensor A(1, 2, 3, 4, 5, 6, 7, 8, 9);
// A = [ 1 2 3
//       2 4 6
//       3 6 9 ]
RankTwoTensor B(9, 8, 7, 6, 5, 4, 3, 2, 1);
// B = [ 9 6 3
//       8 5 2
//       7 4 1 ]
A *= B;
// A = [ 90  54 18
//       114 69 24
//       138 84 30 ]

Definition at line 414 of file RankTwoTensorImplementation.h.

{
  *this = *this * a;
  return *this;
}

◆ operator*=() [2/2]

template<typename T >

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

Multiply this tensor by a scalar (component-wise)

RankTwoTensor A(1, 2, 3, 4, 5, 6, 7, 8, 9);
// A = [ 1 2 3
//       2 4 6
//       3 6 9 ]
A *= 2;
// A = [ 2 4  6
//       4 8  12
//       6 12 18 ]

Definition at line 398 of file RankTwoTensorImplementation.h.

{
  libMesh::TensorValue<T>::operator*=(a);
  return *this;
}

◆ operator+()

template<typename T >

template<typename T2 >

RankTwoTensorTempl< typename libMesh::CompareTypes< T, T2 >::supertype > RankTwoTensorTempl< T >::operator+ ( const libMesh::TypeTensor< T2 > & a ) const

Return the sum of two second order tensors.

RankTwoTensor A(1, 2, 3, 4, 5, 6, 7, 8, 9);
// A = [ 1 2 3
//       2 4 6
//       3 6 9 ]
RankTwoTensor B(9, 8, 7, 6, 5, 4, 3, 2, 1);
// B = [ 9 6 3
//       8 5 2
//       7 4 1 ]
RankTwoTensor C = A + B;
// C = [ 10 8  6
//       10 9  8
//       10 10 10 ]

Definition at line 1408 of file RankTwoTensor.h.

{
  return libMesh::TensorValue<T>::operator+(b);
}

◆ operator+=()

template<typename T >

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

Add another second order tensor to this one.

RankTwoTensor A(1, 2, 3, 4, 5, 6, 7, 8, 9);
// A = [ 1 2 3
//       2 4 6
//       3 6 9 ]
RankTwoTensor B(9, 8, 7, 6, 5, 4, 3, 2, 1);
// B = [ 9 6 3
//       8 5 2
//       7 4 1 ]
A += B;
// A = [ 10 8  6
//       10 9  8
//       10 10 10 ]

Definition at line 375 of file RankTwoTensorImplementation.h.

{
  libMesh::TensorValue<T>::operator+=(a);
  return *this;
}

◆ operator-() [1/2]

template<typename T >

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

Return the negation of this tensor.

RankTwoTensor A(1, 2, 3, 4, 5, 6, 7, 8, 9);
// A = [ 1 2 3
//       2 4 6
//       3 6 9 ]
RankTwoTensor B = -A;
// B = [ -1 -2 -3
//       -2 -4 -6
//       -3 -6 -9 ]

Definition at line 391 of file RankTwoTensorImplementation.h.

{
  return libMesh::TensorValue<T>::operator-();
}

◆ operator-() [2/2]

template<typename T >

template<typename T2 >

RankTwoTensorTempl< typename libMesh::CompareTypes< T, T2 >::supertype > RankTwoTensorTempl< T >::operator- ( const libMesh::TypeTensor< T2 > & a ) const

Return the subtraction of two second order tensors.

RankTwoTensor A(1, 2, 3, 4, 5, 6, 7, 8, 9);
// A = [ 1 2 3
//       2 4 6
//       3 6 9 ]
RankTwoTensor B(9, 8, 7, 6, 5, 4, 3, 2, 1);
// B = [ 9 6 3
//       8 5 2
//       7 4 1 ]
RankTwoTensor C = A - B;
// C = [ -8 -4 0
//       -6 -1 4
//       -4  2 8 ]

Definition at line 1416 of file RankTwoTensor.h.

{
  return libMesh::TensorValue<T>::operator-(b);
}

◆ operator-=()

template<typename T >

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

Subtract another second order tensor from this one.

RankTwoTensor A(1, 2, 3, 4, 5, 6, 7, 8, 9);
// A = [ 1 2 3
//       2 4 6
//       3 6 9 ]
RankTwoTensor B(9, 8, 7, 6, 5, 4, 3, 2, 1);
// B = [ 9 6 3
//       8 5 2
//       7 4 1 ]
A -= B;
// A = [ -8 -4 0
//       -6 -1 4
//       -4  2 8 ]

Definition at line 383 of file RankTwoTensorImplementation.h.

{
  libMesh::TensorValue<T>::operator-=(a);
  return *this;
}

◆ operator/()

template<typename T >

template<typename T2 , typename std::enable_if< libMesh::ScalarTraits< T2 >::value, int >::type >

RankTwoTensorTempl< typename libMesh::CompareTypes< T, T2 >::supertype > RankTwoTensorTempl< T >::operator/ ( const T2 & a ) const

Return this tensor divided by a scalar (component-wise)

RankTwoTensor A(1, 2, 3, 4, 5, 6, 7, 8, 9);
// A = [ 1 2 3
//       2 4 6
//       3 6 9 ]
RankTwoTensor B = A / 2;
// B = [ 0.5 1.0 1.5
//       1.0 2.0 3.0
//       1.5 3.0 4.5 ]

Definition at line 1448 of file RankTwoTensor.h.

{
  return libMesh::TensorValue<T>::operator/(b);
}

◆ operator/=()

template<typename T >

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

Divide this tensor by a scalar (component-wise)

RankTwoTensor A(1, 2, 3, 4, 5, 6, 7, 8, 9);
// A = [ 1 2 3
//       2 4 6
//       3 6 9 ]
A /= 2;
// A = [ 0.5 1.0 1.5
//       1.0 2.0 3.0
//       1.5 3.0 4.5 ]

Definition at line 406 of file RankTwoTensorImplementation.h.

{
  libMesh::TensorValue<T>::operator/=(a);
  return *this;
}

◆ operator=() [1/3]

template<typename T >

RankTwoTensorTempl< T > & RankTwoTensorTempl< T >::operator= ( const ColumnMajorMatrixTempl< T > & a )

Assignment operator (from a ColumnMajorMatrixTempl<T>)

RankTwoTensor A;
// A = [ 0 0 0
//       0 0 0
//       0 0 0 ]
RealVectorValue col1(1, 2, 3);
RealVectorValue col2(4, 5, 6);
RealVectorValue col3(7, 8, 9);
ColumnMajorMatrix B(col1, col2, col3);
// B = [ 1 4 7
//       2 5 8
//       3 6 9 ]
A = B;
// A = [ 1 4 7
//       2 5 8
//       3 6 9 ]

Definition at line 442 of file RankTwoTensorImplementation.h.

{
  if (a.n() != N || a.m() != N)
    mooseError("Dimensions of ColumnMajorMatrixTempl<T> are incompatible with RankTwoTensorTempl");
 
  const T * cmm_rawdata = a.rawData();
  for (const auto i : make_range(N))
    for (const auto j : make_range(N))
      _coords[i * N + j] = cmm_rawdata[i + j * N];
 
  return *this;
}

◆ operator=() [2/3]

template<typename T >

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

default

Assignment operator.

RankTwoTensor A;
// A = [ 0 0 0
//       0 0 0
//       0 0 0 ]
RankTwoTensor B(9, 8, 7, 6, 5, 4, 3, 2, 1);
// B = [ 9 6 3
//       8 5 2
//       7 4 1 ]
A = B;
// A = [ 9 6 3
//       8 5 2
//       7 4 1 ]

◆ operator=() [3/3]

template<typename T >

template<typename Scalar >

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

inline

Assignment-from-scalar operator.

Used only to zero out the tensor.

RankTwoTensor A(1, 2, 3, 4, 5, 6, 7, 8, 9);
// A = [ 1 2 3
//       2 4 6
//       3 6 9 ]
A = 0;
// A = [ 0 0 0
//       0 0 0
//       0 0 0 ]
A = 1;
// This triggers an assertion failure.
A = 0.0;
// This triggers an assertion failure.

Definition at line 553 of file RankTwoTensor.h.

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

◆ operator==()

template<typename T >

bool RankTwoTensorTempl< T >::operator== ( const RankTwoTensorTempl< T > & a ) const

Defines logical equality with another RankTwoTensorTempl<T>

Definition at line 422 of file RankTwoTensorImplementation.h.

{
  for (const auto i : make_range(N))
    for (const auto j : make_range(N))
      if (!MooseUtils::absoluteFuzzyEqual((*this)(i, j), a(i, j)))
        return false;
 
  return true;
}

◆ outerProduct() [1/2]

template<typename T >

RankTwoTensorTempl< T > RankTwoTensorTempl< T >::outerProduct	(	const libMesh::TypeVector< T > &	v1,
		const libMesh::TypeVector< T > &	v2
	)

static

Initialize a second order tensor as the outer product of two vectors, i.e.

\( A_{ij} = a_i b_j \).

RealVectorValue a(1, 2, 3);
RealVectorValue b(4, 5, 6);
auto A = RankTwoTensor::outerProduct(a, b);
// A = [ 4  5  6
//       8  10 12
//       12 15 18 ]

Definition at line 939 of file RankTwoTensorImplementation.h.

{
  RankTwoTensorTempl<T> result;
  for (const auto i : make_range(N))
    for (const auto j : make_range(N))
      result(i, j) = v1(i) * v2(j);
  return result;
}

◆ outerProduct() [2/2]

template<typename T >

RankFourTensorTempl< T > RankTwoTensorTempl< T >::outerProduct ( const RankTwoTensorTempl< T > & b ) const

inline

Return the outer product \( C_{ijkl} = A_{ij} B_{kl} \).

Definition at line 1160 of file RankTwoTensor.h.

  {
    usingTensorIndices(i_, j_, k_, l_);
    return times<i_, j_, k_, l_>(b);
  }

◆ plusTranspose()

template<typename T >

RankTwoTensorTempl< T > RankTwoTensorTempl< T >::plusTranspose ( const RankTwoTensorTempl< T > & a )

static

Initialize a second order tensor with expression \( E_{ij} = C_{ij} + C_{ji} \).

RankTwoTensor C(1, 2, 3, 4, 5, 6, 7, 8, 9);
// C = [ 1 4 7
//       2 5 8
//       3 6 9 ]
auto E = RankTwoTensor::plusTranspose(C);
// E = [ 2  6  10
//       6  10 14
//       10 14 18 ]

Definition at line 295 of file RankTwoTensorImplementation.h.

{
  return a + a.transpose();
}

Referenced by RankTwoTensorTempl< T >::d2thirdInvariant(), RankTwoTensorTempl< T >::dsecondInvariant(), RankTwoTensorTempl< T >::dthirdInvariant(), and RankTwoTensorTempl< T >::thirdInvariant().

◆ positiveProjectionEigenDecomposition()

template<typename T >

RankFourTensorTempl< T > RankTwoTensorTempl< T >::positiveProjectionEigenDecomposition	(	std::vector< T > &	eigval,
		RankTwoTensorTempl< T > &	eigvec
	)		const

Return the positive projection tensor.

Consider the eigenvalue decomposition of this second order tensor \( A = V D V^T \), the part of this tensor that lies on the positive spectrum is defined as \( A_+ = V \left<D\right> V^T \) where the angled brackets are the Macaulay brackets. The positive projection tensor is the linear projection from the full spectrum to the positive spectrum, i.e. \( A_+ = P A \). The derivation of this positive projection tensor can be found in C. Miehe and M. Lambrecht, Commun. Numer. Meth. Engng 2001; 17:337~353

Parameters

eigvals	The three eigenvalues of this second order tensor will be filled into this vector.
eigvecs	The three eigenvectors of this second order tensor will be filled into this tensor.

Returns: The fourth order positive projection tensor.

Definition at line 1455 of file RankTwoTensor.h.

{
  using std::abs;
  if constexpr (MooseUtils::IsLikeReal<T>::value)
  {
    // Compute eigenvectors and eigenvalues of this tensor
    this->symmetricEigenvaluesEigenvectors(eigval, eigvec);
 
    // Separate out positive and negative eigen values
    std::array<T, N> epos;
    std::array<T, N> d;
    for (auto i : libMesh::make_range(N))
    {
      epos[i] = (abs(eigval[i]) + eigval[i]) / 2.0;
      d[i] = 0 < eigval[i] ? 1.0 : 0.0;
    }
 
    // projection tensor
    RankFourTensorTempl<T> proj_pos;
    RankFourTensorTempl<T> Gab, Gba;
 
    for (auto a : libMesh::make_range(N))
    {
      const auto Ma = RankTwoTensorTempl<T>::selfOuterProduct(eigvec.column(a));
      proj_pos += d[a] * Ma.outerProduct(Ma);
    }
 
    usingTensorIndices(i_, j_, k_, l_);
    for (const auto a : libMesh::make_range(N))
      for (const auto b : libMesh::make_range(a))
      {
        const auto Ma = RankTwoTensorTempl<T>::selfOuterProduct(eigvec.column(a));
        const auto Mb = RankTwoTensorTempl<T>::selfOuterProduct(eigvec.column(b));
 
        Gab = Ma.template times<i_, k_, j_, l_>(Mb) + Ma.template times<i_, l_, j_, k_>(Mb);
        Gba = Mb.template times<i_, k_, j_, l_>(Ma) + Mb.template times<i_, l_, j_, k_>(Ma);
 
        T theta_ab;
        if (!MooseUtils::absoluteFuzzyEqual(eigval[a], eigval[b]))
          theta_ab = 0.5 * (epos[a] - epos[b]) / (eigval[a] - eigval[b]);
        else
          theta_ab = 0.25 * (d[a] + d[b]);
 
        proj_pos += theta_ab * (Gab + Gba);
      }
    return proj_pos;
  }
  else
    mooseError("positiveProjectionEigenDecomposition is only available for ordered tensor "
               "component types");
}

◆ print()

template<typename T >

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

Print the rank two tensor.

Definition at line 714 of file RankTwoTensorImplementation.h.

{
  const RankTwoTensorTempl<T> & a = *this;
  for (const auto i : make_range(N))
  {
    for (const auto j : make_range(N))
      stm << std::setw(15) << a(i, j) << ' ';
    stm << std::endl;
  }
}

◆ printADReal()

void ADRankTwoTensor::printADReal	(	unsigned int	nDual,
		std::ostream &	stm = `Moose::out`
	)		const

Print the Real part of the RankTwoTensorTempl<ADReal> along with its first nDual dual numbers.

Definition at line 34 of file RankTwoTensorImplementation.C.

{
  const ADRankTwoTensor & a = *this;
  for (const auto i : make_range(N))
  {
    for (const auto j : make_range(N))
    {
      stm << std::setw(15) << a(i, j).value() << " {";
      for (const auto k : make_range(nDual))
        stm << std::setw(5) << a(i, j).derivatives()[k] << ' ';
      stm << " }";
    }
    stm << std::endl;
  }
}

◆ printReal()

void ADRankTwoTensor::printReal ( std::ostream & stm = Moose::out ) const

Print the Real part of the RankTwoTensorTempl<ADReal>

Definition at line 21 of file RankTwoTensorImplementation.C.

{
  const ADRankTwoTensor & a = *this;
  for (const auto i : make_range(N))
  {
    for (const auto j : make_range(N))
      stm << std::setw(15) << a(i, j).value() << ' ';
    stm << std::endl;
  }
}

◆ rotate()

template<typename T >

void RankTwoTensorTempl< T >::rotate ( const RankTwoTensorTempl< T > & R )

Rotate the tensor in-place given a rotation tensor \( A_{ij} \leftarrow R_{ij} A_{jk} R_{jk} \).

Parameters

R	The rotation tensor

RankTwoTensor A(1, 2, 3, 4, 5, 6, 7, 8, 9);
// A = [ 1 4 7
//       2 5 8
//       3 6 9 ]
RankTwoTensor R(0, 1, 0, 1, 0, 0, 0, 0, 1);
// R = [ 0 1 0
//       1 0 0
//       0 0 1 ]
A.rotate(R);
// A = [ 5 2 8
//       4 1 7
//       6 3 9 ]

Definition at line 318 of file RankTwoTensorImplementation.h.

{
  RankTwoTensorTempl<T> temp;
  for (const auto i : make_range(N))
  {
    const auto i1 = i * N;
    for (const auto j : make_range(N))
    {
      // tmp += R(i,k)*R(j,l)*(*this)(k,l);
      // clang-format off
      const auto j1 = j * N;
      T tmp = R._coords[i1 + 0] * R._coords[j1 + 0] * (*this)(0, 0) +
                 R._coords[i1 + 0] * R._coords[j1 + 1] * (*this)(0, 1) +
                 R._coords[i1 + 0] * R._coords[j1 + 2] * (*this)(0, 2) +
                 R._coords[i1 + 1] * R._coords[j1 + 0] * (*this)(1, 0) +
                 R._coords[i1 + 1] * R._coords[j1 + 1] * (*this)(1, 1) +
                 R._coords[i1 + 1] * R._coords[j1 + 2] * (*this)(1, 2) +
                 R._coords[i1 + 2] * R._coords[j1 + 0] * (*this)(2, 0) +
                 R._coords[i1 + 2] * R._coords[j1 + 1] * (*this)(2, 1) +
                 R._coords[i1 + 2] * R._coords[j1 + 2] * (*this)(2, 2);
      // clang-format on
      temp._coords[i1 + j] = tmp;
    }
  }
  for (unsigned int i = 0; i < N2; i++)
    _coords[i] = temp._coords[i];
}

Referenced by RankTwoTensorTempl< T >::rotated().

◆ rotated()

template<typename T >

RankTwoTensorTempl< T > RankTwoTensorTempl< T >::rotated ( const RankTwoTensorTempl< T > & R ) const

Return the rotated tensor given a rotation tensor \( A'_{ij} = R_{ij} A_{jk} R_{jk} \).

Parameters

R	The rotation tensor

RankTwoTensor A(1, 2, 3, 4, 5, 6, 7, 8, 9);
// A = [ 1 4 7
//       2 5 8
//       3 6 9 ]
RankTwoTensor R(0, 1, 0, 1, 0, 0, 0, 0, 1);
// R = [ 0 1 0
//       1 0 0
//       0 0 1 ]
RankTwoTensor A_rotated = A.rotated(R);
// A_rotated = [ 5 2 8
//               4 1 7
//               6 3 9 ]

Definition at line 309 of file RankTwoTensorImplementation.h.

{
  RankTwoTensorTempl<T> result(*this);
  result.rotate(R);
  return result;
}

◆ rotateXyPlane()

template<typename T >

RankTwoTensorTempl< T > RankTwoTensorTempl< T >::rotateXyPlane ( T a )

Rotate the tensor about the z-axis.

Parameters

a	The rotation angle in radians

Definition at line 348 of file RankTwoTensorImplementation.h.

{
  using std::cos, std::sin;
  T c = cos(a);
  T s = sin(a);
  T x = (*this)(0, 0) * c * c + (*this)(1, 1) * s * s + 2.0 * (*this)(0, 1) * c * s;
  T y = (*this)(0, 0) * s * s + (*this)(1, 1) * c * c - 2.0 * (*this)(0, 1) * c * s;
  T xy = ((*this)(1, 1) - (*this)(0, 0)) * c * s + (*this)(0, 1) * (c * c - s * s);
 
  RankTwoTensorTempl<T> b(*this);
 
  b(0, 0) = x;
  b(1, 1) = y;
  b(1, 0) = b(0, 1) = xy;
 
  return b;
}

◆ secondInvariant()

template<typename T >

T RankTwoTensorTempl< T >::secondInvariant ( ) const

Return the main second invariant of this second order tensor.

\( J_2 = \frac{1}{2} \left( S_{ij}S_{ij} \right) \), where \( S_{ij} = A_{ij} - \frac{1}{3}A_{kk}\delta_{ij} \)

Definition at line 513 of file RankTwoTensorImplementation.h.

{
  T result;
 
  // RankTwoTensorTempl<T> deviatoric(*this);
  // deviatoric.addIa(-1.0/3.0 * this->tr()); // actually construct deviatoric part
  // result = 0.5*(deviatoric + deviatoric.transpose()).doubleContraction(deviatoric +
  // deviatoric.transpose());
  result = Utility::pow<2>((*this)(0, 0) - (*this)(1, 1)) / 6.0;
  result += Utility::pow<2>((*this)(0, 0) - (*this)(2, 2)) / 6.0;
  result += Utility::pow<2>((*this)(1, 1) - (*this)(2, 2)) / 6.0;
  result += Utility::pow<2>((*this)(0, 1) + (*this)(1, 0)) / 4.0;
  result += Utility::pow<2>((*this)(0, 2) + (*this)(2, 0)) / 4.0;
  result += Utility::pow<2>((*this)(1, 2) + (*this)(2, 1)) / 4.0;
  return result;
}

◆ selfOuterProduct()

template<typename T >

RankTwoTensorTempl< T > RankTwoTensorTempl< T >::selfOuterProduct ( const libMesh::TypeVector< T > & v )

static

Initialize a second order tensor as the outer product of a vector with itself, i.e.

\( A_{ij} = a_i a_j \).

RealVectorValue a(1, 2, 3);
auto A = RankTwoTensor::selfOuterProduct(a);
// A = [ 1 2 3
//       2 4 6
//       3 6 9 ]

Definition at line 951 of file RankTwoTensorImplementation.h.

{
  RankTwoTensorTempl<T> result(RankTwoTensorTempl<T>::initNone);
  for (unsigned int i = 0; i < N; ++i)
    for (unsigned int j = 0; j < N; ++j)
      result(i, j) = v(i) * v(j);
  return result;
}

Referenced by RankTwoTensorTempl< T >::positiveProjectionEigenDecomposition().

◆ setToIdentity()

template<typename T >

void RankTwoTensorTempl< T >::setToIdentity ( )

Set the tensor to identity.

RankTwoTensor A;
// A = [ 0 0 0
//       0 0 0
//       0 0 0 ]
A.setToIdentity();
// A = [ 1 0 0
//       0 1 0
//       0 0 1 ]

Definition at line 1000 of file RankTwoTensorImplementation.h.

{
  mooseAssert(N2 == 9, "RankTwoTensorTempl is currently only tested for 3 dimensions.");
  for (const auto i : make_range(N2))
    _coords[i] = identityCoords[i];
}

◆ sin3Lode()

template<typename T >

T RankTwoTensorTempl< T >::sin3Lode	(	const T &	r0,
		const T &	r0_value
	)		const

Sin(3*Lode_angle)

If secondInvariant() <= r0 then return r0_value This is to gaurd against precision-loss errors. Note that sin(3*Lode_angle) is not defined for secondInvariant() = 0

Definition at line 1510 of file RankTwoTensor.h.

{
  using std::pow, std::max, std::sqrt, std::min;
  if constexpr (MooseUtils::IsLikeReal<T>::value)
  {
    T bar = secondInvariant();
    if (bar <= r0)
      // in this case the Lode angle is not defined
      return r0_value;
    else
      // the min and max here gaurd against precision-loss when bar is tiny but nonzero.
      return max(min(-1.5 * sqrt(3.0) * thirdInvariant() / pow(bar, 1.5), 1.0), -1.0);
  }
  else
    mooseError("sin3Lode is only available for ordered tensor component types");
}

◆ square()

template<typename T >

RankTwoTensorTempl< T > RankTwoTensorTempl< T >::square ( ) const

Return \( A_{ij} = A_{ik}A_{kj} \).

RankTwoTensor A(1, 2, 3, 4, 5, 6, 7, 8, 9);
// A = [ 1 4 7
//       2 5 8
//       3 6 9 ]
RankTwoTensor B = A.square();
// B = [ 30 66 102
//       36 81 126
//       42 96 150 ]

Definition at line 302 of file RankTwoTensorImplementation.h.

{
  return *this * *this;
}

◆ surfaceFillFromInputVector()

template<typename T >

void RankTwoTensorTempl< T >::surfaceFillFromInputVector ( const std::vector< T > & input )

sets _coords[0][0], _coords[0][1], _coords[1][0], _coords[1][1] to input, and the remainder to zero

Definition at line 758 of file RankTwoTensorImplementation.h.

{
  if (input.size() == 4)
  {
    // initialize with zeros
    this->zero();
    (*this)(0, 0) = input[0];
    (*this)(0, 1) = input[1];
    (*this)(1, 0) = input[2];
    (*this)(1, 1) = input[3];
  }
  else
    mooseError("please provide correct number of values for surface RankTwoTensorTempl<T> "
               "initialization.");
}

◆ syev()

template<typename T >

void RankTwoTensorTempl< T >::syev	(	const char *	calculation_type,
		std::vector< T > &	eigvals,
		std::vector< T > &	a
	)		const

protected

Uses the petscblaslapack.h LAPACKsyev_ routine to find, for symmetric _coords: (1) the eigenvalues (if calculation_type == "N") (2) the eigenvalues and eigenvectors (if calculation_type == "V")

Parameters

calculation_type	If "N" then calculation eigenvalues only
eigvals	Eigenvalues are placed in this array, in ascending order
a	Eigenvectors are placed in this array if calculation_type == "V". See code in dsymmetricEigenvalues for extracting eigenvectors from the a output.

Definition at line 776 of file RankTwoTensorImplementation.h.

{
  mooseError("The syev method is only supported for Real valued tensors");
}

◆ symmetricEigenvalues()

template<typename T >

void RankTwoTensorTempl< T >::symmetricEigenvalues ( std::vector< T > & eigvals ) const

computes eigenvalues, assuming tens is symmetric, and places them in ascending order in eigvals

Definition at line 788 of file RankTwoTensorImplementation.h.

{
  RankTwoTensorTempl<T> a;
  symmetricEigenvaluesEigenvectors(eigvals, a);
}

◆ symmetricEigenvaluesEigenvectors()

template<typename T >

void RankTwoTensorTempl< T >::symmetricEigenvaluesEigenvectors	(	std::vector< T > &	eigvals,
		RankTwoTensorTempl< T > &	eigvecs
	)		const

computes eigenvalues and eigenvectors, assuming tens is symmetric, and places them in ascending order in eigvals.

eigvecs is a matrix with the first column being the first eigenvector, the second column being the second, etc.

Definition at line 799 of file RankTwoTensorImplementation.h.

{
  mooseError(
      "symmetricEigenvaluesEigenvectors is only available for ordered tensor component types");
}

◆ thirdInvariant()

template<typename T >

T RankTwoTensorTempl< T >::thirdInvariant ( ) const

Denote the _coords[i][j] by A_ij, then S_ij = A_ij - de_ij*tr(A)/3 Then this returns det(S + S.transpose())/2 Note the explicit symmeterisation.

Definition at line 575 of file RankTwoTensorImplementation.h.

{
  const auto s = RankTwoTensorTempl<T>::plusTranspose(deviatoric()) * 0.5;
  return s(0, 0) * (s(1, 1) * s(2, 2) - s(2, 1) * s(1, 2)) -
         s(1, 0) * (s(0, 1) * s(2, 2) - s(2, 1) * s(0, 2)) +
         s(2, 0) * (s(0, 1) * s(1, 2) - s(1, 1) * s(0, 2));
}

◆ times() [1/2]

template<typename T >

template<int n, int o, int p, int q, int r, int s>

RankFourTensorTempl< T > RankTwoTensorTempl< T >::times ( const RankFourTensorTempl< T > & b ) const

Return the single contraction of this second order tensor with a fourth order tensor defined as \( C_{ijkl} = A_{\mathcal{M}(m)\mathcal{M}(n)} B_{\mathcal{M}(p)\mathcal{M}(q)\mathcal{M}(r)\mathcal{M}(s)} \) where the multiplication order is defined by the index map \( \mathcal{M}: \{m,n,p,q,r,s\} \to \{i,j,k,l\} \).

The index map is specified using the template parameters. See examples below for detailed explanation.

Suppose we have a second order tensors A and a fourth order tensor B, and we denote the indices (four output indices and a dummy index to be contracted) as i, j, k, l, m:

usingTensorIndices(i, j, k, l, m);

The single contraction of A and B defined as \( A_{im} B_{mjkl} \) can be expressed using the template specialization times<i, m, m, j, k, l>

RankFourTensor C = A.times<i, m, m, j, k, l>(B);

Similarly, another single contraction of A and B, i.e. \( A_{m, i} A_{j, k, m, l} \) can be expressed using the template specialization times<m, i, j, k, m, l>

RankFourTensor C = A.times<m, i, j, k, m, l>(B);

The combination goes on. Note that this method assumes exactly one repeated index.

Definition at line 1597 of file RankTwoTensor.h.

{
  RankFourTensorTempl<T> result;
  std::size_t x[5];
  for (x[0] = 0; x[0] < N; ++x[0])
    for (x[1] = 0; x[1] < N; ++x[1])
      for (x[2] = 0; x[2] < N; ++x[2])
        for (x[3] = 0; x[3] < N; ++x[3])
          for (x[4] = 0; x[4] < N; ++x[4])
            result(x[0], x[1], x[2], x[3]) += (*this)(x[n], x[o]) * b(x[p], x[q], x[r], x[s]);
 
  return result;
}

◆ times() [2/2]

template<typename T >

template<int n, int o, int p, int q>

RankFourTensorTempl< T > RankTwoTensorTempl< T >::times ( const RankTwoTensorTempl< T > & b ) const

Return the general tensor product of this second order tensor and another second order tensor defined as \( C_{ijkl} = A_{\mathcal{M}(n)\mathcal{M}(o)} B_{\mathcal{M}(p)\mathcal{M}(q)} \) where the multiplication order is defined by the index map \( \mathcal{M}: \{n,o,p,q\} \to \{i,j,k,l\} \).

The index map is specified using the template parameters. See examples below for detailed explanation.

Suppose we have two second order tensors A and B, and we denote the output indices as i, j, k, l:

usingTensorIndices(i, j, k, l);

The outer product of A and B is defined as \( A_{ij} B_{kl} \), hence the template specialization should be times<i, j, k, l>

RankFourTensor C = A.times<i, j, k, l>(B);

The tensor product of A and B, i.e. \( A_{ik} B_{jl} \) can be expressed using the template specialization times<i, k, j, l>

RankFourTensor C = A.times<i, k, j, l>(B);

Similarly, another tensor product of A and B, i.e. \( A_{il} B_{jk} \) can be expressed using the template specialization times<i, l, j, k>

RankFourTensor C = A.times<i, l, j, k>(B);

The combination goes on...

Definition at line 1581 of file RankTwoTensor.h.

{
  RankFourTensorTempl<T> result;
  std::size_t x[4];
  for (x[0] = 0; x[0] < N; ++x[0])
    for (x[1] = 0; x[1] < N; ++x[1])
      for (x[2] = 0; x[2] < N; ++x[2])
        for (x[3] = 0; x[3] < N; ++x[3])
          result(x[0], x[1], x[2], x[3]) = (*this)(x[n], x[o]) * b(x[p], x[q]);
 
  return result;
}

◆ timesTranspose()

template<typename T >

RankTwoTensorTempl< T > RankTwoTensorTempl< T >::timesTranspose ( const RankTwoTensorTempl< T > & a )

static

Initialize a second order tensor with expression \( B_{ij} = F_{ij} F_{ji} \).

RankTwoTensor F(1, 2, 3, 4, 5, 6, 7, 8, 9);
// F = [ 1 4 7
//       2 5 8
//       3 6 9 ]
auto B = RankTwoTensor::timesTranspose(F);
// B = [ 66 78  90
//       78 93  108
//       90 108 126 ]

Definition at line 281 of file RankTwoTensorImplementation.h.

{
  return a * a.transpose();
}

◆ trace()

template<typename T >

T RankTwoTensorTempl< T >::trace ( ) const

A wrapper for tr()

See also: tr()

Definition at line 553 of file RankTwoTensorImplementation.h.

{
  // deprecate this!
  return this->tr();
}

◆ transpose()

template<typename T >

RankTwoTensorTempl< T > RankTwoTensorTempl< T >::transpose ( ) const

Return the tensor transposed.

RankTwoTensor A(1, 2, 3, 4, 5, 6, 7, 8, 9);
// A = [ 1 4 7
//       2 5 8
//       3 6 9 ]
RankTwoTensor At = A.transpose();
// At = [ 1 2 3
//        4 5 6
//        7 8 9 ]

Definition at line 368 of file RankTwoTensorImplementation.h.

{
  return libMesh::TensorValue<T>::transpose();
}

Referenced by RankTwoTensorTempl< T >::plusTranspose(), RankTwoTensorTempl< T >::timesTranspose(), and RankTwoTensorTempl< T >::transposeTimes().

◆ transposeTimes()

template<typename T >

RankTwoTensorTempl< T > RankTwoTensorTempl< T >::transposeTimes ( const RankTwoTensorTempl< T > & a )

static

Initialize a second order tensor with expression \( C_{ij} = F_{ji} F_{ij} \).

RankTwoTensor F(1, 2, 3, 4, 5, 6, 7, 8, 9);
// F = [ 1 4 7
//       2 5 8
//       3 6 9 ]
auto C = RankTwoTensor::transposeTimes(F);
// C = [ 14 32  50
//       32 77  122
//       50 122 194 ]

Definition at line 288 of file RankTwoTensorImplementation.h.

{
  return a.transpose() * a;
}

◆ vectorOuterProduct()

template<typename T >

void RankTwoTensorTempl< T >::vectorOuterProduct	(	const libMesh::TypeVector< T > &	v1,
		const libMesh::TypeVector< T > &	v2
	)

Set the values of the second order tensor to be the outer product of two vectors, i.e.

\( A_{ij} = a_i b_j \).

Deprecated in favor of outerProduct()

RealVectorValue a(1, 2, 3);
RealVectorValue b(4, 5, 6);
RankTwoTensor A;
A.vectorOuterProduct(a, b);
// A = [ 4  5  6
//       8  10 12
//       12 15 18 ]

Definition at line 928 of file RankTwoTensorImplementation.h.

{
  RankTwoTensorTempl<T> & a = *this;
  for (const auto i : make_range(N))
    for (const auto j : make_range(N))
      a(i, j) = v1(i) * v2(j);
}

Friends And Related Symbol Documentation

◆ dataLoad

template<typename T >

template<class T2 >

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

friend

◆ dataStore

template<typename T >

template<class T2 >

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

friend

◆ RankFourTensorTempl

template<typename T >

template<class T2 >

friend class RankFourTensorTempl

friend

Definition at line 1381 of file RankTwoTensor.h.

◆ RankThreeTensorTempl

template<typename T >

template<class T2 >

friend class RankThreeTensorTempl

friend

Definition at line 1383 of file RankTwoTensor.h.

Member Data Documentation

◆ identityCoords

template<typename T >

constexpr Real RankTwoTensorTempl< T >::identityCoords = {1, 0, 0, 0, 1, 0, 0, 0, 1}

staticconstexprprivate

Definition at line 1371 of file RankTwoTensor.h.

1371{1, 0, 0, 0, 1, 0, 0, 0, 1};

◆ N

template<typename T >

constexpr unsigned int RankTwoTensorTempl< T >::N = Moose::dim

staticconstexpr

Tensor dimension, i.e.

number of rows/columns of the second order tensor

Definition at line 95 of file RankTwoTensor.h.

Referenced by RankTwoTensorTempl< T >::printADReal(), and RankTwoTensorTempl< T >::printReal().

◆ N2

template<typename T >

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

staticconstexpr

The square of the tensor dimension.

Definition at line 100 of file RankTwoTensor.h.

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

include/utils/RankTwoTensor.h
include/utils/RankTwoTensorImplementation.h
src/utils/RankTwoTensorImplementation.C

Public Types

Public Member Functions

Static Public Member Functions

Protected Member Functions

Protected Attributes

Static Private Attributes

Friends

Detailed Description

Member Enumeration Documentation

◆ FillMethod

◆ InitMethod

Constructor & Destructor Documentation

◆ RankTwoTensorTempl() [1/11]

◆ RankTwoTensorTempl() [2/11]

◆ RankTwoTensorTempl() [3/11]

◆ RankTwoTensorTempl() [4/11]

◆ RankTwoTensorTempl() [5/11]

◆ RankTwoTensorTempl() [6/11]

◆ RankTwoTensorTempl() [7/11]

◆ RankTwoTensorTempl() [8/11]

◆ RankTwoTensorTempl() [9/11]

◆ RankTwoTensorTempl() [10/11]

◆ RankTwoTensorTempl() [11/11]

Member Function Documentation

◆ addIa()

◆ column()

◆ contraction()

◆ d2secondInvariant()

◆ d2sin3Lode()

◆ d2symmetricEigenvalues()

◆ d2thirdInvariant()

◆ ddet()

◆ deviatoric()

◆ doubleContraction()

◆ dsecondInvariant()

◆ dsin3Lode()

◆ dsymmetricEigenvalues()

◆ dthirdInvariant()

◆ dtrace()

◆ fillColumn()

◆ fillFromInputVector()

◆ fillFromScalarVariable()

◆ fillMethodEnum()

◆ fillRealTensor()

◆ fillRow()

◆ generalSecondInvariant()

◆ genRandomSymmTensor()

◆ genRandomTensor()

◆ getRUDecompositionRotation()

◆ Identity()

◆ initialContraction()

◆ initializeFromColumns()

◆ initializeFromRows()

◆ initializeSymmetric()

◆ initRandom()

◆ inverse()

◆ isSymmetric()

◆ L2norm()

◆ mixedProductJkI()

◆ operator*() [1/3]

◆ operator*() [2/3]

◆ operator*() [3/3]

◆ operator*=() [1/2]

◆ operator*=() [2/2]

◆ operator+()

◆ operator+=()

◆ operator-() [1/2]

◆ operator-() [2/2]

◆ operator-=()

◆ operator/()

◆ operator/=()

◆ operator=() [1/3]

◆ operator=() [2/3]

◆ operator=() [3/3]

◆ operator==()

◆ outerProduct() [1/2]

◆ outerProduct() [2/2]

◆ plusTranspose()

◆ positiveProjectionEigenDecomposition()

◆ print()