www.mooseframework.org
Public Member Functions | Protected Member Functions | Protected Attributes | List of all members
IsotropicTempDepHardening Class Reference

#include <IsotropicTempDepHardening.h>

Inheritance diagram for IsotropicTempDepHardening:
[legend]

Public Member Functions

 IsotropicTempDepHardening (const InputParameters &parameters)
 
virtual void initQpStatefulProperties () override
 
virtual void computeStress (const Elem &current_elem, const SymmElasticityTensor &elasticityTensor, const SymmTensor &stress_old, SymmTensor &strain_increment, SymmTensor &stress_new) override
 
void computeStress (const Elem &current_elem, const SymmElasticityTensor &elasticityTensor, const SymmTensor &stress_old, SymmTensor &strain_increment, SymmTensor &stress_new, SymmTensor &inelastic_strain_increment)
 Compute stress by performing return mapping iterations. More...
 
virtual Real computeReferenceResidual (const Real effective_trial_stress, const Real scalar) override
 Compute a reference quantity to be used for checking relative convergence. More...
 
Real computeTimeStepLimit ()
 Compute the limiting value of the time step for this material. More...
 
void setQp (unsigned int qp)
 Sets the value of the variable _qp for inheriting classes. More...
 
virtual bool modifyStrainIncrement (const Elem &, SymmTensor &strain_increment, SymmTensor &d_strain_dT)
 
virtual bool updateElasticityTensor (SymmElasticityTensor &)
 
virtual bool applyThermalStrain (SymmTensor &strain_increment, SymmTensor &d_strain_dT)
 
void setMaxIts (unsigned int max_its)
 Functions for setting old default tolerances with legacy_return_mapping: More...
 
void setRelativeTolerance (Real relative_tolerance)
 
void setAbsoluteTolerance (Real absolute_tolerance)
 

Protected Member Functions

virtual void computeYieldStress ()
 
virtual void computeStressInitialize (Real effectiveTrialStress, const SymmElasticityTensor &elasticityTensor)
 Perform any necessary initialization before return mapping iterations. More...
 
virtual Real computeHardeningValue (Real scalar)
 
virtual Real computeHardeningDerivative (Real scalar)
 
void initializeHardeningFunctions ()
 
virtual void computeStressFinalize (const SymmTensor &plasticStrainIncrement) override
 Perform any necessary steps to finalize state after return mapping iterations. More...
 
virtual Real computeResidual (const Real effectiveTrialStress, const Real scalar) override
 Compute the residual for a predicted value of the scalar. More...
 
virtual Real computeDerivative (const Real effectiveTrialStress, const Real scalar) override
 Compute the derivative of the residual as a function of the scalar variable. More...
 
virtual void iterationFinalize (Real scalar) override
 Finalize internal state variables for a model for a given iteration. More...
 
void returnMappingSolve (const Real effective_trial_stress, Real &scalar, const ConsoleStream &console)
 Perform the return mapping iterations. More...
 
virtual Real maximumPermissibleValue (const Real effective_trial_stress) const
 Compute the maximum permissible value of the scalar. More...
 

Protected Attributes

MooseSharedPointer< LinearInterpolation > _interp_yield_stress
 
const std::vector< FunctionName > _hardening_functions_names
 
std::vector< PiecewiseLinear * > _hardening_functions
 
std::vector< Real > _hf_temperatures
 
unsigned int _hf_index_lo
 
unsigned int _hf_index_hi
 
Real _hf_fraction
 
Function * _yield_stress_function
 
Real _yield_stress
 
const Real _hardening_constant
 
PiecewiseLinear *const _hardening_function
 
Real _yield_condition
 
Real _shear_modulus
 
Real _hardening_slope
 
MaterialProperty< SymmTensor > & _plastic_strain
 
const MaterialProperty< SymmTensor > & _plastic_strain_old
 
MaterialProperty< Real > & _hardening_variable
 
const MaterialProperty< Real > & _hardening_variable_old
 
Real _effective_strain_increment
 
Real _three_shear_modulus
 3 * shear modulus More...
 
MaterialProperty< Real > & _effective_inelastic_strain
 
const MaterialProperty< Real > & _effective_inelastic_strain_old
 
Real _max_inelastic_increment
 
const bool _has_temp
 
const VariableValue & _temperature
 
const VariableValue & _temperature_old
 
const Real _alpha
 
Function * _alpha_function
 
bool _has_stress_free_temp
 
Real _stress_free_temp
 
bool _mean_alpha_function
 
Real _ref_temp
 
bool _legacy_return_mapping
 Whether to use the legacy return mapping algorithm and compute residuals in the legacy manner. More...
 
bool _check_range
 Whether to check to see whether iterative solution is within admissible range, and set within that range if outside. More...
 
bool & _step_zero_cm
 Restartable data to check for the zeroth and first time steps. More...
 
bool & _step_one_cm
 

Detailed Description

Definition at line 15 of file IsotropicTempDepHardening.h.

Constructor & Destructor Documentation

IsotropicTempDepHardening::IsotropicTempDepHardening ( const InputParameters &  parameters)

Definition at line 37 of file IsotropicTempDepHardening.C.

38  : IsotropicPlasticity(parameters),
39  _hardening_functions_names(getParam<std::vector<FunctionName>>("hardening_functions")),
40  _hf_temperatures(getParam<std::vector<Real>>("temperatures"))
41 {
42  const unsigned int len = _hardening_functions_names.size();
43  if (len < 2)
44  mooseError("At least two stress-strain curves must be provided in hardening_functions");
45  _hardening_functions.resize(len);
46 
47  const unsigned int len_temps = _hf_temperatures.size();
48  if (len != len_temps)
49  mooseError("The vector of hardening function temperatures must have the same length as the "
50  "vector of temperature dependent hardening functions.");
51 
52  // Check that the temperatures are strictly increasing
53  for (unsigned int i = 1; i < len_temps; ++i)
54  {
55  if (_hf_temperatures[i] <= _hf_temperatures[i - 1])
56  mooseError("The temperature dependent hardening functions and corresponding temperatures "
57  "should be listed in order of increasing temperature.");
58  }
59 
60  std::vector<Real> yield_stress_vec;
61  for (unsigned int i = 0; i < len; ++i)
62  {
63  PiecewiseLinear * const f =
64  dynamic_cast<PiecewiseLinear *>(&getFunctionByName(_hardening_functions_names[i]));
65  if (!f)
66  mooseError("Function ", _hardening_functions_names[i], " not found in ", name());
67 
68  _hardening_functions[i] = f;
69 
70  yield_stress_vec.push_back(f->value(0.0, Point()));
71  }
72 
73  _interp_yield_stress = MooseSharedPointer<LinearInterpolation>(
74  new LinearInterpolation(_hf_temperatures, yield_stress_vec));
75 }
const std::vector< FunctionName > _hardening_functions_names
std::vector< PiecewiseLinear * > _hardening_functions
IsotropicPlasticity(const InputParameters &parameters)
MooseSharedPointer< LinearInterpolation > _interp_yield_stress

Member Function Documentation

bool ConstitutiveModel::applyThermalStrain ( SymmTensor strain_increment,
SymmTensor d_strain_dT 
)
virtualinherited

Definition at line 103 of file ConstitutiveModel.C.

Referenced by ConstitutiveModel::modifyStrainIncrement(), and ConstitutiveModel::updateElasticityTensor().

104 {
105  if (_t_step >= 1)
106  _step_zero_cm = false;
107 
108  if (_t_step >= 2)
109  _step_one_cm = false;
110 
111  if (_has_temp && !_step_zero_cm)
112  {
113  Real inc_thermal_strain;
114  Real d_thermal_strain_d_temp;
115 
116  Real old_temp;
118  old_temp = _stress_free_temp;
119  else
120  old_temp = _temperature_old[_qp];
121 
122  Real current_temp = _temperature[_qp];
123 
124  Real delta_t = current_temp - old_temp;
125 
126  Real alpha = _alpha;
127 
128  if (_alpha_function)
129  {
130  Point p;
131  Real alpha_current_temp = _alpha_function->value(current_temp, p);
132  Real alpha_old_temp = _alpha_function->value(old_temp, p);
133  Real alpha_stress_free_temperature = _alpha_function->value(_stress_free_temp, p);
134 
136  {
137  Real small(1e-6);
138 
139  Real numerator = alpha_current_temp * (current_temp - _ref_temp) -
140  alpha_old_temp * (old_temp - _ref_temp);
141  Real denominator = 1.0 + alpha_stress_free_temperature * (_stress_free_temp - _ref_temp);
142  if (denominator < small)
143  mooseError("Denominator too small in thermal strain calculation");
144  inc_thermal_strain = numerator / denominator;
145  d_thermal_strain_d_temp = alpha_current_temp * (current_temp - _ref_temp);
146  }
147  else
148  {
149  inc_thermal_strain = delta_t * 0.5 * (alpha_current_temp + alpha_old_temp);
150  d_thermal_strain_d_temp = alpha_current_temp;
151  }
152  }
153  else
154  {
155  inc_thermal_strain = delta_t * alpha;
156  d_thermal_strain_d_temp = alpha;
157  }
158 
159  strain_increment.addDiag(-inc_thermal_strain);
160  d_strain_dT.addDiag(-d_thermal_strain_d_temp);
161  }
162 
163  bool modified = true;
164  return modified;
165 }
const VariableValue & _temperature
Function * _alpha_function
bool & _step_zero_cm
Restartable data to check for the zeroth and first time steps.
void addDiag(Real value)
Definition: SymmTensor.h:279
const VariableValue & _temperature_old
Real IsotropicPlasticity::computeDerivative ( const Real  effective_trial_stress,
const Real  scalar 
)
overrideprotectedvirtualinherited

Compute the derivative of the residual as a function of the scalar variable.

The residual should be in strain increment units for all models for consistency.

Parameters
effective_trial_stressEffective trial stress
scalarInelastic strain increment magnitude being solved for

Implements SingleVariableReturnMappingSolution.

Definition at line 117 of file IsotropicPlasticity.C.

118 {
119  Real derivative(1);
120  if (_yield_condition > 0)
121  {
123  derivative = -3.0 * _shear_modulus - _hardening_slope;
124  else
125  derivative = -1.0 - _hardening_slope / (3.0 * _shear_modulus);
126  }
127 
128  return derivative;
129 }
bool _legacy_return_mapping
Whether to use the legacy return mapping algorithm and compute residuals in the legacy manner...
Real IsotropicTempDepHardening::computeHardeningDerivative ( Real  scalar)
protectedvirtual

Reimplemented from IsotropicPlasticity.

Definition at line 143 of file IsotropicTempDepHardening.C.

144 {
145  const Real strain_old = _effective_inelastic_strain_old[_qp];
146 
147  const Real derivative =
148  (1.0 - _hf_fraction) *
149  _hardening_functions[_hf_index_lo]->timeDerivative(strain_old, Point()) +
150  _hf_fraction * _hardening_functions[_hf_index_hi]->timeDerivative(strain_old, Point());
151 
152  return derivative;
153 }
std::vector< PiecewiseLinear * > _hardening_functions
const MaterialProperty< Real > & _effective_inelastic_strain_old
Real IsotropicTempDepHardening::computeHardeningValue ( Real  scalar)
protectedvirtual

Reimplemented from IsotropicPlasticity.

Definition at line 132 of file IsotropicTempDepHardening.C.

133 {
134  const Real strain = _effective_inelastic_strain_old[_qp] + scalar;
135 
136  const Real stress =
137  (1.0 - _hf_fraction) * _hardening_functions[_hf_index_lo]->value(strain, Point()) +
138  _hf_fraction * _hardening_functions[_hf_index_hi]->value(strain, Point());
139 
140  return stress - _yield_stress;
141 }
std::vector< PiecewiseLinear * > _hardening_functions
const MaterialProperty< Real > & _effective_inelastic_strain_old
Real ReturnMappingModel::computeReferenceResidual ( const Real  effective_trial_stress,
const Real  scalar 
)
overridevirtualinherited

Compute a reference quantity to be used for checking relative convergence.

This should be in strain increment units for all models for consistency.

Parameters
effective_trial_stressEffective trial stress
scalarInelastic strain increment magnitude being solved for

Implements SingleVariableReturnMappingSolution.

Definition at line 131 of file ReturnMappingModel.C.

Referenced by ReturnMappingModel::~ReturnMappingModel().

132 {
133  return effective_trial_stress / _three_shear_modulus - scalar;
134 }
Real _three_shear_modulus
3 * shear modulus
Real IsotropicPlasticity::computeResidual ( const Real  effective_trial_stress,
const Real  scalar 
)
overrideprotectedvirtualinherited

Compute the residual for a predicted value of the scalar.

This residual should be in strain increment units for all models for consistency.

Parameters
effective_trial_stressEffective trial stress
scalarInelastic strain increment magnitude being solved for

Implements SingleVariableReturnMappingSolution.

Definition at line 93 of file IsotropicPlasticity.C.

94 {
95  Real residual = 0.0;
96  _hardening_slope = 0.0;
97  if (_yield_condition > 0.0)
98  {
101 
102  // The order here is important. The final term can be small, and we don't want it lost to
103  // roundoff.
105  residual = (effectiveTrialStress - _hardening_variable[_qp] - _yield_stress) -
106  (3 * _shear_modulus * scalar);
107  else
108  residual = (effectiveTrialStress - _hardening_variable[_qp] - _yield_stress) /
109  (3.0 * _shear_modulus) -
110  scalar;
111  }
112 
113  return residual;
114 }
MaterialProperty< Real > & _hardening_variable
bool _legacy_return_mapping
Whether to use the legacy return mapping algorithm and compute residuals in the legacy manner...
virtual Real computeHardeningValue(Real scalar)
virtual Real computeHardeningDerivative(Real scalar)
void ReturnMappingModel::computeStress ( const Elem &  current_elem,
const SymmElasticityTensor elasticityTensor,
const SymmTensor stress_old,
SymmTensor strain_increment,
SymmTensor stress_new 
)
overridevirtualinherited

Reimplemented from ConstitutiveModel.

Definition at line 44 of file ReturnMappingModel.C.

Referenced by ReturnMappingModel::~ReturnMappingModel().

49 {
50  // Given the stretching, compute the stress increment and add it to the old stress. Also update
51  // the creep strain
52  // stress = stressOld + stressIncrement
53  if (_t_step == 0 && !_app.isRestarting())
54  return;
55 
56  stress_new = elasticityTensor * strain_increment;
57  stress_new += stress_old;
58 
59  SymmTensor inelastic_strain_increment;
60  computeStress(current_elem,
61  elasticityTensor,
62  stress_old,
63  strain_increment,
64  stress_new,
65  inelastic_strain_increment);
66 }
virtual void computeStress(const Elem &current_elem, const SymmElasticityTensor &elasticityTensor, const SymmTensor &stress_old, SymmTensor &strain_increment, SymmTensor &stress_new) override
void ReturnMappingModel::computeStress ( const Elem &  current_elem,
const SymmElasticityTensor elasticityTensor,
const SymmTensor stress_old,
SymmTensor strain_increment,
SymmTensor stress_new,
SymmTensor inelastic_strain_increment 
)
inherited

Compute stress by performing return mapping iterations.

This can be called either from within this model, or by an external model that combines multiple inelastic models.

Parameters
current_elemCurrent element
elasticityTensorElasticity tensor
stress_oldOld state of stress
strain_incrementStrain increment
stress_newNew state of stress
inelastic_strain_incrementInelastic strain increment

Definition at line 69 of file ReturnMappingModel.C.

75 {
76  // compute deviatoric trial stress
77  SymmTensor dev_trial_stress(stress_new);
78  dev_trial_stress.addDiag(-dev_trial_stress.trace() / 3.0);
79 
80  // compute effective trial stress
81  Real dts_squared = dev_trial_stress.doubleContraction(dev_trial_stress);
82  Real effective_trial_stress = std::sqrt(1.5 * dts_squared);
83 
84  // compute effective strain increment
85  SymmTensor dev_strain_increment(strain_increment);
86  dev_strain_increment.addDiag(-strain_increment.trace() / 3.0);
87  _effective_strain_increment = dev_strain_increment.doubleContraction(dev_strain_increment);
89 
90  const SymmIsotropicElasticityTensor * iso_e_t =
91  dynamic_cast<const SymmIsotropicElasticityTensor *>(&elasticityTensor);
92  if (!iso_e_t)
93  mooseError("Models derived from ReturnMappingModel require a SymmIsotropicElasticityTensor");
94  _three_shear_modulus = 3.0 * iso_e_t->shearModulus();
95 
96  computeStressInitialize(effective_trial_stress, elasticityTensor);
97 
98  Real scalar;
99  returnMappingSolve(effective_trial_stress, scalar, _console);
100 
101  // compute inelastic and elastic strain increments
103  {
104  if (effective_trial_stress < 0.01)
105  effective_trial_stress = 0.01;
106 
107  inelastic_strain_increment = dev_trial_stress;
108  inelastic_strain_increment *= (1.5 * scalar / effective_trial_stress);
109  }
110  else
111  {
112  if (scalar != 0.0)
113  inelastic_strain_increment = dev_trial_stress * (1.5 * scalar / effective_trial_stress);
114  else
115  inelastic_strain_increment = 0.0;
116  }
117 
118  strain_increment -= inelastic_strain_increment;
120 
121  // compute stress increment
122  stress_new = elasticityTensor * strain_increment;
123 
124  // update stress
125  stress_new += stress_old;
126 
127  computeStressFinalize(inelastic_strain_increment);
128 }
MaterialProperty< Real > & _effective_inelastic_strain
bool _legacy_return_mapping
Whether to use the legacy return mapping algorithm and compute residuals in the legacy manner...
Real _three_shear_modulus
3 * shear modulus
void returnMappingSolve(const Real effective_trial_stress, Real &scalar, const ConsoleStream &console)
Perform the return mapping iterations.
Real trace() const
Definition: SymmTensor.h:95
virtual void computeStressInitialize(Real, const SymmElasticityTensor &)
Perform any necessary initialization before return mapping iterations.
const MaterialProperty< Real > & _effective_inelastic_strain_old
virtual void computeStressFinalize(const SymmTensor &)
Perform any necessary steps to finalize state after return mapping iterations.
Real shearModulus() const
Return the shear modulus...
Defines an Isotropic Elasticity Tensor.
void IsotropicPlasticity::computeStressFinalize ( const SymmTensor )
overrideprotectedvirtualinherited

Perform any necessary steps to finalize state after return mapping iterations.

Parameters
inelasticStrainIncrementInelastic strain increment

Reimplemented from ReturnMappingModel.

Definition at line 87 of file IsotropicPlasticity.C.

88 {
89  _plastic_strain[_qp] += plasticStrainIncrement;
90 }
MaterialProperty< SymmTensor > & _plastic_strain
void IsotropicTempDepHardening::computeStressInitialize ( Real  ,
const SymmElasticityTensor  
)
protectedvirtual

Perform any necessary initialization before return mapping iterations.

Parameters
effectiveTrialStressEffective trial stress
elasticityTensorElasticity tensor

Reimplemented from IsotropicPlasticity.

Definition at line 78 of file IsotropicTempDepHardening.C.

80 {
82  dynamic_cast<const SymmIsotropicElasticityTensor *>(&elasticityTensor);
83  if (!eT)
84  mooseError("IsotropicPlasticity requires a SymmIsotropicElasticityTensor");
85 
89  _yield_condition = effectiveTrialStress - _hardening_variable_old[_qp] - _yield_stress;
92 }
MaterialProperty< SymmTensor > & _plastic_strain
MaterialProperty< Real > & _hardening_variable
const MaterialProperty< Real > & _hardening_variable_old
const MaterialProperty< SymmTensor > & _plastic_strain_old
Real shearModulus() const
Return the shear modulus...
Defines an Isotropic Elasticity Tensor.
Real ReturnMappingModel::computeTimeStepLimit ( )
inherited

Compute the limiting value of the time step for this material.

Returns
Limiting time step

Definition at line 137 of file ReturnMappingModel.C.

Referenced by ReturnMappingModel::~ReturnMappingModel().

138 {
139  Real scalar_inelastic_strain_incr;
140 
141  scalar_inelastic_strain_incr =
143  if (MooseUtils::absoluteFuzzyEqual(scalar_inelastic_strain_incr, 0.0))
144  return std::numeric_limits<Real>::max();
145 
146  return _dt * _max_inelastic_increment / scalar_inelastic_strain_incr;
147 }
MaterialProperty< Real > & _effective_inelastic_strain
const MaterialProperty< Real > & _effective_inelastic_strain_old
void IsotropicTempDepHardening::computeYieldStress ( )
protectedvirtual

Reimplemented from IsotropicPlasticity.

Definition at line 156 of file IsotropicTempDepHardening.C.

Referenced by computeStressInitialize().

157 {
159  if (_yield_stress <= 0.0)
160  mooseError("The yield stress must be greater than zero, but during the simulation your yield "
161  "stress became less than zero.");
162 }
const VariableValue & _temperature
MooseSharedPointer< LinearInterpolation > _interp_yield_stress
void IsotropicTempDepHardening::initializeHardeningFunctions ( )
protected

Definition at line 95 of file IsotropicTempDepHardening.C.

Referenced by computeStressInitialize().

96 {
97  const Real temp = _temperature[_qp];
98  if (temp > _hf_temperatures[0] && temp < _hf_temperatures.back())
99  {
100  for (unsigned int i = 0; i < _hf_temperatures.size() - 1; ++i)
101  {
102  if (temp >= _hf_temperatures[i] && temp < _hf_temperatures[i + 1])
103  {
104  _hf_index_lo = i;
105  _hf_index_hi = i + 1;
106  Real temp_lo = _hf_temperatures[i];
107  Real temp_hi = _hf_temperatures[i + 1];
108  _hf_fraction = (temp - temp_lo) / (temp_hi - temp_lo);
109  }
110  }
111  }
112 
113  else if (temp <= _hf_temperatures[0])
114  {
115  _hf_index_lo = 0;
117  _hf_fraction = 0.0;
118  }
119 
120  else if (temp >= _hf_temperatures.back())
121  {
122  _hf_index_lo = _hf_temperatures.size() - 1;
124  _hf_fraction = 1.0;
125  }
126 
127  if (_hf_fraction < 0.0)
128  mooseError("The hardening function fraction cannot be less than zero.");
129 }
const VariableValue & _temperature
void IsotropicPlasticity::initQpStatefulProperties ( )
overridevirtualinherited

Reimplemented from ReturnMappingModel.

Definition at line 64 of file IsotropicPlasticity.C.

65 {
66  _hardening_variable[_qp] = 0;
68 }
MaterialProperty< Real > & _hardening_variable
virtual void initQpStatefulProperties() override
void IsotropicPlasticity::iterationFinalize ( Real  )
overrideprotectedvirtualinherited

Finalize internal state variables for a model for a given iteration.

Parameters
scalarInelastic strain increment magnitude being solved for

Reimplemented from SingleVariableReturnMappingSolution.

Definition at line 132 of file IsotropicPlasticity.C.

133 {
134  if (_yield_condition > 0)
136 }
MaterialProperty< Real > & _hardening_variable
virtual Real computeHardeningValue(Real scalar)
Real SingleVariableReturnMappingSolution::maximumPermissibleValue ( const Real  effective_trial_stress) const
protectedvirtualinherited

Compute the maximum permissible value of the scalar.

For some models, the magnitude of this may be known.

Parameters
effective_trial_stressEffective trial stress

Reimplemented in RadialReturnStressUpdate.

Definition at line 84 of file SingleVariableReturnMappingSolution.C.

Referenced by SingleVariableReturnMappingSolution::internalSolve(), and SingleVariableReturnMappingSolution::setAbsoluteTolerance().

86 {
87  return std::numeric_limits<Real>::max();
88 }
virtual bool ConstitutiveModel::modifyStrainIncrement ( const Elem &  ,
SymmTensor strain_increment,
SymmTensor d_strain_dT 
)
inlinevirtualinherited

Reimplemented in CombinedCreepPlasticity.

Definition at line 34 of file ConstitutiveModel.h.

37  {
38  return applyThermalStrain(strain_increment, d_strain_dT);
39  }
virtual bool applyThermalStrain(SymmTensor &strain_increment, SymmTensor &d_strain_dT)
void SingleVariableReturnMappingSolution::returnMappingSolve ( const Real  effective_trial_stress,
Real &  scalar,
const ConsoleStream &  console 
)
protectedinherited

Perform the return mapping iterations.

Parameters
effective_trial_stressEffective trial stress
scalarInelastic strain increment magnitude being solved for
consoleConsole output

Definition at line 91 of file SingleVariableReturnMappingSolution.C.

Referenced by ReturnMappingModel::computeStress(), SingleVariableReturnMappingSolution::setAbsoluteTolerance(), and RadialReturnStressUpdate::updateState().

94 {
95  std::stringstream iter_output;
96  std::stringstream * iter_output_ptr = (_output_iteration_info ? &iter_output : nullptr);
97 
99  {
100  if (!internalSolve(effective_trial_stress, scalar, iter_output_ptr))
101  {
102  if (iter_output_ptr)
103  mooseError(iter_output_ptr->str());
104  else
105  {
106  internalSolve(effective_trial_stress, scalar, &iter_output);
107  mooseError(iter_output.str());
108  }
109  }
110  else if (iter_output_ptr)
111  console << iter_output_ptr->str();
112  }
113  else
114  {
115  if (!internalSolveLegacy(effective_trial_stress, scalar, iter_output_ptr))
116  {
117  if (iter_output_ptr)
118  mooseError(iter_output_ptr->str());
119  else
120  {
121  internalSolveLegacy(effective_trial_stress, scalar, &iter_output);
122  mooseError(iter_output.str());
123  }
124  }
125  else if (iter_output_ptr)
126  console << iter_output_ptr->str();
127  }
128 }
bool internalSolveLegacy(const Real effective_trial_stress, Real &scalar, std::stringstream *iter_output)
Method called from within this class to perform the actual return mappping iterations.
bool internalSolve(const Real effective_trial_stress, Real &scalar, std::stringstream *iter_output)
Method called from within this class to perform the actual return mappping iterations.
bool _legacy_return_mapping
Whether to use the legacy return mapping algorithm and compute residuals in the legacy manner...
const bool _output_iteration_info
Whether to output iteration information all the time (regardless of whether iterations converge) ...
void SingleVariableReturnMappingSolution::setAbsoluteTolerance ( Real  absolute_tolerance)
inlineinherited

Definition at line 31 of file SingleVariableReturnMappingSolution.h.

31 { _absolute_tolerance = absolute_tolerance; }
Real _absolute_tolerance
Absolute convergence tolerance.
void SingleVariableReturnMappingSolution::setMaxIts ( unsigned int  max_its)
inlineinherited

Functions for setting old default tolerances with legacy_return_mapping:

Definition at line 29 of file SingleVariableReturnMappingSolution.h.

29 { _max_its = max_its; }
unsigned int _max_its
Maximum number of return mapping iterations (used only in legacy return mapping)
void ConstitutiveModel::setQp ( unsigned int  qp)
inherited

Sets the value of the variable _qp for inheriting classes.

Definition at line 86 of file ConstitutiveModel.C.

Referenced by CombinedCreepPlasticity::computeStress(), and ConstitutiveModel::~ConstitutiveModel().

87 {
88  _qp = qp;
89 }
void SingleVariableReturnMappingSolution::setRelativeTolerance ( Real  relative_tolerance)
inlineinherited

Definition at line 30 of file SingleVariableReturnMappingSolution.h.

30 { _relative_tolerance = relative_tolerance; }
Real _relative_tolerance
Relative convergence tolerance.
virtual bool ConstitutiveModel::updateElasticityTensor ( SymmElasticityTensor )
inlinevirtualinherited

Definition at line 40 of file ConstitutiveModel.h.

40 { return false; }

Member Data Documentation

const Real ConstitutiveModel::_alpha
protectedinherited

Definition at line 48 of file ConstitutiveModel.h.

Referenced by ConstitutiveModel::applyThermalStrain().

Function* ConstitutiveModel::_alpha_function
protectedinherited
bool SingleVariableReturnMappingSolution::_check_range
protectedinherited

Whether to check to see whether iterative solution is within admissible range, and set within that range if outside.

Definition at line 86 of file SingleVariableReturnMappingSolution.h.

Referenced by SingleVariableReturnMappingSolution::internalSolve(), and SingleVariableReturnMappingSolution::SingleVariableReturnMappingSolution().

MaterialProperty<Real>& ReturnMappingModel::_effective_inelastic_strain
protectedinherited
const MaterialProperty<Real>& ReturnMappingModel::_effective_inelastic_strain_old
protectedinherited
Real ReturnMappingModel::_effective_strain_increment
protectedinherited

Definition at line 78 of file ReturnMappingModel.h.

Referenced by ReturnMappingModel::computeStress().

const Real IsotropicPlasticity::_hardening_constant
protectedinherited
PiecewiseLinear* const IsotropicPlasticity::_hardening_function
protectedinherited
std::vector<PiecewiseLinear *> IsotropicTempDepHardening::_hardening_functions
protected
const std::vector<FunctionName> IsotropicTempDepHardening::_hardening_functions_names
protected

Definition at line 31 of file IsotropicTempDepHardening.h.

Referenced by IsotropicTempDepHardening().

Real IsotropicPlasticity::_hardening_slope
protectedinherited
MaterialProperty<Real>& IsotropicPlasticity::_hardening_variable
protectedinherited
const MaterialProperty<Real>& IsotropicPlasticity::_hardening_variable_old
protectedinherited
bool ConstitutiveModel::_has_stress_free_temp
protectedinherited

Definition at line 50 of file ConstitutiveModel.h.

Referenced by ConstitutiveModel::applyThermalStrain().

const bool ConstitutiveModel::_has_temp
protectedinherited
Real IsotropicTempDepHardening::_hf_fraction
protected
unsigned int IsotropicTempDepHardening::_hf_index_hi
protected
unsigned int IsotropicTempDepHardening::_hf_index_lo
protected
std::vector<Real> IsotropicTempDepHardening::_hf_temperatures
protected
MooseSharedPointer<LinearInterpolation> IsotropicTempDepHardening::_interp_yield_stress
protected

Definition at line 30 of file IsotropicTempDepHardening.h.

Referenced by computeYieldStress(), and IsotropicTempDepHardening().

bool SingleVariableReturnMappingSolution::_legacy_return_mapping
protectedinherited
Real ReturnMappingModel::_max_inelastic_increment
protectedinherited

Definition at line 85 of file ReturnMappingModel.h.

Referenced by ReturnMappingModel::computeTimeStepLimit().

bool ConstitutiveModel::_mean_alpha_function
protectedinherited
MaterialProperty<SymmTensor>& IsotropicPlasticity::_plastic_strain
protectedinherited
const MaterialProperty<SymmTensor>& IsotropicPlasticity::_plastic_strain_old
protectedinherited
Real ConstitutiveModel::_ref_temp
protectedinherited
Real IsotropicPlasticity::_shear_modulus
protectedinherited
bool& ConstitutiveModel::_step_one_cm
protectedinherited

Definition at line 57 of file ConstitutiveModel.h.

Referenced by ConstitutiveModel::applyThermalStrain().

bool& ConstitutiveModel::_step_zero_cm
protectedinherited

Restartable data to check for the zeroth and first time steps.

Definition at line 56 of file ConstitutiveModel.h.

Referenced by ConstitutiveModel::applyThermalStrain().

Real ConstitutiveModel::_stress_free_temp
protectedinherited

Definition at line 51 of file ConstitutiveModel.h.

Referenced by ConstitutiveModel::applyThermalStrain().

const VariableValue& ConstitutiveModel::_temperature
protectedinherited
const VariableValue& ConstitutiveModel::_temperature_old
protectedinherited

Definition at line 47 of file ConstitutiveModel.h.

Referenced by ConstitutiveModel::applyThermalStrain().

Real ReturnMappingModel::_three_shear_modulus
protectedinherited

3 * shear modulus

Definition at line 81 of file ReturnMappingModel.h.

Referenced by ReturnMappingModel::computeReferenceResidual(), and ReturnMappingModel::computeStress().

Real IsotropicPlasticity::_yield_condition
protectedinherited
Real IsotropicPlasticity::_yield_stress
protectedinherited
Function* IsotropicPlasticity::_yield_stress_function
protectedinherited

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