www.mooseframework.org
Public Types | Public Member Functions | Protected Member Functions | Protected Attributes | List of all members
LinearViscoelasticityBase Class Referenceabstract

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:
[legend]

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)
 

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...
 
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 > & _instantaneous_elasticity_tensor
 Instantaneous elasticity tensor. This IS the real elasticity tensor of the material. More...
 
MaterialProperty< RankFourTensor > & _instantaneous_elasticity_tensor_inv
 Inverse of the instaneous elasticity tensor. 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...
 
MaterialProperty< RankFourTensor > & _first_elasticity_tensor
 Elasticity tensor of a stand-alone elastic spring in the chain. More...
 
MaterialProperty< RankFourTensor > * _first_elasticity_tensor_inv
 
MaterialProperty< std::vector< RankFourTensor > > & _springs_elasticity_tensors
 List of elasticity tensor of each subsequent spring in the chain. More...
 
MaterialProperty< std::vector< RankFourTensor > > * _springs_elasticity_tensors_inv
 
MaterialProperty< std::vector< Real > > & _dashpot_viscosities
 List of viscosities of each subsequent spring in the chain. More...
 
MaterialProperty< std::vector< RankTwoTensor > > & _viscous_strains
 The internal strain variables required by the time-stepping procedure (generally, on a one-on-one basis with the number of dashpot). More...
 
const MaterialProperty< std::vector< 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 > & _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...
 
const MaterialProperty< RankTwoTensor > & _stress_old
 previous value of the stress 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...
 
const MaterialProperty< RankTwoTensor > * _driving_eigenstrain
 Pointer to the value of the driving eigenstrain. 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
 
std::string _base_name
 
std::string _elasticity_tensor_name
 
MaterialProperty< RankFourTensor > & _elasticity_tensor
 
Function *const _prefactor_function
 prefactor function to multiply the elasticity tensor with More...
 

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.

  1. 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.
  2. 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 themsevelves are declared by ComputeLinearViscoelasticStress or LinearViscoelasticStressUpdate.

Definition at line 79 of file LinearViscoelasticityBase.h.

Member Enumeration Documentation

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 85 of file LinearViscoelasticityBase.h.

86  {
88  BackwardEuler,
90  MidPoint,
92  Newmark,
94  Zienkiewicz,
95  };

Constructor & Destructor Documentation

LinearViscoelasticityBase::LinearViscoelasticityBase ( const InputParameters &  parameters)

Definition at line 47 of file LinearViscoelasticityBase.C.

48  : ComputeElasticityTensorBase(parameters),
49  _integration_rule(getParam<MooseEnum>("integration_rule").getEnum<IntegrationRule>()),
50  _theta(getParam<Real>("theta")),
52  declareProperty<RankFourTensor>(_base_name + "apparent_elasticity_tensor")),
54  declareProperty<RankFourTensor>(_base_name + "apparent_elasticity_tensor_inv")),
56  declareProperty<RankFourTensor>(_base_name + "instantaneous_elasticity_tensor")),
58  declareProperty<RankFourTensor>(_base_name + "instantaneous_elasticity_tensor_inv")),
59  _need_viscoelastic_properties_inverse(getParam<bool>("need_viscoelastic_properties_inverse")),
60  _has_longterm_dashpot(false),
61  _components(0),
63  declareProperty<RankFourTensor>(_base_name + "first_elasticity_tensor")),
66  ? &declareProperty<RankFourTensor>(_base_name + "first_elasticity_tensor_inv")
67  : nullptr),
69  declareProperty<std::vector<RankFourTensor>>(_base_name + "springs_elasticity_tensors")),
71  ? &declareProperty<std::vector<RankFourTensor>>(
72  _base_name + "springs_elasticity_tensors_inv")
73  : nullptr),
74  _dashpot_viscosities(declareProperty<std::vector<Real>>(_base_name + "dashpot_viscosities")),
75  _viscous_strains(declareProperty<std::vector<RankTwoTensor>>(_base_name + "viscous_strains")),
77  getMaterialPropertyOld<std::vector<RankTwoTensor>>(_base_name + "viscous_strains")),
78  _apparent_creep_strain(declareProperty<RankTwoTensor>(_base_name + "apparent_creep_strain")),
80  getMaterialPropertyOld<RankTwoTensor>(_base_name + "apparent_creep_strain")),
82  getMaterialPropertyOld<RankTwoTensor>(getParam<std::string>("elastic_strain_name"))),
84  getMaterialPropertyOld<RankTwoTensor>(getParam<std::string>("creep_strain_name"))),
85  _stress_old(getMaterialPropertyOld<RankTwoTensor>(getParam<std::string>("stress_name"))),
86  _has_driving_eigenstrain(isParamValid("driving_eigenstrain")),
88  _has_driving_eigenstrain ? getParam<std::string>("driving_eigenstrain") : ""),
90  ? &getMaterialPropertyByName<RankTwoTensor>(_driving_eigenstrain_name)
91  : nullptr),
92  _force_recompute_properties(getParam<bool>("force_recompute_properties")),
93  _step_zero(declareRestartableData<bool>("step_zero", true))
94 {
95  if (_theta < 0.5)
96  mooseWarning("theta parameter for LinearViscoelasticityBase is below 0.5; time integration may "
97  "not converge!");
98 
99  // force material properties to be considered stateful
100  getMaterialPropertyOld<RankFourTensor>(_base_name + "apparent_elasticity_tensor");
101  getMaterialPropertyOld<RankFourTensor>(_base_name + "apparent_elasticity_tensor_inv");
102  getMaterialPropertyOld<RankFourTensor>(_base_name + "instantaneous_elasticity_tensor");
103  getMaterialPropertyOld<RankFourTensor>(_base_name + "instantaneous_elasticity_tensor_inv");
104  getMaterialPropertyOld<RankFourTensor>(_base_name + "first_elasticity_tensor");
105  getMaterialPropertyOld<std::vector<RankFourTensor>>(_base_name + "springs_elasticity_tensors");
106  getMaterialPropertyOld<std::vector<Real>>(_base_name + "dashpot_viscosities");
107 
109  {
110  getMaterialPropertyOld<RankFourTensor>(_base_name + "first_elasticity_tensor_inv");
111  getMaterialPropertyOld<std::vector<RankFourTensor>>(_base_name +
112  "springs_elasticity_tensors_inv");
113  }
114 }
MaterialProperty< std::vector< RankTwoTensor > > & _viscous_strains
The internal strain variables required by the time-stepping procedure (generally, on a one-on-one bas...
const MaterialProperty< RankTwoTensor > & _apparent_creep_strain_old
bool _has_longterm_dashpot
Indicates if the spring-dashpot assembly has a single dashpot not associated with a spring...
bool _force_recompute_properties
If activated, the time-stepping scheme will be re-initialized at each step of the solver...
MaterialProperty< std::vector< RankFourTensor > > & _springs_elasticity_tensors
List of elasticity tensor of each subsequent spring in the chain.
bool _need_viscoelastic_properties_inverse
If active, indicates that we need to call computeQpViscoelasticPropertiesInv()
MaterialProperty< RankFourTensor > & _instantaneous_elasticity_tensor
Instantaneous elasticity tensor. This IS the real elasticity tensor of the material.
MaterialProperty< std::vector< RankFourTensor > > * _springs_elasticity_tensors_inv
MaterialProperty< RankFourTensor > & _apparent_elasticity_tensor
Apparent elasticity tensor. This is NOT the elasticity tensor of the material.
const MaterialProperty< RankTwoTensor > & _elastic_strain_old
previous value of the elastic strain for update purposes
MaterialProperty< RankFourTensor > & _first_elasticity_tensor
Elasticity tensor of a stand-alone elastic spring in the chain.
MaterialProperty< RankFourTensor > * _first_elasticity_tensor_inv
MaterialProperty< std::vector< Real > > & _dashpot_viscosities
List of viscosities of each subsequent spring in the chain.
const MaterialProperty< RankTwoTensor > & _stress_old
previous value of the stress for update purposes
Real _theta
User-defined value for theta.
std::string _driving_eigenstrain_name
Name of the eigenstrain that drives the additional creep strain.
const MaterialProperty< std::vector< RankTwoTensor > > & _viscous_strains_old
unsigned int _components
This is the number of internal variables required by the model.
MaterialProperty< RankTwoTensor > & _apparent_creep_strain
The apparent creep strain resulting from the internal viscous strains.
const MaterialProperty< RankTwoTensor > * _driving_eigenstrain
Pointer to the value of the driving eigenstrain.
ComputeElasticityTensorBase(const InputParameters &parameters)
bool _has_driving_eigenstrain
Indicates if the model is only driven by the stress, or also by an additional eigenstrain.
MaterialProperty< RankFourTensor > & _instantaneous_elasticity_tensor_inv
Inverse of the instaneous elasticity tensor.
IntegrationRule _integration_rule
Determines how theta is computed.
const MaterialProperty< RankTwoTensor > & _creep_strain_old
Previous value of the true creep strain for update purposes.
MaterialProperty< RankFourTensor > & _apparent_elasticity_tensor_inv
Inverse of the apparent elasticity tensor.

Member Function Documentation

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

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

void LinearViscoelasticityBase::computeQpElasticityTensor ( )
finalprotectedvirtual

Inherited from ComputeElasticityTensorBase.

Implements ComputeElasticityTensorBase.

Definition at line 166 of file LinearViscoelasticityBase.C.

167 {
170 
172 }
void recomputeQpApparentProperties(unsigned int qp)
Compute the apparent properties at a quadrature point.
bool _force_recompute_properties
If activated, the time-stepping scheme will be re-initialized at each step of the solver...
MaterialProperty< RankFourTensor > & _instantaneous_elasticity_tensor
Instantaneous elasticity tensor. This IS the real elasticity tensor of the material.
MaterialProperty< RankFourTensor > & _elasticity_tensor
void ComputeElasticityTensorBase::computeQpProperties ( )
protectedvirtualinherited

Definition at line 39 of file ComputeElasticityTensorBase.C.

40 {
42 
43  // Multiply by prefactor
45  _elasticity_tensor[_qp] *= _prefactor_function->value(_t, _q_point[_qp]);
46 }
Function *const _prefactor_function
prefactor function to multiply the elasticity tensor with
virtual void computeQpElasticityTensor()=0
MaterialProperty< RankFourTensor > & _elasticity_tensor
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().

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 175 of file LinearViscoelasticityBase.C.

Referenced by recomputeQpApparentProperties().

176 {
177  if (MooseUtils::absoluteFuzzyEqual(_first_elasticity_tensor[_qp].L2norm(), 0.0))
178  (*_first_elasticity_tensor_inv)[_qp].zero();
179  else
181 
182  for (unsigned int i = 0; i < _springs_elasticity_tensors[_qp].size(); ++i)
183  {
184  if (MooseUtils::absoluteFuzzyEqual(_springs_elasticity_tensors[_qp][i].L2norm(), 0.0))
185  (*_springs_elasticity_tensors_inv)[_qp][i].zero();
186  else
187  (*_springs_elasticity_tensors_inv)[_qp][i] = _springs_elasticity_tensors[_qp][i].invSymm();
188  }
189 }
MaterialProperty< std::vector< RankFourTensor > > & _springs_elasticity_tensors
List of elasticity tensor of each subsequent spring in the chain.
MaterialProperty< std::vector< RankFourTensor > > * _springs_elasticity_tensors_inv
MaterialProperty< RankFourTensor > & _first_elasticity_tensor
Elasticity tensor of a stand-alone elastic spring in the chain.
MaterialProperty< RankFourTensor > * _first_elasticity_tensor_inv
Real L2norm(const RankTwoTensor &r2tensor)
Real LinearViscoelasticityBase::computeTheta ( Real  dt,
Real  viscosity 
) const
protected

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

Definition at line 192 of file LinearViscoelasticityBase.C.

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

193 {
194  if (MooseUtils::absoluteFuzzyEqual(dt, 0.0))
195  mooseError("linear viscoelasticity cannot be integrated over a dt of ", dt);
196 
197  switch (_integration_rule)
198  {
200  return 1.;
202  return 0.5;
204  return _theta;
206  return 1. / (1. - std::exp(-dt / viscosity)) - viscosity / dt;
207  default:
208  return 1.;
209  }
210  return 1.;
211 }
theta automatically adjusted as a function of the time step and the viscosity
double FORTRAN_CALL() viscosity(double &rho, double &T)
Real _theta
User-defined value for theta.
IntegrationRule _integration_rule
Determines how theta is computed.
bool GuaranteeProvider::hasGuarantee ( const MaterialPropertyName &  prop_name,
Guarantee  guarantee 
)
inherited

Definition at line 14 of file GuaranteeProvider.C.

15 {
16  auto it = _guarantees.find(prop_name);
17  if (it == _guarantees.end())
18  return false;
19 
20  auto it2 = it->second.find(guarantee);
21  return it2 != it->second.end();
22 }
std::map< MaterialPropertyName, std::set< Guarantee > > _guarantees
void LinearViscoelasticityBase::initQpStatefulProperties ( )
overrideprotectedvirtual

Definition at line 117 of file LinearViscoelasticityBase.C.

118 {
119  _apparent_elasticity_tensor[_qp].zero();
123  _first_elasticity_tensor[_qp].zero();
124  _apparent_creep_strain[_qp].zero();
125 
126  _springs_elasticity_tensors[_qp].resize(
127  (_has_longterm_dashpot && _components > 0) ? _components - 1 : _components, RankFourTensor());
128  _dashpot_viscosities[_qp].resize(_components, 0);
129  _viscous_strains[_qp].resize(_components, RankTwoTensor());
130 
132  {
133  (*_first_elasticity_tensor_inv)[_qp].zero();
134  (*_springs_elasticity_tensors_inv)[_qp].resize(_components, RankFourTensor());
135  }
136 }
MaterialProperty< std::vector< RankTwoTensor > > & _viscous_strains
The internal strain variables required by the time-stepping procedure (generally, on a one-on-one bas...
bool _has_longterm_dashpot
Indicates if the spring-dashpot assembly has a single dashpot not associated with a spring...
MaterialProperty< std::vector< RankFourTensor > > & _springs_elasticity_tensors
List of elasticity tensor of each subsequent spring in the chain.
bool _need_viscoelastic_properties_inverse
If active, indicates that we need to call computeQpViscoelasticPropertiesInv()
MaterialProperty< RankFourTensor > & _instantaneous_elasticity_tensor
Instantaneous elasticity tensor. This IS the real elasticity tensor of the material.
MaterialProperty< RankFourTensor > & _apparent_elasticity_tensor
Apparent elasticity tensor. This is NOT the elasticity tensor of the material.
MaterialProperty< RankFourTensor > & _first_elasticity_tensor
Elasticity tensor of a stand-alone elastic spring in the chain.
MaterialProperty< std::vector< Real > > & _dashpot_viscosities
List of viscosities of each subsequent spring in the chain.
unsigned int _components
This is the number of internal variables required by the model.
MaterialProperty< RankTwoTensor > & _apparent_creep_strain
The apparent creep strain resulting from the internal viscous strains.
MaterialProperty< RankFourTensor > & _instantaneous_elasticity_tensor_inv
Inverse of the instaneous elasticity tensor.
MaterialProperty< RankFourTensor > & _apparent_elasticity_tensor_inv
Inverse of the apparent elasticity tensor.
void GuaranteeProvider::issueGuarantee ( const MaterialPropertyName &  prop_name,
Guarantee  guarantee 
)
protectedinherited
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 139 of file LinearViscoelasticityBase.C.

Referenced by computeQpElasticityTensor().

140 {
141  unsigned int qp_prev = _qp;
142  _qp = qp;
143 
144  if (_t_step >= 1)
145  _step_zero = false;
146 
147  // 1. we get the viscoelastic properties and their inverse if needed
151 
152  // 2. we update the internal viscous strains from the previous time step
154 
155  // 3. we compute the apparent elasticity tensor
157 
158  // 4. we transform the internal viscous strains in an apparent creep strain
159  if (!_step_zero)
161 
162  _qp = qp_prev;
163 }
bool _need_viscoelastic_properties_inverse
If active, indicates that we need to call computeQpViscoelasticPropertiesInv()
virtual void computeQpApparentElasticityTensors()=0
This method computes the apparent elasticity tensor used in the internal time-stepping scheme...
virtual void computeQpViscoelasticProperties()=0
This method assigns the mechanical properties of each spring and dashpot in the system.
virtual void computeQpApparentCreepStrain()=0
This method computes the apparent creep strain corresponding to the current viscous_strain of each da...
virtual void computeQpViscoelasticPropertiesInv()
This method computes the inverse elasticity tensor of each spring in the system (if required)...
virtual void updateQpViscousStrains()=0
Update the internal viscous strains at a quadrature point.
void GuaranteeProvider::revokeGuarantee ( const MaterialPropertyName &  prop_name,
Guarantee  guarantee 
)
protectedinherited

Definition at line 32 of file GuaranteeProvider.C.

Referenced by ComputeElasticityTensorCP::ComputeElasticityTensorCP().

33 {
34  auto it = _guarantees.find(prop_name);
35  if (it != _guarantees.end())
36  it->second.erase(guarantee);
37 }
std::map< MaterialPropertyName, std::set< Guarantee > > _guarantees
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().

Member Data Documentation

MaterialProperty<RankTwoTensor>& LinearViscoelasticityBase::_apparent_creep_strain
protected

The apparent creep strain resulting from the internal viscous strains.

Definition at line 223 of file LinearViscoelasticityBase.h.

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

const MaterialProperty<RankTwoTensor>& LinearViscoelasticityBase::_apparent_creep_strain_old
protected

Definition at line 224 of file LinearViscoelasticityBase.h.

MaterialProperty<RankFourTensor>& LinearViscoelasticityBase::_apparent_elasticity_tensor
protected

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

Definition at line 187 of file LinearViscoelasticityBase.h.

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

MaterialProperty<RankFourTensor>& LinearViscoelasticityBase::_apparent_elasticity_tensor_inv
protected
std::string ComputeElasticityTensorBase::_base_name
protectedinherited

Definition at line 28 of file ComputeElasticityTensorBase.h.

Referenced by LinearViscoelasticityBase().

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 204 of file LinearViscoelasticityBase.h.

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

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 233 of file LinearViscoelasticityBase.h.

Referenced by GeneralizedMaxwellBase::updateQpViscousStrains().

MaterialProperty<std::vector<Real> >& LinearViscoelasticityBase::_dashpot_viscosities
protected
const MaterialProperty<RankTwoTensor>* LinearViscoelasticityBase::_driving_eigenstrain
protected

Pointer to the value of the driving eigenstrain.

Definition at line 243 of file LinearViscoelasticityBase.h.

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

std::string LinearViscoelasticityBase::_driving_eigenstrain_name
protected

Name of the eigenstrain that drives the additional creep strain.

Definition at line 241 of file LinearViscoelasticityBase.h.

const MaterialProperty<RankTwoTensor>& LinearViscoelasticityBase::_elastic_strain_old
protected

previous value of the elastic strain for update purposes

Definition at line 227 of file LinearViscoelasticityBase.h.

Referenced by GeneralizedMaxwellBase::updateQpViscousStrains().

MaterialProperty<RankFourTensor>& ComputeElasticityTensorBase::_elasticity_tensor
protectedinherited
std::string ComputeElasticityTensorBase::_elasticity_tensor_name
protectedinherited
MaterialProperty<RankFourTensor>& LinearViscoelasticityBase::_first_elasticity_tensor
protected
MaterialProperty<RankFourTensor>* LinearViscoelasticityBase::_first_elasticity_tensor_inv
protected

Definition at line 208 of file LinearViscoelasticityBase.h.

Referenced by computeQpViscoelasticPropertiesInv().

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 250 of file LinearViscoelasticityBase.h.

Referenced by computeQpElasticityTensor().

bool LinearViscoelasticityBase::_has_driving_eigenstrain
protected
bool LinearViscoelasticityBase::_has_longterm_dashpot
protected
MaterialProperty<RankFourTensor>& LinearViscoelasticityBase::_instantaneous_elasticity_tensor
protected
MaterialProperty<RankFourTensor>& LinearViscoelasticityBase::_instantaneous_elasticity_tensor_inv
protected
IntegrationRule LinearViscoelasticityBase::_integration_rule
protected

Determines how theta is computed.

Definition at line 182 of file LinearViscoelasticityBase.h.

Referenced by computeTheta().

bool LinearViscoelasticityBase::_need_viscoelastic_properties_inverse
protected
Function* const ComputeElasticityTensorBase::_prefactor_function
protectedinherited

prefactor function to multiply the elasticity tensor with

Definition at line 34 of file ComputeElasticityTensorBase.h.

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

MaterialProperty<std::vector<RankFourTensor> >& LinearViscoelasticityBase::_springs_elasticity_tensors
protected
MaterialProperty<std::vector<RankFourTensor> >* LinearViscoelasticityBase::_springs_elasticity_tensors_inv
protected
bool& LinearViscoelasticityBase::_step_zero
protected

Definition at line 252 of file LinearViscoelasticityBase.h.

Referenced by recomputeQpApparentProperties().

const MaterialProperty<RankTwoTensor>& LinearViscoelasticityBase::_stress_old
protected

previous value of the stress for update purposes

Definition at line 236 of file LinearViscoelasticityBase.h.

Referenced by GeneralizedKelvinVoigtBase::updateQpViscousStrains().

Real LinearViscoelasticityBase::_theta
protected

User-defined value for theta.

Definition at line 184 of file LinearViscoelasticityBase.h.

Referenced by computeTheta(), and LinearViscoelasticityBase().

MaterialProperty<std::vector<RankTwoTensor> >& LinearViscoelasticityBase::_viscous_strains
protected

The internal strain variables required by the time-stepping procedure (generally, on a one-on-one basis with the number of dashpot).

Definition at line 219 of file LinearViscoelasticityBase.h.

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

const MaterialProperty<std::vector<RankTwoTensor> >& LinearViscoelasticityBase::_viscous_strains_old
protected

The documentation for this class was generated from the following files: