ElasticityTensorTools.h

Go to the documentation of this file.

//* This file is part of the MOOSE framework
//* https://mooseframework.inl.gov
//*
//* 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
 
#include "RankFourTensorForward.h"
 
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;
}
 
void toVoigtNotationIndexConversion(int, int &, int &);
 
template <bool is_ad>
void
toVoigtNotation(GenericDenseMatrix<is_ad> & voigt_matrix,
                const GenericRankFourTensor<is_ad> & tensor)
{
  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);
    }
}
 
void toMooseVoigtNotationIndexConversion(int, int &, int &);
 
template <bool is_ad>
void
toMooseVoigtNotation(GenericDenseMatrix<is_ad> & voigt_matrix,
                     const GenericRankFourTensor<is_ad> & tensor)
{
  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);
    }
}
}