ComputeLayeredCosseratElasticityTensor defines an elasticity tensor and an elastic flexural rigidity tensor for use in simulations with layered Cosserat materials. More...

#include <ComputeLayeredCosseratElasticityTensor.h>

Inheritance diagram for ComputeLayeredCosseratElasticityTensor:

[legend]

Public Member Functions
	ComputeLayeredCosseratElasticityTensor (const InputParameters &parameters)

bool	hasGuarantee (const MaterialPropertyName &prop_name, Guarantee guarantee)

Static Public Member Functions
static InputParameters	validParams ()

Protected Member Functions
virtual void	computeQpElasticityTensor ()

virtual void	computeQpProperties ()

void	issueGuarantee (const MaterialPropertyName &prop_name, Guarantee guarantee)

void	revokeGuarantee (const MaterialPropertyName &prop_name, Guarantee guarantee)

Protected Attributes
RankFourTensor	_Eijkl
	Conventional elasticity tensor. More...

RankFourTensor	_Bijkl
	Flexural rigidity tensor. More...

RankFourTensor	_Cijkl
	Inverse of elasticity tensor. More...

MaterialProperty< RankFourTensor > &	_elastic_flexural_rigidity_tensor
	Flexural rigidity tensor at the qps. More...

MaterialProperty< RankFourTensor > &	_compliance
	Compliance tensor (_Eijkl^-1) at the qps. 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

ComputeLayeredCosseratElasticityTensor defines an elasticity tensor and an elastic flexural rigidity tensor for use in simulations with layered Cosserat materials.

The layering direction is assumed to be in the "z" direction.

Definition at line 26 of file ComputeLayeredCosseratElasticityTensor.h.

Constructor & Destructor Documentation

◆ ComputeLayeredCosseratElasticityTensor()

ComputeLayeredCosseratElasticityTensor::ComputeLayeredCosseratElasticityTensor ( const InputParameters & parameters )

Definition at line 37 of file ComputeLayeredCosseratElasticityTensor.C.

   : ComputeElasticityTensorBase(parameters),
     _Eijkl(RankFourTensor()),
     _Bijkl(RankFourTensor()),
     _Cijkl(RankFourTensor()),
     _elastic_flexural_rigidity_tensor(
         declareProperty<RankFourTensor>("elastic_flexural_rigidity_tensor")),
     _compliance(declareProperty<RankFourTensor>(_base_name + "compliance_tensor"))
 {
   if (!isParamValid("elasticity_tensor_prefactor"))
     issueGuarantee(_elasticity_tensor_name, Guarantee::CONSTANT_IN_TIME);
  
   const Real E = getParam<Real>("young");
   const Real nu = getParam<Real>("poisson");
   const Real b = getParam<Real>("layer_thickness");
   const Real kn = getParam<Real>("joint_normal_stiffness");
   const Real ks = getParam<Real>("joint_shear_stiffness");
  
   // shear modulus of solid
   const Real G = 0.5 * E / (1.0 + nu);
   // shear modulus of jointed material
   const Real Gprime = G * b * ks / (b * ks + G);
  
   const Real a0000 =
       (b * kn > 0.0)
           ? E / (1.0 - nu * nu - Utility::pow<2>(nu * (1.0 + nu)) / (1.0 - nu * nu + E / b / kn))
           : E / (1.0 - nu * nu);
   const Real a0011 = nu * a0000 / (1.0 - nu);
   const Real a2222 =
       (b * kn > 0.0) ? 1.0 / ((1.0 + nu) * (1.0 - 2.0 * nu) / E / (1.0 - nu) + 1.0 / b / kn) : 0.0;
   const Real a0022 = nu * a2222 / (1.0 - nu);
   const Real a0101 = G;
   const Real a66 = Gprime;
   const Real a77 = 0.5 * (G + Gprime);
  
   // Eijkl does not obey the usual symmetries, viz Eijkl != Ejikl, so must fill manually
   _Eijkl(0, 0, 0, 0) = _Eijkl(1, 1, 1, 1) = a0000;
   _Eijkl(0, 0, 1, 1) = _Eijkl(1, 1, 0, 0) = a0011;
   _Eijkl(2, 2, 2, 2) = a2222;
   _Eijkl(0, 0, 2, 2) = _Eijkl(1, 1, 2, 2) = _Eijkl(2, 2, 0, 0) = _Eijkl(2, 2, 1, 1) = a0022;
   _Eijkl(0, 1, 0, 1) = _Eijkl(0, 1, 1, 0) = _Eijkl(1, 0, 0, 1) = _Eijkl(1, 0, 1, 0) = a0101;
   _Eijkl(0, 2, 0, 2) = _Eijkl(0, 2, 2, 0) = _Eijkl(2, 0, 0, 2) = _Eijkl(1, 2, 1, 2) =
       _Eijkl(1, 2, 2, 1) = _Eijkl(2, 1, 1, 2) = a66;
   _Eijkl(2, 0, 2, 0) = _Eijkl(2, 1, 2, 1) = a77;
  
   // most of Bijkl is zero since the only nonzero moment stresses are m01 and m10.
   // It also does not have the usual symmetries.
   const Real D0 = E * Utility::pow<3>(b) / 12.0 / (1.0 - nu * nu); // bending rigidity of a layer
   const Real b0101 = D0 / b * G / (2.0 * b * ks + G);
   const Real b0110 = -nu * b0101;
   _Bijkl(0, 1, 0, 1) = _Bijkl(1, 0, 1, 0) = b0101;
   _Bijkl(0, 1, 1, 0) = _Bijkl(1, 0, 0, 1) = b0110;
  
   // The compliance tensor also does not obey the usual symmetries, and
   // this is the main reason it is calculated here, since we can't use
   // _Eijkl.invSymm()
   const Real pre = (nu - 1.0) / (a0000 * (nu - 1.0) + 2.0 * a2222 * Utility::pow<2>(nu));
   const Real cp0000 =
       ((a2222 - a0000) * nu * nu + 2.0 * a0000 * nu - a0000) / (2.0 * a0000 * nu - a0000);
   const Real cp0011 = -((a0000 + a2222) * nu * nu - a0000 * nu) / (2.0 * a0000 * nu - a0000);
   _Cijkl(0, 0, 0, 0) = _Cijkl(1, 1, 1, 1) = pre * cp0000;
   _Cijkl(0, 0, 1, 1) = _Cijkl(1, 1, 0, 0) = pre * cp0011;
   _Cijkl(2, 2, 2, 2) = pre * a0000 / a2222;
   _Cijkl(0, 0, 2, 2) = _Cijkl(1, 1, 2, 2) = _Cijkl(2, 2, 0, 0) = _Cijkl(2, 2, 1, 1) = -nu * pre;
   _Cijkl(0, 1, 0, 1) = _Cijkl(0, 1, 1, 0) = _Cijkl(1, 0, 0, 1) = _Cijkl(1, 0, 1, 0) = 0.25 / a0101;
   const Real slip = 2.0 / (G - Gprime);
   _Cijkl(0, 2, 2, 0) = _Cijkl(2, 0, 0, 2) = _Cijkl(1, 2, 2, 1) = _Cijkl(2, 1, 1, 2) = -slip;
   _Cijkl(0, 2, 0, 2) = _Cijkl(1, 2, 1, 2) = (G + Gprime) * slip / 2.0 / Gprime;
   _Cijkl(2, 0, 2, 0) = _Cijkl(2, 1, 2, 1) = slip;
 }

Member Function Documentation

◆ computeQpElasticityTensor()

void ComputeLayeredCosseratElasticityTensor::computeQpElasticityTensor ( )

protectedvirtual

Implements ComputeElasticityTensorBase.

Definition at line 110 of file ComputeLayeredCosseratElasticityTensor.C.

 {
   _elasticity_tensor[_qp] = _Eijkl;
   _elastic_flexural_rigidity_tensor[_qp] = _Bijkl;
   _compliance[_qp] = _Cijkl;
  
   if (_prefactor_function)
     _compliance[_qp] /= _prefactor_function->value(_t, _q_point[_qp]);
 }

◆ 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::ComputeIsotropicElasticityTensor(), 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 ComputeLayeredCosseratElasticityTensor::validParams ( )

static

Definition at line 20 of file ComputeLayeredCosseratElasticityTensor.C.

 {
   InputParameters params = ComputeElasticityTensorBase::validParams();
   params.addClassDescription("Computes Cosserat elasticity and flexural bending rigidity tensors "
                              "relevant for simulations with layered materials.  The layering "
                              "direction is assumed to be perpendicular to the 'z' direction.");
   params.addRequiredParam<Real>("young", "The Young's modulus");
   params.addRequiredParam<Real>("poisson", "The Poisson's ratio");
   params.addRequiredRangeCheckedParam<Real>(
       "layer_thickness", "layer_thickness>=0", "The layer thickness");
   params.addRequiredRangeCheckedParam<Real>(
       "joint_normal_stiffness", "joint_normal_stiffness>=0", "The joint normal stiffness");
   params.addRequiredRangeCheckedParam<Real>(
       "joint_shear_stiffness", "joint_shear_stiffness>=0", "The joint shear stiffness");
   return params;
 }