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

RankThreeTensor is designed to handle any N-dimensional third order tensor, r. More...

#include <RankThreeTensor.h>

Public Types

enum  InitMethod { initNone }
 Initialization method. More...
 
enum  FillMethod { automatic, general, plane_normal }
 To fill up the 27 entries in the 3rd-order tensor, fillFromInputVector is called with one of the following fill_methods. More...
 

Public Member Functions

 RankThreeTensorTempl ()
 Default constructor; fills to zero. More...
 
 RankThreeTensorTempl (const RankThreeTensorTempl< T > &a)=default
 Copy assignment operator must be defined if used. More...
 
template<typename T2 >
 RankThreeTensorTempl (const RankThreeTensorTempl< T2 > &copy)
 Construct from other class template instantiation. More...
 
 RankThreeTensorTempl (const InitMethod)
 Select specific initialization pattern. More...
 
 RankThreeTensorTempl (const std::vector< T > &, FillMethod method=automatic)
 Fill from vector. More...
 
T & operator() (unsigned int i, unsigned int j, unsigned int k)
 Gets the value for the index specified. Takes index = 0,1,2. More...
 
operator() (unsigned int i, unsigned int j, unsigned int k) const
 Gets the value for the index specified. Takes index = 0,1,2. Used for const. More...
 
RankThreeTensorTempl< T > & operator= (const T &value)
 Assignment-from-scalar operator. More...
 
void zero ()
 Zeros out the tensor. More...
 
void print (std::ostream &stm=Moose::out) const
 Print the rank three tensor. More...
 
RankThreeTensorTempl< T > & operator= (const RankThreeTensorTempl< T > &a)
 copies values from "a" into this tensor More...
 
template<typename T2 >
RankThreeTensorTempl< T > & operator= (const RankThreeTensorTempl< T2 > &a)
 
libMesh::VectorValue< T > operator* (const RankTwoTensorTempl< T > &a) const
 b_i = r_ijk * a_jk More...
 
RankTwoTensorTempl< T > operator* (const libMesh::VectorValue< T > &a) const
 b_ij = r_ijk * a_k More...
 
RankThreeTensorTempl< T > operator* (const T a) const
 r_ijk*a More...
 
RankThreeTensorTempl< T > & operator*= (const T a)
 r_ijk *= a More...
 
RankThreeTensorTempl< T > operator/ (const T a) const
 r_ijk/a More...
 
RankThreeTensorTempl< T > & operator/= (const T a)
 r_ijk /= a for all i, j, k More...
 
RankThreeTensorTempl< T > & operator+= (const RankThreeTensorTempl< T > &a)
 r_ijk += a_ijk for all i, j, k More...
 
RankThreeTensorTempl< T > operator+ (const RankThreeTensorTempl< T > &a) const
 r_ijkl + a_ijk More...
 
RankThreeTensorTempl< T > & operator-= (const RankThreeTensorTempl< T > &a)
 r_ijk -= a_ijk More...
 
RankThreeTensorTempl< T > operator- (const RankThreeTensorTempl< T > &a) const
 r_ijk - a_ijk More...
 
RankThreeTensorTempl< T > operator- () const
 -r_ijk More...
 
L2norm () const
 (r_ijk*r_ijk) More...
 
template<class T2 >
void rotate (const T2 &R)
 Rotate the tensor using r_ijk = R_im R_in R_ko r_mno. More...
 
void rotate (const libMesh::TensorValue< T > &R)
 Rotate the tensor using r_ijk = R_im R_in R_ko r_mno. More...
 
void fillFromInputVector (const std::vector< T > &input, FillMethod fill_method=automatic)
 fillFromInputVector takes some number of inputs to fill the Rank-3 tensor. More...
 
void fillFromPlaneNormal (const libMesh::VectorValue< T > &input)
 Fills RankThreeTensor from plane normal vectors ref. More...
 
RankFourTensorTempl< T > mixedProductRankFour (const RankTwoTensorTempl< T > &a) const
 Creates fourth order tensor D_{ijkl}=A_{mij}*b_{mn}*A_{nkl} where A is rank 3 and b is rank 2. More...
 
libMesh::VectorValue< T > doubleContraction (const RankTwoTensorTempl< T > &b) const
 Creates a vector from the double contraction of a rank three and rank two tensor. More...
 

Static Public Member Functions

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

Static Public Attributes

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

Protected Member Functions

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

Protected Attributes

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

Friends

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

Detailed Description

template<typename T>
class RankThreeTensorTempl< T >

RankThreeTensor is designed to handle any N-dimensional third order tensor, r.

Definition at line 55 of file RankThreeTensor.h.

Member Enumeration Documentation

◆ FillMethod

template<typename T>
enum RankThreeTensorTempl::FillMethod

To fill up the 27 entries in the 3rd-order tensor, fillFromInputVector is called with one of the following fill_methods.

See the fill*FromInputVector functions for more details

Enumerator
automatic 
general 
plane_normal 

Definition at line 75 of file RankThreeTensor.h.

◆ InitMethod

template<typename T>
enum RankThreeTensorTempl::InitMethod

Initialization method.

Enumerator
initNone 

Definition at line 65 of file RankThreeTensor.h.

Constructor & Destructor Documentation

◆ RankThreeTensorTempl() [1/5]

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

Default constructor; fills to zero.

Definition at line 47 of file RankThreeTensorImplementation.h.

48 {
49  mooseAssert(N == 3, "RankThreeTensor is currently only tested for 3 dimensions.");
50 
51  for (auto i : make_range(N3))
52  _vals[i] = 0;
53 }
T _vals[N3]
The values of the rank-three tensor stored by index=((i * LIBMESH_DIM + j) * LIBMESH_DIM + k) ...
static constexpr unsigned int N3
IntRange< T > make_range(T beg, T end)
static constexpr unsigned int N
tensor dimension and powers of the dimension

◆ RankThreeTensorTempl() [2/5]

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

Copy assignment operator must be defined if used.

◆ RankThreeTensorTempl() [3/5]

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

Construct from other class template instantiation.

Definition at line 259 of file RankThreeTensor.h.

260 {
261  for (const auto i : libMesh::make_range(N3))
262  _vals[i] = copy._vals[i];
263 }
T _vals[N3]
The values of the rank-three tensor stored by index=((i * LIBMESH_DIM + j) * LIBMESH_DIM + k) ...
static constexpr unsigned int N3
IntRange< T > make_range(T beg, T end)

◆ RankThreeTensorTempl() [4/5]

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

Select specific initialization pattern.

Definition at line 56 of file RankThreeTensorImplementation.h.

57 {
58  switch (init)
59  {
60  case initNone:
61  break;
62 
63  default:
64  mooseError("Unknown RankThreeTensor initialization pattern.");
65  }
66 }
void mooseError(Args &&... args)
Emit an error message with the given stringified, concatenated args and terminate the application...
Definition: MooseError.h:323

◆ RankThreeTensorTempl() [5/5]

template<typename T >
RankThreeTensorTempl< T >::RankThreeTensorTempl ( const std::vector< T > &  input,
FillMethod  method = automatic 
)

Fill from vector.

Definition at line 69 of file RankThreeTensorImplementation.h.

70 {
71  fillFromInputVector(input, fill_method);
72 }
void fillFromInputVector(const std::vector< T > &input, FillMethod fill_method=automatic)
fillFromInputVector takes some number of inputs to fill the Rank-3 tensor.

Member Function Documentation

◆ doubleContraction()

template<typename T >
libMesh::VectorValue< T > RankThreeTensorTempl< T >::doubleContraction ( const RankTwoTensorTempl< T > &  b) const

Creates a vector from the double contraction of a rank three and rank two tensor.

c_i = A_{ijk} * b_{jk}

Definition at line 379 of file RankThreeTensorImplementation.h.

380 {
382 
383  for (auto i : make_range(N))
384  for (auto j : make_range(N2))
385  result(i) += _vals[i * N2 + j] * b._coords[j];
386 
387  return result;
388 }
static constexpr unsigned int N2
T _coords[LIBMESH_DIM *LIBMESH_DIM]
T _vals[N3]
The values of the rank-three tensor stored by index=((i * LIBMESH_DIM + j) * LIBMESH_DIM + k) ...
IntRange< T > make_range(T beg, T end)
static constexpr unsigned int N
tensor dimension and powers of the dimension

◆ fillFromInputVector()

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

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

Parameters
inputthe numbers that will be placed in the tensor
fill_methodthis can be: general (use fillGeneralFromInputVector) more fill_methods to be implemented soon!

Definition at line 255 of file RankThreeTensorImplementation.h.

256 {
257  zero();
258 
259  if (fill_method == automatic)
260  {
261  if (input.size() == 27)
262  fill_method = general;
263  else if (input.size() == 3)
264  fill_method = plane_normal;
265  else
266  mooseError("Unsupported automatic fill method, use 27 values for 'general' and 3 for "
267  "'plane_normal', the supplied size was ",
268  input.size(),
269  ".");
270  }
271 
272  if (fill_method == general)
274 
275  else if (fill_method == plane_normal)
276  {
277  if (input.size() != 3)
278  mooseError("To use fillFromPlaneNormal, your input must have size 3, the supplied size was ",
279  input.size(),
280  ".");
281  fillFromPlaneNormal(libMesh::VectorValue<T>(input[0], input[1], input[2]));
282  }
283 
284  else
285  // This is un-reachable unless a FillMethod is added and the if statement is not updated
286  mooseError("fillFromInputVector called with unknown fill_method of ", fill_method);
287 }
void fillFromPlaneNormal(const libMesh::VectorValue< T > &input)
Fills RankThreeTensor from plane normal vectors ref.
void mooseError(Args &&... args)
Emit an error message with the given stringified, concatenated args and terminate the application...
Definition: MooseError.h:323
void zero()
Zeros out the tensor.
void fillGeneralFromInputVector(const std::vector< T > &input)

◆ fillFromPlaneNormal()

template<typename T >
void RankThreeTensorTempl< T >::fillFromPlaneNormal ( const libMesh::VectorValue< T > &  input)

Fills RankThreeTensor from plane normal vectors ref.

Kuhl et. al. Int. J. Solids Struct. 38(2001) 2933-2952

Parameters
inputplane normal vector

Definition at line 291 of file RankThreeTensorImplementation.h.

292 {
293  unsigned int index = 0;
294  for (auto i : make_range(N))
295  {
296  const T a = input(i);
297  for (auto j : make_range(N))
298  {
299  const T b = input(j);
300  for (auto k : make_range(N))
301  {
302  const T c = input(k);
303  T sum = 0;
304  sum = -2.0 * a * b * c;
305  if (i == j)
306  sum += c;
307  if (i == k)
308  sum += b;
309  _vals[index++] = sum / 2.0;
310  }
311  }
312  }
313 }
T _vals[N3]
The values of the rank-three tensor stored by index=((i * LIBMESH_DIM + j) * LIBMESH_DIM + k) ...
IntRange< T > make_range(T beg, T end)
static constexpr unsigned int N
tensor dimension and powers of the dimension

◆ fillGeneralFromInputVector()

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

Definition at line 365 of file RankThreeTensorImplementation.h.

366 {
367  if (input.size() != 27)
368  mooseError(
369  "To use fillGeneralFromInputVector, your input must have size 27, the supplied size was ",
370  input.size(),
371  ".");
372 
373  for (auto i : make_range(N3))
374  _vals[i] = input[i];
375 }
void mooseError(Args &&... args)
Emit an error message with the given stringified, concatenated args and terminate the application...
Definition: MooseError.h:323
T _vals[N3]
The values of the rank-three tensor stored by index=((i * LIBMESH_DIM + j) * LIBMESH_DIM + k) ...
static constexpr unsigned int N3
IntRange< T > make_range(T beg, T end)

◆ fillMethodEnum()

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

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

Definition at line 41 of file RankThreeTensorImplementation.h.

42 {
43  return MooseEnum("general plane_normal");
44 }
This is a "smart" enum class intended to replace many of the shortcomings in the C++ enum type It sho...
Definition: MooseEnum.h:33

◆ L2norm()

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

(r_ijk*r_ijk)

Definition at line 242 of file RankThreeTensorImplementation.h.

243 {
244  T l2 = 0;
245 
246  for (auto i : make_range(N3))
247  l2 += Utility::pow<2>(_vals[i]);
248 
249  using std::sqrt;
250  return sqrt(l2);
251 }
T _vals[N3]
The values of the rank-three tensor stored by index=((i * LIBMESH_DIM + j) * LIBMESH_DIM + k) ...
static constexpr unsigned int N3
CTSub CT_OPERATOR_BINARY CTMul CTCompareLess CTCompareGreater CTCompareEqual _arg template * sqrt(_arg)) *_arg.template D< dtag >()) CT_SIMPLE_UNARY_FUNCTION(tanh
IntRange< T > make_range(T beg, T end)
CTSub CT_OPERATOR_BINARY CTMul CTCompareLess CTCompareGreater CTCompareEqual _arg template pow< 2 >(tan(_arg))+1.0) *_arg.template D< dtag >()) CT_SIMPLE_UNARY_FUNCTION(sqrt

◆ mixedProductRankFour()

template<typename T >
RankFourTensorTempl< T > RankThreeTensorTempl< T >::mixedProductRankFour ( const RankTwoTensorTempl< T > &  a) const

Creates fourth order tensor D_{ijkl}=A_{mij}*b_{mn}*A_{nkl} where A is rank 3 and b is rank 2.

Parameters
aRankThreeTensor A in the equation above

Definition at line 317 of file RankThreeTensorImplementation.h.

318 {
319  RankFourTensorTempl<T> result;
320 
321  unsigned int index = 0;
322  for (auto i : make_range(N))
323  for (auto j : make_range(N))
324  for (auto k : make_range(N))
325  for (auto l : make_range(N))
326  {
327  for (auto m : make_range(N))
328  for (auto n : make_range(N))
329  result._vals[index] += (*this)(m, i, j) * a(m, n) * (*this)(n, k, l);
330  index++;
331  }
332 
333  return result;
334 }
RankFourTensorTempl is designed to handle any N-dimensional fourth order tensor, C.
T _vals[N4]
The values of the rank-four tensor stored by index=(((i * LIBMESH_DIM + j) * LIBMESH_DIM + k) * LIBME...
IntRange< T > make_range(T beg, T end)
static constexpr unsigned int N
tensor dimension and powers of the dimension

◆ operator()() [1/2]

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

Gets the value for the index specified. Takes index = 0,1,2.

Definition at line 101 of file RankThreeTensor.h.

102  {
103  return _vals[((i * N + j) * N + k)];
104  }
T _vals[N3]
The values of the rank-three tensor stored by index=((i * LIBMESH_DIM + j) * LIBMESH_DIM + k) ...
static constexpr unsigned int N
tensor dimension and powers of the dimension

◆ operator()() [2/2]

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

Gets the value for the index specified. Takes index = 0,1,2. Used for const.

Definition at line 107 of file RankThreeTensor.h.

108  {
109  return _vals[((i * N + j) * N + k)];
110  }
T _vals[N3]
The values of the rank-three tensor stored by index=((i * LIBMESH_DIM + j) * LIBMESH_DIM + k) ...
static constexpr unsigned int N
tensor dimension and powers of the dimension

◆ operator*() [1/3]

template<typename T >
libMesh::VectorValue< T > RankThreeTensorTempl< T >::operator* ( const RankTwoTensorTempl< T > &  a) const

b_i = r_ijk * a_jk

Definition at line 103 of file RankThreeTensorImplementation.h.

104 {
106 
107  for (auto i : make_range(N))
108  {
109  T sum = 0;
110  unsigned int i1 = i * N2;
111  for (unsigned int j1 = 0; j1 < N2; j1 += N)
112  for (auto k : make_range(N))
113  sum += _vals[i1 + j1 + k] * a._coords[j1 + k];
114  result(i) = sum;
115  }
116 
117  return result;
118 }
static constexpr unsigned int N2
T _coords[LIBMESH_DIM *LIBMESH_DIM]
T _vals[N3]
The values of the rank-three tensor stored by index=((i * LIBMESH_DIM + j) * LIBMESH_DIM + k) ...
IntRange< T > make_range(T beg, T end)
static constexpr unsigned int N
tensor dimension and powers of the dimension

◆ operator*() [2/3]

template<typename T >
RankTwoTensorTempl< T > RankThreeTensorTempl< T >::operator* ( const libMesh::VectorValue< T > &  a) const

b_ij = r_ijk * a_k

Definition at line 122 of file RankThreeTensorImplementation.h.

123 {
124  RankTwoTensorTempl<T> result;
125 
126  for (auto i : make_range(N))
127  for (auto j : make_range(N))
128  {
129  T sum = 0;
130  unsigned int i1 = i * N2;
131  unsigned int j1 = j * N;
132  for (auto k : make_range(N))
133  sum += _vals[i1 + j1 + k] * a(k);
134  result(i, j) = sum;
135  }
136 
137  return result;
138 }
static constexpr unsigned int N2
T _vals[N3]
The values of the rank-three tensor stored by index=((i * LIBMESH_DIM + j) * LIBMESH_DIM + k) ...
RankTwoTensorTempl is designed to handle the Stress or Strain Tensor for a fully anisotropic material...
Definition: RankTwoTensor.h:87
IntRange< T > make_range(T beg, T end)
static constexpr unsigned int N
tensor dimension and powers of the dimension

◆ operator*() [3/3]

template<typename T >
RankThreeTensorTempl< T > RankThreeTensorTempl< T >::operator* ( const T  a) const

r_ijk*a

Definition at line 142 of file RankThreeTensorImplementation.h.

143 {
145 
146  for (auto i : make_range(N3))
147  result._vals[i] = _vals[i] * b;
148 
149  return result;
150 }
RankThreeTensor is designed to handle any N-dimensional third order tensor, r.
T _vals[N3]
The values of the rank-three tensor stored by index=((i * LIBMESH_DIM + j) * LIBMESH_DIM + k) ...
static constexpr unsigned int N3
IntRange< T > make_range(T beg, T end)

◆ operator*=()

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

r_ijk *= a

Definition at line 154 of file RankThreeTensorImplementation.h.

155 {
156  for (auto i : make_range(N3))
157  _vals[i] *= a;
158 
159  return *this;
160 }
T _vals[N3]
The values of the rank-three tensor stored by index=((i * LIBMESH_DIM + j) * LIBMESH_DIM + k) ...
static constexpr unsigned int N3
IntRange< T > make_range(T beg, T end)

◆ operator+()

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

r_ijkl + a_ijk

Definition at line 196 of file RankThreeTensorImplementation.h.

197 {
199 
200  for (auto i : make_range(N3))
201  result._vals[i] = _vals[i] + b._vals[i];
202 
203  return result;
204 }
RankThreeTensor is designed to handle any N-dimensional third order tensor, r.
T _vals[N3]
The values of the rank-three tensor stored by index=((i * LIBMESH_DIM + j) * LIBMESH_DIM + k) ...
static constexpr unsigned int N3
IntRange< T > make_range(T beg, T end)

◆ operator+=()

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

r_ijk += a_ijk for all i, j, k

Definition at line 186 of file RankThreeTensorImplementation.h.

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

◆ operator-() [1/2]

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

r_ijk - a_ijk

Definition at line 218 of file RankThreeTensorImplementation.h.

219 {
221 
222  for (auto i : make_range(N3))
223  result._vals[i] = _vals[i] - b._vals[i];
224 
225  return result;
226 }
RankThreeTensor is designed to handle any N-dimensional third order tensor, r.
T _vals[N3]
The values of the rank-three tensor stored by index=((i * LIBMESH_DIM + j) * LIBMESH_DIM + k) ...
static constexpr unsigned int N3
IntRange< T > make_range(T beg, T end)

◆ operator-() [2/2]

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

-r_ijk

Definition at line 230 of file RankThreeTensorImplementation.h.

231 {
233 
234  for (auto i : make_range(N3))
235  result._vals[i] = -_vals[i];
236 
237  return result;
238 }
RankThreeTensor is designed to handle any N-dimensional third order tensor, r.
T _vals[N3]
The values of the rank-three tensor stored by index=((i * LIBMESH_DIM + j) * LIBMESH_DIM + k) ...
static constexpr unsigned int N3
IntRange< T > make_range(T beg, T end)

◆ operator-=()

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

r_ijk -= a_ijk

Definition at line 208 of file RankThreeTensorImplementation.h.

209 {
210  for (auto i : make_range(N3))
211  _vals[i] -= a._vals[i];
212 
213  return *this;
214 }
T _vals[N3]
The values of the rank-three tensor stored by index=((i * LIBMESH_DIM + j) * LIBMESH_DIM + k) ...
static constexpr unsigned int N3
IntRange< T > make_range(T beg, T end)

◆ operator/()

template<typename T >
RankThreeTensorTempl< T > RankThreeTensorTempl< T >::operator/ ( const T  a) const

r_ijk/a

Definition at line 164 of file RankThreeTensorImplementation.h.

165 {
167 
168  for (auto i : make_range(N3))
169  result._vals[i] = _vals[i] / b;
170 
171  return result;
172 }
RankThreeTensor is designed to handle any N-dimensional third order tensor, r.
T _vals[N3]
The values of the rank-three tensor stored by index=((i * LIBMESH_DIM + j) * LIBMESH_DIM + k) ...
static constexpr unsigned int N3
IntRange< T > make_range(T beg, T end)

◆ operator/=()

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

r_ijk /= a for all i, j, k

Definition at line 176 of file RankThreeTensorImplementation.h.

177 {
178  for (auto i : make_range(N3))
179  _vals[i] /= a;
180 
181  return *this;
182 }
T _vals[N3]
The values of the rank-three tensor stored by index=((i * LIBMESH_DIM + j) * LIBMESH_DIM + k) ...
static constexpr unsigned int N3
IntRange< T > make_range(T beg, T end)

◆ operator=() [1/3]

template<typename T >
RankThreeTensorTempl< T > & RankThreeTensorTempl< T >::operator= ( const T &  value)

Assignment-from-scalar operator.

Definition at line 84 of file RankThreeTensorImplementation.h.

85 {
86  for (auto i : make_range(N3))
87  _vals[i] = value;
88  return *this;
89 }
Real value(unsigned n, unsigned alpha, unsigned beta, Real x)
T _vals[N3]
The values of the rank-three tensor stored by index=((i * LIBMESH_DIM + j) * LIBMESH_DIM + k) ...
static constexpr unsigned int N3
IntRange< T > make_range(T beg, T end)

◆ operator=() [2/3]

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

copies values from "a" into this tensor

Definition at line 93 of file RankThreeTensorImplementation.h.

94 {
95  for (auto i : make_range(N3))
96  _vals[i] = a._vals[i];
97 
98  return *this;
99 }
T _vals[N3]
The values of the rank-three tensor stored by index=((i * LIBMESH_DIM + j) * LIBMESH_DIM + k) ...
static constexpr unsigned int N3
IntRange< T > make_range(T beg, T end)

◆ operator=() [3/3]

template<typename T >
template<typename T2 >
RankThreeTensorTempl< T > & RankThreeTensorTempl< T >::operator= ( const RankThreeTensorTempl< T2 > &  a)

Definition at line 318 of file RankThreeTensor.h.

319 {
320  for (const auto i : libMesh::make_range(N))
321  for (const auto j : libMesh::make_range(N))
322  for (const auto k : libMesh::make_range(N))
323  (*this)(i, j, k) = a(i, j, k);
324 
325  return *this;
326 }
IntRange< T > make_range(T beg, T end)
static constexpr unsigned int N
tensor dimension and powers of the dimension

◆ print()

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

Print the rank three tensor.

Definition at line 392 of file RankThreeTensorImplementation.h.

393 {
394  for (auto i : make_range(N))
395  {
396  stm << "a(" << i << ", j, k) = \n";
397  for (auto j : make_range(N))
398  {
399  for (auto k : make_range(N))
400  stm << std::setw(15) << (*this)(i, j, k) << ' ';
401  stm << "\n";
402  }
403  stm << "\n";
404  }
405 
406  stm << std::flush;
407 }
IntRange< T > make_range(T beg, T end)
static constexpr unsigned int N
tensor dimension and powers of the dimension

◆ rotate() [1/2]

template<typename T >
template<class T2 >
void RankThreeTensorTempl< T >::rotate ( const T2 &  R)

Rotate the tensor using r_ijk = R_im R_in R_ko r_mno.

Definition at line 268 of file RankThreeTensor.h.

269 {
270  unsigned int index = 0;
271  for (const auto i : libMesh::make_range(N))
272  for (const auto j : libMesh::make_range(N))
273  for (const auto k : libMesh::make_range(N))
274  {
275  unsigned int index2 = 0;
276  T sum = 0.0;
277  for (const auto m : libMesh::make_range(N))
278  {
279  T a = R(i, m);
280  for (const auto n : libMesh::make_range(N))
281  {
282  T ab = a * R(j, n);
283  for (const auto o : libMesh::make_range(N))
284  sum += ab * R(k, o) * _vals[index2++];
285  }
286  }
287  _vals[index++] = sum;
288  }
289 }
T _vals[N3]
The values of the rank-three tensor stored by index=((i * LIBMESH_DIM + j) * LIBMESH_DIM + k) ...
IntRange< T > make_range(T beg, T end)
static constexpr unsigned int N
tensor dimension and powers of the dimension

◆ rotate() [2/2]

template<typename T >
void RankThreeTensorTempl< T >::rotate ( const libMesh::TensorValue< T > &  R)

Rotate the tensor using r_ijk = R_im R_in R_ko r_mno.

Definition at line 338 of file RankThreeTensorImplementation.h.

339 {
340  RankThreeTensorTempl<T> old = *this;
341 
342  unsigned int index = 0;
343  for (auto i : make_range(N))
344  for (auto j : make_range(N))
345  for (auto k : make_range(N))
346  {
347  T sum = 0.0;
348  unsigned int index2 = 0;
349  for (auto m : make_range(N))
350  {
351  T a = R(i, m);
352  for (auto n : make_range(N))
353  {
354  T ab = a * R(j, n);
355  for (auto o : make_range(N))
356  sum += ab * R(k, o) * old._vals[index2++];
357  }
358  }
359  _vals[index++] = sum;
360  }
361 }
RankThreeTensor is designed to handle any N-dimensional third order tensor, r.
T _vals[N3]
The values of the rank-three tensor stored by index=((i * LIBMESH_DIM + j) * LIBMESH_DIM + k) ...
IntRange< T > make_range(T beg, T end)
static constexpr unsigned int N
tensor dimension and powers of the dimension

◆ zero()

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

Zeros out the tensor.

Definition at line 76 of file RankThreeTensorImplementation.h.

77 {
78  for (auto i : make_range(N3))
79  _vals[i] = 0;
80 }
T _vals[N3]
The values of the rank-three tensor stored by index=((i * LIBMESH_DIM + j) * LIBMESH_DIM + k) ...
static constexpr unsigned int N3
IntRange< T > make_range(T beg, T end)

Friends And Related Function Documentation

◆ dataLoad

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

◆ dataStore

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

◆ operator<<

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

Definition at line 121 of file RankThreeTensor.h.

122  {
123  t.print(os);
124  return os;
125  }
std::basic_ostream< charT, traits > * os
Definition: InfixIterator.h:33
void print(std::ostream &stm=Moose::out) const
Print the rank three tensor.

◆ RankFourTensorTempl

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

Definition at line 234 of file RankThreeTensor.h.

◆ RankThreeTensorTempl

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

Definition at line 231 of file RankThreeTensor.h.

◆ RankTwoTensorTempl

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

Definition at line 228 of file RankThreeTensor.h.

Member Data Documentation

◆ _vals

template<typename T>
T RankThreeTensorTempl< T >::_vals[N3]
protected

◆ N

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

tensor dimension and powers of the dimension

Definition at line 59 of file RankThreeTensor.h.

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

◆ N2

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

Definition at line 60 of file RankThreeTensor.h.

◆ N3

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

Definition at line 61 of file RankThreeTensor.h.


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