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. More...
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. More...
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. More...
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. More...
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) More...
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) More...
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) More...
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) More...

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 (unsigned int j = 0; j < LIBMESH_DIM; ++j)
  //      for (unsigned int l = 0; l < LIBMESH_DIM; ++l)
  //        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 StressDivergenceRSphericalTensors::calculateJacobian(), StressDivergenceRZTensors::calculateJacobian(), CrackTipEnrichmentStressDivergenceTensors::computeQpJacobian(), StressDivergenceTensors::computeQpJacobian(), CrackTipEnrichmentStressDivergenceTensors::computeQpOffDiagJacobian(), and StressDivergenceTensors::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 (unsigned int j = 0; j < LIBMESH_DIM; ++j)
    for (unsigned int m = 0; m < LIBMESH_DIM; ++m)
      for (unsigned int n = 0; n < LIBMESH_DIM; ++n)
        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 82 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;
}

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 115 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(), ComputePlaneStressIsotropicElasticityTensor::ComputePlaneStressIsotropicElasticityTensor(), and CappedMohrCoulombStressUpdate::preReturnMapV().

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 71 of file ElasticityTensorTools.h.

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

Referenced by getIsotropicBulkModulus(), getIsotropicYoungsModulus(), RadialReturnStressUpdate::updateState(), and ADRadialReturnStressUpdate< compute_stage >::updateState().

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 98 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(), ComputePlaneStressIsotropicElasticityTensor::ComputePlaneStressIsotropicElasticityTensor(), ComputeForceStabilizedSmallStrainNOSPD::computeQpDeformationGradient(), ComputeSmearedCrackingStress::updateCrackingStateAndStress(), 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 (unsigned int j = 0; j < LIBMESH_DIM; ++j)
    for (unsigned int m = 0; m < LIBMESH_DIM; ++m)
      for (unsigned int n = 0; n < LIBMESH_DIM; ++n)
        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 (unsigned int j = 0; j < LIBMESH_DIM; ++j)
    for (unsigned int l = 0; l < LIBMESH_DIM; ++l)
      for (unsigned int m = 0; m < LIBMESH_DIM; ++m)
        for (unsigned int n = 0; n < LIBMESH_DIM; ++n)
          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().