ComputeEigenstrain computes an Eigenstrain that results from an initial stress The initial stress is defined in terms of Functions, which may be multiplied by optional AuxVariables. More...

#include <ComputeEigenstrainFromInitialStress.h>

Inheritance diagram for ComputeEigenstrainFromInitialStress:

[legend]

Public Member Functions
	ComputeEigenstrainFromInitialStress (const InputParameters &parameters)

Static Public Member Functions
static InputParameters	validParams ()

Protected Member Functions
virtual void	computeQpEigenstrain () override
	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 std::string	_base_name
	base_name for elasticity tensor to use to convert stress to strain More...

const MaterialProperty< RankFourTensor > &	_elasticity_tensor
	elasticity tensor used to convert stress to strain More...

const MaterialProperty< RankTwoTensor > &	_eigenstrain_old
	Stores the total eigenstrain in the previous step. More...

const bool	_ini_aux_provided
	Whether the user has supplied AuxVariables representing the initial stress. More...

std::vector< const Function * >	_initial_stress_fcn
	initial stress components More...

std::vector< const VariableValue * >	_ini_aux
	AuxVariables defining the initial stress. 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

ComputeEigenstrain computes an Eigenstrain that results from an initial stress The initial stress is defined in terms of Functions, which may be multiplied by optional AuxVariables.

Definition at line 25 of file ComputeEigenstrainFromInitialStress.h.

Constructor & Destructor Documentation

◆ ComputeEigenstrainFromInitialStress()

ComputeEigenstrainFromInitialStress::ComputeEigenstrainFromInitialStress ( const InputParameters & parameters )

Definition at line 42 of file ComputeEigenstrainFromInitialStress.C.

   : ComputeEigenstrainBase(parameters),
     _base_name(isParamValid("base_name") ? getParam<std::string>("base_name") + "_" : ""),
     _elasticity_tensor(getMaterialPropertyByName<RankFourTensor>(_base_name + "elasticity_tensor")),
     _eigenstrain_old(getMaterialPropertyOld<RankTwoTensor>(_eigenstrain_name)),
     _ini_aux_provided(isParamValid("initial_stress_aux"))
 {
   const std::vector<FunctionName> & fcn_names(
       getParam<std::vector<FunctionName>>("initial_stress"));
   const std::size_t num = fcn_names.size();
  
   if (num != LIBMESH_DIM * LIBMESH_DIM)
     paramError(
         "initial_stress",
         "ComputeEigenstrainFromInitialStress: " + Moose::stringify(LIBMESH_DIM * LIBMESH_DIM) +
             " initial stress functions must be provided.  You supplied " + Moose::stringify(num) +
             "\n");
  
   _initial_stress_fcn.resize(num);
   for (unsigned i = 0; i < num; ++i)
     _initial_stress_fcn[i] = &getFunctionByName(fcn_names[i]);
  
   if (_ini_aux_provided)
   {
     const std::size_t aux_size = coupledComponents("initial_stress_aux");
     if (aux_size != LIBMESH_DIM * LIBMESH_DIM)
       paramError("initial_stress_aux",
                  "ComputeEigenstrainFromInitialStress: If you supply initial_stress_aux, " +
                      Moose::stringify(LIBMESH_DIM * LIBMESH_DIM) +
                      " values must be given.  You supplied " + Moose::stringify(aux_size) + "\n");
     _ini_aux.resize(0);
     for (unsigned i = 0; i < aux_size; ++i)
       _ini_aux.push_back(&coupledValue("initial_stress_aux", i));
   }
 }

Member Function Documentation

◆ computeQpEigenstrain()

void ComputeEigenstrainFromInitialStress::computeQpEigenstrain ( )

overrideprotectedvirtual

Compute the eigenstrain and store in _eigenstrain.

Implements ComputeEigenstrainBase.

Definition at line 80 of file ComputeEigenstrainFromInitialStress.C.

 {
   if (_t_step == 1)
   {
     RankTwoTensor initial_stress;
     for (unsigned i = 0; i < LIBMESH_DIM; ++i)
       for (unsigned j = 0; j < LIBMESH_DIM; ++j)
       {
         initial_stress(i, j) = _initial_stress_fcn[i * LIBMESH_DIM + j]->value(_t, _q_point[_qp]);
         if (_ini_aux_provided)
           initial_stress(i, j) *= (*_ini_aux[i * LIBMESH_DIM + j])[_qp];
       }
  
     _eigenstrain[_qp] = -_elasticity_tensor[_qp].invSymm() * initial_stress;
   }
   else
     _eigenstrain[_qp] = _eigenstrain_old[_qp];
 }

◆ 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 ComputeEigenstrainFromInitialStress::validParams ( )

static

Definition at line 20 of file ComputeEigenstrainFromInitialStress.C.

 {
   InputParameters params = ComputeEigenstrainBase::validParams();
   params.addClassDescription("Computes an eigenstrain from an initial stress");
   params.addRequiredParam<std::vector<FunctionName>>(
       "initial_stress",
       "A list of functions describing the initial stress.  There must be 9 of these, corresponding "
       "to the xx, yx, zx, xy, yy, zy, xz, yz, zz components respectively.  To compute the "
       "eigenstrain correctly, your elasticity tensor should not be time-varying in the first "
       "timestep");
   params.addCoupledVar("initial_stress_aux",
                        "A list of 9 AuxVariables describing the initial stress.  If provided, each "
                        "of these is multiplied by its corresponding initial_stress function to "
                        "obtain the relevant component of initial stress.");
   params.addParam<std::string>("base_name",
                                "The base_name for the elasticity tensor that will be "
                                "used to compute strain from stress.  Do not provide "
                                "any base_name if your elasticity tensor does not use "
                                "one.");
   return params;
 }