RankTwoScalarTools Namespace Reference

Enumerations
enum class	InvariantType {   VonMisesStress , EffectiveStrain , Hydrostatic , L2norm ,   VolumetricStrain , FirstInvariant , SecondInvariant , ThirdInvariant ,   TriaxialityStress , MaxShear , StressIntensity , MaxPrincipal ,   MidPrincipal , MinPrincipal }
enum class	CylindricalComponent { AxialStress , HoopStress , RadialStress }
enum class	SphericalComponent { HoopStress , RadialStress }

Functions
MooseEnum	scalarOptions ()
	This enum is left for legacy calls.
MooseEnum	invariantOptions ()
MooseEnum	cylindricalOptions ()
MooseEnum	sphericalOptions ()
template<typename T >
T	component (const RankTwoTensorTempl< T > &r2tensor, unsigned int i, unsigned int j)
template<typename T >
T	component (const RankTwoTensorTempl< T > &r2tensor, unsigned int i, unsigned int j, Point &direction)
template<typename T >
T	vonMisesStress (const RankTwoTensorTempl< T > &stress)
template<typename T >
T	effectiveStrain (const RankTwoTensorTempl< T > &strain)
template<typename T >
T	hydrostatic (const RankTwoTensorTempl< T > &r2tensor)
template<typename T >
T	L2norm (const RankTwoTensorTempl< T > &r2tensor)
template<typename T >
T	volumetricStrain (const RankTwoTensorTempl< T > &strain)
template<typename T >
T	firstInvariant (const RankTwoTensorTempl< T > &r2tensor)
template<typename T >
T	secondInvariant (const RankTwoTensorTempl< T > &r2tensor)
template<typename T >
T	thirdInvariant (const RankTwoTensorTempl< T > &r2tensor)
template<typename T >
T	calcEigenValuesEigenVectors (const RankTwoTensorTempl< T > &r2tensor, unsigned int index, Point &eigenvec)
template<typename T >
T	maxPrincipal (const RankTwoTensorTempl< T > &r2tensor, Point &direction)
template<typename T >
T	midPrincipal (const RankTwoTensorTempl< T > &r2tensor, Point &direction)
template<typename T >
T	minPrincipal (const RankTwoTensorTempl< T > &r2tensor, Point &direction)
template<typename T >
T	axialStress (const RankTwoTensorTempl< T > &stress, const Point &point1, const Point &point2, Point &direction)
void	normalPositionVector (const Point &point1, const Point &point2, const Point &curr_point, Point &normalPosition)
template<typename T >
T	hoopStress (const RankTwoTensorTempl< T > &stress, const Point &point1, const Point &point2, const Point &curr_point, Point &direction)
template<typename T >
T	radialStress (const RankTwoTensorTempl< T > &stress, const Point &point1, const Point &point2, const Point &curr_point, Point &direction)
template<typename T >
T	radialStress (const RankTwoTensorTempl< T > &stress, const Point &center, const Point &curr_point, Point &direction)
template<typename T >
T	hoopStress (const RankTwoTensorTempl< T > &stress, const Point &center, const Point &curr_point, Point &direction)
template<typename T >
T	directionValueTensor (const RankTwoTensorTempl< T > &r2tensor, const Point &direction)
template<typename T >
T	triaxialityStress (const RankTwoTensorTempl< T > &stress)
template<typename T >
T	maxShear (const RankTwoTensorTempl< T > &stress)
template<typename T >
T	stressIntensity (const RankTwoTensorTempl< T > &stress)
template<typename T >
T	getQuantity (const RankTwoTensorTempl< T > &tensor, const MooseEnum &scalar_type, const Point &point1, const Point &point2, const Point &curr_point, Point &direction)
template<typename T >
T	getCylindricalComponent (const RankTwoTensorTempl< T > &tensor, const CylindricalComponent &scalar_type, const Point &point1, const Point &point2, const Point &curr_point, Point &direction)
template<typename T >
T	getSphericalComponent (const RankTwoTensorTempl< T > &tensor, const SphericalComponent &scalar_type, const Point &center, const Point &curr_point, Point &direction)
template<typename T >
T	getPrincipalComponent (const RankTwoTensorTempl< T > &tensor, const InvariantType &scalar_type, Point &direction)
template<typename T >
T	getDirectionalComponent (const RankTwoTensorTempl< T > &tensor, const Point &direction)
template<typename T >
T	getInvariant (const RankTwoTensorTempl< T > &tensor, const InvariantType &scalar_type)
void	setRotationMatrix (const RealVectorValue &outwardnormal, const RealVectorValue &axialVector, RankTwoTensor &rotationMatrix, const bool transpose)
template<bool is_ad>
void	RankTwoTensorToVoigtVector (const GenericRankTwoTensor< is_ad > &tensor, GenericDenseVector< is_ad > &voigt_vector)
template<bool is_ad>
void	VoigtVectorToRankTwoTensor (const GenericDenseVector< is_ad > &voigt_vector, GenericRankTwoTensor< is_ad > &tensor)

Enumeration Type Documentation

CylindricalComponent

enum class RankTwoScalarTools::CylindricalComponent

strong

Enumerator
AxialStress
HoopStress
RadialStress

Definition at line 49 of file RankTwoScalarTools.h.

{
  AxialStress,
  HoopStress,
  RadialStress
};

InvariantType

enum class RankTwoScalarTools::InvariantType

strong

Enumerator
VonMisesStress
EffectiveStrain
Hydrostatic
L2norm
VolumetricStrain
FirstInvariant
SecondInvariant
ThirdInvariant
TriaxialityStress
MaxShear
StressIntensity
MaxPrincipal
MidPrincipal
MinPrincipal

Definition at line 31 of file RankTwoScalarTools.h.

{
  VonMisesStress,
  EffectiveStrain,
  Hydrostatic,
  L2norm,
  VolumetricStrain,
  FirstInvariant,
  SecondInvariant,
  ThirdInvariant,
  TriaxialityStress,
  MaxShear,
  StressIntensity,
  MaxPrincipal,
  MidPrincipal,
  MinPrincipal
};

SphericalComponent

enum class RankTwoScalarTools::SphericalComponent

strong

Enumerator
HoopStress
RadialStress

Definition at line 56 of file RankTwoScalarTools.h.

{
  HoopStress,
  RadialStress
};

Function Documentation

axialStress()

template<typename T >

T RankTwoScalarTools::axialStress	(	const RankTwoTensorTempl< T > &	stress,
		const Point &	point1,
		const Point &	point2,
		Point &	direction
	)

Definition at line 294 of file RankTwoScalarTools.h.

{
  Point axis = point2 - point1;
  axis /= axis.norm();
 
  // Calculate the stress in the direction of the axis specifed by the user
  T axial_stress = axis * (stress * axis);
 
  direction = axis;
 
  return axial_stress;
}

Referenced by RankTwoBasedFailureCriteriaNOSPD::computeFailureCriterionValue(), getCylindricalComponent(), and getQuantity().

calcEigenValuesEigenVectors()

template<typename T >

T RankTwoScalarTools::calcEigenValuesEigenVectors	(	const RankTwoTensorTempl< T > &	r2tensor,
		unsigned int	index,
		Point &	eigenvec
	)

Definition at line 231 of file RankTwoScalarTools.h.

{
  std::vector<T> eigenval(LIBMESH_DIM);
  RankTwoTensorTempl<T> eigvecs;
  r2tensor.symmetricEigenvaluesEigenvectors(eigenval, eigvecs);
 
  T val = eigenval[index];
  eigenvec = eigvecs.column(index);
 
  return val;
}

Referenced by maxPrincipal(), midPrincipal(), minPrincipal(), and TEST().

component() [1/2]

template<typename T >

T RankTwoScalarTools::component	(	const RankTwoTensorTempl< T > &	r2tensor,
		unsigned int	i,
		unsigned int	j
	)

Definition at line 67 of file RankTwoScalarTools.h.

{
  return r2tensor(i, j);
}

Referenced by MaterialTensorIntegralTempl< is_ad >::computeQpIntegral(), RankTwoCartesianComponentTempl< is_ad >::computeQpProperties(), RankTwoAuxTempl< is_ad >::computeValue(), NodalRankTwoPD::computeValue(), and LineMaterialRankTwoSampler::getScalarFromProperty().

component() [2/2]

template<typename T >

T RankTwoScalarTools::component	(	const RankTwoTensorTempl< T > &	r2tensor,
		unsigned int	i,
		unsigned int	j,
		Point &	direction
	)

Definition at line 78 of file RankTwoScalarTools.h.

{
  direction.zero();
  if (i == j)
    direction(i) = 1.0;
  else
  {
    direction(i) = std::sqrt(0.5);
    direction(j) = std::sqrt(0.5);
  }
 
  return r2tensor(i, j);
}

cylindricalOptions()

MooseEnum RankTwoScalarTools::cylindricalOptions

(

)

Definition at line 34 of file RankTwoScalarTools.C.

{
  return MooseEnum("AxialStress HoopStress RadialStress");
}

directionValueTensor()

template<typename T >

T RankTwoScalarTools::directionValueTensor	(	const RankTwoTensorTempl< T > &	r2tensor,
		const Point &	direction
	)

Definition at line 476 of file RankTwoScalarTools.h.

{
  T tensor_value_in_direction = direction * (r2tensor * direction);
 
  return tensor_value_in_direction;
}

Referenced by getDirectionalComponent(), CrackFrontNonlocalStress::getQPCrackFrontScalar(), and getQuantity().

effectiveStrain()

template<typename T >

T RankTwoScalarTools::effectiveStrain

(

const RankTwoTensorTempl< T > &

strain

)

Definition at line 113 of file RankTwoScalarTools.h.

{
  return std::sqrt(2.0 / 3.0 * strain.doubleContraction(strain));
}

Referenced by RankTwoBasedFailureCriteriaNOSPD::computeFailureCriterionValue(), and RankTwoInvariantTempl< is_ad >::computeQpProperties().

firstInvariant()

template<typename T >

T RankTwoScalarTools::firstInvariant

(

const RankTwoTensorTempl< T > &

r2tensor

)

Definition at line 175 of file RankTwoScalarTools.h.

{
  return r2tensor.trace();
}

Referenced by getInvariant(), and getQuantity().

getCylindricalComponent()

template<typename T >

T RankTwoScalarTools::getCylindricalComponent	(	const RankTwoTensorTempl< T > &	tensor,
		const CylindricalComponent &	scalar_type,
		const Point &	point1,
		const Point &	point2,
		const Point &	curr_point,
		Point &	direction
	)

Definition at line 580 of file RankTwoScalarTools.h.

{
  switch (scalar_type)
  {
    case CylindricalComponent::AxialStress:
      return axialStress(tensor, point1, point2, direction);
    case CylindricalComponent::HoopStress:
      return hoopStress(tensor, point1, point2, curr_point, direction);
    case CylindricalComponent::RadialStress:
      return radialStress(tensor, point1, point2, curr_point, direction);
    default:
      mooseError("RankTwoCylindricalComponent Error: scalar type invalid");
  }
}

Referenced by RankTwoCylindricalComponentTempl< is_ad >::computeQpProperties().

getDirectionalComponent()

template<typename T >

T RankTwoScalarTools::getDirectionalComponent	(	const RankTwoTensorTempl< T > &	tensor,
		const Point &	direction
	)

Definition at line 640 of file RankTwoScalarTools.h.

{
  return directionValueTensor(tensor, direction);
}

Referenced by RankTwoDirectionalComponentTempl< is_ad >::computeQpProperties().

getInvariant()

template<typename T >

T RankTwoScalarTools::getInvariant	(	const RankTwoTensorTempl< T > &	tensor,
		const InvariantType &	scalar_type
	)

Definition at line 647 of file RankTwoScalarTools.h.

{
  switch (scalar_type)
  {
    case InvariantType::VonMisesStress:
      return vonMisesStress(tensor);
    case InvariantType::EffectiveStrain:
      mooseError("To compute an effective inelastic strain use "
                 "RankTwoScalarTools::effectiveStrain()");
    case InvariantType::Hydrostatic:
      return hydrostatic(tensor);
    case InvariantType::L2norm:
      return L2norm(tensor);
    case InvariantType::VolumetricStrain:
      return volumetricStrain(tensor);
    case InvariantType::FirstInvariant:
      return firstInvariant(tensor);
    case InvariantType::SecondInvariant:
      return secondInvariant(tensor);
    case InvariantType::ThirdInvariant:
      return thirdInvariant(tensor);
    case InvariantType::TriaxialityStress:
      return triaxialityStress(tensor);
    case InvariantType::MaxShear:
      return maxShear(tensor);
    case InvariantType::StressIntensity:
      return stressIntensity(tensor);
    default:
      mooseError("RankTwoCartesianComponent Error: Pass valid invariant - " +
                 invariantOptions().getRawNames());
  }
}

Referenced by RankTwoInvariantTempl< is_ad >::computeQpProperties().

getPrincipalComponent()

template<typename T >

T RankTwoScalarTools::getPrincipalComponent	(	const RankTwoTensorTempl< T > &	tensor,
		const InvariantType &	scalar_type,
		Point &	direction
	)

Definition at line 621 of file RankTwoScalarTools.h.

{
  switch (scalar_type)
  {
    case InvariantType::MaxPrincipal:
      return maxPrincipal(tensor, direction);
    case InvariantType::MidPrincipal:
      return midPrincipal(tensor, direction);
    case InvariantType::MinPrincipal:
      return minPrincipal(tensor, direction);
    default:
      mooseError("RankTwoInvariant Error: valid invariant");
  }
}

Referenced by RankTwoInvariantTempl< is_ad >::computeQpProperties().

getQuantity()

template<typename T >

T RankTwoScalarTools::getQuantity	(	const RankTwoTensorTempl< T > &	tensor,
		const MooseEnum &	scalar_type,
		const Point &	point1,
		const Point &	point2,
		const Point &	curr_point,
		Point &	direction
	)

Definition at line 527 of file RankTwoScalarTools.h.

{
  switch (scalar_type)
  {
    case 0:
      return vonMisesStress(tensor);
    case 1:
      mooseError("To compute an effective inelastic strain use "
                 "RankTwoScalarTools::effectiveStrain()");
    case 2:
      return hydrostatic(tensor);
    case 3:
      return L2norm(tensor);
    case 4:
      return maxPrincipal(tensor, direction);
    case 5:
      return midPrincipal(tensor, direction);
    case 6:
      return minPrincipal(tensor, direction);
    case 7:
      return volumetricStrain(tensor);
    case 8:
      return firstInvariant(tensor);
    case 9:
      return secondInvariant(tensor);
    case 10:
      return thirdInvariant(tensor);
    case 11:
      return axialStress(tensor, point1, point2, direction);
    case 12:
      return hoopStress(tensor, point1, point2, curr_point, direction);
    case 13:
      return radialStress(tensor, point1, point2, curr_point, direction);
    case 14:
      return triaxialityStress(tensor);
    case 15:
      return directionValueTensor(tensor, direction);
    case 16:
      return maxShear(tensor);
    case 17:
      return stressIntensity(tensor);
    default:
      mooseError("RankTwoScalarTools Error: invalid scalar type");
  }
}

Referenced by RankTwoScalarAuxTempl< is_ad >::computeValue(), NodalRankTwoPD::computeValue(), XFEMRankTwoTensorMarkerUserObject::doesElementCrack(), MeshCut2DRankTwoTensorNucleation::doesElementCrack(), NodalRankTwoScalarPD::gatherWeightedValue(), and LineMaterialRankTwoScalarSampler::getScalarFromProperty().

getSphericalComponent()

template<typename T >

T RankTwoScalarTools::getSphericalComponent	(	const RankTwoTensorTempl< T > &	tensor,
		const SphericalComponent &	scalar_type,
		const Point &	center,
		const Point &	curr_point,
		Point &	direction
	)

Definition at line 602 of file RankTwoScalarTools.h.

{
  switch (scalar_type)
  {
    case SphericalComponent::HoopStress:
      return hoopStress(tensor, center, curr_point, direction);
    case SphericalComponent::RadialStress:
      return radialStress(tensor, center, curr_point, direction);
    default:
      mooseError("RankTwoSphericalComponent Error: scalar type invalid");
  }
}

Referenced by RankTwoSphericalComponentTempl< is_ad >::computeQpProperties().

hoopStress() [1/2]

template<typename T >

T RankTwoScalarTools::hoopStress	(	const RankTwoTensorTempl< T > &	stress,
		const Point &	center,
		const Point &	curr_point,
		Point &	direction
	)

Definition at line 422 of file RankTwoScalarTools.h.

{
  Point radial = curr_point - center;
  Real r = radial.norm();
  radial /= r;
 
  // Given normal vector N=(n1,n2,n3) and current point C(c1,c2,c3), the tangential plane is then
  // defined as n1(x-c1) + n2(y-c2) + n3(z-c3)=0. Let us assume n1!=0, the arbitrary point P on this
  // plane can be taken as P(x,c2+r,c3+r) where r is the radius. The x can be solved as x =
  // -r(n2+n3)/n1 + c1. The tangential vector PC is given as P-C.
 
  Point tangential;
 
  if (!MooseUtils::absoluteFuzzyEqual(radial(0), 0.0))
  {
    Real x = curr_point(0) - (radial(1) + radial(2)) * r / radial(0);
    tangential = Point(x, curr_point(1) + r, curr_point(2) + r) - curr_point;
  }
  else if (!MooseUtils::absoluteFuzzyEqual(radial(1), 0.0))
  {
    Real y = curr_point(1) - (radial(0) + radial(2)) * r / radial(1);
    tangential = Point(curr_point(0) + r, y, curr_point(2) + r) - curr_point;
  }
  else if (!MooseUtils::absoluteFuzzyEqual(radial(1), 0.0))
  {
    Real z = curr_point(2) - (radial(0) + radial(1)) * r / radial(2);
    tangential = Point(curr_point(0) + r, curr_point(1) + r, z) - curr_point;
  }
  else
    mooseError("In Hoop stress calculation for spherical geometry, the current (quadracture) point "
               "is likely to be at the center. ");
 
  tangential /= tangential.norm();
 
  // Compute the scalar stress component in the hoop direction
  T hoop_stress = 0.0;
  for (unsigned int i = 0; i < 3; ++i)
    for (unsigned int j = 0; j < 3; ++j)
      hoop_stress += tangential(j) * stress(j, i) * tangential(i);
 
  direction = tangential;
 
  return hoop_stress;
}

hoopStress() [2/2]

template<typename T >

T RankTwoScalarTools::hoopStress	(	const RankTwoTensorTempl< T > &	stress,
		const Point &	point1,
		const Point &	point2,
		const Point &	curr_point,
		Point &	direction
	)

Definition at line 336 of file RankTwoScalarTools.h.

{
  // Calculate the cross of the normal to the axis of rotation from the current
  // location and the axis of rotation
  Point xp;
  normalPositionVector(point1, point2, curr_point, xp);
  Point axis_rotation = point2 - point1;
  Point yp = axis_rotation / axis_rotation.norm();
  Point zp = xp.cross(yp);
 
  // Calculate the scalar value of the hoop stress
  T hoop_stress = zp * (stress * zp);
 
  direction = zp;
 
  return hoop_stress;
}

Referenced by getCylindricalComponent(), getQuantity(), and getSphericalComponent().

hydrostatic()

template<typename T >

T RankTwoScalarTools::hydrostatic

(

const RankTwoTensorTempl< T > &

r2tensor

)

Definition at line 124 of file RankTwoScalarTools.h.

{
  return r2tensor.trace() / 3.0;
}

Referenced by getInvariant(), getQuantity(), and triaxialityStress().

invariantOptions()

MooseEnum RankTwoScalarTools::invariantOptions

(

)

Definition at line 26 of file RankTwoScalarTools.C.

{
  return MooseEnum("VonMisesStress EffectiveStrain Hydrostatic L2norm VolumetricStrain "
                   "FirstInvariant SecondInvariant "
                   "ThirdInvariant TriaxialityStress MaxShear StressIntensity EffectiveStrain");
}

Referenced by getInvariant().

L2norm()

template<typename T >

T RankTwoScalarTools::L2norm

(

const RankTwoTensorTempl< T > &

r2tensor

)

Definition at line 134 of file RankTwoScalarTools.h.

{
  return r2tensor.L2norm();
}

maxPrincipal()

template<typename T >

T RankTwoScalarTools::maxPrincipal	(	const RankTwoTensorTempl< T > &	r2tensor,
		Point &	direction
	)

Definition at line 253 of file RankTwoScalarTools.h.

{
  return calcEigenValuesEigenVectors(r2tensor, (LIBMESH_DIM - 1), direction);
}

Referenced by RankTwoBasedFailureCriteriaNOSPD::computeFailureCriterionValue(), getPrincipalComponent(), getQuantity(), and maxShear().

maxShear()

template<typename T >

T RankTwoScalarTools::maxShear

(

const RankTwoTensorTempl< T > &

stress

)

Definition at line 499 of file RankTwoScalarTools.h.

{
  Point dummy;
  return (maxPrincipal(stress, dummy) - minPrincipal(stress, dummy)) / 2.;
}

Referenced by RankTwoBasedFailureCriteriaNOSPD::computeFailureCriterionValue(), getInvariant(), getQuantity(), and stressIntensity().

midPrincipal()

template<typename T >

T RankTwoScalarTools::midPrincipal	(	const RankTwoTensorTempl< T > &	r2tensor,
		Point &	direction
	)

Definition at line 266 of file RankTwoScalarTools.h.

{
  return calcEigenValuesEigenVectors(r2tensor, 1, direction);
}

Referenced by getPrincipalComponent(), and getQuantity().

minPrincipal()

template<typename T >

T RankTwoScalarTools::minPrincipal	(	const RankTwoTensorTempl< T > &	r2tensor,
		Point &	direction
	)

Definition at line 279 of file RankTwoScalarTools.h.

{
  return calcEigenValuesEigenVectors(r2tensor, 0, direction);
}

Referenced by getPrincipalComponent(), getQuantity(), and maxShear().

normalPositionVector()

void RankTwoScalarTools::normalPositionVector	(	const Point &	point1,
		const Point &	point2,
		const Point &	curr_point,
		Point &	normalPosition
	)

Definition at line 46 of file RankTwoScalarTools.C.

{
  // Find the nearest point on the axis of rotation (defined by point2 - point1)
  // to the current position, e.g. the normal to the axis of rotation at the
  // current position
  Point axis_rotation = point2 - point1;
  Point positionWRTpoint1 = point1 - curr_point;
  Real projection = (axis_rotation * positionWRTpoint1) / axis_rotation.norm_sq();
  Point normal = point1 - projection * axis_rotation;
 
  // Calculate the direction normal to the plane formed by the axis of rotation
  // and the normal to the axis of rotation from the current position.
  normalPosition = curr_point - normal;
  normalPosition /= normalPosition.norm();
}

Referenced by hoopStress(), and radialStress().

radialStress() [1/2]

template<typename T >

T RankTwoScalarTools::radialStress	(	const RankTwoTensorTempl< T > &	stress,
		const Point &	center,
		const Point &	curr_point,
		Point &	direction
	)

Definition at line 397 of file RankTwoScalarTools.h.

{
  Point radial = curr_point - center;
  radial /= radial.norm();
 
  // Compute the scalar stress component in the radial direction
  T radial_stress = radial * (stress * radial);
 
  direction = radial;
 
  return radial_stress;
}

radialStress() [2/2]

template<typename T >

T RankTwoScalarTools::radialStress	(	const RankTwoTensorTempl< T > &	stress,
		const Point &	point1,
		const Point &	point2,
		const Point &	curr_point,
		Point &	direction
	)

Definition at line 369 of file RankTwoScalarTools.h.

{
  Point radial_norm;
  normalPositionVector(point1, point2, curr_point, radial_norm);
 
  // Compute the scalar stress component in the direction of the normal vector from the
  // user-defined axis of rotation.
  T radial_stress = radial_norm * (stress * radial_norm);
 
  direction = radial_norm;
 
  return radial_stress;
}

Referenced by getCylindricalComponent(), getQuantity(), and getSphericalComponent().

RankTwoTensorToVoigtVector()

template<bool is_ad>

void RankTwoScalarTools::RankTwoTensorToVoigtVector	(	const GenericRankTwoTensor< is_ad > &	tensor,
		GenericDenseVector< is_ad > &	voigt_vector
	)

Definition at line 687 of file RankTwoScalarTools.h.

{
  voigt_vector(0) = tensor(0, 0);
  voigt_vector(1) = tensor(1, 1);
  voigt_vector(2) = tensor(2, 2);
  voigt_vector(3) = tensor(0, 1);
  voigt_vector(4) = tensor(1, 2);
  voigt_vector(5) = tensor(0, 2);
}

scalarOptions()

MooseEnum RankTwoScalarTools::scalarOptions

(

)

This enum is left for legacy calls.

Definition at line 17 of file RankTwoScalarTools.C.

{
  return MooseEnum("VonMisesStress EffectiveStrain Hydrostatic L2norm MaxPrincipal "
                   "MidPrincipal MinPrincipal VolumetricStrain FirstInvariant SecondInvariant "
                   "ThirdInvariant AxialStress HoopStress RadialStress TriaxialityStress "
                   "Direction MaxShear StressIntensity");
}

Referenced by NodalRankTwoPD::validParams(), NodalRankTwoScalarPD::validParams(), RankTwoScalarAuxTempl< is_ad >::validParams(), LineMaterialRankTwoScalarSampler::validParams(), MeshCut2DRankTwoTensorNucleation::validParams(), and XFEMRankTwoTensorMarkerUserObject::validParams().

secondInvariant()

template<typename T >

T RankTwoScalarTools::secondInvariant

(

const RankTwoTensorTempl< T > &

r2tensor

)

Definition at line 189 of file RankTwoScalarTools.h.

{
  T val = 0.0;
  for (unsigned int i = 0; i < 2; ++i)
    for (unsigned int j = i + 1; j < 3; ++j)
    {
      val += r2tensor(i, i) * r2tensor(j, j);
      val -= (r2tensor(i, j) * r2tensor(i, j) + r2tensor(j, i) * r2tensor(j, i)) * 0.5;
    }
 
  return val;
}

Referenced by getInvariant(), and getQuantity().

setRotationMatrix()

void RankTwoScalarTools::setRotationMatrix	(	const RealVectorValue &	outwardnormal,
		const RealVectorValue &	axialVector,
		RankTwoTensor &	rotationMatrix,
		const bool	transpose
	)

Definition at line 66 of file RankTwoScalarTools.C.

{
  RealVectorValue radial_vector(outwardnormal);
  RealVectorValue azimuthal_vector(0, 0, 0);
  RealVectorValue polar_vector(axialVector);
 
  Real rv_norm = radial_vector.norm();
  if (rv_norm)
    radial_vector /= rv_norm;
  else
    mooseError("The outward normal vector cannot be a zero vector");
 
  azimuthal_vector = polar_vector.cross(radial_vector);
  azimuthal_vector /= azimuthal_vector.norm();
 
  if (!transpose)
  {
    // Considering that Moose uses convention [T'] = [Q][T][Q_transpose], the
    // basis vectors of old coordinate system should be arranged column wise
    // to construct the rotation matrix Q.
 
    rotationMatrix.fillColumn(0, radial_vector);
    rotationMatrix.fillColumn(1, azimuthal_vector);
    rotationMatrix.fillColumn(2, polar_vector);
  }
  else
  {
    rotationMatrix.fillRow(0, radial_vector);
    rotationMatrix.fillRow(1, azimuthal_vector);
    rotationMatrix.fillRow(2, polar_vector);
  }
}

Referenced by HillElastoPlasticityStressUpdateTempl< is_ad >::initQpStatefulProperties().

sphericalOptions()

MooseEnum RankTwoScalarTools::sphericalOptions

(

)

Definition at line 40 of file RankTwoScalarTools.C.

{
  return MooseEnum("HoopStress RadialStress");
}

stressIntensity()

template<typename T >

T RankTwoScalarTools::stressIntensity

(

const RankTwoTensorTempl< T > &

stress

)

Definition at line 509 of file RankTwoScalarTools.h.

{
  return 2. * maxShear(stress);
}

Referenced by getInvariant(), and getQuantity().

thirdInvariant()

template<typename T >

T RankTwoScalarTools::thirdInvariant

(

const RankTwoTensorTempl< T > &

r2tensor

)

Definition at line 208 of file RankTwoScalarTools.h.

{
  T val = 0.0;
  val = r2tensor(0, 0) * r2tensor(1, 1) * r2tensor(2, 2) -
        r2tensor(0, 0) * r2tensor(1, 2) * r2tensor(2, 1) +
        r2tensor(0, 1) * r2tensor(1, 2) * r2tensor(2, 0) -
        r2tensor(0, 1) * r2tensor(1, 0) * r2tensor(2, 2) +
        r2tensor(0, 2) * r2tensor(1, 0) * r2tensor(2, 1) -
        r2tensor(0, 2) * r2tensor(1, 1) * r2tensor(2, 0);
 
  return val;
}

Referenced by getInvariant(), and getQuantity().

triaxialityStress()

template<typename T >

T RankTwoScalarTools::triaxialityStress

(

const RankTwoTensorTempl< T > &

stress

)

Definition at line 488 of file RankTwoScalarTools.h.

{
  return hydrostatic(stress) / vonMisesStress(stress);
}

Referenced by getInvariant(), and getQuantity().

VoigtVectorToRankTwoTensor()

template<bool is_ad>

void RankTwoScalarTools::VoigtVectorToRankTwoTensor	(	const GenericDenseVector< is_ad > &	voigt_vector,
		GenericRankTwoTensor< is_ad > &	tensor
	)

Definition at line 700 of file RankTwoScalarTools.h.

{
  tensor(0, 0) = voigt_vector(0);
  tensor(1, 1) = voigt_vector(1);
  tensor(2, 2) = voigt_vector(2);
  tensor(0, 1) = tensor(1, 0) = voigt_vector(3);
  tensor(1, 2) = tensor(2, 1) = voigt_vector(4);
  tensor(0, 2) = tensor(2, 0) = voigt_vector(5);
}

volumetricStrain()

template<typename T >

T RankTwoScalarTools::volumetricStrain

(

const RankTwoTensorTempl< T > &

strain

)

Definition at line 164 of file RankTwoScalarTools.h.

{
  return std::exp(strain(0, 0)) * std::exp(strain(1, 1)) * std::exp(strain(2, 2)) - 1.0;
}

Referenced by getInvariant(), and getQuantity().

vonMisesStress()

template<typename T >

T RankTwoScalarTools::vonMisesStress

(

const RankTwoTensorTempl< T > &

stress

)

Definition at line 100 of file RankTwoScalarTools.h.

{
  RankTwoTensorTempl<T> dev_stress = stress.deviatoric();
 
  return std::sqrt(1.5 * dev_stress.doubleContraction(dev_stress));
}

Referenced by RankTwoBasedFailureCriteriaNOSPD::computeFailureCriterionValue(), getInvariant(), getQuantity(), and triaxialityStress().