ComputeIsotropicElasticityTensor defines an elasticity tensor material for isotropic materials. More...

#include <ComputeIsotropicElasticityTensor.h>

Inheritance diagram for ComputeIsotropicElasticityTensor:

Public Member Functions
	ComputeIsotropicElasticityTensor (const InputParameters &parameters)

bool	hasGuarantee (const MaterialPropertyName &prop_name, Guarantee guarantee)

Static Public Member Functions
static InputParameters	validParams ()

Protected Member Functions
virtual void	computeQpElasticityTensor () override

virtual void	computeQpProperties ()

void	issueGuarantee (const MaterialPropertyName &prop_name, Guarantee guarantee)

void	revokeGuarantee (const MaterialPropertyName &prop_name, Guarantee guarantee)

Protected Attributes
bool	_bulk_modulus_set
	Elastic constants. More...

bool	_lambda_set

bool	_poissons_ratio_set

bool	_shear_modulus_set

bool	_youngs_modulus_set

Real	_bulk_modulus

Real	_lambda

Real	_poissons_ratio

Real	_shear_modulus

Real	_youngs_modulus

RankFourTensor	_Cijkl
	Individual elasticity tensor. More...

Real	_effective_stiffness_local
	Effective stiffness of the element: function of material properties. More...

const std::string	_base_name

std::string	_elasticity_tensor_name

MaterialProperty< RankFourTensor > &	_elasticity_tensor

MaterialProperty< Real > &	_effective_stiffness

const Function *const	_prefactor_function
	prefactor function to multiply the elasticity tensor with More...

Private Attributes
std::map< MaterialPropertyName, std::set< Guarantee > >	_guarantees

Detailed Description

ComputeIsotropicElasticityTensor defines an elasticity tensor material for isotropic materials.

Definition at line 23 of file ComputeIsotropicElasticityTensor.h.

Constructor & Destructor Documentation

◆ ComputeIsotropicElasticityTensor()

ComputeIsotropicElasticityTensor::ComputeIsotropicElasticityTensor ( const InputParameters & parameters )

Definition at line 29 of file ComputeIsotropicElasticityTensor.C.

   : ComputeElasticityTensorBase(parameters),
     _bulk_modulus_set(parameters.isParamValid("bulk_modulus")),
     _lambda_set(parameters.isParamValid("lambda")),
     _poissons_ratio_set(parameters.isParamValid("poissons_ratio")),
     _shear_modulus_set(parameters.isParamValid("shear_modulus")),
     _youngs_modulus_set(parameters.isParamValid("youngs_modulus")),
     _bulk_modulus(_bulk_modulus_set ? getParam<Real>("bulk_modulus") : -1),
     _lambda(_lambda_set ? getParam<Real>("lambda") : -1),
     _poissons_ratio(_poissons_ratio_set ? getParam<Real>("poissons_ratio") : -1),
     _shear_modulus(_shear_modulus_set ? getParam<Real>("shear_modulus") : -1),
     _youngs_modulus(_youngs_modulus_set ? getParam<Real>("youngs_modulus") : -1),
     _effective_stiffness_local(parameters.isParamValid("effective_stiffness_local"))
 {
   unsigned int num_elastic_constants = _bulk_modulus_set + _lambda_set + _poissons_ratio_set +
                                        _shear_modulus_set + _youngs_modulus_set;
   if (num_elastic_constants != 2)
     mooseError("Exactly two elastic constants must be defined for material '" + name() + "'.");
  
   // all tensors created by this class are always isotropic
   issueGuarantee(_elasticity_tensor_name, Guarantee::ISOTROPIC);
   issueGuarantee("effective_stiffness", Guarantee::ISOTROPIC);
   if (!isParamValid("elasticity_tensor_prefactor"))
     issueGuarantee(_elasticity_tensor_name, Guarantee::CONSTANT_IN_TIME);
  
   if (_bulk_modulus_set && _bulk_modulus <= 0.0)
     mooseError("Bulk modulus must be positive in material '" + name() + "'.");
  
   if (_poissons_ratio_set && (_poissons_ratio <= -1.0 || _poissons_ratio >= 0.5))
     mooseError("Poissons ratio must be greater than -1 and less than 0.5 in "
                "material '" +
                name() + "'.");
  
   if (_shear_modulus_set && _shear_modulus < 0.0)
     mooseError("Shear modulus must not be negative in material '" + name() + "'.");
  
   if (_youngs_modulus_set && _youngs_modulus <= 0.0)
     mooseError("Youngs modulus must be positive in material '" + name() + "'.");
  
   std::vector<Real> iso_const(2);
   Real elas_mod;
   Real poiss_rat;
  
   if (_youngs_modulus_set && _poissons_ratio_set)
   {
     _Cijkl.fillSymmetricIsotropicEandNu(_youngs_modulus, _poissons_ratio);
     _effective_stiffness_local =
         std::max(std::sqrt((_youngs_modulus * (1 - _poissons_ratio)) /
                            ((1 + _poissons_ratio) * (1 - 2 * _poissons_ratio))),
                  std::sqrt(_youngs_modulus / (2 * (1 + _poissons_ratio))));
     return;
   }
  
   if (_lambda_set && _shear_modulus_set)
   {
     iso_const[0] = _lambda;
     iso_const[1] = _shear_modulus;
     elas_mod = (_shear_modulus * (3 * _lambda + 2 * _shear_modulus)) / (_lambda + _shear_modulus);
     poiss_rat = _lambda / (2 * (_lambda + _shear_modulus));
     _effective_stiffness_local =
         std::max(std::sqrt((elas_mod * (1 - poiss_rat)) / ((1 + poiss_rat) * (1 - 2 * poiss_rat))),
                  std::sqrt(_shear_modulus));
   }
   else if (_shear_modulus_set && _bulk_modulus_set)
   {
     iso_const[0] = _bulk_modulus - 2.0 / 3.0 * _shear_modulus;
     iso_const[1] = _shear_modulus;
     elas_mod = (9 * _bulk_modulus * _shear_modulus) / (3 * _bulk_modulus + _shear_modulus);
     poiss_rat =
         (3 * _bulk_modulus - 2 * _shear_modulus) / (2 * (3 * _bulk_modulus + _shear_modulus));
     _effective_stiffness_local =
         std::max(std::sqrt((elas_mod * (1 - poiss_rat)) / ((1 + poiss_rat) * (1 - 2 * poiss_rat))),
                  std::sqrt(_shear_modulus));
   }
   else if (_poissons_ratio_set && _bulk_modulus_set)
   {
     iso_const[0] = 3.0 * _bulk_modulus * _poissons_ratio / (1.0 + _poissons_ratio);
     iso_const[1] =
         3.0 * _bulk_modulus * (1.0 - 2.0 * _poissons_ratio) / (2.0 * (1.0 + _poissons_ratio));
     elas_mod = 3 * _bulk_modulus * (1 - 2 * _poissons_ratio);
     poiss_rat = _poissons_ratio;
     _effective_stiffness_local =
         std::max(std::sqrt((elas_mod * (1 - poiss_rat)) / ((1 + poiss_rat) * (1 - 2 * poiss_rat))),
                  std::sqrt(elas_mod / (2 * (1 + poiss_rat))));
   }
   else if (_lambda_set && _bulk_modulus_set)
   {
     iso_const[0] = _lambda;
     iso_const[1] = 3.0 * (_bulk_modulus - _lambda) / 2.0;
     elas_mod = (9 * _bulk_modulus * (_bulk_modulus - _lambda)) / (3 * _bulk_modulus - _lambda);
     poiss_rat = (_lambda) / ((3 * _bulk_modulus - _lambda));
     _effective_stiffness_local =
         std::max(std::sqrt((elas_mod * (1 - poiss_rat)) / ((1 + poiss_rat) * (1 - 2 * poiss_rat))),
                  std::sqrt(elas_mod / (2 * (1 + poiss_rat))));
   }
   else if (_shear_modulus_set && _youngs_modulus_set)
   {
     iso_const[0] = _shear_modulus * (_youngs_modulus - 2.0 * _shear_modulus) /
                    (3.0 * _shear_modulus - _youngs_modulus);
     iso_const[1] = _shear_modulus;
     elas_mod = _youngs_modulus;
     poiss_rat = (_youngs_modulus - 2 * _shear_modulus) / (2 * _shear_modulus);
     _effective_stiffness_local =
         std::max(std::sqrt((elas_mod * (1 - poiss_rat)) / ((1 + poiss_rat) * (1 - 2 * poiss_rat))),
                  std::sqrt(elas_mod / (2 * (1 + poiss_rat))));
   }
   else if (_shear_modulus_set && _poissons_ratio_set)
   {
     iso_const[0] = 2.0 * _shear_modulus * _poissons_ratio / (1.0 - 2.0 * _poissons_ratio);
     iso_const[1] = _shear_modulus;
     elas_mod = (2 * _shear_modulus * (1 + _poissons_ratio));
     poiss_rat = (_poissons_ratio);
     _effective_stiffness_local =
         std::max(std::sqrt((elas_mod * (1 - poiss_rat)) / ((1 + poiss_rat) * (1 - 2 * poiss_rat))),
                  std::sqrt(elas_mod / (2 * (1 + poiss_rat))));
   }
   else if (_youngs_modulus_set && _bulk_modulus_set)
   {
     iso_const[0] = 3.0 * _bulk_modulus * (3.0 * _bulk_modulus - _youngs_modulus) /
                    (9.0 * _bulk_modulus - _youngs_modulus);
     iso_const[1] = 3.0 * _bulk_modulus * _youngs_modulus / (9.0 * _bulk_modulus - _youngs_modulus);
     elas_mod = (_youngs_modulus);
     poiss_rat = (3 * _bulk_modulus - _youngs_modulus) / (6 * _bulk_modulus);
     _effective_stiffness_local =
         std::max(std::sqrt((elas_mod * (1 - poiss_rat)) / ((1 + poiss_rat) * (1 - 2 * poiss_rat))),
                  std::sqrt(elas_mod / (2 * (1 + poiss_rat))));
   }
   else if (_lambda_set && _poissons_ratio_set)
   {
     iso_const[0] = _lambda;
     iso_const[1] = _lambda * (1.0 - 2.0 * _poissons_ratio) / (2.0 * _poissons_ratio);
     elas_mod = (_lambda * (1 + _poissons_ratio) * (1 - 2 * _poissons_ratio)) / (_poissons_ratio);
     poiss_rat = (_poissons_ratio);
     _effective_stiffness_local =
         std::max(std::sqrt((elas_mod * (1 - poiss_rat)) / ((1 + poiss_rat) * (1 - 2 * poiss_rat))),
                  std::sqrt(elas_mod / (2 * (1 + poiss_rat))));
   }
   else if (_lambda_set && _youngs_modulus_set)
   {
     iso_const[0] = _lambda;
     iso_const[1] = (_youngs_modulus - 3.0 * _lambda +
                     std::sqrt(_youngs_modulus * _youngs_modulus + 9.0 * _lambda * _lambda +
                               2.0 * _youngs_modulus * _lambda)) /
                    4.0;
     elas_mod = (_youngs_modulus);
     poiss_rat = (2 * _lambda) / (_youngs_modulus + _lambda +
                                  std::sqrt(std::pow(_youngs_modulus, 2) + 9 * std::pow(_lambda, 2) +
                                            2 * _youngs_modulus * _lambda));
     _effective_stiffness_local =
         std::max(std::sqrt((elas_mod * (1 - poiss_rat)) / ((1 + poiss_rat) * (1 - 2 * poiss_rat))),
                  std::sqrt(elas_mod / (2 * (1 + poiss_rat))));
   }
   else
     mooseError("Incorrect combination of elastic properties in ComputeIsotropicElasticityTensor.");
  
   // Fill elasticity tensor
   _Cijkl.fillFromInputVector(iso_const, RankFourTensor::symmetric_isotropic);
 }

Member Function Documentation

◆ computeQpElasticityTensor()

void ComputeIsotropicElasticityTensor::computeQpElasticityTensor ( )

overrideprotectedvirtual

Implements ComputeElasticityTensorBase.

Definition at line 190 of file ComputeIsotropicElasticityTensor.C.

 {
   // Assign elasticity tensor at a given quad point
   _elasticity_tensor[_qp] = _Cijkl;
  
   // Assign effective stiffness at a given quad point
   _effective_stiffness[_qp] = _effective_stiffness_local;
 }

◆ computeQpProperties()

void ComputeElasticityTensorBase::computeQpProperties ( )

protectedvirtualinherited

Definition at line 43 of file ComputeElasticityTensorBase.C.

 {
   _effective_stiffness[_qp] = 0; // Currently overriden by ComputeIsotropicElasticityTensor
   computeQpElasticityTensor();
  
   // Multiply by prefactor
   if (_prefactor_function)
   {
     _elasticity_tensor[_qp] *= _prefactor_function->value(_t, _q_point[_qp]);
     _effective_stiffness[_qp] *= std::sqrt(_prefactor_function->value(_t, _q_point[_qp]));
   }
 }

◆ hasGuarantee()

bool GuaranteeProvider::hasGuarantee	(	const MaterialPropertyName &	prop_name,
		Guarantee	guarantee
	)

inherited

Definition at line 16 of file GuaranteeProvider.C.

 {
   auto it = _guarantees.find(prop_name);
   if (it == _guarantees.end())
     return false;
  
   auto it2 = it->second.find(guarantee);
   return it2 != it->second.end();
 }

◆ issueGuarantee()

void GuaranteeProvider::issueGuarantee	(	const MaterialPropertyName &	prop_name,
		Guarantee	guarantee
	)

protectedinherited

Definition at line 27 of file GuaranteeProvider.C.

 {
   // intentional insertion
   _guarantees[prop_name].insert(guarantee);
 }

Referenced by ADComputeVariableIsotropicElasticityTensor< compute_stage >::ADComputeVariableIsotropicElasticityTensor(), ComputeCosseratElasticityTensor::ComputeCosseratElasticityTensor(), ComputeElasticityTensor::ComputeElasticityTensor(), ComputeIsotropicElasticityTensor(), ComputeLayeredCosseratElasticityTensor::ComputeLayeredCosseratElasticityTensor(), ComputeVariableIsotropicElasticityTensor::ComputeVariableIsotropicElasticityTensor(), GeneralizedKelvinVoigtModel::GeneralizedKelvinVoigtModel(), and GeneralizedMaxwellModel::GeneralizedMaxwellModel().

◆ revokeGuarantee()

void GuaranteeProvider::revokeGuarantee	(	const MaterialPropertyName &	prop_name,
		Guarantee	guarantee
	)

protectedinherited

Definition at line 34 of file GuaranteeProvider.C.

 {
   auto it = _guarantees.find(prop_name);
   if (it != _guarantees.end())
     it->second.erase(guarantee);
 }

Referenced by ComputeElasticityTensorCP::ComputeElasticityTensorCP().

◆ validParams()

InputParameters ComputeIsotropicElasticityTensor::validParams ( )

static

Definition at line 17 of file ComputeIsotropicElasticityTensor.C.

 {
   InputParameters params = ComputeElasticityTensorBase::validParams();
   params.addClassDescription("Compute a constant isotropic elasticity tensor.");
   params.addParam<Real>("bulk_modulus", "The bulk modulus for the material.");
   params.addParam<Real>("lambda", "Lame's first constant for the material.");
   params.addParam<Real>("poissons_ratio", "Poisson's ratio for the material.");
   params.addParam<Real>("shear_modulus", "The shear modulus of the material.");
   params.addParam<Real>("youngs_modulus", "Young's modulus of the material.");
   return params;
 }