ElasticityTensorTools.h

Go to the documentation of this file.

//* This file is part of the MOOSE framework
//* https://www.mooseframework.org
//*
//* All rights reserved, see COPYRIGHT for full restrictions
//* https://github.com/idaholab/moose/blob/master/COPYRIGHT
//*
//* Licensed under LGPL 2.1, please see LICENSE for details
//* https://www.gnu.org/licenses/lgpl-2.1.html
 
#pragma once
 
template <typename>
class RankFourTensorTempl;
typedef RankFourTensorTempl<Real> RankFourTensor;
namespace libMesh
{
template <typename>
class VectorValue;
typedef VectorValue<Real> RealGradient;
}
using libMesh::RealGradient;
 
namespace ElasticityTensorTools
{
 
Real elasticJacobian(const RankFourTensor & r4t,
                     unsigned int i,
                     unsigned int k,
                     const RealGradient & grad_test,
                     const RealGradient & grad_phi);
 
Real elasticJacobianWC(const RankFourTensor & r4t,
                       unsigned int i,
                       unsigned int k,
                       const RealGradient & grad_test,
                       Real phi);
 
Real momentJacobian(const RankFourTensor & r4t,
                    unsigned int i,
                    unsigned int k,
                    Real test,
                    const RealGradient & grad_phi);
 
Real
momentJacobianWC(const RankFourTensor & r4t, unsigned int i, unsigned int k, Real test, Real phi);
 
template <typename T>
T
getIsotropicShearModulus(const RankFourTensorTempl<T> & elasticity_tensor)
{
  return elasticity_tensor(0, 1, 0, 1);
}
 
template <typename T>
T
getIsotropicBulkModulus(const RankFourTensorTempl<T> & elasticity_tensor)
{
  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;
}
 
template <typename T>
T
getIsotropicYoungsModulus(const RankFourTensorTempl<T> & elasticity_tensor)
{
  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;
}
 
template <typename T>
T
getIsotropicPoissonsRatio(const RankFourTensorTempl<T> & elasticity_tensor)
{
  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;
}
 
}