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:302

◆ 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 378 of file RankThreeTensorImplementation.h.

379 {
381 
382  for (auto i : make_range(N))
383  for (auto j : make_range(N2))
384  result(i) += _vals[i * N2 + j] * b._coords[j];
385 
386  return result;
387 }
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 254 of file RankThreeTensorImplementation.h.

255 {
256  zero();
257 
258  if (fill_method == automatic)
259  {
260  if (input.size() == 27)
261  fill_method = general;
262  else if (input.size() == 3)
263  fill_method = plane_normal;
264  else
265  mooseError("Unsupported automatic fill method, use 27 values for 'general' and 3 for "
266  "'plane_normal', the supplied size was ",
267  input.size(),
268  ".");
269  }
270 
271  if (fill_method == general)
273 
274  else if (fill_method == plane_normal)
275  {
276  if (input.size() != 3)
277  mooseError("To use fillFromPlaneNormal, your input must have size 3, the supplied size was ",
278  input.size(),
279  ".");
280  fillFromPlaneNormal(libMesh::VectorValue<T>(input[0], input[1], input[2]));
281  }
282 
283  else
284  // This is un-reachable unless a FillMethod is added and the if statement is not updated
285  mooseError("fillFromInputVector called with unknown fill_method of ", fill_method);
286 }
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:302
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 290 of file RankThreeTensorImplementation.h.

291 {
292  unsigned int index = 0;
293  for (auto i : make_range(N))
294  {
295  const T a = input(i);
296  for (auto j : make_range(N))
297  {
298  const T b = input(j);
299  for (auto k : make_range(N))
300  {
301  const T c = input(k);
302  T sum = 0;
303  sum = -2.0 * a * b * c;
304  if (i == j)
305  sum += c;
306  if (i == k)
307  sum += b;
308  _vals[index++] = sum / 2.0;
309  }
310  }
311  }
312 }
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 364 of file RankThreeTensorImplementation.h.

365 {
366  if (input.size() != 27)
367  mooseError(
368  "To use fillGeneralFromInputVector, your input must have size 27, the supplied size was ",
369  input.size(),
370  ".");
371 
372  for (auto i : make_range(N3))
373  _vals[i] = input[i];
374 }
void mooseError(Args &&... args)
Emit an error message with the given stringified, concatenated args and terminate the application...
Definition: MooseError.h:302
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  return std::sqrt(l2);
250 }
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 316 of file RankThreeTensorImplementation.h.

317 {
318  RankFourTensorTempl<T> result;
319 
320  unsigned int index = 0;
321  for (auto i : make_range(N))
322  for (auto j : make_range(N))
323  for (auto k : make_range(N))
324  for (auto l : make_range(N))
325  {
326  for (auto m : make_range(N))
327  for (auto n : make_range(N))
328  result._vals[index] += (*this)(m, i, j) * a(m, n) * (*this)(n, k, l);
329  index++;
330  }
331 
332  return result;
333 }
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 391 of file RankThreeTensorImplementation.h.

392 {
393  for (auto i : make_range(N))
394  {
395  stm << "a(" << i << ", j, k) = \n";
396  for (auto j : make_range(N))
397  {
398  for (auto k : make_range(N))
399  stm << std::setw(15) << (*this)(i, j, k) << ' ';
400  stm << "\n";
401  }
402  stm << "\n";
403  }
404 
405  stm << std::flush;
406 }
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 337 of file RankThreeTensorImplementation.h.

338 {
339  RankThreeTensorTempl<T> old = *this;
340 
341  unsigned int index = 0;
342  for (auto i : make_range(N))
343  for (auto j : make_range(N))
344  for (auto k : make_range(N))
345  {
346  T sum = 0.0;
347  unsigned int index2 = 0;
348  for (auto m : make_range(N))
349  {
350  T a = R(i, m);
351  for (auto n : make_range(N))
352  {
353  T ab = a * R(j, n);
354  for (auto o : make_range(N))
355  sum += ab * R(k, o) * old._vals[index2++];
356  }
357  }
358  _vals[index++] = sum;
359  }
360 }
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: