ElasticityTensorTools Namespace Reference

Functions
Real	elasticJacobian (const RankFourTensor &r4t, unsigned int i, unsigned int k, const RealGradient &grad_test, const RealGradient &grad_phi)
	This is used for the standard kernel stress_ij*d(test)/dx_j, when varied wrt u_k Jacobian entry: d(stress_ij*d(test)/dx_j)/du_k = d(C_ijmn*du_m/dx_n*dtest/dx_j)/du_k.
Real	elasticJacobianWC (const RankFourTensor &r4t, unsigned int i, unsigned int k, const RealGradient &grad_test, Real phi)
	This is used for the standard kernel stress_ij*d(test)/dx_j, when varied wrt w_k (the cosserat rotation) Jacobian entry: d(stress_ij*d(test)/dx_j)/dw_k = d(C_ijmn*eps_mnp*w_p*dtest/dx_j)/dw_k.
Real	momentJacobian (const RankFourTensor &r4t, unsigned int i, unsigned int k, Real test, const RealGradient &grad_phi)
	This is used for the moment-balancing kernel eps_ijk*stress_jk*test, when varied wrt u_k Jacobian entry: d(eps_ijm*stress_jm*test)/du_k = d(eps_ijm*C_jmln*du_l/dx_n*test)/du_k.
Real	momentJacobianWC (const RankFourTensor &r4t, unsigned int i, unsigned int k, Real test, Real phi)
	This is used for the moment-balancing kernel eps_ijk*stress_jk*test, when varied wrt w_k (the cosserat rotation) Jacobian entry: d(eps_ijm*stress_jm*test)/dw_k = d(eps_ijm*C_jmln*eps_lnp*w_p*test)/dw_k.
template<typename T >
T	getIsotropicShearModulus (const RankFourTensorTempl< T > &elasticity_tensor)
	Get the shear modulus for an isotropic elasticity tensor param elasticity_tensor the tensor (must be isotropic, but not checked for efficiency)
template<typename T >
T	getIsotropicBulkModulus (const RankFourTensorTempl< T > &elasticity_tensor)
	Get the bulk modulus for an isotropic elasticity tensor param elasticity_tensor the tensor (must be isotropic, but not checked for efficiency)
template<typename T >
T	getIsotropicYoungsModulus (const RankFourTensorTempl< T > &elasticity_tensor)
	Get the Young's modulus for an isotropic elasticity tensor param elasticity_tensor the tensor (must be isotropic, but not checked for efficiency)
template<typename T >
T	getIsotropicPoissonsRatio (const RankFourTensorTempl< T > &elasticity_tensor)
	Get the Poisson's modulus for an isotropic elasticity tensor param elasticity_tensor the tensor (must be isotropic, but not checked for efficiency)
void	toVoigtNotationIndexConversion (int, int &, int &)
template<bool is_ad>
void	toVoigtNotation (GenericDenseMatrix< is_ad > &voigt_matrix, const GenericRankFourTensor< is_ad > &tensor)
void	toMooseVoigtNotationIndexConversion (int, int &, int &)
template<bool is_ad>
void	toMooseVoigtNotation (GenericDenseMatrix< is_ad > &voigt_matrix, const GenericRankFourTensor< is_ad > &tensor)

Function Documentation

elasticJacobian()

Real ElasticityTensorTools::elasticJacobian	(	const RankFourTensor &	r4t,
		unsigned int	i,
		unsigned int	k,
		const RealGradient &	grad_test,
		const RealGradient &	grad_phi
	)

This is used for the standard kernel stress_ij*d(test)/dx_j, when varied wrt u_k Jacobian entry: d(stress_ij*d(test)/dx_j)/du_k = d(C_ijmn*du_m/dx_n*dtest/dx_j)/du_k.

Definition at line 21 of file ElasticityTensorTools.C.

{
  // d(stress_ij*d(test)/dx_j)/du_k = d(C_ijmn*du_m/dx_n dtest/dx_j)/du_k (which is nonzero for m ==
  // k)
 
  const Real gt0 = grad_test(0);
  const Real gt1 = grad_test(1);
  const Real gt2 = grad_test(2);
  const Real gp0 = grad_phi(0);
  const Real gp1 = grad_phi(1);
  const Real gp2 = grad_phi(2);
 
  // clang-format off
  // This is the algorithm that is unrolled below:
  //
  //    Real sum = 0.0;
  //    for (const auto j: make_range(Moose::dim))
  //      for (const auto l: make_range(Moose::dim))
  //        sum += r4t(i, j, k, l) * grad_phi(l) * grad_test(j);
  //    return sum;
 
  return
     (
         r4t(i,0,k,0) * gp0
       + r4t(i,0,k,1) * gp1
       + r4t(i,0,k,2) * gp2
     ) * gt0
     +
     (
         r4t(i,1,k,0) * gp0
       + r4t(i,1,k,1) * gp1
       + r4t(i,1,k,2) * gp2
     ) * gt1
     +
     (
         r4t(i,2,k,0) * gp0
       + r4t(i,2,k,1) * gp1
       + r4t(i,2,k,2) * gp2
     ) * gt2;
  // clang-format on
}

Referenced by StressDivergenceRZTensors::calculateJacobian(), StressDivergenceTensors::computeQpJacobian(), CrackTipEnrichmentStressDivergenceTensors::computeQpJacobian(), StressDivergenceTensors::computeQpOffDiagJacobian(), and CrackTipEnrichmentStressDivergenceTensors::computeQpOffDiagJacobian().

elasticJacobianWC()

Real ElasticityTensorTools::elasticJacobianWC	(	const RankFourTensor &	r4t,
		unsigned int	i,
		unsigned int	k,
		const RealGradient &	grad_test,
		Real	phi
	)

This is used for the standard kernel stress_ij*d(test)/dx_j, when varied wrt w_k (the cosserat rotation) Jacobian entry: d(stress_ij*d(test)/dx_j)/dw_k = d(C_ijmn*eps_mnp*w_p*dtest/dx_j)/dw_k.

Definition at line 68 of file ElasticityTensorTools.C.

{
  // d(stress_ij*d(test)/dx_j)/dw_k = d(C_ijmn*eps_mnp*w_p*dtest/dx_j)/dw_k (only nonzero for p ==
  // k)
  Real sum = 0.0;
  for (const auto j : make_range(Moose::dim))
    for (const auto m : make_range(Moose::dim))
      for (const auto n : make_range(Moose::dim))
        sum += r4t(i, j, m, n) * PermutationTensor::eps(m, n, k) * grad_test(j);
  return sum * phi;
}

Referenced by CosseratStressDivergenceTensors::computeQpOffDiagJacobian().

getIsotropicBulkModulus()

template<typename T >

T ElasticityTensorTools::getIsotropicBulkModulus

(

const RankFourTensorTempl< T > &

elasticity_tensor

)

Get the bulk modulus for an isotropic elasticity tensor param elasticity_tensor the tensor (must be isotropic, but not checked for efficiency)

Definition at line 81 of file ElasticityTensorTools.h.

{
  const T shear_modulus = getIsotropicShearModulus(elasticity_tensor);
  // dilatational modulus is defined as lambda plus two mu
  const T dilatational_modulus = elasticity_tensor(0, 0, 0, 0);
  const T lambda = dilatational_modulus - 2.0 * shear_modulus;
  const T bulk_modulus = lambda + 2.0 * shear_modulus / 3.0;
  return bulk_modulus;
}

Referenced by ComputeSimoHughesJ2PlasticityStress::computeQpPK1Stress(), and ConstantsFromElasticityTensorTempl< is_ad >::computeQpProperties().

getIsotropicPoissonsRatio()

template<typename T >

T ElasticityTensorTools::getIsotropicPoissonsRatio

(

const RankFourTensorTempl< T > &

elasticity_tensor

)

Get the Poisson's modulus for an isotropic elasticity tensor param elasticity_tensor the tensor (must be isotropic, but not checked for efficiency)

Definition at line 114 of file ElasticityTensorTools.h.

{
  const T poissons_ratio = elasticity_tensor(1, 1, 0, 0) /
                           (elasticity_tensor(1, 1, 1, 1) + elasticity_tensor(1, 1, 0, 0));
  return poissons_ratio;
}

Referenced by ComputeStrainBaseNOSPD::computeBondStretch(), ParametricMaterialBasePD::computeMaterialConstants(), ConstantsFromElasticityTensorTempl< is_ad >::computeQpProperties(), CappedMohrCoulombStressUpdate::preReturnMapV(), ComputePlaneStressIsotropicElasticityTensor::residualSetup(), ADComputeSmearedCrackingStress::updateCrackingStateAndStress(), and ComputeSmearedCrackingStress::updateCrackingStateAndStress().

getIsotropicShearModulus()

template<typename T >

T ElasticityTensorTools::getIsotropicShearModulus

(

const RankFourTensorTempl< T > &

elasticity_tensor

)

Get the shear modulus for an isotropic elasticity tensor param elasticity_tensor the tensor (must be isotropic, but not checked for efficiency)

Definition at line 70 of file ElasticityTensorTools.h.

{
  return elasticity_tensor(0, 1, 0, 1);
}

Referenced by ComputeSimoHughesJ2PlasticityStress::computeDerivative(), ComputeSimoHughesJ2PlasticityStress::computeQpPK1Stress(), ConstantsFromElasticityTensorTempl< is_ad >::computeQpProperties(), ComputeSimoHughesJ2PlasticityStress::computeReferenceResidual(), ComputeSimoHughesJ2PlasticityStress::computeResidual(), HillCreepStressUpdateTempl< is_ad >::computeStressInitialize(), HillPlasticityStressUpdateTempl< is_ad >::computeStressInitialize(), RadialReturnStressUpdateTempl< is_ad >::computeStressInitialize(), getIsotropicBulkModulus(), getIsotropicYoungsModulus(), ComputeSimoHughesJ2PlasticityStress::preStep(), and ComputeCreepPlasticityStress::updateQpState().

getIsotropicYoungsModulus()

template<typename T >

T ElasticityTensorTools::getIsotropicYoungsModulus

(

const RankFourTensorTempl< T > &

elasticity_tensor

)

Get the Young's modulus for an isotropic elasticity tensor param elasticity_tensor the tensor (must be isotropic, but not checked for efficiency)

Definition at line 97 of file ElasticityTensorTools.h.

{
  const T shear_modulus = getIsotropicShearModulus(elasticity_tensor);
  // dilatational modulus is defined as lambda plus two mu
  const T dilatational_modulus = elasticity_tensor(0, 0, 0, 0);
  const T lambda = dilatational_modulus - 2.0 * shear_modulus;
  const T youngs_modulus =
      shear_modulus * (3.0 * lambda + 2.0 * shear_modulus) / (lambda + shear_modulus);
  return youngs_modulus;
}

Referenced by ParametricMaterialBasePD::computeMaterialConstants(), ComputeStrainBaseNOSPD::computeQpDeformationGradient(), ConstantsFromElasticityTensorTempl< is_ad >::computeQpProperties(), ComputePlaneStressIsotropicElasticityTensor::residualSetup(), ADComputeSmearedCrackingStress::updateCrackingStateAndStress(), ComputeSmearedCrackingStress::updateCrackingStateAndStress(), ADComputeSmearedCrackingStress::updateLocalElasticityTensor(), and ComputeSmearedCrackingStress::updateLocalElasticityTensor().

momentJacobian()

Real ElasticityTensorTools::momentJacobian	(	const RankFourTensor &	r4t,
		unsigned int	i,
		unsigned int	k,
		Real	test,
		const RealGradient &	grad_phi
	)

This is used for the moment-balancing kernel eps_ijk*stress_jk*test, when varied wrt u_k Jacobian entry: d(eps_ijm*stress_jm*test)/du_k = d(eps_ijm*C_jmln*du_l/dx_n*test)/du_k.

Definition at line 85 of file ElasticityTensorTools.C.

{
  // Jacobian entry: d(eps_ijm*stress_jm*test)/du_k = d(eps_ijm*C_jmln*du_l/dx_n*test)/du_k (only
  // nonzero for l == k)
  Real sum = 0.0;
  for (const auto j : make_range(Moose::dim))
    for (const auto m : make_range(Moose::dim))
      for (const auto n : make_range(Moose::dim))
        sum += PermutationTensor::eps(i, j, m) * r4t(j, m, k, n) * grad_phi(n);
  return test * sum;
}

Referenced by MomentBalancing::computeQpOffDiagJacobian().

momentJacobianWC()

Real ElasticityTensorTools::momentJacobianWC	(	const RankFourTensor &	r4t,
		unsigned int	i,
		unsigned int	k,
		Real	test,
		Real	phi
	)

This is used for the moment-balancing kernel eps_ijk*stress_jk*test, when varied wrt w_k (the cosserat rotation) Jacobian entry: d(eps_ijm*stress_jm*test)/dw_k = d(eps_ijm*C_jmln*eps_lnp*w_p*test)/dw_k.

Definition at line 102 of file ElasticityTensorTools.C.

{
  // Jacobian entry: d(eps_ijm*stress_jm*test)/dw_k = d(eps_ijm*C_jmln*eps_lnp*w_p*test)/dw_k (only
  // nonzero for p ==k)
  Real sum = 0.0;
  for (const auto j : make_range(Moose::dim))
    for (const auto l : make_range(Moose::dim))
      for (const auto m : make_range(Moose::dim))
        for (const auto n : make_range(Moose::dim))
          sum +=
              PermutationTensor::eps(i, j, m) * r4t(j, m, l, n) * PermutationTensor::eps(l, n, k);
 
  return test * phi * sum;
}

Referenced by MomentBalancing::computeQpJacobian(), and MomentBalancing::computeQpOffDiagJacobian().

toMooseVoigtNotation()

template<bool is_ad>

void ElasticityTensorTools::toMooseVoigtNotation	(	GenericDenseMatrix< is_ad > &	voigt_matrix,
		const GenericRankFourTensor< is_ad > &	tensor
	)

Definition at line 146 of file ElasticityTensorTools.h.

{
  static std::vector<int> index_vector = {0, 1, 2, 3, 4, 5};
  int a = 0;
  int b = 0;
  int c = 0;
  int d = 0;
  for (int i : index_vector)
    for (int j : index_vector)
    {
      toMooseVoigtNotationIndexConversion(i, a, b);
      toMooseVoigtNotationIndexConversion(j, c, d);
      voigt_matrix(i, j) = tensor(a, b, c, d);
    }
}

toMooseVoigtNotationIndexConversion()

void ElasticityTensorTools::toMooseVoigtNotationIndexConversion	(	int	k,
		int &	a,
		int &	b
	)

Definition at line 150 of file ElasticityTensorTools.C.

{
  if (k < 3 && k >= 0)
    a = b = k;
  else if (k == 3)
  {
    a = 0;
    b = 1;
  }
  else if (k == 4)
  {
    a = 1;
    b = 2;
  }
  else if (k == 5)
  {
    a = 0;
    b = 2;
  }
  else
    mooseError("\nIndex out of bound while converting from tensor to MOOSE voigt notation in "
               "toMooseVoigtNotationIndexConversion");
}

Referenced by toMooseVoigtNotation().

toVoigtNotation()

template<bool is_ad>

void ElasticityTensorTools::toVoigtNotation	(	GenericDenseMatrix< is_ad > &	voigt_matrix,
		const GenericRankFourTensor< is_ad > &	tensor
	)

Definition at line 125 of file ElasticityTensorTools.h.

{
  std::vector<int> index_vector = {0, 1, 2, 3, 4, 5};
  int a = 0;
  int b = 0;
  int c = 0;
  int d = 0;
  for (int i : index_vector)
    for (int j : index_vector)
    {
      toVoigtNotationIndexConversion(i, a, b);
      toVoigtNotationIndexConversion(j, c, d);
      voigt_matrix(i, j) = tensor(a, b, c, d);
    }
}

toVoigtNotationIndexConversion()

void ElasticityTensorTools::toVoigtNotationIndexConversion	(	int	k,
		int &	a,
		int &	b
	)

Definition at line 118 of file ElasticityTensorTools.C.

{
  if (k < 3 && k >= 0)
    a = b = k;
  else if (k == 3)
  {
    a = 1;
    b = 2;
  }
  else if (k == 4)
  {
    a = 0;
    b = 2;
  }
  else if (k == 5)
  {
    a = 0;
    b = 1;
  }
  else
    mooseError("\nIndex out of bound while converting from tensor to voigt notation in "
               "toVoigtNotationIndexConversion");
}

Referenced by toVoigtNotation().