libMesh
Loading...
Searching...
No Matches
Classes | Public Types | Public Member Functions | Static Public Member Functions | Protected Attributes | List of all members
libMesh::TensorValue< T > Class Template Reference

This class defines a tensor in LIBMESH_DIM dimensional Real or Complex space. More...

#include <tensor_value.h>

Inheritance diagram for libMesh::TensorValue< T >:
[legend]

Classes

struct  rebind
 

Public Types

typedef T value_type
 
typedef std::tuple< unsigned int, unsigned int > index_type
 Helper typedef for generic index programming.
 

Public Member Functions

 TensorValue ()
 Empty constructor.
 
 TensorValue (const T &xx, const T &xy=0, const T &xz=0, const T &yx=0, const T &yy=0, const T &yz=0, const T &zx=0, const T &zy=0, const T &zz=0)
 Constructor-from-T.
 
template<typename Scalar >
 TensorValue (const Scalar &xx, const Scalar &xy=0, const Scalar &xz=0, const Scalar &yx=0, const Scalar &yy=0, const Scalar &yz=0, const Scalar &zx=0, const Scalar &zy=0, typename std::enable_if< ScalarTraits< Scalar >::value, const Scalar >::type &zz=0)
 Constructor-from-scalars.
 
template<typename T2 >
 TensorValue (const TypeVector< T2 > &vx)
 Constructor.
 
template<typename T2 >
 TensorValue (const TypeVector< T2 > &vx, const TypeVector< T2 > &vy)
 Constructor.
 
template<typename T2 >
 TensorValue (const TypeVector< T2 > &vx, const TypeVector< T2 > &vy, const TypeVector< T2 > &vz)
 Constructor.
 
template<typename T2 >
 TensorValue (const TensorValue< T2 > &p)
 Copy-constructor.
 
template<typename T2 >
 TensorValue (const TypeTensor< T2 > &p)
 Copy-constructor.
 
 TensorValue (const TypeTensor< Real > &p_re, const TypeTensor< Real > &p_im)
 Constructor that takes two TypeTensor<Real> representing the real and imaginary part as arguments.
 
template<typename Scalar >
std::enable_if< ScalarTraits< Scalar >::value, TensorValue & >::type operator= (const Scalar &libmesh_dbg_var(p))
 Assignment-from-scalar operator.
 
template<typename T2 >
void assign (const TypeTensor< T2 > &)
 Assign to this tensor without creating a temporary.
 
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
 
TypeVector< T > column (const unsigned int r) const
 
template<typename T2 >
TypeTensor< typename CompareTypes< T, T2 >::supertype > operator+ (const TypeTensor< T2 > &) const
 Add another tensor to this tensor.
 
template<typename T2 >
const TypeTensor< T > & operator+= (const TypeTensor< T2 > &)
 Add to this tensor.
 
template<typename T2 >
void add (const TypeTensor< T2 > &)
 Add to this tensor without creating a temporary.
 
template<typename T2 >
void add_scaled (const TypeTensor< T2 > &, const T &)
 Add a scaled tensor to this tensor without creating a temporary.
 
template<typename T2 >
TypeTensor< typename CompareTypes< T, T2 >::supertype > operator- (const TypeTensor< T2 > &) const
 Subtract a tensor from this tensor.
 
TypeTensor< T > operator- () const
 
template<typename T2 >
const TypeTensor< T > & operator-= (const TypeTensor< T2 > &)
 Subtract from this tensor.
 
template<typename T2 >
void subtract (const TypeTensor< T2 > &)
 Subtract from this tensor without creating a temporary.
 
template<typename T2 >
void subtract_scaled (const TypeTensor< T2 > &, const T &)
 Subtract a scaled value from this tensor without creating a temporary.
 
template<typename Scalar >
auto operator* (const Scalar &scalar) const -> typename std::enable_if< ScalarTraits< Scalar >::value, TypeTensor< decltype(T() *scalar)> >::type
 Multiply this tensor by a scalar value.
 
template<typename T2 >
TypeTensor< typename CompareTypes< T, T2 >::supertype > operator* (const TypeTensor< T2 > &) const
 Multiply 2 tensors together, i.e.
 
template<typename T2 >
TypeVector< typename CompareTypes< T, T2 >::supertype > operator* (const TypeVector< T2 > &) const
 Right-multiply this tensor by a vector, i.e.
 
template<typename Scalar , typename std::enable_if< ScalarTraits< Scalar >::value, int >::type = 0>
const TypeTensor< T > & operator*= (const Scalar &factor)
 Multiply this tensor by a scalar value in place.
 
template<typename T2 >
const TypeTensor< T > & operator*= (const TypeTensor< T2 > &)
 Multiply this tensor by a tensor value in place.
 
template<typename Scalar >
std::enable_if< ScalarTraits< Scalar >::value, TypeTensor< typenameCompareTypes< T, Scalar >::supertype > >::type operator/ (const Scalar &) const
 Divide each entry of this tensor by a scalar value.
 
const TypeTensor< T > & operator/= (const T &)
 Divide each entry of this tensor by a scalar value.
 
template<typename T2 >
CompareTypes< T, T2 >::supertype contract (const TypeTensor< T2 > &) const
 Multiply 2 tensors together to return a scalar, i.e.
 
template<typename T2 >
TypeVector< typename CompareTypes< T, T2 >::supertype > left_multiply (const TypeVector< T2 > &p) const
 Left-multiply this tensor by a vector, i.e.
 
TypeTensor< T > transpose () const
 
TypeTensor< T > inverse () const
 
void solve (const TypeVector< T > &b, TypeVector< T > &x) const
 Solve the 2x2 or 3x3 system of equations A*x = b for x by directly inverting A and multiplying it by b.
 
auto norm () const
 
auto norm_sq () const
 
bool is_zero () const
 
T det () const
 
T tr () const
 
void zero ()
 Set all entries of the tensor to 0.
 
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 print (std::ostream &os=libMesh::out) const
 Formatted print to a stream which defaults to libMesh::out.
 
void write_unformatted (std::ostream &out_stream, const bool newline=true) const
 Unformatted print to the stream out.
 
bool is_hpd (Real rel_tol=TOLERANCE *TOLERANCE) const
 Returns true if the TypeTensor is Hermitian (or symmetric, when T==Real) and positive-definite to within the provided relative tolerance, false otherwise.
 

Static Public Member Functions

static TensorValue< Real > intrinsic_rotation_matrix (Real phi, Real theta, Real psi)
 Generate the intrinsic rotation matrix associated with the provided Euler angles.
 
static TensorValue< Real > inverse_intrinsic_rotation_matrix (Real phi, Real theta, Real psi)
 Invert the rotation that would occur if the same angles were provided to intrinsic_rotation_matrix, e.g.
 
static TensorValue< Real > extrinsic_rotation_matrix (Real angle1_deg, Real angle2_deg, Real angle3_deg)
 Generate the extrinsic rotation matrix associated with the provided Euler angles.
 
static TensorValue< Real > inverse_extrinsic_rotation_matrix (Real angle1_deg, Real angle2_deg, Real angle3_deg)
 Invert the rotation that would occur if the same angles were provided to extrinsic_rotation_matrix, e.g.
 

Protected Attributes

T _coords [LIBMESH_DIM *LIBMESH_DIM]
 The coordinates of the TypeTensor.
 

Detailed Description

template<typename T>
class libMesh::TensorValue< T >

This class defines a tensor in LIBMESH_DIM dimensional Real or Complex space.

The typedef RealTensorValue always defines a real-valued tensor, and NumberTensorValue defines a real or complex-valued tensor depending on how the library was configured.

Author
Roy H. Stogner
Date
2004

Definition at line 44 of file tensor_value.h.

Member Typedef Documentation

◆ index_type

template<typename T >
typedef std::tuple<unsigned int, unsigned int> libMesh::TypeTensor< T >::index_type
inherited

Helper typedef for generic index programming.

Definition at line 125 of file type_tensor.h.

◆ value_type

template<typename T >
typedef T libMesh::TensorValue< T >::value_type

Definition at line 47 of file tensor_value.h.

Constructor & Destructor Documentation

◆ TensorValue() [1/9]

template<typename T >
libMesh::TensorValue< T >::TensorValue ( )
inline

Empty constructor.

Gives the tensor 0 in LIBMESH_DIM dimensional T space.

Definition at line 215 of file tensor_value.h.

215 :
216 TypeTensor<T> ()
217{
218}

◆ TensorValue() [2/9]

template<typename T >
libMesh::TensorValue< T >::TensorValue ( const T &  xx,
const T &  xy = 0,
const T &  xz = 0,
const T &  yx = 0,
const T &  yy = 0,
const T &  yz = 0,
const T &  zx = 0,
const T &  zy = 0,
const T &  zz = 0 
)
inlineexplicit

Constructor-from-T.

By default sets higher dimensional entries to 0.

Definition at line 224 of file tensor_value.h.

232 :
233 TypeTensor<T> (xx,xy,xz,yx,yy,yz,zx,zy,zz)
234{
235}

◆ TensorValue() [3/9]

template<typename T >
template<typename Scalar >
libMesh::TensorValue< T >::TensorValue ( const Scalar &  xx,
const Scalar &  xy = 0,
const Scalar &  xz = 0,
const Scalar &  yx = 0,
const Scalar &  yy = 0,
const Scalar &  yz = 0,
const Scalar &  zx = 0,
const Scalar &  zy = 0,
typename std::enable_if< ScalarTraits< Scalar >::value, const Scalar >::type &  zz = 0 
)
inlineexplicit

Constructor-from-scalars.

By default sets higher dimensional entries to 0.

Definition at line 241 of file tensor_value.h.

251 :
252 TypeTensor<T> (xx,xy,xz,yx,yy,yz,zx,zy,zz)
253{
254}

◆ TensorValue() [4/9]

template<typename T >
template<typename T2 >
libMesh::TensorValue< T >::TensorValue ( const TypeVector< T2 > &  vx)
inline

Constructor.

Takes 1 row vector for LIBMESH_DIM=1

Definition at line 271 of file tensor_value.h.

271 :
272 TypeTensor<T> (vx)
273{
274}

◆ TensorValue() [5/9]

template<typename T >
template<typename T2 >
libMesh::TensorValue< T >::TensorValue ( const TypeVector< T2 > &  vx,
const TypeVector< T2 > &  vy 
)
inline

Constructor.

Takes 2 row vectors for LIBMESH_DIM=2

Definition at line 281 of file tensor_value.h.

282 :
283 TypeTensor<T> (vx, vy)
284{
285}

◆ TensorValue() [6/9]

template<typename T >
template<typename T2 >
libMesh::TensorValue< T >::TensorValue ( const TypeVector< T2 > &  vx,
const TypeVector< T2 > &  vy,
const TypeVector< T2 > &  vz 
)
inline

Constructor.

Takes 3 row vectors for LIBMESH_DIM=3

Definition at line 292 of file tensor_value.h.

294 :
295 TypeTensor<T> (vx, vy, vz)
296{
297}

◆ TensorValue() [7/9]

template<typename T >
template<typename T2 >
libMesh::TensorValue< T >::TensorValue ( const TensorValue< T2 > &  p)
inline

Copy-constructor.

Definition at line 261 of file tensor_value.h.

261 :
262 TypeTensor<T> (p)
263{
264}

◆ TensorValue() [8/9]

template<typename T >
template<typename T2 >
libMesh::TensorValue< T >::TensorValue ( const TypeTensor< T2 > &  p)
inline

Copy-constructor.

Definition at line 304 of file tensor_value.h.

304 :
305 TypeTensor<T> (p)
306{
307}

◆ TensorValue() [9/9]

template<typename T >
libMesh::TensorValue< T >::TensorValue ( const TypeTensor< Real > &  p_re,
const TypeTensor< Real > &  p_im 
)
inline

Constructor that takes two TypeTensor<Real> representing the real and imaginary part as arguments.

Definition at line 313 of file tensor_value.h.

314 :
315 TypeTensor<T> (Complex (p_re(0,0), p_im(0,0)),
316 Complex (p_re(0,1), p_im(0,1)),
317 Complex (p_re(0,2), p_im(0,2)),
318 Complex (p_re(1,0), p_im(1,0)),
319 Complex (p_re(1,1), p_im(1,1)),
320 Complex (p_re(1,2), p_im(1,2)),
321 Complex (p_re(2,0), p_im(2,0)),
322 Complex (p_re(2,1), p_im(2,1)),
323 Complex (p_re(2,2), p_im(2,2)))
324{
325}
libMesh::Complex
std::complex< Real > Complex
Definition libmesh_common.h:180

Member Function Documentation

◆ add()

template<typename T >
template<typename T2 >
void libMesh::TypeTensor< T >::add ( const TypeTensor< T2 > &  p)
inlineinherited

Add to this tensor without creating a temporary.

Definition at line 847 of file type_tensor.h.

848{
849 for (unsigned int i=0; i<LIBMESH_DIM*LIBMESH_DIM; i++)
850 _coords[i] += p._coords[i];
851}
libMesh::TypeTensor::_coords
T _coords[LIBMESH_DIM *LIBMESH_DIM]
The coordinates of the TypeTensor.
Definition type_tensor.h:451

References libMesh::TypeTensor< T >::_coords.

Referenced by NonlinearNeoHookeCurrentConfig::init_for_qp().

◆ add_scaled()

template<typename T >
template<typename T2 >
void libMesh::TypeTensor< T >::add_scaled ( const TypeTensor< T2 > &  p,
const T &  factor 
)
inlineinherited

Add a scaled tensor to this tensor without creating a temporary.

Definition at line 858 of file type_tensor.h.

859{
860 for (unsigned int i=0; i<LIBMESH_DIM*LIBMESH_DIM; i++)
861 _coords[i] += factor*p._coords[i];
862
863}

References libMesh::TypeTensor< T >::_coords.

Referenced by libMesh::HPCoarsenTest::add_projection(), LargeDeformationElasticity::compute_stresses(), LinearElasticityWithContact::compute_stresses(), libMesh::MeshFunction::hessian(), libMesh::PatchRecoveryErrorEstimator::EstimateError::operator()(), libMesh::WeightedPatchRecoveryErrorEstimator::EstimateError::operator()(), libMesh::System::point_hessian(), and libMesh::HPCoarsenTest::select_refinement().

◆ assign()

template<typename T >
template<typename T2 >
void libMesh::TypeTensor< T >::assign ( const TypeTensor< T2 > &  p)
inlineinherited

Assign to this tensor without creating a temporary.

Definition at line 703 of file type_tensor.h.

704{
705 for (unsigned int i=0; i<LIBMESH_DIM*LIBMESH_DIM; i++)
706 _coords[i] = p._coords[i];
707}

References libMesh::TypeTensor< T >::_coords.

◆ column()

template<typename T >
TypeVector< T > libMesh::TypeTensor< T >::column ( const unsigned int  r) const
inlineinherited
Returns
A copy of one column of the tensor as a TypeVector.

Definition at line 786 of file type_tensor.h.

787{
788 TypeVector<T> return_vector;
789
790 for (unsigned int i=0; i<LIBMESH_DIM; i++)
791 return_vector._coords[i] = _coords[i*LIBMESH_DIM + r];
792
793 return return_vector;
794}

References libMesh::TypeVector< T >::_coords.

Referenced by TypeTensorTest::testRowCol().

◆ contract()

template<typename T >
template<typename T2 >
CompareTypes< T, T2 >::supertype libMesh::TypeTensor< T >::contract ( const TypeTensor< T2 > &  t) const
inlineinherited

Multiply 2 tensors together to return a scalar, i.e.

Multiply 2 tensors together, i.e.

\( \sum_{ij} A_{ij} B_{ij} \) The tensors may contain different numeric types. Also known as the "double inner product" or "double dot product" of tensors.

Returns
The scalar-valued result, this tensor is unchanged.

sum Aij*Bij. The tensors may be of different types.

Definition at line 1275 of file type_tensor.h.

1276{
1277 typename CompareTypes<T,T2>::supertype sum = 0.;
1278 for (unsigned int i=0; i<LIBMESH_DIM*LIBMESH_DIM; i++)
1279 sum += _coords[i]*t._coords[i];
1280 return sum;
1281}

References libMesh::TypeTensor< T >::_coords.

Referenced by libMesh::HPCoarsenTest::add_projection(), libMesh::VariationalSmootherSystem::element_time_derivative(), libMesh::TensorTools::inner_product(), and libMesh::HPCoarsenTest::select_refinement().

◆ det()

template<typename T >
T libMesh::TypeTensor< T >::det ( ) const
inlineinherited
Returns
The determinant of the tensor.

Because these are 3x3 tensors at most, we don't do an LU decomposition like DenseMatrix does.

Definition at line 1306 of file type_tensor.h.

1307{
1308#if LIBMESH_DIM == 1
1309 return _coords[0];
1310#endif
1311
1312#if LIBMESH_DIM == 2
1313 return (_coords[0] * _coords[3]
1314 - _coords[1] * _coords[2]);
1315#endif
1316
1317#if LIBMESH_DIM == 3
1318 return (_coords[0] * _coords[4] * _coords[8]
1319 + _coords[1] * _coords[5] * _coords[6]
1320 + _coords[2] * _coords[3] * _coords[7]
1321 - _coords[0] * _coords[5] * _coords[7]
1322 - _coords[1] * _coords[3] * _coords[8]
1323 - _coords[2] * _coords[4] * _coords[6]);
1324#endif
1325}

Referenced by NonlinearNeoHookeCurrentConfig::calculate_stress(), NonlinearNeoHookeCurrentConfig::calculate_tangent(), libMesh::VariationalSmootherSystem::compute_mesh_quality_info(), LargeDeformationElasticity::compute_stresses(), libMesh::VariationalSmootherSystem::element_time_derivative(), NonlinearNeoHookeCurrentConfig::get_linearized_stiffness(), GradDivExactSolution::grad(), NonlinearNeoHookeCurrentConfig::init_for_qp(), GradDivExactSolution::operator()(), libMesh::Hex::quality(), and libMesh::Sphere::Sphere().

◆ extrinsic_rotation_matrix()

template<typename T >
TensorValue< Real > libMesh::TensorValue< T >::extrinsic_rotation_matrix ( Real  angle1_deg,
Real  angle2_deg,
Real  angle3_deg 
)
static

Generate the extrinsic rotation matrix associated with the provided Euler angles.

An extrinsic rotation rotates the bodies in the domain and leaves the coordinate axes fixed. We follow the convention described at https://en.wikipedia.org/wiki/Euler_angles#Rotation_matrix and we use the matrix described by the 'Proper Euler Angles' column and Z1 X2 Z3 row, which indicates that the rotations are performed sequentially about the z, x, and z axes, in that order. A positive angle yields a counter-clockwise rotation about the axis in question. Note that angles should be provided in degrees

Parameters
angle1_degrotation angle around z-axis
angle2_degrotation angle around x-axis (post angle1)
angle3_degrotation angle around z-axis (post angle1 and angle2)
Returns
The associated rotation matrix

Definition at line 372 of file tensor_value.h.

375{
376#if LIBMESH_DIM == 3
377 const auto angle1 = angle1_deg / 180. * pi;
378 const auto angle2 = angle2_deg / 180. * pi;
379 const auto angle3 = angle3_deg / 180. * pi;
380 const auto s1 = std::sin(angle1), c1 = std::cos(angle1);
381 const auto s2 = std::sin(angle2), c2 = std::cos(angle2);
382 const auto s3 = std::sin(angle3), c3 = std::cos(angle3);
383
384 return TensorValue<Real>(c1 * c3 - c2 * s1 * s3,
385 -c1 * s3 - c2 * c3 * s1,
386 s1 * s2,
387 c3 * s1 + c1 * c2 * s3,
388 c1 * c2 * c3 - s1 * s3,
389 -c1 * s2,
390 s2 * s3,
391 c3 * s2,
392 c2);
393#else
394 libmesh_ignore(angle1_deg, angle2_deg, angle3_deg);
395 libmesh_error_msg("TensorValue<T>::extrinsic_rotation_matrix() requires libMesh to be compiled "
396 "with LIBMESH_DIM==3");
397 // We'll never get here
398 return TensorValue<Real>();
399#endif
400}
libMesh::libmesh_ignore
void libmesh_ignore(const Args &...)
Definition libmesh_common.h:569
libMesh::pi
const Real pi
.
Definition libmesh.h:292

References libMesh::libmesh_ignore(), and libMesh::pi.

Referenced by libMesh::TensorValue< T >::inverse_extrinsic_rotation_matrix(), and TypeTensorTest::testRotation().

◆ intrinsic_rotation_matrix()

template<typename T >
TensorValue< Real > libMesh::TensorValue< T >::intrinsic_rotation_matrix ( Real  phi,
Real  theta,
Real  psi 
)
static

Generate the intrinsic rotation matrix associated with the provided Euler angles.

An intrinsic rotation leaves bodies in the domain fixed while rotating the coordinate axes. We follow the convention described at http://mathworld.wolfram.com/EulerAngles.html (equations 6-14 give the entries of the composite transformation matrix). The rotations are performed sequentially about the z, x', and z'' axes, in that order. A positive angle for a given step in the rotation sequences gives the appearance of rotating an entity in the domain counter-clockwise around the rotation axis, although in fact it is the coordinate axes themselves that are rotating. In order to give the appearance of a body rotating counter-clockwise, we actually rotate the coordinate axes by the \emph negative of the angle passed into the method. All angles should be provided in degrees

Parameters
phiThe \emph negative of the angle we will rotate the coordinate axes around the original z-axis
thetaThe \emph negative of the angle we will rotate the coordinate axes around the "current" x-axis (post phi), e.g. x'
psiThe \emph negative of the angle we will rotate the coordinate axes around the "current" z-axis (post phi and theta), e.g. z''
Returns
The associated rotation matrix

Definition at line 330 of file tensor_value.h.

331{
332#if LIBMESH_DIM == 3
333 // We apply a negative sign here or else we don't get the appearance of
334 // counter-clockwise/right-hand-rule rotation of the bodies with respect to the coordinate axes
335 // (but as explained in the method doxygen we are *actually* rotating the coordinate axes while
336 // leaving the bodies fixed)
337 const Real p = -phi / 180. * pi;
338 const Real t = -theta / 180. * pi;
339 const Real s = -psi / 180. * pi;
340 const Real sp = std::sin(p), cp = std::cos(p);
341 const Real st = std::sin(t), ct = std::cos(t);
342 const Real ss = std::sin(s), cs = std::cos(s);
343
344 return TensorValue<Real>(cp * cs - sp * ct * ss,
345 sp * cs + cp * ct * ss,
346 st * ss,
347 -cp * ss - sp * ct * cs,
348 -sp * ss + cp * ct * cs,
349 st * cs,
350 sp * st,
351 -cp * st,
352 ct);
353#else
354 libmesh_ignore(phi, theta, psi);
355 libmesh_error_msg("TensorValue<T>::intrinsic_rotation_matrix() requires libMesh to be compiled "
356 "with LIBMESH_DIM==3");
357 // We'll never get here
358 return TensorValue<Real>();
359#endif
360}
libMesh::Real
DIE A HORRIBLE DEATH HERE typedef LIBMESH_DEFAULT_SCALAR_TYPE Real
Definition libmesh_common.h:144

References libMesh::libmesh_ignore(), libMesh::pi, and libMesh::Real.

Referenced by libMesh::TensorValue< T >::inverse_intrinsic_rotation_matrix(), and libMesh::MeshTools::Modification::rotate().

◆ inverse()

template<typename T >
TypeTensor< T > libMesh::TypeTensor< T >::inverse ( ) const
inlineinherited
Returns
The inverse of this tensor as an independent object.

Definition at line 1087 of file type_tensor.h.

1088{
1089#if LIBMESH_DIM == 1
1090 if (_coords[0] == static_cast<T>(0.))
1091 libmesh_convergence_failure();
1092 return TypeTensor(1. / _coords[0]);
1093#endif
1094
1095#if LIBMESH_DIM == 2
1096 // Get convenient reference to this.
1097 const TypeTensor<T> & A = *this;
1098
1099 // Use temporary variables, avoid multiple accesses
1100 T a = A(0,0), b = A(0,1),
1101 c = A(1,0), d = A(1,1);
1102
1103 // Make sure det = ad - bc is not zero
1104 T my_det = a*d - b*c;
1105
1106 if (my_det == static_cast<T>(0.))
1107 libmesh_convergence_failure();
1108
1109 return TypeTensor(d/my_det, -b/my_det, -c/my_det, a/my_det);
1110#endif
1111
1112#if LIBMESH_DIM == 3
1113 // Get convenient reference to this.
1114 const TypeTensor<T> & A = *this;
1115
1116 T a11 = A(0,0), a12 = A(0,1), a13 = A(0,2),
1117 a21 = A(1,0), a22 = A(1,1), a23 = A(1,2),
1118 a31 = A(2,0), a32 = A(2,1), a33 = A(2,2);
1119
1120 T my_det = a11*(a33*a22-a32*a23) - a21*(a33*a12-a32*a13) + a31*(a23*a12-a22*a13);
1121
1122 if (my_det == static_cast<T>(0.))
1123 libmesh_convergence_failure();
1124
1125 // Inline comment characters are for lining up columns.
1126 return TypeTensor( (a33*a22-a32*a23)/my_det, -(a33*a12-a32*a13)/my_det, (a23*a12-a22*a13)/my_det,
1127 -(a33*a21-a31*a23)/my_det, (a33*a11-a31*a13)/my_det, -(a23*a11-a21*a13)/my_det,
1128 (a32*a21-a31*a22)/my_det, -(a32*a11-a31*a12)/my_det, (a22*a11-a21*a12)/my_det);
1129#endif
1130}
libMesh::TypeTensor::TypeTensor
friend class TypeTensor
Definition type_tensor.h:55
b
static const Real b
Definition disjoint_neighbor_test.C:24

References b.

Referenced by NonlinearNeoHookeCurrentConfig::calculate_stress(), libMesh::VariationalSmootherSystem::element_time_derivative(), libMesh::VariationalSmootherSystem::get_target_to_reference_jacobian(), NonlinearNeoHookeCurrentConfig::init_for_qp(), and TypeTensorTest::testInverse().

◆ inverse_extrinsic_rotation_matrix()

template<typename T >
TensorValue< Real > libMesh::TensorValue< T >::inverse_extrinsic_rotation_matrix ( Real  angle1_deg,
Real  angle2_deg,
Real  angle3_deg 
)
static

Invert the rotation that would occur if the same angles were provided to extrinsic_rotation_matrix, e.g.

return to the original starting point

Definition at line 404 of file tensor_value.h.

407{
408 // The inverse of a rotation matrix is just the transpose
409 return TensorValue<T>::extrinsic_rotation_matrix(angle1_deg, angle2_deg, angle3_deg).transpose();
410}
libMesh::TensorValue::extrinsic_rotation_matrix
static TensorValue< Real > extrinsic_rotation_matrix(Real angle1_deg, Real angle2_deg, Real angle3_deg)
Generate the extrinsic rotation matrix associated with the provided Euler angles.
Definition tensor_value.h:372

References libMesh::TensorValue< T >::extrinsic_rotation_matrix(), and libMesh::TypeTensor< T >::transpose().

Referenced by TypeTensorTest::testRotation().

◆ inverse_intrinsic_rotation_matrix()

template<typename T >
TensorValue< Real > libMesh::TensorValue< T >::inverse_intrinsic_rotation_matrix ( Real  phi,
Real  theta,
Real  psi 
)
static

Invert the rotation that would occur if the same angles were provided to intrinsic_rotation_matrix, e.g.

return to the original starting point. All angles should be provided in degrees

Definition at line 364 of file tensor_value.h.

365{
366 // The inverse of a rotation matrix is just the transpose
367 return TensorValue<T>::intrinsic_rotation_matrix(phi, theta, psi).transpose();
368}
libMesh::TensorValue::intrinsic_rotation_matrix
static TensorValue< Real > intrinsic_rotation_matrix(Real phi, Real theta, Real psi)
Generate the intrinsic rotation matrix associated with the provided Euler angles.
Definition tensor_value.h:330

References libMesh::TensorValue< T >::intrinsic_rotation_matrix(), and libMesh::TypeTensor< T >::transpose().

◆ is_hpd()

template<typename T >
bool libMesh::TypeTensor< T >::is_hpd ( Real  rel_tol = TOLERANCE*TOLERANCE) const
inherited

Returns true if the TypeTensor is Hermitian (or symmetric, when T==Real) and positive-definite to within the provided relative tolerance, false otherwise.

Definition at line 67 of file type_tensor.C.

68{
69 // Convenient reference to this object, to be used for matrix
70 // operations.
71 const auto & A = *this;
72
73 // The norm of this matrix, needed for relative tolerance checks.
74 auto A_norm = A.norm();
75
76 // The zero matrix is only positive semi-definite
77 if (A_norm == 0)
78 return false;
79
80 // An absolute tolerance (based on the user's provided relative
81 // tolerance) to be used in the floating point comparisons below.
82 auto abs_tol = rel_tol * A_norm;
83
84 // Form the complex conjugate transpose of A
85 TypeTensor<T> A_conjugate_transpose;
86 for (unsigned int i=0; i<LIBMESH_DIM; i++)
87 for (unsigned int j=0; j<LIBMESH_DIM; j++)
88 A_conjugate_transpose(i,j) = libmesh_conj(A(j,i));
89
90 // Check if Hermitian
91 if ((A - A_conjugate_transpose).norm() > abs_tol)
92 return false;
93
94 // If we made it here, then we are Hermitian, so now we just need to
95 // check if we are positive-definite by checking that all principal
96 // minors are positive. Note: the determinant of a Hermitian matrix
97 // and all principal minors are real-valued. Since we already
98 // checked that the matrix is Hermitian above, we don't bother to
99 // check the complex parts are also zero now.
100
101 // For 3x3 and 2x2, check the 1x1 determinant
102#if LIBMESH_DIM > 1
103 if (std::real(A(0,0)) < -abs_tol)
104 return false;
105#endif
106
107 // For 3x3, check the upper 2x2 determinant
108#if LIBMESH_DIM > 2
109 if (std::real(A(0,0)*A(1,1) - A(0,1)*A(1,0)) < -abs_tol)
110 return false;
111#endif
112
113 // Finally, check the full determinant
114 if (std::real(A.det()) < -abs_tol)
115 return false;
116
117 // If we made it here, then the matrix is Hermitian
118 // positive-definite.
119 return true;
120}
libMesh::libmesh_conj
T libmesh_conj(T a)
Definition libmesh_common.h:191
std::real
boost::multiprecision::float128 real(const boost::multiprecision::float128 in)
Definition float128_shims.h:82

References libMesh::libmesh_conj(), and std::real().

Referenced by TypeTensorTest::testIsHPD().

◆ is_zero()

template<typename T >
bool libMesh::TypeTensor< T >::is_zero ( ) const
inlineinherited
Returns
True if all values in the tensor are zero

Definition at line 1296 of file type_tensor.h.

1297{
1298 for (const auto & val : _coords)
1299 if (val != T(0))
1300 return false;
1301 return true;
1302}

Referenced by TypeTensorTest::testIsZero().

◆ left_multiply()

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

Left-multiply this tensor by a vector, i.e.

matrix-vector product. The tensor and vector may contain different numeric types.

Returns
A copy of the result vector, this tensor is unchanged.

Definition at line 1218 of file type_tensor.h.

1219{
1220 TypeVector<typename CompareTypes<T,T2>::supertype> returnval;
1221 for (unsigned int i=0; i<LIBMESH_DIM; i++)
1222 for (unsigned int j=0; j<LIBMESH_DIM; j++)
1223 returnval(i) += p(j)*(*this)(j,i);
1224
1225 return returnval;
1226}

Referenced by AzimuthalPeriodicBoundary::get_corresponding_pos().

◆ norm()

template<typename T >
auto libMesh::TypeTensor< T >::norm ( ) const
inlineinherited
Returns
The Frobenius norm of the tensor, i.e. the square-root of the sum of the elements squared.

Definition at line 1287 of file type_tensor.h.

1288{
1289 using std::sqrt;
1290 return sqrt(this->norm_sq());
1291}
libMesh::TypeTensor::norm_sq
auto norm_sq() const
Definition type_tensor.h:1356

◆ norm_sq()

template<typename T >
auto libMesh::TypeTensor< T >::norm_sq ( ) const
inlineinherited
Returns
The Frobenius norm of the tensor squared, i.e. sum of the element magnitudes squared.

Definition at line 1356 of file type_tensor.h.

1357{
1358 Real sum = 0.;
1359 for (unsigned int i=0; i<LIBMESH_DIM*LIBMESH_DIM; i++)
1360 sum += TensorTools::norm_sq(_coords[i]);
1361 return sum;
1362}
libMesh::TensorTools::norm_sq
auto norm_sq(const T &a)
Definition tensor_tools.h:104

References libMesh::TensorTools::norm_sq(), and libMesh::Real.

Referenced by libMesh::UniformRefinementEstimator::_estimate_error(), libMesh::ExactErrorEstimator::find_squared_element_error(), libMesh::TensorTools::norm_sq(), libMesh::TensorTools::norm_sq(), and libMesh::HPCoarsenTest::select_refinement().

◆ operator()() [1/2]

template<typename T >
T & libMesh::TypeTensor< T >::operator() ( const unsigned int  i,
const unsigned int  j 
)
inlineinherited
Returns
A writable reference to the (i,j) entry of the tensor.

Definition at line 732 of file type_tensor.h.

734{
735#if LIBMESH_DIM < 3
736
737 libmesh_error_msg_if(i >= LIBMESH_DIM || j >= LIBMESH_DIM,
738 "ERROR: You are assigning to a tensor component that is out of range for the compiled LIBMESH_DIM!");
739
740#endif
741
742 libmesh_assert_less (i, LIBMESH_DIM);
743 libmesh_assert_less (j, LIBMESH_DIM);
744
745 return _coords[i*LIBMESH_DIM+j];
746}

◆ operator()() [2/2]

template<typename T >
const T & libMesh::TypeTensor< T >::operator() ( const unsigned int  i,
const unsigned int  j 
) const
inlineinherited
Returns
A const reference to the (i,j) entry of the tensor.

Definition at line 713 of file type_tensor.h.

715{
716 libmesh_assert_less (i, 3);
717 libmesh_assert_less (j, 3);
718
719#if LIBMESH_DIM < 3
720 const static T my_zero = 0;
721 if (i >= LIBMESH_DIM || j >= LIBMESH_DIM)
722 return my_zero;
723#endif
724
725 return _coords[i*LIBMESH_DIM+j];
726}

◆ operator*() [1/3]

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

Multiply this tensor by a scalar value.

Returns
A copy of the result, this tensor is unchanged.

Definition at line 972 of file type_tensor.h.

975{
976 typedef decltype((*this)(0, 0) * factor) TS;
977
978
979#if LIBMESH_DIM == 1
980 return TypeTensor<TS>(_coords[0]*factor);
981#endif
982
983#if LIBMESH_DIM == 2
984 return TypeTensor<TS>(_coords[0]*factor,
985 _coords[1]*factor,
986 _coords[2]*factor,
987 _coords[3]*factor);
988#endif
989
990#if LIBMESH_DIM == 3
991 return TypeTensor<TS>(_coords[0]*factor,
992 _coords[1]*factor,
993 _coords[2]*factor,
994 _coords[3]*factor,
995 _coords[4]*factor,
996 _coords[5]*factor,
997 _coords[6]*factor,
998 _coords[7]*factor,
999 _coords[8]*factor);
1000#endif
1001}

◆ operator*() [2/3]

template<typename T >
template<typename T2 >
TypeTensor< typename CompareTypes< T, T2 >::supertype > libMesh::TypeTensor< T >::operator* ( const TypeTensor< T2 > &  p) const
inlineinherited

Multiply 2 tensors together, i.e.

matrix-matrix product. The tensors may contain different numeric types.

Returns
A copy of the result, this tensor is unchanged.

Definition at line 1240 of file type_tensor.h.

1241{
1242 TypeTensor<typename CompareTypes<T, T2>::supertype> returnval;
1243 for (unsigned int i=0; i<LIBMESH_DIM; i++)
1244 for (unsigned int j=0; j<LIBMESH_DIM; j++)
1245 for (unsigned int k=0; k<LIBMESH_DIM; k++)
1246 returnval(i,j) += (*this)(i,k)*p(k,j);
1247
1248 return returnval;
1249}

◆ operator*() [3/3]

template<typename T >
template<typename T2 >
TypeVector< typename CompareTypes< T, T2 >::supertype > libMesh::TypeTensor< T >::operator* ( const TypeVector< T2 > &  p) const
inlineinherited

Right-multiply this tensor by a vector, i.e.

matrix-vector product. The tensor and vector may contain different numeric types.

Returns
A copy of the result vector, this tensor is unchanged.

Definition at line 1204 of file type_tensor.h.

1205{
1206 TypeVector<typename CompareTypes<T,T2>::supertype> returnval;
1207 for (unsigned int i=0; i<LIBMESH_DIM; i++)
1208 for (unsigned int j=0; j<LIBMESH_DIM; j++)
1209 returnval(i) += (*this)(i,j)*p(j);
1210
1211 return returnval;
1212}

◆ operator*=() [1/2]

template<typename T >
template<typename Scalar , typename std::enable_if< ScalarTraits< Scalar >::value, int >::type = 0>
const TypeTensor< T > & libMesh::TypeTensor< T >::operator*= ( const Scalar &  factor)
inlineinherited

Multiply this tensor by a scalar value in place.

Returns
A reference to *this.

Definition at line 268 of file type_tensor.h.

269 {
270 for (unsigned int i=0; i<LIBMESH_DIM*LIBMESH_DIM; i++)
271 _coords[i] *= factor;
272
273 return *this;
274 }

References libMesh::TypeTensor< T >::_coords.

◆ operator*=() [2/2]

template<typename T >
template<typename T2 >
const TypeTensor< T > & libMesh::TypeTensor< T >::operator*= ( const TypeTensor< T2 > &  p)
inlineinherited

Multiply this tensor by a tensor value in place.

Returns
A reference to *this

Definition at line 1254 of file type_tensor.h.

1255{
1256 TypeTensor<T> temp;
1257 for (unsigned int i=0; i<LIBMESH_DIM; i++)
1258 for (unsigned int j=0; j<LIBMESH_DIM; j++)
1259 for (unsigned int k=0; k<LIBMESH_DIM; k++)
1260 temp(i,j) += (*this)(i,k)*p(k,j);
1261
1262 this->assign(temp);
1263 return *this;
1264}
libMesh::TypeTensor::assign
void assign(const TypeTensor< T2 > &)
Assign to this tensor without creating a temporary.
Definition type_tensor.h:703

◆ operator+()

template<typename T >
template<typename T2 >
TypeTensor< typename CompareTypes< T, T2 >::supertype > libMesh::TypeTensor< T >::operator+ ( const TypeTensor< T2 > &  p) const
inlineinherited

Add another tensor to this tensor.

Returns
A copy of the result, this tensor is unchanged.

Definition at line 801 of file type_tensor.h.

802{
803
804#if LIBMESH_DIM == 1
805 return TypeTensor<typename CompareTypes<T, T2>::supertype>(_coords[0] + p._coords[0]);
806#endif
807
808#if LIBMESH_DIM == 2
809 return TypeTensor<typename CompareTypes<T, T2>::supertype>(_coords[0] + p._coords[0],
810 _coords[1] + p._coords[1],
811 0.,
812 _coords[2] + p._coords[2],
813 _coords[3] + p._coords[3]);
814#endif
815
816#if LIBMESH_DIM == 3
817 return TypeTensor<typename CompareTypes<T, T2>::supertype>(_coords[0] + p._coords[0],
818 _coords[1] + p._coords[1],
819 _coords[2] + p._coords[2],
820 _coords[3] + p._coords[3],
821 _coords[4] + p._coords[4],
822 _coords[5] + p._coords[5],
823 _coords[6] + p._coords[6],
824 _coords[7] + p._coords[7],
825 _coords[8] + p._coords[8]);
826#endif
827
828}

References libMesh::TypeTensor< T >::_coords.

◆ operator+=()

template<typename T >
template<typename T2 >
const TypeTensor< T > & libMesh::TypeTensor< T >::operator+= ( const TypeTensor< T2 > &  p)
inlineinherited

Add to this tensor.

Returns
A reference to *this.

Definition at line 835 of file type_tensor.h.

836{
837 this->add (p);
838
839 return *this;
840}
libMesh::TypeTensor::add
void add(const TypeTensor< T2 > &)
Add to this tensor without creating a temporary.
Definition type_tensor.h:847

◆ operator-() [1/2]

template<typename T >
TypeTensor< T > libMesh::TypeTensor< T >::operator- ( ) const
inlineinherited
Returns
The negative of this tensor in a separate copy.

Definition at line 938 of file type_tensor.h.

939{
940
941#if LIBMESH_DIM == 1
942 return TypeTensor(-_coords[0]);
943#endif
944
945#if LIBMESH_DIM == 2
946 return TypeTensor(-_coords[0],
947 -_coords[1],
948 -_coords[2],
949 -_coords[3]);
950#endif
951
952#if LIBMESH_DIM == 3
953 return TypeTensor(-_coords[0],
954 -_coords[1],
955 -_coords[2],
956 -_coords[3],
957 -_coords[4],
958 -_coords[5],
959 -_coords[6],
960 -_coords[7],
961 -_coords[8]);
962#endif
963
964}

◆ operator-() [2/2]

template<typename T >
template<typename T2 >
TypeTensor< typename CompareTypes< T, T2 >::supertype > libMesh::TypeTensor< T >::operator- ( const TypeTensor< T2 > &  p) const
inlineinherited

Subtract a tensor from this tensor.

Returns
A copy of the result, this tensor is unchanged.

Definition at line 871 of file type_tensor.h.

872{
873
874#if LIBMESH_DIM == 1
875 return TypeTensor<typename CompareTypes<T, T2>::supertype>(_coords[0] - p._coords[0]);
876#endif
877
878#if LIBMESH_DIM == 2
879 return TypeTensor<typename CompareTypes<T, T2>::supertype>(_coords[0] - p._coords[0],
880 _coords[1] - p._coords[1],
881 0.,
882 _coords[2] - p._coords[2],
883 _coords[3] - p._coords[3]);
884#endif
885
886#if LIBMESH_DIM == 3
887 return TypeTensor<typename CompareTypes<T, T2>::supertype>(_coords[0] - p._coords[0],
888 _coords[1] - p._coords[1],
889 _coords[2] - p._coords[2],
890 _coords[3] - p._coords[3],
891 _coords[4] - p._coords[4],
892 _coords[5] - p._coords[5],
893 _coords[6] - p._coords[6],
894 _coords[7] - p._coords[7],
895 _coords[8] - p._coords[8]);
896#endif
897
898}

References libMesh::TypeTensor< T >::_coords.

◆ operator-=()

template<typename T >
template<typename T2 >
const TypeTensor< T > & libMesh::TypeTensor< T >::operator-= ( const TypeTensor< T2 > &  p)
inlineinherited

Subtract from this tensor.

Returns
A reference to *this.

Definition at line 905 of file type_tensor.h.

906{
907 this->subtract (p);
908
909 return *this;
910}
libMesh::TypeTensor::subtract
void subtract(const TypeTensor< T2 > &)
Subtract from this tensor without creating a temporary.
Definition type_tensor.h:917

◆ operator/()

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

Divide each entry of this tensor by a scalar value.

Returns
A copy of the result, this tensor is unchanged.

Definition at line 1022 of file type_tensor.h.

1023{
1024 libmesh_assert_not_equal_to (factor, static_cast<T>(0.));
1025
1026 typedef typename CompareTypes<T, Scalar>::supertype TS;
1027
1028#if LIBMESH_DIM == 1
1029 return TypeTensor<TS>(_coords[0]/factor);
1030#endif
1031
1032#if LIBMESH_DIM == 2
1033 return TypeTensor<TS>(_coords[0]/factor,
1034 _coords[1]/factor,
1035 _coords[2]/factor,
1036 _coords[3]/factor);
1037#endif
1038
1039#if LIBMESH_DIM == 3
1040 return TypeTensor<TS>(_coords[0]/factor,
1041 _coords[1]/factor,
1042 _coords[2]/factor,
1043 _coords[3]/factor,
1044 _coords[4]/factor,
1045 _coords[5]/factor,
1046 _coords[6]/factor,
1047 _coords[7]/factor,
1048 _coords[8]/factor);
1049#endif
1050
1051}

◆ operator/=()

template<typename T >
const TypeTensor< T > & libMesh::TypeTensor< T >::operator/= ( const T &  factor)
inlineinherited

Divide each entry of this tensor by a scalar value.

Returns
A reference to *this.

Definition at line 1187 of file type_tensor.h.

1188{
1189 libmesh_assert_not_equal_to (factor, static_cast<T>(0.));
1190
1191 for (unsigned int i=0; i<LIBMESH_DIM*LIBMESH_DIM; i++)
1192 _coords[i] /= factor;
1193
1194 return *this;
1195}

◆ operator<() [1/3]

bool libMesh::TypeTensor< Complex >::operator< ( const TypeTensor< Complex > &  rhs) const
inherited

Definition at line 157 of file type_tensor.C.

158{
159 for (unsigned int i=0; i<LIBMESH_DIM; i++)
160 for (unsigned int j=0; j<LIBMESH_DIM; j++)
161 {
162 if ((*this)(i,j).real() < rhs(i,j).real())
163 return true;
164 if ((*this)(i,j).real() > rhs(i,j).real())
165 return false;
166 if ((*this)(i,j).imag() < rhs(i,j).imag())
167 return true;
168 if ((*this)(i,j).imag() > rhs(i,j).imag())
169 return false;
170 }
171 return false;
172}
std::imag
boost::multiprecision::float128 imag(const boost::multiprecision::float128)
Definition float128_shims.h:88

◆ operator<() [2/3]

bool libMesh::TypeTensor< Real >::operator< ( const TypeTensor< Real > &  rhs) const
inherited

Definition at line 124 of file type_tensor.C.

125{
126 for (unsigned int i=0; i<LIBMESH_DIM; i++)
127 for (unsigned int j=0; j<LIBMESH_DIM; j++)
128 {
129 if ((*this)(i,j) < rhs(i,j))
130 return true;
131 if ((*this)(i,j) > rhs(i,j))
132 return false;
133 }
134 return false;
135}

◆ operator<() [3/3]

template<typename T >
bool libMesh::TypeTensor< T >::operator< ( const TypeTensor< T > &  rhs) const
inherited
Returns
true if this tensor is "less" than another. Useful for sorting.

◆ operator=()

template<typename T >
template<typename Scalar >
std::enable_if< ScalarTraits< Scalar >::value, TensorValue & >::type libMesh::TensorValue< T >::operator= ( const Scalar &  libmesh_dbg_varp)
inline

Assignment-from-scalar operator.

Used only to zero out tensors.

Definition at line 145 of file tensor_value.h.

146 { libmesh_assert_equal_to (p, Scalar(0)); this->zero(); return *this; }
libMesh::TypeTensor::zero
void zero()
Set all entries of the tensor to 0.
Definition type_tensor.h:1346

References libMesh::TypeTensor< T >::zero().

◆ operator==()

template<typename T >
bool libMesh::TypeTensor< T >::operator== ( const TypeTensor< T > &  rhs) const
inlineinherited
Returns
true if two tensors are equal, false otherwise.

Definition at line 1368 of file type_tensor.h.

1369{
1370#if LIBMESH_DIM == 1
1371 return (std::abs(_coords[0] - rhs._coords[0])
1372 < TOLERANCE);
1373#endif
1374
1375#if LIBMESH_DIM == 2
1376 return ((std::abs(_coords[0] - rhs._coords[0]) +
1377 std::abs(_coords[1] - rhs._coords[1]) +
1378 std::abs(_coords[2] - rhs._coords[2]) +
1379 std::abs(_coords[3] - rhs._coords[3]))
1380 < 4.*TOLERANCE);
1381#endif
1382
1383#if LIBMESH_DIM == 3
1384 return ((std::abs(_coords[0] - rhs._coords[0]) +
1385 std::abs(_coords[1] - rhs._coords[1]) +
1386 std::abs(_coords[2] - rhs._coords[2]) +
1387 std::abs(_coords[3] - rhs._coords[3]) +
1388 std::abs(_coords[4] - rhs._coords[4]) +
1389 std::abs(_coords[5] - rhs._coords[5]) +
1390 std::abs(_coords[6] - rhs._coords[6]) +
1391 std::abs(_coords[7] - rhs._coords[7]) +
1392 std::abs(_coords[8] - rhs._coords[8]))
1393 < 9.*TOLERANCE);
1394#endif
1395
1396}
libMesh::TOLERANCE
static constexpr Real TOLERANCE
Definition libmesh_common.h:151

References libMesh::TypeTensor< T >::_coords, and libMesh::TOLERANCE.

◆ operator>() [1/3]

bool libMesh::TypeTensor< Complex >::operator> ( const TypeTensor< Complex > &  rhs) const
inherited

Definition at line 177 of file type_tensor.C.

178{
179 for (unsigned int i=0; i<LIBMESH_DIM; i++)
180 for (unsigned int j=0; j<LIBMESH_DIM; j++)
181 {
182 if ((*this)(i,j).real() > rhs(i,j).real())
183 return true;
184 if ((*this)(i,j).real() < rhs(i,j).real())
185 return false;
186 if ((*this)(i,j).imag() > rhs(i,j).imag())
187 return true;
188 if ((*this)(i,j).imag() < rhs(i,j).imag())
189 return false;
190 }
191 return false;
192}

◆ operator>() [2/3]

bool libMesh::TypeTensor< Real >::operator> ( const TypeTensor< Real > &  rhs) const
inherited

Definition at line 140 of file type_tensor.C.

141{
142 for (unsigned int i=0; i<LIBMESH_DIM; i++)
143 for (unsigned int j=0; j<LIBMESH_DIM; j++)
144 {
145 if ((*this)(i,j) > rhs(i,j))
146 return true;
147 if ((*this)(i,j) < rhs(i,j))
148 return false;
149 }
150 return false;
151}

◆ operator>() [3/3]

template<typename T >
bool libMesh::TypeTensor< T >::operator> ( const TypeTensor< T > &  rhs) const
inherited
Returns
true if this tensor is "greater" than another.

◆ print()

template<typename T >
void libMesh::TypeTensor< T >::print ( std::ostream &  os = libMesh::out) const
inherited

Formatted print to a stream which defaults to libMesh::out.

Definition at line 1399 of file type_tensor.h.

1400{
1401#if LIBMESH_DIM == 1
1402
1403 os << "x=" << (*this)(0,0) << std::endl;
1404
1405#endif
1406#if LIBMESH_DIM == 2
1407
1408 os << "(xx,xy)=("
1409 << std::setw(8) << (*this)(0,0) << ", "
1410 << std::setw(8) << (*this)(0,1) << ")"
1411 << std::endl;
1412 os << "(yx,yy)=("
1413 << std::setw(8) << (*this)(1,0) << ", "
1414 << std::setw(8) << (*this)(1,1) << ")"
1415 << std::endl;
1416
1417#endif
1418#if LIBMESH_DIM == 3
1419
1420 os << "(xx,xy,xz)=("
1421 << std::setw(8) << (*this)(0,0) << ", "
1422 << std::setw(8) << (*this)(0,1) << ", "
1423 << std::setw(8) << (*this)(0,2) << ")"
1424 << std::endl;
1425 os << "(yx,yy,yz)=("
1426 << std::setw(8) << (*this)(1,0) << ", "
1427 << std::setw(8) << (*this)(1,1) << ", "
1428 << std::setw(8) << (*this)(1,2) << ")"
1429 << std::endl;
1430 os << "(zx,zy,zz)=("
1431 << std::setw(8) << (*this)(2,0) << ", "
1432 << std::setw(8) << (*this)(2,1) << ", "
1433 << std::setw(8) << (*this)(2,2) << ")"
1434 << std::endl;
1435#endif
1436}

◆ row()

template<typename T >
TypeVector< T > libMesh::TypeTensor< T >::row ( const unsigned int  r) const
inlineinherited
Returns
A copy of one row of the tensor as a TypeVector.

Definition at line 772 of file type_tensor.h.

773{
774 TypeVector<T> return_vector;
775
776 for (unsigned int j=0; j<LIBMESH_DIM; j++)
777 return_vector._coords[j] = _coords[r*LIBMESH_DIM + j];
778
779 return return_vector;
780}

References libMesh::TypeVector< T >::_coords.

Referenced by SolutionGradient< dim >::component(), SolutionGradient< dim >::operator()(), and TypeTensorTest::testRowCol().

◆ slice() [1/2]

template<typename T >
TypeTensorColumn< T > libMesh::TypeTensor< T >::slice ( const unsigned int  i)
inlineinherited
Returns
A writable proxy for the \( i^{th} \) column of the tensor.

Definition at line 762 of file type_tensor.h.

763{
764 libmesh_assert_less (i, LIBMESH_DIM);
765 return TypeTensorColumn<T>(*this, i);
766}

◆ slice() [2/2]

template<typename T >
ConstTypeTensorColumn< T > libMesh::TypeTensor< T >::slice ( const unsigned int  i) const
inlineinherited
Returns
A proxy for the \( i^{th} \) column of the tensor.

Definition at line 752 of file type_tensor.h.

753{
754 libmesh_assert_less (i, LIBMESH_DIM);
755 return ConstTypeTensorColumn<T>(*this, i);
756}

◆ solve()

template<typename T >
void libMesh::TypeTensor< T >::solve ( const TypeVector< T > &  b,
TypeVector< T > &  x 
) const
inlineinherited

Solve the 2x2 or 3x3 system of equations A*x = b for x by directly inverting A and multiplying it by b.

Returns
The solution in the x vector.

Definition at line 1136 of file type_tensor.h.

1137{
1138#if LIBMESH_DIM == 1
1139 if (_coords[0] == static_cast<T>(0.))
1140 libmesh_convergence_failure();
1141 x(0) = b(0) / _coords[0];
1142#endif
1143
1144#if LIBMESH_DIM == 2
1145 T my_det = _coords[0]*_coords[3] - _coords[1]*_coords[2];
1146
1147 if (my_det == static_cast<T>(0.))
1148 libmesh_convergence_failure();
1149
1150 T my_det_inv = 1./my_det;
1151
1152 x(0) = my_det_inv*( _coords[3]*b(0) - _coords[1]*b(1));
1153 x(1) = my_det_inv*(-_coords[2]*b(0) + _coords[0]*b(1));
1154#endif
1155
1156#if LIBMESH_DIM == 3
1157 T my_det =
1158 // a11*(a33 *a22 - a32 *a23)
1159 _coords[0]*(_coords[8]*_coords[4] - _coords[7]*_coords[5])
1160 // -a21*(a33 *a12 - a32 *a13)
1161 -_coords[3]*(_coords[8]*_coords[1] - _coords[7]*_coords[2]) +
1162 // +a31*(a23 *a12 - a22 *a13)
1163 +_coords[6]*(_coords[5]*_coords[1] - _coords[4]*_coords[2]);
1164
1165 if (my_det == static_cast<T>(0.))
1166 libmesh_convergence_failure();
1167
1168 T my_det_inv = 1./my_det;
1169 x(0) = my_det_inv*((_coords[8]*_coords[4] - _coords[7]*_coords[5])*b(0) -
1170 (_coords[8]*_coords[1] - _coords[7]*_coords[2])*b(1) +
1171 (_coords[5]*_coords[1] - _coords[4]*_coords[2])*b(2));
1172
1173 x(1) = my_det_inv*((_coords[6]*_coords[5] - _coords[8]*_coords[3])*b(0) +
1174 (_coords[8]*_coords[0] - _coords[6]*_coords[2])*b(1) -
1175 (_coords[5]*_coords[0] - _coords[3]*_coords[2])*b(2));
1176
1177 x(2) = my_det_inv*((_coords[7]*_coords[3] - _coords[6]*_coords[4])*b(0) -
1178 (_coords[7]*_coords[0] - _coords[6]*_coords[1])*b(1) +
1179 (_coords[4]*_coords[0] - _coords[3]*_coords[1])*b(2));
1180#endif
1181}

References b.

Referenced by InfFERadialTest::base_point(), and libMesh::InfFEMap::inverse_map().

◆ subtract()

template<typename T >
template<typename T2 >
void libMesh::TypeTensor< T >::subtract ( const TypeTensor< T2 > &  p)
inlineinherited

Subtract from this tensor without creating a temporary.

Definition at line 917 of file type_tensor.h.

918{
919 for (unsigned int i=0; i<LIBMESH_DIM*LIBMESH_DIM; i++)
920 _coords[i] -= p._coords[i];
921}

References libMesh::TypeTensor< T >::_coords.

◆ subtract_scaled()

template<typename T >
template<typename T2 >
void libMesh::TypeTensor< T >::subtract_scaled ( const TypeTensor< T2 > &  p,
const T &  factor 
)
inlineinherited

Subtract a scaled value from this tensor without creating a temporary.

Definition at line 928 of file type_tensor.h.

929{
930 for (unsigned int i=0; i<LIBMESH_DIM*LIBMESH_DIM; i++)
931 _coords[i] -= factor*p._coords[i];
932}

References libMesh::TypeTensor< T >::_coords.

Referenced by libMesh::HPCoarsenTest::select_refinement().

◆ tr()

template<typename T >
T libMesh::TypeTensor< T >::tr ( ) const
inlineinherited
Returns
The trace of the tensor.

Definition at line 1329 of file type_tensor.h.

1330{
1331#if LIBMESH_DIM == 1
1332 return _coords[0];
1333#endif
1334
1335#if LIBMESH_DIM == 2
1336 return _coords[0] + _coords[3];
1337#endif
1338
1339#if LIBMESH_DIM == 3
1340 return _coords[0] + _coords[4] + _coords[8];
1341#endif
1342}

◆ transpose()

template<typename T >
TypeTensor< T > libMesh::TypeTensor< T >::transpose ( ) const
inlineinherited
Returns
The transpose of this tensor (with complex numbers not conjugated).

Definition at line 1057 of file type_tensor.h.

1058{
1059#if LIBMESH_DIM == 1
1060 return TypeTensor(_coords[0]);
1061#endif
1062
1063#if LIBMESH_DIM == 2
1064 return TypeTensor(_coords[0],
1065 _coords[2],
1066 _coords[1],
1067 _coords[3]);
1068#endif
1069
1070#if LIBMESH_DIM == 3
1071 return TypeTensor(_coords[0],
1072 _coords[3],
1073 _coords[6],
1074 _coords[1],
1075 _coords[4],
1076 _coords[7],
1077 _coords[2],
1078 _coords[5],
1079 _coords[8]);
1080#endif
1081}

Referenced by assemble_shell(), NonlinearNeoHookeCurrentConfig::calculate_stress(), libMesh::VariationalSmootherSystem::compute_mesh_quality_info(), LargeDeformationElasticity::compute_stresses(), libMesh::VariationalSmootherSystem::element_time_derivative(), libMesh::get_jacobian_at_qp(), GradDivExactSolution::grad(), CurlCurlExactSolution::grad(), libMesh::TensorValue< T >::inverse_extrinsic_rotation_matrix(), libMesh::TensorValue< T >::inverse_intrinsic_rotation_matrix(), GradDivExactSolution::operator()(), CurlCurlExactSolution::operator()(), and TypeTensorTest::testIsHPD().

◆ write_unformatted()

template<typename T >
void libMesh::TypeTensor< T >::write_unformatted ( std::ostream &  out_stream,
const bool  newline = true 
) const
inherited

Unformatted print to the stream out.

Simply prints the elements of the tensor separated by spaces and newlines.

Definition at line 39 of file type_tensor.C.

41{
42 libmesh_assert (out_stream);
43
44 out_stream << std::setiosflags(std::ios::showpoint)
45 << (*this)(0,0) << " "
46 << (*this)(0,1) << " "
47 << (*this)(0,2) << " ";
48 if (newline)
49 out_stream << '\n';
50
51 out_stream << std::setiosflags(std::ios::showpoint)
52 << (*this)(1,0) << " "
53 << (*this)(1,1) << " "
54 << (*this)(1,2) << " ";
55 if (newline)
56 out_stream << '\n';
57
58 out_stream << std::setiosflags(std::ios::showpoint)
59 << (*this)(2,0) << " "
60 << (*this)(2,1) << " "
61 << (*this)(2,2) << " ";
62 if (newline)
63 out_stream << '\n';
64}
libMesh::libmesh_assert
libmesh_assert(ctx)

References libMesh::libmesh_assert().

◆ zero()

template<typename T >
void libMesh::TypeTensor< T >::zero ( )
inlineinherited

Set all entries of the tensor to 0.

Definition at line 1346 of file type_tensor.h.

1347{
1348 for (unsigned int i=0; i<LIBMESH_DIM*LIBMESH_DIM; i++)
1349 _coords[i] = 0.;
1350}

Referenced by LargeDeformationElasticity::compute_stresses(), LinearElasticityWithContact::compute_stresses(), NonlinearNeoHookeCurrentConfig::init_for_qp(), libMesh::TensorValue< T >::operator=(), and libMesh::TypeTensor< T >::operator=().

Member Data Documentation

◆ _coords

template<typename T >
T libMesh::TypeTensor< T >::_coords[LIBMESH_DIM *LIBMESH_DIM]
protectedinherited

The coordinates of the TypeTensor.

Definition at line 451 of file type_tensor.h.

Referenced by libMesh::TypeTensor< T >::add(), libMesh::TypeTensor< T >::add_scaled(), libMesh::TypeTensor< T >::assign(), libMesh::TypeTensor< T >::contract(), libMesh::TypeTensor< T >::operator*=(), libMesh::TypeTensor< T >::operator+(), libMesh::TypeTensor< T >::operator-(), libMesh::TypeTensor< T >::operator==(), libMesh::TypeTensor< T >::subtract(), libMesh::TypeTensor< T >::subtract_scaled(), and libMesh::TypeTensor< T >::TypeTensor().

The documentation for this class was generated from the following files:
Generated on Fri Aug 21 2026 13:33:00 for libMesh by doxygen 1.9.8