This class is a base class for materials consisting of an assembly of linear springs and dashpots. More...

#include <LinearViscoelasticityBase.h>

Inheritance diagram for LinearViscoelasticityBase:

Public Types
enum	IntegrationRule { IntegrationRule::BackwardEuler, IntegrationRule::MidPoint, IntegrationRule::Newmark, IntegrationRule::Zienkiewicz }
	Determines how theta is calculated for the time-integration system. More...

Public Member Functions
	LinearViscoelasticityBase (const InputParameters &parameters)

void	recomputeQpApparentProperties (unsigned int qp)
	Compute the apparent properties at a quadrature point. More...

bool	hasGuarantee (const MaterialPropertyName &prop_name, Guarantee guarantee)

Static Public Member Functions
static InputParameters	validParams ()

Protected Member Functions
virtual void	initQpStatefulProperties () override

virtual void	computeQpElasticityTensor () final
	Inherited from ComputeElasticityTensorBase. More...

virtual void	computeQpViscoelasticProperties ()=0
	This method assigns the mechanical properties of each spring and dashpot in the system. More...

virtual void	computeQpViscoelasticPropertiesInv ()
	This method computes the inverse elasticity tensor of each spring in the system (if required). More...

virtual void	computeQpApparentElasticityTensors ()=0
	This method computes the apparent elasticity tensor used in the internal time-stepping scheme. More...

virtual void	computeQpApparentCreepStrain ()=0
	This method computes the apparent creep strain corresponding to the current viscous_strain of each dashpot. More...

virtual void	updateQpViscousStrains ()=0
	Update the internal viscous strains at a quadrature point. More...

void	declareViscoelasticProperties ()
	Declare all necessary MaterialProperties for the model. More...

Real	computeTheta (Real dt, Real viscosity) const
	Provides theta as a function of the time step and a viscosity. More...

virtual void	computeQpProperties ()

void	issueGuarantee (const MaterialPropertyName &prop_name, Guarantee guarantee)

void	revokeGuarantee (const MaterialPropertyName &prop_name, Guarantee guarantee)

Protected Attributes
IntegrationRule	_integration_rule
	Determines how theta is computed. More...

Real	_theta
	User-defined value for theta. More...

MaterialProperty< RankFourTensor > &	_apparent_elasticity_tensor
	Apparent elasticity tensor. This is NOT the elasticity tensor of the material. More...

MaterialProperty< RankFourTensor > &	_apparent_elasticity_tensor_inv
	Inverse of the apparent elasticity tensor. More...

MaterialProperty< RankFourTensor > &	_elasticity_tensor_inv
	Instantaneous elasticity tensor. This IS the real elasticity tensor of the material. More...

bool	_need_viscoelastic_properties_inverse
	If active, indicates that we need to call computeQpViscoelasticPropertiesInv() More...

bool	_has_longterm_dashpot
	Indicates if the spring-dashpot assembly has a single dashpot not associated with a spring. More...

unsigned int	_components
	This is the number of internal variables required by the model. More...

const MaterialProperty< RankTwoTensor > &	_elastic_strain_old
	previous value of the elastic strain for update purposes More...

const MaterialProperty< RankTwoTensor > &	_creep_strain_old
	Previous value of the true creep strain for update purposes. More...

bool	_has_driving_eigenstrain
	Indicates if the model is only driven by the stress, or also by an additional eigenstrain. More...

std::string	_driving_eigenstrain_name
	Name of the eigenstrain that drives the additional creep strain. More...

bool	_force_recompute_properties
	If activated, the time-stepping scheme will be re-initialized at each step of the solver. More...

bool &	_step_zero
	checks whether we are at the first time step 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...


MaterialProperty< RankFourTensor > &	_first_elasticity_tensor
	Elasticity tensor of a stand-alone elastic spring in the chain. More...

MaterialProperty< RankFourTensor > *	_first_elasticity_tensor_inv


std::vector< MaterialProperty< RankFourTensor > * >	_springs_elasticity_tensors
	List of elasticity tensor of each subsequent spring in the chain. More...

std::vector< MaterialProperty< RankFourTensor > * >	_springs_elasticity_tensors_inv

std::vector< const MaterialProperty< RankFourTensor > * >	_springs_elasticity_tensors_inv_old


std::vector< MaterialProperty< Real > * >	_dashpot_viscosities
	List of viscosities of each subsequent dashpot in the chain. More...

std::vector< const MaterialProperty< Real > * >	_dashpot_viscosities_old


std::vector< MaterialProperty< RankTwoTensor > * >	_viscous_strains

std::vector< const MaterialProperty< RankTwoTensor > * >	_viscous_strains_old


MaterialProperty< RankTwoTensor > &	_apparent_creep_strain
	The apparent creep strain resulting from the internal viscous strains. More...

const MaterialProperty< RankTwoTensor > &	_apparent_creep_strain_old


const MaterialProperty< RankTwoTensor > *	_driving_eigenstrain
	Pointer to the value of the driving eigenstrain. More...

const MaterialProperty< RankTwoTensor > *	_driving_eigenstrain_old

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

Detailed Description

This class is a base class for materials consisting of an assembly of linear springs and dashpots.

It represents the arrangement of the system (typically, in parallel or in series), the mechanical * properties of each individual spring and dashpot in the model, and the internal strains associated with each dashpot.

To use a linear viscoelastic model, the user must provide a LinearViscoelasticityManager, that will initialize and update the internal time-stepping scheme at the beginning and the end of each time step.

To compute the stress associated with a linear viscoelastic model, the user must either use a ComputeLinearViscoelasticStress material (for total small strain formulations), or a ComputeMultipleInelasticStress material associated with a LinearViscoelasticStressUpdate material if there are multiple sources of inelastic strains (this requires to use incremental strains).

The rate-dependent problem is solved using an internal 1-step finite difference scheme. The scheme itself depends only on the arrangement of the system, and not the individual properties. The scheme acts upon a series of internal strain variables, stored in the _viscous_strains material properties. At the start of each time step, the apparent elastic properties of the assembly and the apparent creep strain are calculated. The rate-dependent problem becomes then equivalent to a purely elastic system. At the end of the time step, the internal strain variables are updated according to the current values of the stress and the strain.

The real system refers to stress = elasticity_tensor : (mechanical_strain - creep_strain)

The internal time-stepping scheme uses the following conversion: stress = apparent_elasticity_tensor : (mechanical_strain - apparent_creep_strain)

The creep strain is generally driven only by the mechanical stress, but it can be driven by an eigenstrain in addition to the stress. This means that the creep strain is calculated as if the eigenstrain were to contribute to the global mechanical stress of the system.

The determination of the apparent properties, as well as the update of the internal strain variables depend only on the arrangement of the system (in parralel or series), and not their actual properties. These calculations are generally only performed at the beginning of the time step, but the user (or derived classes) can enforce these to be performed at each step of the nonlinear solver if necessary.

The time-integration uses a 1-step Newmark finite difference scheme. This scheme is controlled by a parameter theta (between 0 and 1, default-value 1). Theta can be automatically calibrated depending on the value of the dashpot viscosities in order to reproduce the exact integral of exponential series (integration_rule = "zienkiewicz"). Theta cannot be set to 0 (purely explicit system), and setting theta < 0.5 may cause the scheme to diverge (the "backward_euler" "mid_point" and "zienkiewicz" schemes are unconditionally stable).

This class is virtual. Deriving this class must be done in two steps.

Classes inheriting directly from LinearViscoelasticityBase must represent a distinct spring-dashpot architecture (examples in GeneralizedKelvinVoigtBase and GeneralizedMaxwellBase), and must inherit only methods related to the time-stepping scheme itself.
Classes inheriting inderectly from LinearViscoelasticityBase must provide the actual properties of each spring and dashpot in the assembly (examples in GeneralizedKelvinVoigtModel and GeneralizedMaxwellModel). These classes must not override methods related to the time-stepping scheme.

This class does not store the true creep strain of the material, but an equivalent creep strain adapted for numerical efficiency. The true creep strain itself is declared by ComputeLinearViscoelasticStress or LinearViscoelasticStressUpdate.

Definition at line 81 of file LinearViscoelasticityBase.h.

Member Enumeration Documentation

◆ IntegrationRule

enum LinearViscoelasticityBase::IntegrationRule

strong

Determines how theta is calculated for the time-integration system.

Enumerator
BackwardEuler	theta = 1
MidPoint	theta = 0.5
Newmark	theta defined by the user
Zienkiewicz	theta automatically adjusted as a function of the time step and the viscosity

Definition at line 87 of file LinearViscoelasticityBase.h.

   {
     BackwardEuler,
     MidPoint,
     Newmark,
     Zienkiewicz,
   };

Constructor & Destructor Documentation

◆ LinearViscoelasticityBase()

LinearViscoelasticityBase::LinearViscoelasticityBase ( const InputParameters & parameters )

Definition at line 50 of file LinearViscoelasticityBase.C.

   : ComputeElasticityTensorBase(parameters),
     _integration_rule(getParam<MooseEnum>("integration_rule").getEnum<IntegrationRule>()),
     _theta(getParam<Real>("theta")),
     _apparent_elasticity_tensor(
         declareProperty<RankFourTensor>(_base_name + "apparent_elasticity_tensor")),
     _apparent_elasticity_tensor_inv(
         declareProperty<RankFourTensor>(_base_name + "apparent_elasticity_tensor_inv")),
     _elasticity_tensor_inv(declareProperty<RankFourTensor>(_elasticity_tensor_name + "_inv")),
     _need_viscoelastic_properties_inverse(getParam<bool>("need_viscoelastic_properties_inverse")),
     _has_longterm_dashpot(false),
     _components(0),
     _first_elasticity_tensor(
         declareProperty<RankFourTensor>(_base_name + "spring_elasticity_tensor_0")),
     _first_elasticity_tensor_inv(
         _need_viscoelastic_properties_inverse
             ? &declareProperty<RankFourTensor>(_base_name + "spring_elasticity_tensor_0_inv")
             : nullptr),
     _apparent_creep_strain(declareProperty<RankTwoTensor>(_base_name + "apparent_creep_strain")),
     _apparent_creep_strain_old(
         getMaterialPropertyOld<RankTwoTensor>(_base_name + "apparent_creep_strain")),
     _elastic_strain_old(
         getMaterialPropertyOld<RankTwoTensor>(getParam<std::string>("elastic_strain_name"))),
     _creep_strain_old(
         getMaterialPropertyOld<RankTwoTensor>(getParam<std::string>("creep_strain_name"))),
     _has_driving_eigenstrain(isParamValid("driving_eigenstrain")),
     _driving_eigenstrain_name(
         _has_driving_eigenstrain ? getParam<std::string>("driving_eigenstrain") : ""),
     _driving_eigenstrain(_has_driving_eigenstrain
                              ? &getMaterialPropertyByName<RankTwoTensor>(_driving_eigenstrain_name)
                              : nullptr),
     _driving_eigenstrain_old(_has_driving_eigenstrain
                                  ? &getMaterialPropertyOld<RankTwoTensor>(_driving_eigenstrain_name)
                                  : nullptr),
     _force_recompute_properties(getParam<bool>("force_recompute_properties")),
     _step_zero(declareRestartableData<bool>("step_zero", true))
 {
   if (_theta < 0.5)
     mooseWarning("theta parameter for LinearViscoelasticityBase is below 0.5; time integration may "
                  "not converge!");
  
   // force material properties to be considered stateful
   getMaterialPropertyOld<RankFourTensor>(_base_name + "apparent_elasticity_tensor");
   getMaterialPropertyOld<RankFourTensor>(_base_name + "apparent_elasticity_tensor_inv");
   getMaterialPropertyOld<RankFourTensor>(_elasticity_tensor_name);
   getMaterialPropertyOld<RankFourTensor>(_elasticity_tensor_name + "_inv");
   getMaterialPropertyOld<RankFourTensor>(_base_name + "spring_elasticity_tensor_0");
   if (_need_viscoelastic_properties_inverse)
     getMaterialPropertyOld<RankFourTensor>(_base_name + "spring_elasticity_tensor_0_inv");
 }

Member Function Documentation

◆ computeQpApparentCreepStrain()

virtual void LinearViscoelasticityBase::computeQpApparentCreepStrain ( )

protectedpure virtual

This method computes the apparent creep strain corresponding to the current viscous_strain of each dashpot.

It must be called after the apparent elasticity tensors have been calculated.

This method is purely virtual. Inherited classes must override it.

This method is related to the internal time-stepping scheme. It should only be overwritten by classes that inherit directly from LinearViscoelasticityBase, and that represent a different spring-dashpot assembly. See GeneralizedKelvinVoigtBase for example.

Implemented in GeneralizedKelvinVoigtBase, and GeneralizedMaxwellBase.

Referenced by recomputeQpApparentProperties().

◆ computeQpApparentElasticityTensors()

virtual void LinearViscoelasticityBase::computeQpApparentElasticityTensors ( )

protectedpure virtual

This method computes the apparent elasticity tensor used in the internal time-stepping scheme.

It is called after the mechanical properties have been set, and before the apparent creep strains are calculated.

This method is also responsible for calculating the instantaneous elasticity tensor, and the inverse of both the apparent and instantaneous elasticity tensors.

This method is purely virtual. Inherited classes must override it.

This method is related to the internal time-stepping scheme. It should only be overwritten by classes that inherit directly from LinearViscoelasticityBase, and that represent a different spring-dashpot assembly. See GeneralizedKelvinVoigtBase for example.

Implemented in GeneralizedKelvinVoigtBase, and GeneralizedMaxwellBase.

Referenced by recomputeQpApparentProperties().

◆ computeQpElasticityTensor()

void LinearViscoelasticityBase::computeQpElasticityTensor ( )

finalprotectedvirtual

Inherited from ComputeElasticityTensorBase.

Implements ComputeElasticityTensorBase.

Definition at line 192 of file LinearViscoelasticityBase.C.

 {
   if (_force_recompute_properties)
     recomputeQpApparentProperties(_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]));
   }
 }

◆ computeQpViscoelasticProperties()

virtual void LinearViscoelasticityBase::computeQpViscoelasticProperties ( )

protectedpure virtual

This method assigns the mechanical properties of each spring and dashpot in the system.

This method is purely virtual. Inherited classes must override it.

This method is related to the storage of the mechanical properties of each spring and dashpot in the system, and not the internal time-stepping procedure. Only end-user classes should override it. See GeneralizedKelvinVoigModel for example.

Implemented in GeneralizedMaxwellModel, and GeneralizedKelvinVoigtModel.

Referenced by recomputeQpApparentProperties().

◆ computeQpViscoelasticPropertiesInv()

void LinearViscoelasticityBase::computeQpViscoelasticPropertiesInv ( )

protectedvirtual

This method computes the inverse elasticity tensor of each spring in the system (if required).

This method is virtual. Its default behavior computes the inverse of each tensor. It must be inherited only if there is a faster way to compute this inverse (for example, if they are known).

This method is related to the storage of the mechanical properties of each spring and dashpot in the system, and not the internal time-stepping procedure. Only end-user classes should override it. See GeneralizedKelvinVoigtModel for example.

Reimplemented in GeneralizedMaxwellModel, and GeneralizedKelvinVoigtModel.

Definition at line 199 of file LinearViscoelasticityBase.C.

 {
   if (MooseUtils::absoluteFuzzyEqual(_first_elasticity_tensor[_qp].L2norm(), 0.0))
     (*_first_elasticity_tensor_inv)[_qp].zero();
   else
     (*_first_elasticity_tensor_inv)[_qp] = _first_elasticity_tensor[_qp].invSymm();
  
   for (unsigned int i = 0; i < _springs_elasticity_tensors.size(); ++i)
   {
     if (MooseUtils::absoluteFuzzyEqual((*_springs_elasticity_tensors[i])[_qp].L2norm(), 0.0))
       (*_springs_elasticity_tensors_inv[i])[_qp].zero();
     else
       (*_springs_elasticity_tensors_inv[i])[_qp] = (*_springs_elasticity_tensors[i])[_qp].invSymm();
   }
 }

Referenced by recomputeQpApparentProperties().

◆ computeTheta()

Real LinearViscoelasticityBase::computeTheta	(	Real	dt,
		Real	viscosity
	)		const

protected

Provides theta as a function of the time step and a viscosity.

Definition at line 216 of file LinearViscoelasticityBase.C.

 {
   if (MooseUtils::absoluteFuzzyEqual(dt, 0.0))
     mooseError("linear viscoelasticity cannot be integrated over a dt of ", dt);
  
   switch (_integration_rule)
   {
     case IntegrationRule::BackwardEuler:
       return 1.;
     case IntegrationRule::MidPoint:
       return 0.5;
     case IntegrationRule::Newmark:
       return _theta;
     case IntegrationRule::Zienkiewicz:
       return 1. / (1. - std::exp(-dt / viscosity)) - viscosity / dt;
     default:
       return 1.;
   }
   return 1.;
 }

Referenced by GeneralizedKelvinVoigtBase::computeQpApparentCreepStrain(), GeneralizedMaxwellBase::computeQpApparentCreepStrain(), GeneralizedMaxwellBase::computeQpApparentElasticityTensors(), GeneralizedKelvinVoigtBase::computeQpApparentElasticityTensors(), GeneralizedMaxwellBase::updateQpViscousStrains(), and GeneralizedKelvinVoigtBase::updateQpViscousStrains().

◆ declareViscoelasticProperties()

void LinearViscoelasticityBase::declareViscoelasticProperties ( )

protected

Declare all necessary MaterialProperties for the model.

This method must be called once at the end of the constructor of a final inherited class, after _components has been set. See GeneralizedKelvinVoigtModel or GeneralizedMaxwell model for example.

Definition at line 102 of file LinearViscoelasticityBase.C.

 {
   for (unsigned int i = 0; i < _components; ++i)
   {
     std::string ith = Moose::stringify(i + 1);
  
     if (!_has_longterm_dashpot || (_components > 0 && i < _components - 1))
     {
       _springs_elasticity_tensors.push_back(
           &declareProperty<RankFourTensor>(_base_name + "spring_elasticity_tensor_" + ith));
       getMaterialPropertyOld<RankFourTensor>(_base_name + "spring_elasticity_tensor_" + ith);
     }
  
     _dashpot_viscosities.push_back(&declareProperty<Real>(_base_name + "dashpot_viscosity_" + ith));
     _dashpot_viscosities_old.push_back(
         &getMaterialPropertyOld<Real>(_base_name + "dashpot_viscosity_" + ith));
  
     _viscous_strains.push_back(
         &declareProperty<RankTwoTensor>(_base_name + "viscous_strain_" + ith));
     _viscous_strains_old.push_back(
         &getMaterialPropertyOld<RankTwoTensor>(_base_name + "viscous_strain_" + ith));
  
     if (_need_viscoelastic_properties_inverse)
     {
       _springs_elasticity_tensors_inv.push_back(&declareProperty<RankFourTensor>(
           _base_name + "spring_elasticity_tensor_" + ith + "_inv"));
       _springs_elasticity_tensors_inv_old.push_back(&getMaterialPropertyOld<RankFourTensor>(
           _base_name + "spring_elasticity_tensor_" + ith + "_inv"));
     }
   }
 }

Referenced by GeneralizedKelvinVoigtModel::GeneralizedKelvinVoigtModel(), and GeneralizedMaxwellModel::GeneralizedMaxwellModel().

◆ 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();
 }

◆ initQpStatefulProperties()

void LinearViscoelasticityBase::initQpStatefulProperties ( )

overrideprotectedvirtual

Definition at line 135 of file LinearViscoelasticityBase.C.

 {
   if (_components != _viscous_strains.size())
     mooseError(
         "inconsistent numbers of dashpots and viscous strains in LinearViscoelasticityBase;"
         " Make sure declareViscoelasticProperties has been called in the viscoelastic model");
  
   _apparent_creep_strain[_qp].zero();
   _apparent_elasticity_tensor[_qp].zero();
   _apparent_elasticity_tensor_inv[_qp].zero();
   _elasticity_tensor_inv[_qp].zero();
   _first_elasticity_tensor[_qp].zero();
   if (_need_viscoelastic_properties_inverse)
     (*_first_elasticity_tensor_inv)[_qp].zero();
  
   for (unsigned int i = 0; i < _components; ++i)
   {
     if (!_has_longterm_dashpot || (_components > 0 && i < _components - 1))
     {
       (*_springs_elasticity_tensors[i])[_qp].zero();
       if (_need_viscoelastic_properties_inverse)
         (*_springs_elasticity_tensors_inv[i])[_qp].zero();
     }
  
     (*_dashpot_viscosities[i])[_qp] = 0.0;
     (*_viscous_strains[i])[_qp].zero();
   }
 }

◆ 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::ComputeLayeredCosseratElasticityTensor(), ComputeVariableIsotropicElasticityTensor::ComputeVariableIsotropicElasticityTensor(), GeneralizedKelvinVoigtModel::GeneralizedKelvinVoigtModel(), and GeneralizedMaxwellModel::GeneralizedMaxwellModel().

◆ recomputeQpApparentProperties()

void LinearViscoelasticityBase::recomputeQpApparentProperties ( unsigned int qp )

Compute the apparent properties at a quadrature point.

This initializes the internal time-stepping scheme, and must be called at the beginning of the time step.

This method is called by LinearViscoelasticityManager.

Definition at line 165 of file LinearViscoelasticityBase.C.

 {
   unsigned int qp_prev = _qp;
   _qp = qp;
  
   if (_t_step >= 1)
     _step_zero = false;
  
   // 1. we get the viscoelastic properties and their inverse if needed
   computeQpViscoelasticProperties();
   if (_need_viscoelastic_properties_inverse)
     computeQpViscoelasticPropertiesInv();
  
   // 2. we update the internal viscous strains from the previous time step
   updateQpViscousStrains();
  
   // 3. we compute the apparent elasticity tensor
   computeQpApparentElasticityTensors();
  
   // 4. we transform the internal viscous strains in an apparent creep strain
   if (!_step_zero)
     computeQpApparentCreepStrain();
  
   _qp = qp_prev;
 }

Referenced by computeQpElasticityTensor().

◆ 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().

◆ updateQpViscousStrains()

virtual void LinearViscoelasticityBase::updateQpViscousStrains ( )

protectedpure virtual

Update the internal viscous strains at a quadrature point.

Calling this method is required at the end of each time step to update the internal time-stepping scheme correctly.

This method is pure virtual. Inherited classes must override it.

This method is related to the internal time-stepping scheme. It should only be overwritten by classes that inherit directly from LinearViscoelasticityBase, and that represent a different spring-dashpot assembly. See GeneralizedKelvinVoigtBase or GeneralizedMaxwellBase for example.

Implemented in GeneralizedKelvinVoigtBase, and GeneralizedMaxwellBase.

Referenced by recomputeQpApparentProperties().

◆ validParams()

InputParameters LinearViscoelasticityBase::validParams ( )

static

Definition at line 16 of file LinearViscoelasticityBase.C.

 {
   MooseEnum integration("backward-euler mid-point newmark zienkiewicz", "backward-euler");
  
   InputParameters params = ComputeElasticityTensorBase::validParams();
   params.addParam<MooseEnum>("integration_rule",
                              integration,
                              "describes how the viscoelastic behavior is integrated through time");
   params.addRangeCheckedParam<Real>("theta",
                                     1,
                                     "theta > 0 & theta <= 1",
                                     "coefficient for Newmark integration rule (between 0 and 1)");
   params.addParam<std::string>("driving_eigenstrain",
                                "name of the eigenstrain that increases the creep strains");
   params.addParam<std::string>(
       "elastic_strain_name", "elastic_strain", "name of the true elastic strain of the material");
   params.addParam<std::string>("creep_strain_name",
                                "creep_strain",
                                "name of the true creep strain of the material"
                                "(computed by LinearViscoelasticStressUpdate or"
                                "ComputeLinearViscoelasticStress)");
   params.addParam<bool>("force_recompute_properties",
                         false,
                         "forces the computation of the viscoelastic properties at each step of"
                         "the solver (default: false)");
   params.addParam<bool>(
       "need_viscoelastic_properties_inverse",
       false,
       "checks whether the model requires the computation of the inverse viscoelastic"
       "properties (default: false)");
   params.suppressParameter<FunctionName>("elasticity_tensor_prefactor");
   return params;
 }

Referenced by GeneralizedKelvinVoigtBase::validParams(), and GeneralizedMaxwellBase::validParams().

Member Data Documentation

◆ _apparent_creep_strain

MaterialProperty<RankTwoTensor>& LinearViscoelasticityBase::_apparent_creep_strain

protected

The apparent creep strain resulting from the internal viscous strains.

Definition at line 241 of file LinearViscoelasticityBase.h.

Referenced by GeneralizedKelvinVoigtBase::computeQpApparentCreepStrain(), GeneralizedMaxwellBase::computeQpApparentCreepStrain(), and initQpStatefulProperties().

◆ _apparent_creep_strain_old

const MaterialProperty<RankTwoTensor>& LinearViscoelasticityBase::_apparent_creep_strain_old

protected

Definition at line 242 of file LinearViscoelasticityBase.h.

◆ _apparent_elasticity_tensor

MaterialProperty<RankFourTensor>& LinearViscoelasticityBase::_apparent_elasticity_tensor

protected

Apparent elasticity tensor. This is NOT the elasticity tensor of the material.

Definition at line 197 of file LinearViscoelasticityBase.h.

Referenced by GeneralizedKelvinVoigtBase::computeQpApparentElasticityTensors(), GeneralizedMaxwellBase::computeQpApparentElasticityTensors(), and initQpStatefulProperties().

◆ _apparent_elasticity_tensor_inv

MaterialProperty<RankFourTensor>& LinearViscoelasticityBase::_apparent_elasticity_tensor_inv

protected

Inverse of the apparent elasticity tensor.

Definition at line 199 of file LinearViscoelasticityBase.h.

Referenced by GeneralizedMaxwellBase::computeQpApparentCreepStrain(), GeneralizedMaxwellBase::computeQpApparentElasticityTensors(), GeneralizedKelvinVoigtBase::computeQpApparentElasticityTensors(), and initQpStatefulProperties().

◆ _base_name

const std::string ComputeElasticityTensorBase::_base_name

protectedinherited

Definition at line 37 of file ComputeElasticityTensorBase.h.

Referenced by declareViscoelasticProperties(), and LinearViscoelasticityBase().

◆ _components

unsigned int LinearViscoelasticityBase::_components

protected

This is the number of internal variables required by the model.

This must be set in the constructor of an inherited class. See GeneralizedKelvinVoigtModel for example.

Definition at line 214 of file LinearViscoelasticityBase.h.

Referenced by declareViscoelasticProperties(), GeneralizedKelvinVoigtModel::GeneralizedKelvinVoigtModel(), GeneralizedMaxwellModel::GeneralizedMaxwellModel(), and initQpStatefulProperties().

◆ _creep_strain_old

const MaterialProperty<RankTwoTensor>& LinearViscoelasticityBase::_creep_strain_old

protected

Previous value of the true creep strain for update purposes.

This is calculated by a ComputeLinearViscoelasticStress or a LinearViscoelasticStressUpdate material.

Definition at line 252 of file LinearViscoelasticityBase.h.

Referenced by GeneralizedMaxwellBase::updateQpViscousStrains().

◆ _dashpot_viscosities

std::vector<MaterialProperty<Real> *> LinearViscoelasticityBase::_dashpot_viscosities

protected

List of viscosities of each subsequent dashpot in the chain.

Definition at line 228 of file LinearViscoelasticityBase.h.

Referenced by GeneralizedKelvinVoigtBase::computeQpApparentCreepStrain(), GeneralizedMaxwellBase::computeQpApparentCreepStrain(), GeneralizedMaxwellBase::computeQpApparentElasticityTensors(), GeneralizedKelvinVoigtBase::computeQpApparentElasticityTensors(), GeneralizedKelvinVoigtModel::computeQpViscoelasticProperties(), GeneralizedMaxwellModel::computeQpViscoelasticProperties(), declareViscoelasticProperties(), and initQpStatefulProperties().

◆ _dashpot_viscosities_old

std::vector<const MaterialProperty<Real> *> LinearViscoelasticityBase::_dashpot_viscosities_old

protected

Definition at line 229 of file LinearViscoelasticityBase.h.

Referenced by declareViscoelasticProperties(), GeneralizedKelvinVoigtBase::updateQpViscousStrains(), and GeneralizedMaxwellBase::updateQpViscousStrains().

◆ _driving_eigenstrain

const MaterialProperty<RankTwoTensor>* LinearViscoelasticityBase::_driving_eigenstrain

protected

Pointer to the value of the driving eigenstrain.

Definition at line 259 of file LinearViscoelasticityBase.h.

Referenced by GeneralizedKelvinVoigtBase::computeQpApparentCreepStrain(), and GeneralizedMaxwellBase::computeQpApparentCreepStrain().

◆ _driving_eigenstrain_name

std::string LinearViscoelasticityBase::_driving_eigenstrain_name

protected

Name of the eigenstrain that drives the additional creep strain.

Definition at line 257 of file LinearViscoelasticityBase.h.

◆ _driving_eigenstrain_old

const MaterialProperty<RankTwoTensor>* LinearViscoelasticityBase::_driving_eigenstrain_old

protected

Definition at line 260 of file LinearViscoelasticityBase.h.

◆ _effective_stiffness

MaterialProperty<Real>& ComputeElasticityTensorBase::_effective_stiffness

protectedinherited

Definition at line 41 of file ComputeElasticityTensorBase.h.

Referenced by ComputeIsotropicElasticityTensor::computeQpElasticityTensor(), and ComputeElasticityTensorBase::computeQpProperties().

◆ _elastic_strain_old

const MaterialProperty<RankTwoTensor>& LinearViscoelasticityBase::_elastic_strain_old

protected

previous value of the elastic strain for update purposes

Definition at line 246 of file LinearViscoelasticityBase.h.

Referenced by GeneralizedKelvinVoigtBase::updateQpViscousStrains(), and GeneralizedMaxwellBase::updateQpViscousStrains().

◆ _elasticity_tensor

MaterialProperty<RankFourTensor>& ComputeElasticityTensorBase::_elasticity_tensor

protectedinherited

Definition at line 40 of file ComputeElasticityTensorBase.h.

Referenced by GeneralizedKelvinVoigtBase::computeQpApparentCreepStrain(), GeneralizedMaxwellBase::computeQpApparentCreepStrain(), GeneralizedMaxwellBase::computeQpApparentElasticityTensors(), GeneralizedKelvinVoigtBase::computeQpApparentElasticityTensors(), ComputeCosseratElasticityTensor::computeQpElasticityTensor(), ComputeElasticityTensor::computeQpElasticityTensor(), ComputeConcentrationDependentElasticityTensor::computeQpElasticityTensor(), ComputeIsotropicElasticityTensor::computeQpElasticityTensor(), ComputePolycrystalElasticityTensor::computeQpElasticityTensor(), ComputeElasticityTensorCP::computeQpElasticityTensor(), ComputeLayeredCosseratElasticityTensor::computeQpElasticityTensor(), ComputeVariableIsotropicElasticityTensor::computeQpElasticityTensor(), and ComputeElasticityTensorBase::computeQpProperties().

◆ _elasticity_tensor_inv

MaterialProperty<RankFourTensor>& LinearViscoelasticityBase::_elasticity_tensor_inv

protected

Instantaneous elasticity tensor. This IS the real elasticity tensor of the material.

Inverse of the instaneous elasticity tensor

Definition at line 204 of file LinearViscoelasticityBase.h.

Referenced by GeneralizedKelvinVoigtBase::computeQpApparentElasticityTensors(), GeneralizedMaxwellBase::computeQpApparentElasticityTensors(), and initQpStatefulProperties().

◆ _elasticity_tensor_name

std::string ComputeElasticityTensorBase::_elasticity_tensor_name

protectedinherited

Definition at line 38 of file ComputeElasticityTensorBase.h.

Referenced by ComputeCosseratElasticityTensor::ComputeCosseratElasticityTensor(), ComputeElasticityTensor::ComputeElasticityTensor(), ComputeElasticityTensorCP::ComputeElasticityTensorCP(), ComputeIsotropicElasticityTensor::ComputeIsotropicElasticityTensor(), ComputeLayeredCosseratElasticityTensor::ComputeLayeredCosseratElasticityTensor(), ComputePolycrystalElasticityTensor::ComputePolycrystalElasticityTensor(), ComputeVariableIsotropicElasticityTensor::ComputeVariableIsotropicElasticityTensor(), GeneralizedKelvinVoigtModel::GeneralizedKelvinVoigtModel(), GeneralizedMaxwellModel::GeneralizedMaxwellModel(), ComputeVariableIsotropicElasticityTensor::initialSetup(), and LinearViscoelasticityBase().

◆ _first_elasticity_tensor

MaterialProperty<RankFourTensor>& LinearViscoelasticityBase::_first_elasticity_tensor

protected

Elasticity tensor of a stand-alone elastic spring in the chain.

Definition at line 217 of file LinearViscoelasticityBase.h.

Referenced by GeneralizedMaxwellBase::computeQpApparentCreepStrain(), GeneralizedKelvinVoigtBase::computeQpApparentElasticityTensors(), GeneralizedMaxwellBase::computeQpApparentElasticityTensors(), GeneralizedKelvinVoigtModel::computeQpViscoelasticProperties(), GeneralizedMaxwellModel::computeQpViscoelasticProperties(), computeQpViscoelasticPropertiesInv(), and initQpStatefulProperties().

◆ _first_elasticity_tensor_inv

MaterialProperty<RankFourTensor>* LinearViscoelasticityBase::_first_elasticity_tensor_inv

protected

Definition at line 218 of file LinearViscoelasticityBase.h.

Referenced by computeQpViscoelasticPropertiesInv().

◆ _force_recompute_properties

bool LinearViscoelasticityBase::_force_recompute_properties

protected

If activated, the time-stepping scheme will be re-initialized at each step of the solver.

This may be required for models in which the mechanical properties vary following other variables. If the mechanical properties are constant through the time step, this can be set to false.

Definition at line 268 of file LinearViscoelasticityBase.h.

Referenced by computeQpElasticityTensor().