ComputeVariableBaseEigenstrain computes an Eigenstrain based on a real tensor value material property base (a), a real material property prefactor (p) and a rank two tensor offset tensor (b) p * a + b. More...

#include <ComputeVariableBaseEigenStrain.h>

Inheritance diagram for ComputeVariableBaseEigenStrain:

[legend]

Public Member Functions
	ComputeVariableBaseEigenStrain (const InputParameters &parameters)

Static Public Member Functions
static InputParameters	validParams ()

Protected Member Functions
virtual void	computeQpEigenstrain ()
	Compute the eigenstrain and store in _eigenstrain. More...

virtual void	initQpStatefulProperties ()

virtual void	computeQpProperties ()

Real	computeVolumetricStrainComponent (const Real volumetric_strain) const
	Helper function for models that compute the eigenstrain based on a volumetric strain. More...

Protected Attributes
const MaterialProperty< RealTensorValue > &	_base_tensor

const MaterialProperty< Real > &	_prefactor

RankTwoTensor	_offset_tensor

const std::string	_base_name
	Base name prepended to material property name. More...

std::string	_eigenstrain_name
	Material property name for the eigenstrain tensor. More...

MaterialProperty< RankTwoTensor > &	_eigenstrain
	Stores the current total eigenstrain. More...

bool &	_step_zero
	Restartable data to check for the zeroth and first time steps for thermal calculations. More...

Detailed Description

ComputeVariableBaseEigenstrain computes an Eigenstrain based on a real tensor value material property base (a), a real material property prefactor (p) and a rank two tensor offset tensor (b) p * a + b.

Definition at line 27 of file ComputeVariableBaseEigenStrain.h.

Constructor & Destructor Documentation

◆ ComputeVariableBaseEigenStrain()

ComputeVariableBaseEigenStrain::ComputeVariableBaseEigenStrain ( const InputParameters & parameters )

Definition at line 30 of file ComputeVariableBaseEigenStrain.C.

   : ComputeEigenstrainBase(parameters),
     _base_tensor(getMaterialProperty<RealTensorValue>("base_tensor_property_name")),
     _prefactor(getMaterialProperty<Real>("prefactor"))
 {
   if (isParamValid("offset_tensor"))
     _offset_tensor.fillFromInputVector(getParam<std::vector<Real>>("offset_tensor"));
   else
     _offset_tensor.zero();
 }

Member Function Documentation

◆ computeQpEigenstrain()

void ComputeVariableBaseEigenStrain::computeQpEigenstrain ( )

protectedvirtual

Compute the eigenstrain and store in _eigenstrain.

Implements ComputeEigenstrainBase.

Definition at line 42 of file ComputeVariableBaseEigenStrain.C.

 {
   RankTwoTensor base_rank_two_tensor = _base_tensor[_qp];
   _eigenstrain[_qp] = base_rank_two_tensor * _prefactor[_qp] + _offset_tensor;
 }

◆ computeQpProperties()

void ComputeEigenstrainBase::computeQpProperties ( )

protectedvirtualinherited

Definition at line 49 of file ComputeEigenstrainBase.C.

 {
   if (_t_step >= 1)
     _step_zero = false;
  
   // Skip the eigenstrain calculation in step zero because no solution is computed during
   // the zeroth step, hence computing the eigenstrain in the zeroth step would result in
   // an incorrect calculation of mechanical_strain, which is stateful.
   if (!_step_zero)
     computeQpEigenstrain();
 }

◆ computeVolumetricStrainComponent()

Real ComputeEigenstrainBase::computeVolumetricStrainComponent ( const Real volumetric_strain ) const

protectedinherited

Helper function for models that compute the eigenstrain based on a volumetric strain.

This function computes the diagonal components of the eigenstrain tensor as logarithmic strains.

Parameters

volumetric_strain The current volumetric strain to be applied

Returns: Current strain in one direction due to volumetric strain, expressed as a logarithmic strain

Definition at line 62 of file ComputeEigenstrainBase.C.

 {
   // The engineering strain in a given direction is:
   // epsilon_eng = cbrt(volumetric_strain + 1.0) - 1.0
   //
   // We need to provide this as a logarithmic strain to be consistent with the strain measure
   // used for finite strain:
   // epsilon_log = log(1.0 + epsilon_eng)
   //
   // This can be simplified down to a more direct form:
   // epsilon_log = log(cbrt(volumetric_strain + 1.0))
   // or:
   // epsilon_log = (1/3) log(volumetric_strain + 1.0)
  
   return std::log(volumetric_strain + 1.0) / 3.0;
 }

◆ initQpStatefulProperties()

void ComputeEigenstrainBase::initQpStatefulProperties ( )

protectedvirtualinherited

Reimplemented in ComputeReducedOrderEigenstrain.

Definition at line 41 of file ComputeEigenstrainBase.C.

 {
   // This property can be promoted to be stateful by other models that use it,
   // so it needs to be initalized.
   _eigenstrain[_qp].zero();
 }

◆ validParams()

InputParameters ComputeVariableBaseEigenStrain::validParams ( )

static

Definition at line 17 of file ComputeVariableBaseEigenStrain.C.

 {
   InputParameters params = ComputeEigenstrainBase::validParams();
   params.addClassDescription("Computes Eigenstrain based on material property tensor base");
   params.addRequiredParam<MaterialPropertyName>("base_tensor_property_name",
                                                 "Name of base tensor property");
   params.addParam<MaterialPropertyName>(
       "prefactor", 1.0, "Name of material defining the variable dependence");
   params.addParam<std::vector<Real>>(
       "offset_tensor", "Vector of values defining the constant base tensor for the Eigenstrain");
   return params;
 }