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

#include <AbaqusCreepMaterial.h>

Inheritance diagram for AbaqusCreepMaterial:
[legend]

Public Types

enum  CRACKING_RELEASE { CR_ABRUPT = 0, CR_EXPONENTIAL, CR_POWER, CR_UNKNOWN }
 

Public Member Functions

 AbaqusCreepMaterial (const InputParameters &parameters)
 
virtual ~AbaqusCreepMaterial ()
 
virtual void applyThermalStrain ()
 
virtual void applyVolumetricStrain ()
 
QBase * qrule ()
 
const Point & q_point (unsigned i) const
 
Real JxW (unsigned i) const
 

Static Public Member Functions

static void rotateSymmetricTensor (const ColumnMajorMatrix &R, const SymmTensor &T, SymmTensor &result)
 

Protected Member Functions

virtual void initStatefulProperties (unsigned n_points)
 
void computeStress ()
 Compute the stress (sigma += deltaSigma) More...
 
virtual void initQpStatefulProperties ()
 
virtual void initialSetup ()
 
virtual void timestepSetup ()
 
virtual void jacobianSetup ()
 
virtual void computeProperties ()
 
void computeElasticityTensor ()
 
virtual bool updateElasticityTensor (SymmElasticityTensor &tensor)
 Return true if the elasticity tensor changed. More...
 
virtual void elementInit ()
 
virtual void modifyStrainIncrement ()
 Modify increment for things like thermal strain. More...
 
virtual void crackingStrainDirections ()
 Determine cracking directions. Rotate elasticity tensor. More...
 
virtual unsigned int getNumKnownCrackDirs () const
 
virtual void computeEshelby ()
 
virtual void computeStrainEnergyDensity ()
 
virtual void computeThermalJvec ()
 
virtual void computeCurrentInstantaneousThermalExpansionCoefficient ()
 
virtual void crackingStressRotation ()
 
virtual Real computeCrackFactor (int i, Real &sigma, Real &flagVal)
 
virtual void finalizeStress ()
 Rotate stress to current configuration. More...
 
virtual void computePreconditioning ()
 
void applyCracksToTensor (SymmTensor &tensor, const RealVectorValue &sigma)
 
void elasticityTensor (SymmElasticityTensor *e)
 
SymmElasticityTensorelasticityTensor () const
 
const SolidMechanics::Elementelement () const
 
int delta (int i, int j) const
 
template<typename T >
MaterialProperty< T > & createProperty (const std::string &prop_name)
 
template<typename T >
const MaterialProperty< T > & getPropertyOld (const std::string &prop_name)
 
virtual void checkElasticConstants ()
 
virtual void createElasticityTensor ()
 
virtual void computeConstitutiveModelStress ()
 Compute the stress (sigma += deltaSigma) More...
 
void createConstitutiveModel (const std::string &cm_name)
 

Protected Attributes

FileName _plugin
 
Real _youngs_modulus
 
Real _poissons_ratio
 
unsigned int _num_state_vars
 
unsigned int _integration_flag
 
unsigned int _solve_definition
 
unsigned int _routine_flag
 
void * _handle
 
creep_t _creep
 
Real _SERD
 
Real _P
 
Real _QTILD
 
Real _TEMP
 
Real _DTEMP
 
Real _DTIME
 
Real _CMNAME
 
Real _LEXIMP
 
Real _LEND
 
Real _NSTATV
 
Real _DECRA [5]
 
Real _DESWA [5]
 
Real * _STATEV
 
Real _PREDEF [1]
 
Real _DPRED [1]
 
Real _TIME [2]
 
Real _EC [2]
 
Real _ESW [2]
 
Real _COORDS [3]
 
int _NOEL
 
int _NPT
 
int _LAYER
 
int _KSPT
 
int _KSTEP
 
int _KINC
 
Real _ebulk3
 
Real _eg2
 
Real _eg
 
Real _eg3
 
Real _elam
 
Real _elasticity_tensor [3]
 
Real _stress_component [6]
 
MaterialProperty< std::vector< Real > > & _state_var
 
const MaterialProperty< std::vector< Real > > & _state_var_old
 
MaterialProperty< SymmTensor > & _trial_stress
 
const MaterialProperty< SymmTensor > & _trial_stress_old
 
MaterialProperty< SymmTensor > & _dev_trial_stress
 
const MaterialProperty< SymmTensor > & _dev_trial_stress_old
 
MaterialProperty< Real > & _ets
 
const MaterialProperty< Real > & _ets_old
 
MaterialProperty< SymmTensor > & _stress
 
const MaterialProperty< SymmTensor > & _stress_old
 
MaterialProperty< Real > & _creep_inc
 
const MaterialProperty< Real > & _creep_inc_old
 
MaterialProperty< Real > & _total_creep
 
const MaterialProperty< Real > & _total_creep_old
 
MaterialProperty< Real > & _swell_inc
 
const MaterialProperty< Real > & _swell_inc_old
 
MaterialProperty< Real > & _total_swell
 
const MaterialProperty< Real > & _total_swell_old
 
Moose::CoordinateSystemType _coord_type
 
const std::string _appended_property_name
 
bool _bulk_modulus_set
 
bool _lambda_set
 
bool _poissons_ratio_set
 
bool _shear_modulus_set
 
bool _youngs_modulus_set
 
Real _bulk_modulus
 
Real _lambda
 
Real _shear_modulus
 
Function * _youngs_modulus_function
 
Function * _poissons_ratio_function
 
const CRACKING_RELEASE _cracking_release
 
Real _cracking_stress
 
const Real _cracking_residual_stress
 
const Real _cracking_beta
 
const std::string _compute_method
 
Function *const _cracking_stress_function
 
Real _cracking_alpha
 
std::vector< unsigned int > _active_crack_planes
 
const unsigned int _max_cracks
 
const Real _cracking_neg_fraction
 
const bool _has_temp
 
const VariableValue & _temperature
 
const VariableValue & _temperature_old
 
const VariableGradient & _temp_grad
 
const Real _alpha
 
Function * _alpha_function
 
PiecewiseLinear * _piecewise_linear_alpha_function
 
bool _has_stress_free_temp
 
Real _stress_free_temp
 
bool _mean_alpha_function
 
Real _ref_temp
 
std::map< SubdomainID, std::vector< MooseSharedPointer< VolumetricModel > > > _volumetric_models
 
std::set< std::string > _dep_matl_props
 
MaterialProperty< SymmTensor > & _total_strain
 
const MaterialProperty< SymmTensor > & _total_strain_old
 
MaterialProperty< SymmTensor > & _elastic_strain
 
const MaterialProperty< SymmTensor > & _elastic_strain_old
 
MaterialProperty< RealVectorValue > * _crack_flags
 
const MaterialProperty< RealVectorValue > * _crack_flags_old
 
RealVectorValue _crack_flags_local
 
MaterialProperty< RealVectorValue > * _crack_count
 
const MaterialProperty< RealVectorValue > * _crack_count_old
 
MaterialProperty< ColumnMajorMatrix > * _crack_rotation
 
const MaterialProperty< ColumnMajorMatrix > * _crack_rotation_old
 
MaterialProperty< RealVectorValue > * _crack_strain
 
const MaterialProperty< RealVectorValue > * _crack_strain_old
 
MaterialProperty< RealVectorValue > * _crack_max_strain
 
const MaterialProperty< RealVectorValue > * _crack_max_strain_old
 
ColumnMajorMatrix _principal_strain
 
MaterialProperty< SymmElasticityTensor > & _Jacobian_mult
 
SymmTensor _d_strain_dT
 
MaterialProperty< SymmTensor > & _d_stress_dT
 
SymmTensor _total_strain_increment
 Total strain increment, including mechanical strains and eigenstrains. More...
 
SymmTensor _mechanical_strain_increment
 Mechanical strain increment, which is the total strain increment minus eigenstrains. More...
 
SymmTensor _strain_increment
 In most models, this is the mechanical strain increment, but for inelastic models, it has the inelastic component subtracted from it, so it is the elastic strain increment. More...
 
const bool _compute_JIntegral
 
const bool _compute_InteractionIntegral
 
MaterialProperty< Real > * _SED
 
const MaterialProperty< Real > * _SED_old
 
MaterialProperty< RankTwoTensor > * _Eshelby_tensor
 
MaterialProperty< RealVectorValue > * _J_thermal_term_vec
 
MaterialProperty< Real > * _current_instantaneous_thermal_expansion_coef
 
std::vector< SubdomainID > _block_id
 
std::map< SubdomainID, MooseSharedPointer< ConstitutiveModel > > _constitutive_model
 
std::set< MooseSharedPointer< ConstitutiveModel > > _models_to_free
 
bool _constitutive_active
 
bool & _step_zero
 Restartable data to check for the zeroth and first time steps for thermal calculations. More...
 
bool & _step_one
 

Detailed Description

Definition at line 49 of file AbaqusCreepMaterial.h.

Member Enumeration Documentation

◆ CRACKING_RELEASE

Enumerator
CR_ABRUPT 
CR_EXPONENTIAL 
CR_POWER 
CR_UNKNOWN 

Definition at line 48 of file SolidModel.h.

Constructor & Destructor Documentation

◆ AbaqusCreepMaterial()

AbaqusCreepMaterial::AbaqusCreepMaterial ( const InputParameters &  parameters)

Definition at line 45 of file AbaqusCreepMaterial.C.

46  : SolidModel(parameters),
47  _plugin(getParam<FileName>("plugin")),
48  _youngs_modulus(getParam<Real>("youngs_modulus")),
49  _poissons_ratio(getParam<Real>("poissons_ratio")),
50  _num_state_vars(getParam<Real>("num_state_vars")),
51  _integration_flag(getParam<unsigned int>("integration_flag")),
52  _solve_definition(getParam<unsigned int>("solve_definition")),
53  _routine_flag(getParam<unsigned int>("routine_flag")),
54  _state_var(declareProperty<std::vector<Real>>("state_var")),
55  _state_var_old(getMaterialPropertyOld<std::vector<Real>>("state_var")),
56  _trial_stress(declareProperty<SymmTensor>("trial_stress")),
57  _trial_stress_old(getMaterialPropertyOld<SymmTensor>("trial_stress")),
58  _dev_trial_stress(declareProperty<SymmTensor>("dev_trial_stress")),
59  _dev_trial_stress_old(getMaterialPropertyOld<SymmTensor>("dev_trial_stress")),
60  _ets(declareProperty<Real>("effective_trial_stress")),
61  _ets_old(getMaterialPropertyOld<Real>("effective_trial_stress")),
62  _stress(declareProperty<SymmTensor>("stress")),
63  _stress_old(getMaterialPropertyOld<SymmTensor>("stress")),
64  _creep_inc(declareProperty<Real>("creep_inc")),
65  _creep_inc_old(getMaterialPropertyOld<Real>("creep_inc")),
66  _total_creep(declareProperty<Real>("total_creep")),
67  _total_creep_old(getMaterialPropertyOld<Real>("total_creep")),
68  _swell_inc(declareProperty<Real>("swell_inc")),
69  _swell_inc_old(getMaterialPropertyOld<Real>("swell_inc")),
70  _total_swell(declareProperty<Real>("total_swell")),
71  _total_swell_old(getMaterialPropertyOld<Real>("total_swell"))
72 {
73 #if defined(METHOD)
74  _plugin += std::string("-") + QUOTE(METHOD) + ".plugin";
75 #endif
76 
77  _STATEV = new Real[_num_state_vars];
78 
79  // Set subroutine values
83 
84  // Calculate constants needed for elasticity tensor
85  _ebulk3 = _youngs_modulus / (1. - 2. * _poissons_ratio);
87  _eg = _eg2 / 2.;
88  _eg3 = 3. * _eg;
89  _elam = (_ebulk3 - _eg2) / 3.;
90 
94 
95  // Open the library
96  _handle = dlopen(_plugin.c_str(), RTLD_LAZY);
97 
98  if (!_handle)
99  {
100  std::ostringstream error;
101  error << "Cannot open library: " << dlerror() << '\n';
102  mooseError(error.str());
103  }
104 
105  // Reset errors
106  dlerror();
107 
108  // Snag the function pointer from the library
109  {
110  void * pointer = dlsym(_handle, "creep_");
111  _creep = *reinterpret_cast<creep_t *>(&pointer);
112  }
113 
114  // Catch errors
115  const char * dlsym_error = dlerror();
116  if (dlsym_error)
117  {
118  dlclose(_handle);
119  std::ostringstream error;
120  error << "Cannot load symbol 'creep_': " << dlsym_error << '\n';
121  mooseError(error.str());
122  }
123 }
MaterialProperty< SymmTensor > & _trial_stress
MaterialProperty< Real > & _ets
MaterialProperty< std::vector< Real > > & _state_var
MaterialProperty< SymmTensor > & _stress
const MaterialProperty< SymmTensor > & _stress_old
const MaterialProperty< Real > & _creep_inc_old
MaterialProperty< Real > & _swell_inc
const MaterialProperty< Real > & _total_swell_old
const MaterialProperty< Real > & _ets_old
void(* creep_t)(Real DECRA[], Real DESWA[], Real STATEV[], Real *SERD, Real EC[], Real ESW[], Real *P, Real *QTILD, Real *TEMP, Real *DTEMP, Real PREDEF[], Real DPRED[], Real TIME[], Real *DTIME, Real *CMNAME, Real *LEXIMP, Real *LEND, Real COORDS[], Real *NSTATV, int *NOEL, int *NPT, int *LAYER, int *KSPT, int *KSTEP, int *KINC)
MaterialProperty< Real > & _total_creep
const MaterialProperty< Real > & _swell_inc_old
const MaterialProperty< SymmTensor > & _trial_stress_old
MaterialProperty< Real > & _total_swell
MaterialProperty< Real > & _creep_inc
unsigned int _num_state_vars
const MaterialProperty< std::vector< Real > > & _state_var_old
const MaterialProperty< SymmTensor > & _dev_trial_stress_old
unsigned int _integration_flag
unsigned int _solve_definition
const MaterialProperty< Real > & _total_creep_old
SolidModel(const InputParameters &parameters)
Definition: SolidModel.C:140
MaterialProperty< SymmTensor > & _dev_trial_stress

◆ ~AbaqusCreepMaterial()

AbaqusCreepMaterial::~AbaqusCreepMaterial ( )
virtual

Definition at line 125 of file AbaqusCreepMaterial.C.

126 {
127  delete _STATEV;
128 
129  dlclose(_handle);
130 }

Member Function Documentation

◆ applyCracksToTensor()

void SolidModel::applyCracksToTensor ( SymmTensor tensor,
const RealVectorValue &  sigma 
)
protectedinherited

Definition at line 1123 of file SolidModel.C.

Referenced by SolidModel::crackingStressRotation().

1124 {
1125  // Form transformation matrix R*E*R^T
1126  const ColumnMajorMatrix & R((*_crack_rotation)[_qp]);
1127 
1128  // Rotate to crack frame
1129  rotateSymmetricTensor(R.transpose(), tensor, tensor);
1130 
1131  // Reset stress if cracked
1132  if ((*_crack_flags)[_qp](0) < 1)
1133  {
1134  tensor(0, 0) = sigma(0);
1135  }
1136  if ((*_crack_flags)[_qp](1) < 1)
1137  {
1138  tensor(1, 1) = sigma(1);
1139  }
1140  if ((*_crack_flags)[_qp](2) < 1)
1141  {
1142  tensor(2, 2) = sigma(2);
1143  }
1144 
1145  // Rotate back to global frame
1146  rotateSymmetricTensor(R, tensor, tensor);
1147 }
MaterialProperty< ColumnMajorMatrix > * _crack_rotation
Definition: SolidModel.h:128
MaterialProperty< RealVectorValue > * _crack_flags
Definition: SolidModel.h:123
static void rotateSymmetricTensor(const ColumnMajorMatrix &R, const SymmTensor &T, SymmTensor &result)
Definition: SolidModel.C:663

◆ applyThermalStrain()

void SolidModel::applyThermalStrain ( )
virtualinherited

Definition at line 591 of file SolidModel.C.

Referenced by SolidModel::modifyStrainIncrement().

592 {
593  if (_has_temp && !_step_zero)
594  {
595  Real inc_thermal_strain;
596  Real d_thermal_strain_d_temp;
597 
598  Real old_temp;
600  old_temp = _stress_free_temp;
601  else
602  old_temp = _temperature_old[_qp];
603 
604  Real current_temp = _temperature[_qp];
605 
606  Real delta_t = current_temp - old_temp;
607 
608  Real alpha = _alpha;
609 
610  if (_alpha_function)
611  {
612  Point p;
613  Real alpha_current_temp = _alpha_function->value(current_temp, p);
614  Real alpha_old_temp = _alpha_function->value(old_temp, p);
615 
617  {
618  Real alpha_stress_free_temperature = _alpha_function->value(_stress_free_temp, p);
619  Real small(1e-6);
620 
621  Real numerator = alpha_current_temp * (current_temp - _ref_temp) -
622  alpha_old_temp * (old_temp - _ref_temp);
623  Real denominator = 1.0 + alpha_stress_free_temperature * (_stress_free_temp - _ref_temp);
624  if (denominator < small)
625  mooseError("Denominator too small in thermal strain calculation");
626  inc_thermal_strain = numerator / denominator;
627  d_thermal_strain_d_temp = alpha_current_temp * (current_temp - _ref_temp);
628  }
629  else
630  {
631  inc_thermal_strain = delta_t * 0.5 * (alpha_current_temp + alpha_old_temp);
632  d_thermal_strain_d_temp = alpha_current_temp;
633  }
634  }
635  else
636  {
637  inc_thermal_strain = delta_t * alpha;
638  d_thermal_strain_d_temp = alpha;
639  }
640 
641  _strain_increment.addDiag(-inc_thermal_strain);
642  _d_strain_dT.addDiag(-d_thermal_strain_d_temp);
643  }
644 }
const Real _alpha
Definition: SolidModel.h:98
const VariableValue & _temperature_old
Definition: SolidModel.h:96
Real _stress_free_temp
Definition: SolidModel.h:102
bool & _step_zero
Restartable data to check for the zeroth and first time steps for thermal calculations.
Definition: SolidModel.h:262
bool & _step_one
Definition: SolidModel.h:263
bool _mean_alpha_function
Definition: SolidModel.h:103
const bool _has_temp
Definition: SolidModel.h:94
SymmTensor _d_strain_dT
Definition: SolidModel.h:140
SymmTensor _strain_increment
In most models, this is the mechanical strain increment, but for inelastic models, it has the inelastic component subtracted from it, so it is the elastic strain increment.
Definition: SolidModel.h:152
const VariableValue & _temperature
Definition: SolidModel.h:95
bool _has_stress_free_temp
Definition: SolidModel.h:101
Function * _alpha_function
Definition: SolidModel.h:99
Real _ref_temp
Definition: SolidModel.h:104
void addDiag(Real value)
Definition: SymmTensor.h:282

◆ applyVolumetricStrain()

void SolidModel::applyVolumetricStrain ( )
virtualinherited

Definition at line 649 of file SolidModel.C.

Referenced by SolidModel::modifyStrainIncrement().

650 {
651  const Real V0Vold = 1 / _element->volumeRatioOld(_qp);
652  const SubdomainID current_block = _current_elem->subdomain_id();
653  const std::vector<MooseSharedPointer<VolumetricModel>> & vm(_volumetric_models[current_block]);
654  for (unsigned int i(0); i < vm.size(); ++i)
655  {
656  vm[i]->modifyStrain(_qp, V0Vold, _strain_increment, _d_strain_dT);
657  }
658 }
SymmTensor _d_strain_dT
Definition: SolidModel.h:140
SymmTensor _strain_increment
In most models, this is the mechanical strain increment, but for inelastic models, it has the inelastic component subtracted from it, so it is the elastic strain increment.
Definition: SolidModel.h:152
SolidMechanics::Element * _element
Definition: SolidModel.h:271
std::map< SubdomainID, std::vector< MooseSharedPointer< VolumetricModel > > > _volumetric_models
Definition: SolidModel.h:106
virtual Real volumeRatioOld(unsigned) const
Definition: Element.h:61

◆ checkElasticConstants()

void SolidModel::checkElasticConstants ( )
protectedvirtualinherited

Reimplemented in MacroElastic.

Definition at line 377 of file SolidModel.C.

Referenced by SolidModel::initialSetup().

378 {
379  int num_elastic_constants = _bulk_modulus_set + _lambda_set + _poissons_ratio_set +
381 
382  if (num_elastic_constants != 2)
383  {
384  std::string err("Exactly two elastic constants must be defined for material '");
385  err += name();
386  err += "'.";
387  mooseError(err);
388  }
389 
390  if (_bulk_modulus_set && _bulk_modulus <= 0)
391  {
392  std::string err("Bulk modulus must be positive in material '");
393  err += name();
394  err += "'.";
395  mooseError(err);
396  }
397  if (_poissons_ratio_set && (_poissons_ratio <= -1.0 || _poissons_ratio >= 0.5))
398  {
399  std::string err("Poissons ratio must be greater than -1 and less than 0.5 in material '");
400  err += name();
401  err += "'.";
402  mooseError(err);
403  }
405  {
406  std::string err("Shear modulus must not be negative in material '");
407  err += name();
408  err += "'.";
409  mooseError(err);
410  }
412  {
413  std::string err("Youngs modulus must be positive in material '");
414  err += name();
415  err += "'.";
416  mooseError(err);
417  }
418 
419  // Calculate lambda, the shear modulus, and Young's modulus
420  if (_lambda_set && _shear_modulus_set) // First and second Lame
421  {
425  }
426  else if (_lambda_set && _poissons_ratio_set)
427  {
428  _shear_modulus = (_lambda * (1.0 - 2.0 * _poissons_ratio)) / (2.0 * _poissons_ratio);
431  }
432  else if (_lambda_set && _bulk_modulus_set)
433  {
434  _shear_modulus = 3.0 * (_bulk_modulus - _lambda) / 2.0;
438  }
439  else if (_lambda_set && _youngs_modulus_set)
440  {
442  ((_youngs_modulus - 3.0 * _lambda) / 4.0) +
443  (std::sqrt((_youngs_modulus - 3.0 * _lambda) * (_youngs_modulus - 3.0 * _lambda) +
444  8.0 * _lambda * _youngs_modulus) /
445  4.0);
447  }
449  {
450  _lambda = (2.0 * _shear_modulus * _poissons_ratio) / (1.0 - 2.0 * _poissons_ratio);
453  }
455  {
456  _lambda = _bulk_modulus - 2.0 * _shear_modulus / 3.0;
460  (3 * _bulk_modulus - 2 * _shear_modulus) / (2 * (3 * _bulk_modulus + _shear_modulus));
461  }
463  {
467  }
469  {
472  (3.0 * _bulk_modulus * (1.0 - 2.0 * _poissons_ratio)) / (2.0 * (1.0 + _poissons_ratio));
475  }
476  else if (_youngs_modulus_set && _poissons_ratio_set) // Young's Modulus and Poisson's Ratio
477  {
479  ((1.0 + _poissons_ratio) * (1 - 2.0 * _poissons_ratio));
480  _shear_modulus = _youngs_modulus / (2.0 * (1.0 + _poissons_ratio));
481  }
483  {
484  _lambda = 3.0 * _bulk_modulus * (3.0 * _bulk_modulus - _youngs_modulus) /
485  (9.0 * _bulk_modulus - _youngs_modulus);
489  }
490 
491  _lambda_set = true;
492  _shear_modulus_set = true;
493  _youngs_modulus_set = true;
494  _poissons_ratio_set = true;
495 }
Real _poissons_ratio
Definition: SolidModel.h:73
Real _bulk_modulus
Definition: SolidModel.h:71
bool _youngs_modulus_set
Definition: SolidModel.h:69
bool _poissons_ratio_set
Definition: SolidModel.h:67
const std::string name
Definition: Setup.h:22
bool _shear_modulus_set
Definition: SolidModel.h:68
bool _bulk_modulus_set
Definition: SolidModel.h:65
Real _youngs_modulus
Definition: SolidModel.h:75
bool _lambda_set
Definition: SolidModel.h:66
Real _lambda
Definition: SolidModel.h:72
Real _shear_modulus
Definition: SolidModel.h:74

◆ computeConstitutiveModelStress()

void SolidModel::computeConstitutiveModelStress ( )
protectedvirtualinherited

Compute the stress (sigma += deltaSigma)

Definition at line 841 of file SolidModel.C.

Referenced by SolidModel::computeProperties().

842 {
843  // Given the stretching, compute the stress increment and add it to the old stress. Also update
844  // the creep strain
845  // stress = stressOld + stressIncrement
846 
847  const SubdomainID current_block = _current_elem->subdomain_id();
848  MooseSharedPointer<ConstitutiveModel> cm = _constitutive_model[current_block];
849 
850  mooseAssert(_constitutive_active, "Logic error. ConstitutiveModel not active.");
851 
852  // Let's be a little careful and check for a non-existent
853  // ConstitutiveModel, which could be returned as a default value
854  // from std::map::operator[]
855  if (!cm)
856  mooseError("Logic error. No ConstitutiveModel for current_block=", current_block, ".");
857 
858  cm->setQp(_qp);
859  cm->computeStress(
860  *_current_elem, *elasticityTensor(), _stress_old, _strain_increment, _stress[_qp]);
861 }
bool _constitutive_active
Definition: SolidModel.h:254
SymmElasticityTensor * elasticityTensor() const
Definition: SolidModel.h:225
std::map< SubdomainID, MooseSharedPointer< ConstitutiveModel > > _constitutive_model
Definition: SolidModel.h:251
SymmTensor _strain_increment
In most models, this is the mechanical strain increment, but for inelastic models, it has the inelastic component subtracted from it, so it is the elastic strain increment.
Definition: SolidModel.h:152
SymmTensor _stress_old
Definition: SolidModel.h:115
MaterialProperty< SymmTensor > & _stress
Definition: SolidModel.h:109

◆ computeCrackFactor()

Real SolidModel::computeCrackFactor ( int  i,
Real &  sigma,
Real &  flagVal 
)
protectedvirtualinherited

Definition at line 1408 of file SolidModel.C.

Referenced by SolidModel::crackingStressRotation().

1409 {
1411  {
1412  if ((*_crack_max_strain)[_qp](i) < (*_crack_strain)[_qp](i))
1413  {
1414  std::stringstream err;
1415  err << "Max strain less than crack strain: " << i << " " << sigma << ", "
1416  << (*_crack_max_strain)[_qp](i) << ", " << (*_crack_strain)[_qp](i) << ", "
1417  << _principal_strain(0, 0) << ", " << _principal_strain(1, 0) << ", "
1418  << _principal_strain(2, 0) << _elastic_strain[_qp] << std::endl;
1419  mooseError(err.str());
1420  }
1421  const Real crackMaxStrain((*_crack_max_strain)[_qp](i));
1422  // Compute stress that follows exponental curve
1426  (crackMaxStrain - (*_crack_strain)[_qp](i))));
1427  // Compute ratio of current stiffness to original stiffness
1428  flagVal = sigma * (*_crack_strain)[_qp](i) / (crackMaxStrain * _cracking_stress);
1429  }
1430  else
1431  {
1432  if (_cracking_residual_stress == 0)
1433  {
1434  const Real tiny(1e-16);
1435  flagVal = tiny;
1436  sigma = tiny * (*_crack_strain)[_qp](i) * _youngs_modulus;
1437  }
1438  else
1439  {
1441  flagVal = sigma / ((*_crack_max_strain)[_qp](i) * _youngs_modulus);
1442  }
1443  }
1444  if (flagVal < 0)
1445  {
1446  std::stringstream err;
1447  err << "Negative crack flag found: " << i << " " << flagVal << ", "
1448  << (*_crack_max_strain)[_qp](i) << ", " << (*_crack_strain)[_qp](i) << ", " << std::endl;
1449  mooseError(err.str());
1450  }
1451  return flagVal;
1452 }
const Real _cracking_residual_stress
Definition: SolidModel.h:82
Real _cracking_stress
Definition: SolidModel.h:81
const CRACKING_RELEASE _cracking_release
Definition: SolidModel.h:80
Real _cracking_alpha
Definition: SolidModel.h:87
Real _youngs_modulus
Definition: SolidModel.h:75
MaterialProperty< SymmTensor > & _elastic_strain
Definition: SolidModel.h:120
ColumnMajorMatrix _principal_strain
Definition: SolidModel.h:134
MaterialProperty< RealVectorValue > * _crack_max_strain
Definition: SolidModel.h:132
MaterialProperty< RealVectorValue > * _crack_strain
Definition: SolidModel.h:130
const Real _cracking_beta
Definition: SolidModel.h:83

◆ computeCurrentInstantaneousThermalExpansionCoefficient()

void SolidModel::computeCurrentInstantaneousThermalExpansionCoefficient ( )
protectedvirtualinherited

Definition at line 1644 of file SolidModel.C.

Referenced by SolidModel::computeProperties(), and SolidModel::computeThermalJvec().

1645 {
1647  "_current_instantaneous_thermal_expansion_coef not initialized");
1648 
1649  (*_current_instantaneous_thermal_expansion_coef)[_qp] = 0.0;
1650 
1651  if (_alpha_function)
1652  {
1653  Point p;
1654  Real current_temp = _temperature[_qp];
1655 
1656  if (!_mean_alpha_function)
1657  {
1658  Real alpha = _alpha_function->value(current_temp, p);
1659  (*_current_instantaneous_thermal_expansion_coef)[_qp] = alpha;
1660  }
1661  else
1662  {
1663  Real small(1e-6);
1664  Real dalphabar_dT = _alpha_function->timeDerivative(current_temp, p);
1665  Real alphabar_Tsf = _alpha_function->value(_stress_free_temp, p);
1666  Real alphabar = _alpha_function->value(current_temp, p);
1667  Real numerator = dalphabar_dT * (current_temp - _ref_temp) + alphabar;
1668  Real denominator = 1.0 + alphabar_Tsf * (_stress_free_temp - _ref_temp);
1669  if (denominator < small)
1670  mooseError("Denominator too small in thermal strain calculation");
1671  (*_current_instantaneous_thermal_expansion_coef)[_qp] = numerator / denominator;
1672  }
1673  }
1674  else
1676 }
const Real _alpha
Definition: SolidModel.h:98
Real _stress_free_temp
Definition: SolidModel.h:102
bool _mean_alpha_function
Definition: SolidModel.h:103
const VariableValue & _temperature
Definition: SolidModel.h:95
MaterialProperty< Real > * _current_instantaneous_thermal_expansion_coef
Definition: SolidModel.h:164
Function * _alpha_function
Definition: SolidModel.h:99
Real _ref_temp
Definition: SolidModel.h:104

◆ computeElasticityTensor()

void SolidModel::computeElasticityTensor ( )
protectedinherited

Definition at line 865 of file SolidModel.C.

Referenced by SolidModel::computeProperties().

866 {
867  if (_cracking_stress_function != NULL)
868  {
869  _cracking_stress = _cracking_stress_function->value(_t, _q_point[_qp]);
870  }
871 
873 
875 
877 
879 
881 
882  if (changed || _cracking_stress > 0)
883  {
885  }
886 }
Real _cracking_stress
Definition: SolidModel.h:81
SymmElasticityTensor * _local_elasticity_tensor
Definition: SolidModel.h:273
virtual bool updateElasticityTensor(SymmElasticityTensor &tensor)
Return true if the elasticity tensor changed.
Definition: SolidModel.C:891
Function *const _cracking_stress_function
Definition: SolidModel.h:85
const MaterialProperty< SymmTensor > & _stress_old_prop
Definition: SolidModel.h:112
MaterialProperty< SymmElasticityTensor > & _elasticity_tensor
Definition: SolidModel.h:136
void calculate(unsigned int qp)
Public function that will be called whenever the values for this matrix need to be filled in...
SymmTensor _stress_old
Definition: SolidModel.h:115
const MaterialProperty< SymmTensor > & _elastic_strain_old
Definition: SolidModel.h:121
virtual void crackingStrainDirections()
Determine cracking directions. Rotate elasticity tensor.
Definition: SolidModel.C:1048

◆ computeEshelby()

void SolidModel::computeEshelby ( )
protectedvirtualinherited

Definition at line 792 of file SolidModel.C.

Referenced by SolidModel::computeProperties().

793 {
794  mooseAssert(_SED, "_SED not initialized");
795  mooseAssert(_Eshelby_tensor, "_Eshelby_tensor not initialized");
796  // Cauchy stress (sigma) in a colum major matrix:
797  ColumnMajorMatrix stress_CMM;
798  stress_CMM(0, 0) = _stress[_qp].xx();
799  stress_CMM(0, 1) = _stress[_qp].xy();
800  stress_CMM(0, 2) = _stress[_qp].xz();
801  stress_CMM(1, 0) = _stress[_qp].xy();
802  stress_CMM(1, 1) = _stress[_qp].yy();
803  stress_CMM(1, 2) = _stress[_qp].yz();
804  stress_CMM(2, 0) = _stress[_qp].xz();
805  stress_CMM(2, 1) = _stress[_qp].yz();
806  stress_CMM(2, 2) = _stress[_qp].zz();
807 
808  // Deformation gradient (F):
809  ColumnMajorMatrix F;
811  // Displacement gradient (H):
812  ColumnMajorMatrix H(F);
813  H.addDiag(-1.0);
814  Real detF = _element->detMatrix(F);
815  ColumnMajorMatrix Finv;
816  _element->invertMatrix(F, Finv);
817  ColumnMajorMatrix FinvT;
818  FinvT = Finv.transpose();
819  ColumnMajorMatrix HT;
820  HT = H.transpose();
821 
822  // 1st Piola-Kirchoff Stress (P):
823  ColumnMajorMatrix piola;
824  piola = stress_CMM * FinvT;
825  piola *= detF;
826 
827  // HTP = H^T * P = H^T * detF * sigma * FinvT;
828  ColumnMajorMatrix HTP;
829  HTP = HT * piola;
830 
831  ColumnMajorMatrix WI;
832  WI.identity();
833  WI *= (*_SED)[_qp];
834  WI *= detF;
835  (*_Eshelby_tensor)[_qp] = WI - HTP;
836 }
MaterialProperty< Real > * _SED
Definition: SolidModel.h:158
virtual void computeDeformationGradient(unsigned int, ColumnMajorMatrix &)
Definition: Element.h:51
static Real detMatrix(const ColumnMajorMatrix &A)
Definition: Element.C:31
SolidMechanics::Element * _element
Definition: SolidModel.h:271
MaterialProperty< SymmTensor > & _stress
Definition: SolidModel.h:109
static void invertMatrix(const ColumnMajorMatrix &A, ColumnMajorMatrix &Ainv)
Definition: Element.C:52
MaterialProperty< RankTwoTensor > * _Eshelby_tensor
Definition: SolidModel.h:160

◆ computePreconditioning()

void SolidModel::computePreconditioning ( )
protectedvirtualinherited

Definition at line 944 of file SolidModel.C.

Referenced by SolidModel::computeProperties().

945 {
946  mooseAssert(_local_elasticity_tensor, "null elasticity tensor");
947 
948  // _Jacobian_mult[_qp] = *_local_elasticity_tensor;
949  // _d_stress_dT[_qp] = *_local_elasticity_tensor * _d_strain_dT;
952 }
SymmElasticityTensor * _local_elasticity_tensor
Definition: SolidModel.h:273
MaterialProperty< SymmElasticityTensor > & _Jacobian_mult
Definition: SolidModel.h:137
MaterialProperty< SymmTensor > & _d_stress_dT
Definition: SolidModel.h:143
MaterialProperty< SymmElasticityTensor > & _elasticity_tensor
Definition: SolidModel.h:136
SymmTensor _d_strain_dT
Definition: SolidModel.h:140

◆ computeProperties()

void SolidModel::computeProperties ( )
protectedvirtualinherited

Definition at line 729 of file SolidModel.C.

730 {
731  if (_t_step >= 1)
732  _step_zero = false;
733 
734  if (_t_step >= 2)
735  _step_one = false;
736 
737  elementInit();
738  _element->init();
739 
740  for (_qp = 0; _qp < _qrule->n_points(); ++_qp)
741  {
744 
747 
749 
751  computeStress();
752  else
754 
755  if (_compute_JIntegral)
757 
759 
761 
762  finalizeStress();
763 
764  if (_compute_JIntegral)
765  computeEshelby();
766 
769 
772 
774  }
775 }
const bool _compute_JIntegral
Definition: SolidModel.h:154
bool _constitutive_active
Definition: SolidModel.h:254
SymmTensor _total_strain_increment
Total strain increment, including mechanical strains and eigenstrains.
Definition: SolidModel.h:146
virtual void modifyStrainIncrement()
Modify increment for things like thermal strain.
Definition: SolidModel.C:560
const bool _compute_InteractionIntegral
Definition: SolidModel.h:155
virtual void computeStrain(const unsigned qp, const SymmTensor &total_strain_old, SymmTensor &total_strain_new, SymmTensor &strain_increment)=0
virtual void computeEshelby()
Definition: SolidModel.C:792
SymmTensor _mechanical_strain_increment
Mechanical strain increment, which is the total strain increment minus eigenstrains.
Definition: SolidModel.h:148
virtual void computePreconditioning()
Definition: SolidModel.C:944
MaterialProperty< SymmTensor > & _total_strain
Definition: SolidModel.h:117
const MaterialProperty< SymmTensor > & _total_strain_old
Definition: SolidModel.h:118
virtual void crackingStressRotation()
Definition: SolidModel.C:1237
virtual void computeCurrentInstantaneousThermalExpansionCoefficient()
Definition: SolidModel.C:1644
virtual void elementInit()
Definition: SolidModel.h:180
bool & _step_zero
Restartable data to check for the zeroth and first time steps for thermal calculations.
Definition: SolidModel.h:262
bool & _step_one
Definition: SolidModel.h:263
const bool _has_temp
Definition: SolidModel.h:94
MaterialProperty< SymmTensor > & _elastic_strain
Definition: SolidModel.h:120
virtual void computeConstitutiveModelStress()
Compute the stress (sigma += deltaSigma)
Definition: SolidModel.C:841
SymmTensor _strain_increment
In most models, this is the mechanical strain increment, but for inelastic models, it has the inelastic component subtracted from it, so it is the elastic strain increment.
Definition: SolidModel.h:152
const MaterialProperty< SymmTensor > & _elastic_strain_old
Definition: SolidModel.h:121
SolidMechanics::Element * _element
Definition: SolidModel.h:271
virtual void computeStrainEnergyDensity()
Definition: SolidModel.C:780
virtual void finalizeStress()
Rotate stress to current configuration.
Definition: SolidModel.C:932
virtual void computeThermalJvec()
Definition: SolidModel.C:1628
virtual void init()
Definition: Element.h:49
virtual void computeStress()
Compute the stress (sigma += deltaSigma)
Definition: SolidModel.h:191
void computeElasticityTensor()
Definition: SolidModel.C:865

◆ computeStrainEnergyDensity()

void SolidModel::computeStrainEnergyDensity ( )
protectedvirtualinherited

Definition at line 780 of file SolidModel.C.

Referenced by SolidModel::computeProperties().

781 {
782  mooseAssert(_SED, "_SED not initialized");
783  mooseAssert(_SED_old, "_SED_old not initialized");
784  (*_SED)[_qp] = (*_SED_old)[_qp] +
785  _stress[_qp].doubleContraction(_mechanical_strain_increment) / 2 +
786  _stress_old_prop[_qp].doubleContraction(_mechanical_strain_increment) / 2;
787 }
const MaterialProperty< Real > * _SED_old
Definition: SolidModel.h:159
MaterialProperty< Real > * _SED
Definition: SolidModel.h:158
SymmTensor _mechanical_strain_increment
Mechanical strain increment, which is the total strain increment minus eigenstrains.
Definition: SolidModel.h:148
const MaterialProperty< SymmTensor > & _stress_old_prop
Definition: SolidModel.h:112
MaterialProperty< SymmTensor > & _stress
Definition: SolidModel.h:109

◆ computeStress()

void AbaqusCreepMaterial::computeStress ( )
protectedvirtual

Compute the stress (sigma += deltaSigma)

Reimplemented from SolidModel.

Definition at line 151 of file AbaqusCreepMaterial.C.

152 {
153  // Recover "old" state variables
154  for (unsigned int i = 0; i < _num_state_vars; i++)
155  _STATEV[i] = _state_var_old[_qp][i];
156 
157  // Initialize DECRA and DESWA arrays
158  for (unsigned int i = 0; i < 5; i++)
159  {
160  _DECRA[i] = 0.0;
161  _DESWA[i] = 0.0;
162  }
163 
164  // Calculate stress array components
168 
172 
176 
180 
181  // Calculate trial stress and deviatoric trial stress
182  SymmTensor trial_stress(_stress_component[0],
187  _stress_component[5]);
188  _trial_stress[_qp] = trial_stress;
189  _trial_stress[_qp] += _stress_old[_qp];
190  _dev_trial_stress[_qp] = _trial_stress[_qp];
191  _dev_trial_stress[_qp].addDiag(-_trial_stress[_qp].trace() / 3.0);
192 
193  // Calculate effective trial stress (_ets)
194  Real dts_squared = _dev_trial_stress[_qp].doubleContraction(_dev_trial_stress[_qp]);
195 
196  if (dts_squared >= 0.)
197  _ets[_qp] = std::sqrt(1.5 * dts_squared);
198  else
199  mooseError("Attempted to take square root of a negative number!\n");
200 
201  // Calculate gradient of dev stress potential (grad_dts)
202  // grad_dts = d(qtild)/d(dev_trial_stress)
203  SymmTensor delta_dts = _dev_trial_stress[_qp] - _dev_trial_stress_old[_qp];
204 
205  Real delta_ets = _ets[_qp] - _ets_old[_qp];
206 
207  Real grad_dts_potential[6];
208  for (unsigned int i = 0; i < 6; i++)
209  {
210  if (delta_dts.component(i) == 0.0)
211  grad_dts_potential[i] = 0.0;
212  else
213  grad_dts_potential[i] = delta_ets / delta_dts.component(i);
214  }
215 
216  SymmTensor grad_dts(grad_dts_potential[0],
217  grad_dts_potential[1],
218  grad_dts_potential[2],
219  grad_dts_potential[3],
220  grad_dts_potential[4],
221  grad_dts_potential[5]);
222 
223  // Pass variables in for information
224  _KSTEP = _t_step; // Step number
225  _TIME[0] = _dt; // Value of step time at the end of the increment - Check
226  _TIME[1] = _t; // Value of total time at the end of the increment - Check
227  _DTIME = _dt; // Time increment
228  _EC[0] = _total_creep_old[_qp]; // Metal and Drucker-Prager creep at the start of the increment
229  _EC[1] = _total_creep[_qp]; // Metal and Drucker-Prager creep at the end of the increment
230  _ESW[0] = _total_swell_old[_qp]; // Metal swell at the start of the increment
231  _ESW[1] = _total_swell[_qp]; // Metal swell at the end of the increment
232  _QTILD = _ets[_qp]; // Von mises equivalent stress
233  _P = -_trial_stress[_qp].trace(); // Equivalent pressure stress
234 
235  // Connection to extern statement
236  _creep(_DECRA,
237  _DESWA,
238  _STATEV,
239  &_SERD,
240  _EC,
241  _ESW,
242  &_P,
243  &_QTILD,
244  &_TEMP,
245  &_DTEMP,
246  _PREDEF,
247  _DPRED,
248  _TIME,
249  &_DTIME,
250  &_CMNAME,
251  &_LEXIMP,
252  &_LEND,
253  _COORDS,
254  &_NSTATV,
255  &_NOEL,
256  &_NPT,
257  &_LAYER,
258  &_KSPT,
259  &_KSTEP,
260  &_KINC);
261 
262  // Update state variables
263  for (unsigned int i = 0; i < _num_state_vars; i++)
264  _state_var[_qp][i] = _STATEV[i];
265 
266  // Solve for Incremental creep (creep_inc_used) and/or Incremental Swell (swell_inc_used) based on
267  // definition
268  // NOTE: Below are equations for metal creep and/or time-dependent volumetric swelling materials
269  // only
270  // Drucker-Prager, Capped Drucker-Prager, and Gasket materials have not been included
271  _creep_inc[_qp] = _DECRA[0];
272  _total_creep[_qp] = _creep_inc[_qp];
273  _total_creep[_qp] += _total_creep_old[_qp];
274 
275  _swell_inc[_qp] = _DESWA[0];
276  _total_swell[_qp] = _swell_inc[_qp];
277  _total_swell[_qp] += _total_swell_old[_qp];
278 
279  Real p = -_trial_stress[_qp].trace();
280  Real pold = -_trial_stress_old[_qp].trace();
281 
282  Real creep_inc_used = 0.0;
283  Real swell_inc_used = 0.0;
284 
285  if (_integration_flag == 0 && _solve_definition == 1)
286  {
287  creep_inc_used = _DECRA[0];
288  swell_inc_used = _DESWA[0];
289  }
290  else if (_integration_flag == 1 && _solve_definition == 2)
291  {
292  creep_inc_used =
293  (_DECRA[1] * (_total_creep[_qp] - _total_creep_old[_qp])) + _creep_inc_old[_qp];
294  swell_inc_used =
295  (_DESWA[1] * (_total_creep[_qp] - _total_creep_old[_qp])) + _swell_inc_old[_qp];
296  }
297  else if (_integration_flag == 1 && _solve_definition == 3)
298  {
299  creep_inc_used =
300  (_DECRA[2] * (_total_swell[_qp] - _total_swell_old[_qp])) + _creep_inc_old[_qp];
301  swell_inc_used =
302  (_DESWA[2] * (_total_swell[_qp] - _total_swell_old[_qp])) + _swell_inc_old[_qp];
303  }
304  else if (_integration_flag == 1 && _solve_definition == 4)
305  {
306  creep_inc_used = (_DECRA[3] * (p - pold)) + _creep_inc_old[_qp];
307  swell_inc_used = (_DESWA[3] * (p - pold)) + _swell_inc_old[_qp];
308  }
309  else if (_integration_flag == 1 && _solve_definition == 5)
310  {
311  creep_inc_used = (_DECRA[4] * (_ets[_qp] - _ets_old[_qp])) + _creep_inc_old[_qp];
312  swell_inc_used = (_DESWA[4] * (_ets[_qp] - _ets_old[_qp])) + _swell_inc_old[_qp];
313  }
314 
315  // Calculate Incremental Creep Strain (total_effects)
316  // Incremental creep strain = ((1/3)*(swell_inc_used)*R) + (creep_inc_used*grad_dts)
317  // R = The matrix with the anisotropic swelling ratios in the diagonal if anisotropic swelling is
318  // defined; Otherwise R = Identity
319  SymmTensor R(1., 1., 1., 0., 0., 0.);
320  SymmTensor total_effects = (R * (swell_inc_used / 3.)) + (grad_dts * (creep_inc_used));
321 
322  // Modify strain increment
323  _strain_increment += total_effects;
324 
328 
332 
336 
340 
341  // Update Stress
342  SymmTensor stressnew(_stress_component[0],
347  _stress_component[5]);
348  _stress[_qp] = stressnew;
349  _stress[_qp] += _stress_old[_qp];
350 }
MaterialProperty< SymmTensor > & _trial_stress
MaterialProperty< Real > & _ets
MaterialProperty< std::vector< Real > > & _state_var
MaterialProperty< SymmTensor > & _stress
const MaterialProperty< SymmTensor > & _stress_old
const MaterialProperty< Real > & _creep_inc_old
MaterialProperty< Real > & _swell_inc
const MaterialProperty< Real > & _total_swell_old
const MaterialProperty< Real > & _ets_old
MaterialProperty< Real > & _total_creep
const MaterialProperty< Real > & _swell_inc_old
const MaterialProperty< SymmTensor > & _trial_stress_old
MaterialProperty< Real > & _total_swell
MaterialProperty< Real > & _creep_inc
Real component(unsigned int i) const
Definition: SymmTensor.h:100
unsigned int _num_state_vars
SymmTensor _strain_increment
In most models, this is the mechanical strain increment, but for inelastic models, it has the inelastic component subtracted from it, so it is the elastic strain increment.
Definition: SolidModel.h:152
const MaterialProperty< std::vector< Real > > & _state_var_old
const MaterialProperty< SymmTensor > & _dev_trial_stress_old
unsigned int _integration_flag
unsigned int _solve_definition
const MaterialProperty< Real > & _total_creep_old
MaterialProperty< SymmTensor > & _dev_trial_stress

◆ computeThermalJvec()

void SolidModel::computeThermalJvec ( )
protectedvirtualinherited

Definition at line 1628 of file SolidModel.C.

Referenced by SolidModel::computeProperties().

1629 {
1630  mooseAssert(_J_thermal_term_vec, "_J_thermal_term_vec not initialized");
1631 
1632  Real stress_trace = _stress[_qp].xx() + _stress[_qp].yy() + _stress[_qp].zz();
1633 
1635  for (unsigned int i = 0; i < LIBMESH_DIM; ++i)
1636  {
1637  Real dthermstrain_dx =
1639  (*_J_thermal_term_vec)[_qp](i) = stress_trace * dthermstrain_dx;
1640  }
1641 }
virtual void computeCurrentInstantaneousThermalExpansionCoefficient()
Definition: SolidModel.C:1644
const VariableGradient & _temp_grad
Definition: SolidModel.h:97
MaterialProperty< RealVectorValue > * _J_thermal_term_vec
Definition: SolidModel.h:161
MaterialProperty< SymmTensor > & _stress
Definition: SolidModel.h:109
MaterialProperty< Real > * _current_instantaneous_thermal_expansion_coef
Definition: SolidModel.h:164

◆ crackingStrainDirections()

void SolidModel::crackingStrainDirections ( )
protectedvirtualinherited

Determine cracking directions. Rotate elasticity tensor.

Definition at line 1048 of file SolidModel.C.

Referenced by SolidModel::computeElasticityTensor().

1049 {
1050  bool cracking_locally_active(false);
1051  if (_cracking_stress > 0)
1052  {
1053  // Compute whether cracking has occurred
1054  (*_crack_rotation)[_qp] = (*_crack_rotation_old)[_qp];
1055 
1056  ColumnMajorMatrix RT((*_crack_rotation)[_qp].transpose());
1057  SymmTensor ePrime;
1058  rotateSymmetricTensor(RT, _elastic_strain[_qp], ePrime);
1059 
1060  for (unsigned int i(0); i < 3; ++i)
1061  {
1062  (*_crack_max_strain)[_qp](i) = (*_crack_max_strain_old)[_qp](i);
1063 
1064  if (_cracking_neg_fraction == 0 && ePrime(i, i) < 0)
1065  {
1066  _crack_flags_local(i) = 1;
1067  }
1068  else if (_cracking_neg_fraction > 0 &&
1069  (*_crack_strain)[_qp](i) * _cracking_neg_fraction > ePrime(i, i))
1070  {
1071  if (-(*_crack_strain)[_qp](i) * _cracking_neg_fraction > ePrime(i, i))
1072  {
1073  _crack_flags_local(i) = 1;
1074  }
1075  else
1076  {
1077  // s = a*e^2 + b*e + c
1078  // a = (Ec-Eo)/(4etr)
1079  // b = (Ec+Eo)/2
1080  // c = (Ec-Eo)*etr/4
1081  // etr = _cracking_neg_fraction * strain when crack occurred
1082  const Real etr = _cracking_neg_fraction * (*_crack_strain)[_qp](i);
1083  const Real Eo = _cracking_stress / (*_crack_strain)[_qp](i);
1084  const Real Ec = Eo * (*_crack_flags_old)[_qp](i);
1085  const Real a = (Ec - Eo) / (4 * etr);
1086  const Real b = (Ec + Eo) / 2;
1087  // Compute the ratio of the current transition stiffness to the original stiffness
1088  _crack_flags_local(i) = (2 * a * etr + b) / Eo;
1089  cracking_locally_active = true;
1090  }
1091  }
1092  else
1093  {
1094  _crack_flags_local(i) = (*_crack_flags_old)[_qp](i);
1095  if (_crack_flags_local(i) < 1)
1096  {
1097  cracking_locally_active = true;
1098  }
1099  }
1100  }
1101  }
1102  if (cracking_locally_active)
1103  {
1104  // Adjust the elasticity matrix for cracking. This must be used by the
1105  // constitutive law.
1106  if (_compute_method == "ShearRetention")
1108  else
1110 
1111  ColumnMajorMatrix R_9x9(9, 9);
1112  const ColumnMajorMatrix & R((*_crack_rotation)[_qp]);
1115 
1117  }
1118 }
MaterialProperty< ColumnMajorMatrix > * _crack_rotation
Definition: SolidModel.h:128
Real _cracking_stress
Definition: SolidModel.h:81
SymmElasticityTensor * _local_elasticity_tensor
Definition: SolidModel.h:273
void form9x9Rotation(const ColumnMajorMatrix &R_3x3, ColumnMajorMatrix &R_9x9) const
virtual void adjustForCrackingWithShearRetention(const RealVectorValue &crack_flags)
virtual void adjustForCracking(const RealVectorValue &crack_flags)
MaterialProperty< SymmElasticityTensor > & _elasticity_tensor
Definition: SolidModel.h:136
const std::string _compute_method
Definition: SolidModel.h:84
const Real _cracking_neg_fraction
Definition: SolidModel.h:90
MaterialProperty< SymmTensor > & _elastic_strain
Definition: SolidModel.h:120
void rotateFromLocalToGlobal(const ColumnMajorMatrix &R)
const MaterialProperty< RealVectorValue > * _crack_max_strain_old
Definition: SolidModel.h:133
MaterialProperty< RealVectorValue > * _crack_strain
Definition: SolidModel.h:130
RealVectorValue _crack_flags_local
Definition: SolidModel.h:125
static void rotateSymmetricTensor(const ColumnMajorMatrix &R, const SymmTensor &T, SymmTensor &result)
Definition: SolidModel.C:663

◆ crackingStressRotation()

void SolidModel::crackingStressRotation ( )
protectedvirtualinherited

Definition at line 1237 of file SolidModel.C.

Referenced by SolidModel::computeProperties().

1238 {
1239  if (_cracking_stress_function != NULL)
1240  {
1241  _cracking_stress = _cracking_stress_function->value(_t, _q_point[_qp]);
1242  }
1243 
1244  if (_cracking_stress > 0)
1245  {
1246 
1248 
1249  for (unsigned i(0); i < 3; ++i)
1250  {
1251  if (_principal_strain(i, 0) > (*_crack_max_strain_old)[_qp](i))
1252  {
1253  (*_crack_max_strain)[_qp](i) = _principal_strain(i, 0);
1254  }
1255  }
1256 
1257  // Check for new cracks.
1258  // This must be done in the crack-local coordinate frame.
1259 
1260  // Rotate stress to cracked orientation.
1261  ColumnMajorMatrix R((*_crack_rotation)[_qp]);
1262  ColumnMajorMatrix RT((*_crack_rotation)[_qp].transpose());
1263  SymmTensor sigmaPrime;
1264  rotateSymmetricTensor(RT, _stress[_qp], sigmaPrime);
1265 
1266  unsigned int num_cracks(0);
1267  for (unsigned i(0); i < 3; ++i)
1268  {
1269  _crack_flags_local(i) = 1;
1270  (*_crack_strain)[_qp](i) = (*_crack_strain_old)[_qp](i);
1271  if ((*_crack_flags_old)[_qp](i) < 1)
1272  {
1273  ++num_cracks;
1274  }
1275  }
1276 
1277  bool new_crack(false);
1278  bool cracked(false);
1279  RealVectorValue sigma;
1280  for (unsigned i(0); i < 3; ++i)
1281  {
1282  sigma(i) = sigmaPrime(i, i);
1283  (*_crack_flags)[_qp](i) = (*_crack_flags_old)[_qp](i);
1284  if (sigma(i) <= 1e-4)
1285  {
1286  if ((*_crack_flags)[_qp](i) == 1)
1287  {
1288  (*_crack_max_strain)[_qp](i) = _principal_strain(i, 0);
1289  }
1290  }
1291 
1292  // _cracked_this_step[_q_point[_qp]] = 0;
1293  Real crackFactor(1);
1294  if (_cracking_release == CR_POWER)
1295  {
1296  (*_crack_count)[_qp](i) = (*_crack_count_old)[_qp](i);
1297  }
1298  if ((_cracking_release == CR_POWER && sigma(i) > _cracking_stress &&
1299  _active_crack_planes[i] == 1
1300  // && (*_crack_count)[_qp](i) == 0
1301  )
1302  // || _cracked_this_step_count[_q_point[_qp]] > 5
1303  )
1304  {
1305  cracked = true;
1306  ++((*_crack_count)[_qp](i));
1307  // _cracked_this_step[_q_point[_qp]] = 1;
1308  // Assume Poisson's ratio drops to zero for this direction. Stiffness is then Young's
1309  // modulus.
1310  const Real stiff = _youngs_modulus_function
1311  ? _youngs_modulus_function->value(_temperature[_qp], Point())
1312  : _youngs_modulus;
1313 
1314  if ((*_crack_count_old)[_qp](i) == 0)
1315  {
1316  new_crack = true;
1317  ++num_cracks;
1318 
1319  (*_crack_strain)[_qp](i) = _cracking_stress / stiff;
1320  }
1321  // Compute stress, factor....
1322  (*_crack_flags)[_qp](i) *= 1. / 3.;
1323 
1324  if ((*_crack_max_strain)[_qp](i) < (*_crack_strain)[_qp](i))
1325  {
1326  (*_crack_max_strain)[_qp](i) = (*_crack_strain)[_qp](i);
1327  }
1328  sigma(i) = (*_crack_flags)[_qp](i) * stiff * _principal_strain(i, 0);
1329  }
1330  else if ((_cracking_release != CR_POWER && (*_crack_flags_old)[_qp](i) == 1 &&
1331  sigma(i) > _cracking_stress && num_cracks < _max_cracks &&
1332  _active_crack_planes[i] == 1)
1333  // || _cracked_this_step_count[_q_point[_qp]] > 5
1334  )
1335  {
1336  // A new crack
1337  // _cracked_this_step[_q_point[_qp]] = 1;
1338 
1339  cracked = true;
1340  new_crack = true;
1341  ++num_cracks;
1342 
1343  // Assume Poisson's ratio drops to zero for this direction. Stiffness is then Young's
1344  // modulus.
1345  const Real stiff = _youngs_modulus_function
1346  ? _youngs_modulus_function->value(_temperature[_qp], Point())
1347  : _youngs_modulus;
1348 
1349  (*_crack_strain)[_qp](i) = _cracking_stress / stiff;
1350  if ((*_crack_max_strain)[_qp](i) < (*_crack_strain)[_qp](i))
1351  {
1352  (*_crack_max_strain)[_qp](i) = (*_crack_strain)[_qp](i);
1353  }
1354 
1355  crackFactor = computeCrackFactor(i, sigma(i), (*_crack_flags)[_qp](i));
1356 
1357  (*_crack_flags)[_qp](i) = crackFactor;
1358  _crack_flags_local(i) = crackFactor;
1359 
1360  // May want to set the old value. This may help with the nonlinear solve
1361  // since the stress cannot bounce between just below the critical stress and
1362  // effectively zero. However, this may set allow cracking prematurely.
1363  // (*_crack_flags_old)[_qp](i) = crackFactor;
1364  // (*_crack_strain_old)[_qp](i) = _principal_strain(i,0);
1365  }
1366  else if (_cracking_release != CR_POWER && (*_crack_flags_old)[_qp](i) < 1 &&
1367  std::abs(_principal_strain(i, 0) - (*_crack_max_strain)[_qp](i)) < 1e-10)
1368  {
1369  // Previously cracked,
1370  // Crack opening
1371  cracked = true;
1372  crackFactor = computeCrackFactor(i, sigma(i), (*_crack_flags)[_qp](i));
1373  (*_crack_flags)[_qp](i) = crackFactor;
1374  _crack_flags_local(i) = crackFactor;
1375  }
1376  else if (_cracking_neg_fraction > 0 &&
1379  {
1380  // s = a*e^2 + b*e + c
1381  // a = (Ec-Eo)/(4etr)
1382  // b = (Ec+Eo)/2
1383  // c = (Ec-Eo)*etr/4
1384  // etr = _cracking_neg_fraction * strain when crack occurred
1385  cracked = true;
1386  const Real etr = _cracking_neg_fraction * (*_crack_strain)[_qp](i);
1387  const Real Eo = _cracking_stress / (*_crack_strain)[_qp](i);
1388  const Real Ec = Eo * (*_crack_flags_old)[_qp](i);
1389  const Real a = (Ec - Eo) / (4 * etr);
1390  const Real b = (Ec + Eo) / 2;
1391  const Real c = (Ec - Eo) * etr / 4;
1392  sigma(i) = (a * _principal_strain(i, 0) + b) * _principal_strain(i, 0) + c;
1393  }
1394  }
1395 
1396  if (!new_crack)
1397  {
1398  (*_crack_rotation)[_qp] = (*_crack_rotation_old)[_qp];
1399  }
1400  if (cracked)
1401  {
1402  applyCracksToTensor(_stress[_qp], sigma);
1403  }
1404  }
1405 }
MaterialProperty< ColumnMajorMatrix > * _crack_rotation
Definition: SolidModel.h:128
const MaterialProperty< RealVectorValue > * _crack_count_old
Definition: SolidModel.h:127
const unsigned int _max_cracks
Definition: SolidModel.h:89
Real _cracking_stress
Definition: SolidModel.h:81
void applyCracksToTensor(SymmTensor &tensor, const RealVectorValue &sigma)
Definition: SolidModel.C:1123
virtual Real computeCrackFactor(int i, Real &sigma, Real &flagVal)
Definition: SolidModel.C:1408
Function * _youngs_modulus_function
Definition: SolidModel.h:77
const CRACKING_RELEASE _cracking_release
Definition: SolidModel.h:80
Function *const _cracking_stress_function
Definition: SolidModel.h:85
const MaterialProperty< RealVectorValue > * _crack_flags_old
Definition: SolidModel.h:124
void computeCrackStrainAndOrientation(ColumnMajorMatrix &principal_strain)
Definition: SolidModel.C:1152
const Real _cracking_neg_fraction
Definition: SolidModel.h:90
Real _youngs_modulus
Definition: SolidModel.h:75
MaterialProperty< RealVectorValue > * _crack_flags
Definition: SolidModel.h:123
ColumnMajorMatrix _principal_strain
Definition: SolidModel.h:134
const MaterialProperty< RealVectorValue > * _crack_max_strain_old
Definition: SolidModel.h:133
const VariableValue & _temperature
Definition: SolidModel.h:95
MaterialProperty< RealVectorValue > * _crack_max_strain
Definition: SolidModel.h:132
const MaterialProperty< RealVectorValue > * _crack_strain_old
Definition: SolidModel.h:131
MaterialProperty< RealVectorValue > * _crack_strain
Definition: SolidModel.h:130
MaterialProperty< SymmTensor > & _stress
Definition: SolidModel.h:109
std::vector< unsigned int > _active_crack_planes
Definition: SolidModel.h:88
RealVectorValue _crack_flags_local
Definition: SolidModel.h:125
static void rotateSymmetricTensor(const ColumnMajorMatrix &R, const SymmTensor &T, SymmTensor &result)
Definition: SolidModel.C:663

◆ createConstitutiveModel()

void SolidModel::createConstitutiveModel ( const std::string &  cm_name)
protectedinherited

Definition at line 1591 of file SolidModel.C.

Referenced by CLSHPlasticMaterial::CLSHPlasticMaterial(), Elastic::Elastic(), LinearStrainHardening::LinearStrainHardening(), and PowerLawCreep::PowerLawCreep().

1592 {
1593 
1594  Factory & factory = _app.getFactory();
1595  InputParameters params = factory.getValidParams(cm_name);
1596 
1597  params.applyParameters(parameters());
1598  params.set<SubProblem *>("_subproblem") = &_subproblem;
1599  MooseSharedPointer<ConstitutiveModel> cm =
1600  factory.create<ConstitutiveModel>(cm_name, name() + "Model", params, _tid);
1601 
1602  _models_to_free.insert(
1603  cm); // Keep track of the dynamic memory that is created internally to this object
1604 
1605  _constitutive_active = true;
1606  for (unsigned i(0); i < _block_id.size(); ++i)
1607  {
1608  _constitutive_model[_block_id[i]] = cm;
1609  }
1610 }
bool _constitutive_active
Definition: SolidModel.h:254
std::vector< SubdomainID > _block_id
Definition: SolidModel.h:249
const std::string name
Definition: Setup.h:22
std::set< MooseSharedPointer< ConstitutiveModel > > _models_to_free
Definition: SolidModel.h:253
std::map< SubdomainID, MooseSharedPointer< ConstitutiveModel > > _constitutive_model
Definition: SolidModel.h:251

◆ createElasticityTensor()

void SolidModel::createElasticityTensor ( )
protectedvirtualinherited

Reimplemented in MacroElastic.

Definition at line 500 of file SolidModel.C.

Referenced by SolidModel::initialSetup().

501 {
502  bool constant(true);
503 
506  {
507  constant = false;
508  }
509 
511  mooseAssert(_youngs_modulus_set, "Internal error: Youngs modulus not set");
512  mooseAssert(_poissons_ratio_set, "Internal error: Poissons ratio not set");
515  iso->calculate(0);
516  elasticityTensor(iso);
517 }
Real _poissons_ratio
Definition: SolidModel.h:73
Real _cracking_stress
Definition: SolidModel.h:81
SymmElasticityTensor * elasticityTensor() const
Definition: SolidModel.h:225
bool _youngs_modulus_set
Definition: SolidModel.h:69
bool _poissons_ratio_set
Definition: SolidModel.h:67
Function * _youngs_modulus_function
Definition: SolidModel.h:77
Function *const _cracking_stress_function
Definition: SolidModel.h:85
Function * _poissons_ratio_function
Definition: SolidModel.h:78
void calculate(unsigned int qp)
Public function that will be called whenever the values for this matrix need to be filled in...
Real _youngs_modulus
Definition: SolidModel.h:75
void setYoungsModulus(const Real E)
Set the Young&#39;s Modulus.
Defines an Isotropic Elasticity Tensor.
void setPoissonsRatio(const Real nu)
Set Poissons Ratio.

◆ createProperty()

template<typename T >
MaterialProperty<T>& SolidModel::createProperty ( const std::string &  prop_name)
inlineprotectedinherited

Definition at line 232 of file SolidModel.h.

233  {
234  std::string name(prop_name + _appended_property_name);
235  return declareProperty<T>(name);
236  }
const std::string _appended_property_name
Definition: SolidModel.h:63
const std::string name
Definition: Setup.h:22

◆ delta()

int SolidModel::delta ( int  i,
int  j 
) const
inlineprotectedinherited

Definition at line 229 of file SolidModel.h.

229 { return i == j; }

◆ elasticityTensor() [1/2]

void SolidModel::elasticityTensor ( SymmElasticityTensor e)
protectedinherited

Definition at line 551 of file SolidModel.C.

552 {
555 }
SymmElasticityTensor * _local_elasticity_tensor
Definition: SolidModel.h:273

◆ elasticityTensor() [2/2]

SymmElasticityTensor* SolidModel::elasticityTensor ( ) const
inlineprotectedinherited

◆ element()

const SolidMechanics::Element* SolidModel::element ( ) const
inlineprotectedinherited

Definition at line 227 of file SolidModel.h.

Referenced by SolidModel::createElement().

227 { return _element; }
SolidMechanics::Element * _element
Definition: SolidModel.h:271

◆ elementInit()

virtual void SolidModel::elementInit ( )
inlineprotectedvirtualinherited

Definition at line 180 of file SolidModel.h.

Referenced by SolidModel::computeProperties().

180 {}

◆ finalizeStress()

void SolidModel::finalizeStress ( )
protectedvirtualinherited

Rotate stress to current configuration.

Definition at line 932 of file SolidModel.C.

Referenced by SolidModel::computeProperties().

933 {
934  std::vector<SymmTensor *> t(3);
935  t[0] = &_elastic_strain[_qp];
936  t[1] = &_total_strain[_qp];
937  t[2] = &_stress[_qp];
939 }
virtual void finalizeStress(std::vector< SymmTensor *> &)
Rotate stress to current configuration.
Definition: Element.h:64
MaterialProperty< SymmTensor > & _total_strain
Definition: SolidModel.h:117
MaterialProperty< SymmTensor > & _elastic_strain
Definition: SolidModel.h:120
SolidMechanics::Element * _element
Definition: SolidModel.h:271
MaterialProperty< SymmTensor > & _stress
Definition: SolidModel.h:109

◆ getNumKnownCrackDirs()

unsigned int SolidModel::getNumKnownCrackDirs ( ) const
protectedvirtualinherited

Definition at line 1455 of file SolidModel.C.

Referenced by SolidModel::computeCrackStrainAndOrientation().

1456 {
1457  const unsigned fromElement = _element->getNumKnownCrackDirs();
1458  unsigned int retVal(0);
1459  for (unsigned int i(0); i < 3 - fromElement; ++i)
1460  {
1461  retVal += ((*_crack_flags_old)[_qp](i) < 1);
1462  }
1463  return retVal + fromElement;
1464 }
virtual unsigned int getNumKnownCrackDirs() const
Definition: Element.h:66
SolidMechanics::Element * _element
Definition: SolidModel.h:271

◆ getPropertyOld()

template<typename T >
const MaterialProperty<T>& SolidModel::getPropertyOld ( const std::string &  prop_name)
inlineprotectedinherited

Definition at line 239 of file SolidModel.h.

240  {
241  std::string name(prop_name + _appended_property_name);
242  return getMaterialPropertyOld<T>(name);
243  }
const std::string _appended_property_name
Definition: SolidModel.h:63
const std::string name
Definition: Setup.h:22

◆ initialSetup()

void SolidModel::initialSetup ( )
protectedvirtualinherited

Definition at line 957 of file SolidModel.C.

958 {
959 
961 
963 
964  // Load in the volumetric models and constitutive models
965  bool set_constitutive_active = false;
966  for (unsigned i(0); i < _block_id.size(); ++i)
967  {
968 
969  // const std::vector<Material*> * mats_p;
970  std::vector<MooseSharedPointer<Material>> const * mats_p;
971  std::string suffix;
972  if (_bnd)
973  {
974  mats_p = &_fe_problem.getMaterialWarehouse()[Moose::FACE_MATERIAL_DATA].getActiveBlockObjects(
975  _block_id[i], _tid);
976  suffix = "_face";
977  }
978  else
979  mats_p = &_fe_problem.getMaterialWarehouse().getActiveBlockObjects(_block_id[i], _tid);
980 
981  const std::vector<MooseSharedPointer<Material>> & mats = *mats_p;
982 
983  for (unsigned int j = 0; j < mats.size(); ++j)
984  {
985  MooseSharedPointer<VolumetricModel> vm =
986  MooseSharedNamespace::dynamic_pointer_cast<VolumetricModel>(mats[j]);
987  if (vm)
988  {
989  const std::vector<std::string> & dep_matl_props = vm->getDependentMaterialProperties();
990  for (unsigned k = 0; k < dep_matl_props.size(); ++k)
991  {
992  if ("" != dep_matl_props[k] &&
993  _dep_matl_props.find(dep_matl_props[k]) == _dep_matl_props.end())
994  {
995  mooseError("A VolumetricModel depends on " + dep_matl_props[k] +
996  ", but that material property was not given in the dep_matl_props line.");
997  }
998  }
999  _volumetric_models[_block_id[i]].push_back(vm);
1000  }
1001  }
1002 
1003  for (std::map<SubdomainID, MooseSharedPointer<ConstitutiveModel>>::iterator iter =
1004  _constitutive_model.begin();
1005  iter != _constitutive_model.end();
1006  ++iter)
1007  {
1008  iter->second->initialSetup();
1009  }
1010 
1011  if (isParamValid("constitutive_model") && !_constitutive_active)
1012  {
1013  // User-defined name of the constitutive model (a Material object)
1014  std::string constitutive_model = getParam<std::string>("constitutive_model") + suffix;
1015 
1016  for (unsigned int j = 0; j < mats.size(); ++j)
1017  {
1018  MooseSharedPointer<ConstitutiveModel> cm =
1019  MooseSharedNamespace::dynamic_pointer_cast<ConstitutiveModel>(mats[j]);
1020 
1021  if (cm && cm->name() == constitutive_model)
1022  {
1023  _constitutive_model[_block_id[i]] = cm;
1024  set_constitutive_active = true;
1025  break;
1026  }
1027  }
1028 
1029  if (!set_constitutive_active)
1030  mooseError("Unable to find constitutive model " + constitutive_model);
1031  }
1032  }
1033  if (set_constitutive_active)
1034  _constitutive_active = true;
1035 
1037  {
1038  // Make sure that timeDerivative is supported for _alpha_function. If not, it will error out.
1039  Point dummy_point;
1040  Real dummy_temp = 0;
1041  _alpha_function->timeDerivative(dummy_temp, dummy_point);
1042  }
1043 }
std::set< std::string > _dep_matl_props
Definition: SolidModel.h:107
const bool _compute_JIntegral
Definition: SolidModel.h:154
bool _constitutive_active
Definition: SolidModel.h:254
virtual void checkElasticConstants()
Definition: SolidModel.C:377
virtual void createElasticityTensor()
Definition: SolidModel.C:500
std::vector< SubdomainID > _block_id
Definition: SolidModel.h:249
std::map< SubdomainID, MooseSharedPointer< ConstitutiveModel > > _constitutive_model
Definition: SolidModel.h:251
Function * _alpha_function
Definition: SolidModel.h:99
virtual std::vector< std::string > getDependentMaterialProperties() const
std::map< SubdomainID, std::vector< MooseSharedPointer< VolumetricModel > > > _volumetric_models
Definition: SolidModel.h:106

◆ initQpStatefulProperties()

void SolidModel::initQpStatefulProperties ( )
protectedvirtualinherited

Reimplemented in AbaqusUmatMaterial, and PLC_LSH.

Definition at line 696 of file SolidModel.C.

Referenced by PLC_LSH::initQpStatefulProperties(), and SolidModel::initStatefulProperties().

697 {
698  if (isParamValid("initial_stress"))
699  {
700  const std::vector<Real> & s = getParam<std::vector<Real>>("initial_stress");
701  if (6 != s.size())
702  {
703  mooseError("initial_stress must give six values");
704  }
705  _stress[_qp].fillFromInputVector(s);
706  }
707 
708  if (_cracking_stress_function != NULL)
709  {
710  _cracking_stress = _cracking_stress_function->value(_t, _q_point[_qp]);
711  }
712  if (_cracking_stress > 0)
713  {
714  (*_crack_flags)[_qp](0) = (*_crack_flags)[_qp](1) = (*_crack_flags)[_qp](2) = 1;
715  if (_crack_count)
716  {
717  (*_crack_count)[_qp](0) = (*_crack_count)[_qp](1) = (*_crack_count)[_qp](2) = 0;
718  }
719 
720  (*_crack_rotation)[_qp].identity();
721  }
722  if (_SED)
723  (*_SED)[_qp] = 0;
724 }
MaterialProperty< Real > * _SED
Definition: SolidModel.h:158
Real _cracking_stress
Definition: SolidModel.h:81
MaterialProperty< RealVectorValue > * _crack_count
Definition: SolidModel.h:126
Function *const _cracking_stress_function
Definition: SolidModel.h:85
MaterialProperty< RealVectorValue > * _crack_flags
Definition: SolidModel.h:123
MaterialProperty< SymmTensor > & _stress
Definition: SolidModel.h:109

◆ initStatefulProperties()

void AbaqusCreepMaterial::initStatefulProperties ( unsigned  n_points)
protectedvirtual

Reimplemented from SolidModel.

Definition at line 133 of file AbaqusCreepMaterial.C.

134 {
135  for (unsigned qp(0); qp < n_points; ++qp)
136  {
137  // Initialize state variable vector
138  _state_var[qp].resize(_num_state_vars);
139  for (unsigned int i = 0; i < _num_state_vars; i++)
140  {
141  _state_var[qp][i] = 0.0;
142  }
143  }
144 }
MaterialProperty< std::vector< Real > > & _state_var
unsigned int _num_state_vars

◆ jacobianSetup()

void SolidModel::jacobianSetup ( )
protectedvirtualinherited

Definition at line 533 of file SolidModel.C.

534 {
535  // if (_cracking_stress > 0)
536  // {
537  // for (std::map<Point, unsigned>::iterator i = _cracked_this_step.begin();
538  // i != _cracked_this_step.end(); ++i)
539  // {
540  // if (i->second)
541  // {
542  // ++_cracked_this_step_count[i->first];
543  // }
544  // }
545  // }
546 }

◆ JxW()

Real SolidModel::JxW ( unsigned  i) const
inlineinherited

◆ modifyStrainIncrement()

void SolidModel::modifyStrainIncrement ( )
protectedvirtualinherited

Modify increment for things like thermal strain.

Definition at line 560 of file SolidModel.C.

Referenced by SolidModel::computeProperties().

561 {
562  bool modified = false;
563  _d_strain_dT.zero();
564 
565  const SubdomainID current_block = _current_elem->subdomain_id();
567  {
568  MooseSharedPointer<ConstitutiveModel> cm = _constitutive_model[current_block];
569 
570  // Let's be a little careful and check for a non-existent
571  // ConstitutiveModel, which could be returned as a default value
572  // from std::map::operator[]
573  if (!cm)
574  mooseError("ConstitutiveModel not available for block ", current_block);
575 
576  cm->setQp(_qp);
577  modified |= cm->modifyStrainIncrement(*_current_elem, _strain_increment, _d_strain_dT);
578  }
579 
580  if (!modified)
581  {
583  }
584 
586 }
bool _constitutive_active
Definition: SolidModel.h:254
void zero()
Definition: SymmTensor.h:276
virtual void applyThermalStrain()
Definition: SolidModel.C:591
SymmTensor _d_strain_dT
Definition: SolidModel.h:140
virtual void applyVolumetricStrain()
Definition: SolidModel.C:649
std::map< SubdomainID, MooseSharedPointer< ConstitutiveModel > > _constitutive_model
Definition: SolidModel.h:251
SymmTensor _strain_increment
In most models, this is the mechanical strain increment, but for inelastic models, it has the inelastic component subtracted from it, so it is the elastic strain increment.
Definition: SolidModel.h:152

◆ q_point()

const Point& SolidModel::q_point ( unsigned  i) const
inlineinherited

◆ qrule()

QBase* SolidModel::qrule ( )
inlineinherited

◆ rotateSymmetricTensor()

void SolidModel::rotateSymmetricTensor ( const ColumnMajorMatrix &  R,
const SymmTensor T,
SymmTensor result 
)
staticinherited

Definition at line 663 of file SolidModel.C.

Referenced by SolidModel::applyCracksToTensor(), SolidModel::computeCrackStrainAndOrientation(), SolidModel::crackingStrainDirections(), and SolidModel::crackingStressRotation().

666 {
667 
668  // R T Rt
669  // 00 01 02 00 01 02 00 10 20
670  // 10 11 12 * 10 11 12 * 01 11 21
671  // 20 21 22 20 21 22 02 12 22
672  //
673  const Real T00 = R(0, 0) * T.xx() + R(0, 1) * T.xy() + R(0, 2) * T.zx();
674  const Real T01 = R(0, 0) * T.xy() + R(0, 1) * T.yy() + R(0, 2) * T.yz();
675  const Real T02 = R(0, 0) * T.zx() + R(0, 1) * T.yz() + R(0, 2) * T.zz();
676 
677  const Real T10 = R(1, 0) * T.xx() + R(1, 1) * T.xy() + R(1, 2) * T.zx();
678  const Real T11 = R(1, 0) * T.xy() + R(1, 1) * T.yy() + R(1, 2) * T.yz();
679  const Real T12 = R(1, 0) * T.zx() + R(1, 1) * T.yz() + R(1, 2) * T.zz();
680 
681  const Real T20 = R(2, 0) * T.xx() + R(2, 1) * T.xy() + R(2, 2) * T.zx();
682  const Real T21 = R(2, 0) * T.xy() + R(2, 1) * T.yy() + R(2, 2) * T.yz();
683  const Real T22 = R(2, 0) * T.zx() + R(2, 1) * T.yz() + R(2, 2) * T.zz();
684 
685  result.xx(T00 * R(0, 0) + T01 * R(0, 1) + T02 * R(0, 2));
686  result.yy(T10 * R(1, 0) + T11 * R(1, 1) + T12 * R(1, 2));
687  result.zz(T20 * R(2, 0) + T21 * R(2, 1) + T22 * R(2, 2));
688  result.xy(T00 * R(1, 0) + T01 * R(1, 1) + T02 * R(1, 2));
689  result.yz(T10 * R(2, 0) + T11 * R(2, 1) + T12 * R(2, 2));
690  result.zx(T00 * R(2, 0) + T01 * R(2, 1) + T02 * R(2, 2));
691 }
Real yz() const
Definition: SymmTensor.h:136
Real zx() const
Definition: SymmTensor.h:137
Real yy() const
Definition: SymmTensor.h:133
Real xx() const
Definition: SymmTensor.h:132
Real xy() const
Definition: SymmTensor.h:135
Real zz() const
Definition: SymmTensor.h:134

◆ timestepSetup()

void SolidModel::timestepSetup ( )
protectedvirtualinherited

Definition at line 522 of file SolidModel.C.

523 {
524  // if (_cracking_stress > 0)
525  // {
526  // _cracked_this_step_count.clear();
527  // }
528 }

◆ updateElasticityTensor()

bool SolidModel::updateElasticityTensor ( SymmElasticityTensor tensor)
protectedvirtualinherited

Return true if the elasticity tensor changed.

Reimplemented in MacroElastic.

Definition at line 891 of file SolidModel.C.

Referenced by SolidModel::computeElasticityTensor().

892 {
893  bool changed(false);
895  {
896  const SubdomainID current_block = _current_elem->subdomain_id();
897  MooseSharedPointer<ConstitutiveModel> cm = _constitutive_model[current_block];
898 
899  // Let's be a little careful and check for a non-existent
900  // ConstitutiveModel, which could be returned as a default value
901  // from std::map::operator[]
902  if (!cm)
903  mooseError("ConstitutiveModel not available for block ", current_block);
904 
905  cm->setQp(_qp);
906  changed |= cm->updateElasticityTensor(tensor);
907  }
908 
910  {
911  SymmIsotropicElasticityTensor * t = dynamic_cast<SymmIsotropicElasticityTensor *>(&tensor);
912  if (!t)
913  {
914  mooseError("Cannot use Youngs modulus or Poissons ratio functions");
915  }
916  t->unsetConstants();
917  Point p;
919  ? _youngs_modulus_function->value(_temperature[_qp], p)
920  : _youngs_modulus));
922  ? _poissons_ratio_function->value(_temperature[_qp], p)
923  : _poissons_ratio));
924  changed = true;
925  }
926  return changed;
927 }
Real _poissons_ratio
Definition: SolidModel.h:73
bool _constitutive_active
Definition: SolidModel.h:254
Function * _youngs_modulus_function
Definition: SolidModel.h:77
Function * _poissons_ratio_function
Definition: SolidModel.h:78
std::map< SubdomainID, MooseSharedPointer< ConstitutiveModel > > _constitutive_model
Definition: SolidModel.h:251
Real _youngs_modulus
Definition: SolidModel.h:75
const VariableValue & _temperature
Definition: SolidModel.h:95
void setYoungsModulus(const Real E)
Set the Young&#39;s Modulus.
Defines an Isotropic Elasticity Tensor.
void setPoissonsRatio(const Real nu)
Set Poissons Ratio.

Member Data Documentation

◆ _active_crack_planes

std::vector<unsigned int> SolidModel::_active_crack_planes
protectedinherited

Definition at line 88 of file SolidModel.h.

Referenced by SolidModel::crackingStressRotation(), and SolidModel::SolidModel().

◆ _alpha

const Real SolidModel::_alpha
protectedinherited

◆ _alpha_function

Function* SolidModel::_alpha_function
protectedinherited

◆ _appended_property_name

const std::string SolidModel::_appended_property_name
protectedinherited

Definition at line 63 of file SolidModel.h.

Referenced by SolidModel::createProperty(), and SolidModel::getPropertyOld().

◆ _block_id

std::vector<SubdomainID> SolidModel::_block_id
protectedinherited

◆ _bulk_modulus

Real SolidModel::_bulk_modulus
protectedinherited

Definition at line 71 of file SolidModel.h.

Referenced by SolidModel::checkElasticConstants().

◆ _bulk_modulus_set

bool SolidModel::_bulk_modulus_set
protectedinherited

Definition at line 65 of file SolidModel.h.

Referenced by SolidModel::checkElasticConstants().

◆ _CMNAME

Real AbaqusCreepMaterial::_CMNAME
protected

Definition at line 68 of file AbaqusCreepMaterial.h.

Referenced by computeStress().

◆ _compute_InteractionIntegral

const bool SolidModel::_compute_InteractionIntegral
protectedinherited

Definition at line 155 of file SolidModel.h.

Referenced by SolidModel::computeProperties(), and SolidModel::SolidModel().

◆ _compute_JIntegral

const bool SolidModel::_compute_JIntegral
protectedinherited

◆ _compute_method

const std::string SolidModel::_compute_method
protectedinherited

Definition at line 84 of file SolidModel.h.

Referenced by SolidModel::crackingStrainDirections().

◆ _constitutive_active

bool SolidModel::_constitutive_active
protectedinherited

◆ _constitutive_model

std::map<SubdomainID, MooseSharedPointer<ConstitutiveModel> > SolidModel::_constitutive_model
protectedinherited

◆ _coord_type

Moose::CoordinateSystemType SolidModel::_coord_type
protectedinherited

Definition at line 61 of file SolidModel.h.

Referenced by SolidModel::createElement(), and SolidModel::SolidModel().

◆ _COORDS

Real AbaqusCreepMaterial::_COORDS[3]
protected

Definition at line 71 of file AbaqusCreepMaterial.h.

Referenced by computeStress().

◆ _crack_count

MaterialProperty<RealVectorValue>* SolidModel::_crack_count
protectedinherited

Definition at line 126 of file SolidModel.h.

Referenced by SolidModel::initQpStatefulProperties(), and SolidModel::SolidModel().

◆ _crack_count_old

const MaterialProperty<RealVectorValue>* SolidModel::_crack_count_old
protectedinherited

Definition at line 127 of file SolidModel.h.

Referenced by SolidModel::crackingStressRotation(), and SolidModel::SolidModel().

◆ _crack_flags

MaterialProperty<RealVectorValue>* SolidModel::_crack_flags
protectedinherited

◆ _crack_flags_local

RealVectorValue SolidModel::_crack_flags_local
protectedinherited

◆ _crack_flags_old

const MaterialProperty<RealVectorValue>* SolidModel::_crack_flags_old
protectedinherited

Definition at line 124 of file SolidModel.h.

Referenced by SolidModel::crackingStressRotation(), and SolidModel::SolidModel().

◆ _crack_max_strain

MaterialProperty<RealVectorValue>* SolidModel::_crack_max_strain
protectedinherited

◆ _crack_max_strain_old

const MaterialProperty<RealVectorValue>* SolidModel::_crack_max_strain_old
protectedinherited

◆ _crack_rotation

MaterialProperty<ColumnMajorMatrix>* SolidModel::_crack_rotation
protectedinherited

◆ _crack_rotation_old

const MaterialProperty<ColumnMajorMatrix>* SolidModel::_crack_rotation_old
protectedinherited

Definition at line 129 of file SolidModel.h.

Referenced by SolidModel::SolidModel().

◆ _crack_strain

MaterialProperty<RealVectorValue>* SolidModel::_crack_strain
protectedinherited

◆ _crack_strain_old

const MaterialProperty<RealVectorValue>* SolidModel::_crack_strain_old
protectedinherited

Definition at line 131 of file SolidModel.h.

Referenced by SolidModel::crackingStressRotation(), and SolidModel::SolidModel().

◆ _cracking_alpha

Real SolidModel::_cracking_alpha
protectedinherited

Definition at line 87 of file SolidModel.h.

Referenced by SolidModel::computeCrackFactor(), and SolidModel::SolidModel().

◆ _cracking_beta

const Real SolidModel::_cracking_beta
protectedinherited

Definition at line 83 of file SolidModel.h.

Referenced by SolidModel::computeCrackFactor().

◆ _cracking_neg_fraction

const Real SolidModel::_cracking_neg_fraction
protectedinherited

◆ _cracking_release

const CRACKING_RELEASE SolidModel::_cracking_release
protectedinherited

◆ _cracking_residual_stress

const Real SolidModel::_cracking_residual_stress
protectedinherited

Definition at line 82 of file SolidModel.h.

Referenced by SolidModel::computeCrackFactor().

◆ _cracking_stress

Real SolidModel::_cracking_stress
protectedinherited

◆ _cracking_stress_function

Function* const SolidModel::_cracking_stress_function
protectedinherited

◆ _creep

creep_t AbaqusCreepMaterial::_creep
protected

Definition at line 65 of file AbaqusCreepMaterial.h.

Referenced by AbaqusCreepMaterial(), and computeStress().

◆ _creep_inc

MaterialProperty<Real>& AbaqusCreepMaterial::_creep_inc
protected

Definition at line 96 of file AbaqusCreepMaterial.h.

Referenced by computeStress().

◆ _creep_inc_old

const MaterialProperty<Real>& AbaqusCreepMaterial::_creep_inc_old
protected

Definition at line 97 of file AbaqusCreepMaterial.h.

Referenced by computeStress().

◆ _current_instantaneous_thermal_expansion_coef

MaterialProperty<Real>* SolidModel::_current_instantaneous_thermal_expansion_coef
protectedinherited

◆ _d_strain_dT

SymmTensor SolidModel::_d_strain_dT
protectedinherited

◆ _d_stress_dT

MaterialProperty<SymmTensor>& SolidModel::_d_stress_dT
protectedinherited

Definition at line 143 of file SolidModel.h.

Referenced by SolidModel::computePreconditioning().

◆ _DECRA

Real AbaqusCreepMaterial::_DECRA[5]
protected

Definition at line 71 of file AbaqusCreepMaterial.h.

Referenced by computeStress().

◆ _dep_matl_props

std::set<std::string> SolidModel::_dep_matl_props
protectedinherited

Definition at line 107 of file SolidModel.h.

Referenced by SolidModel::initialSetup(), and SolidModel::SolidModel().

◆ _DESWA

Real AbaqusCreepMaterial::_DESWA[5]
protected

Definition at line 71 of file AbaqusCreepMaterial.h.

Referenced by computeStress().

◆ _dev_trial_stress

MaterialProperty<SymmTensor>& AbaqusCreepMaterial::_dev_trial_stress
protected

Definition at line 90 of file AbaqusCreepMaterial.h.

Referenced by computeStress().

◆ _dev_trial_stress_old

const MaterialProperty<SymmTensor>& AbaqusCreepMaterial::_dev_trial_stress_old
protected

Definition at line 91 of file AbaqusCreepMaterial.h.

Referenced by computeStress().

◆ _DPRED

Real AbaqusCreepMaterial::_DPRED[1]
protected

Definition at line 71 of file AbaqusCreepMaterial.h.

Referenced by computeStress().

◆ _DTEMP

Real AbaqusCreepMaterial::_DTEMP
protected

Definition at line 68 of file AbaqusCreepMaterial.h.

Referenced by computeStress().

◆ _DTIME

Real AbaqusCreepMaterial::_DTIME
protected

Definition at line 68 of file AbaqusCreepMaterial.h.

Referenced by computeStress().

◆ _ebulk3

Real AbaqusCreepMaterial::_ebulk3
protected

Definition at line 77 of file AbaqusCreepMaterial.h.

Referenced by AbaqusCreepMaterial().

◆ _EC

Real AbaqusCreepMaterial::_EC[2]
protected

Definition at line 71 of file AbaqusCreepMaterial.h.

Referenced by computeStress().

◆ _eg

Real AbaqusCreepMaterial::_eg
protected

Definition at line 77 of file AbaqusCreepMaterial.h.

Referenced by AbaqusCreepMaterial().

◆ _eg2

Real AbaqusCreepMaterial::_eg2
protected

Definition at line 77 of file AbaqusCreepMaterial.h.

Referenced by AbaqusCreepMaterial().

◆ _eg3

Real AbaqusCreepMaterial::_eg3
protected

Definition at line 77 of file AbaqusCreepMaterial.h.

Referenced by AbaqusCreepMaterial().

◆ _elam

Real AbaqusCreepMaterial::_elam
protected

Definition at line 77 of file AbaqusCreepMaterial.h.

Referenced by AbaqusCreepMaterial().

◆ _elastic_strain

MaterialProperty<SymmTensor>& SolidModel::_elastic_strain
protectedinherited

◆ _elastic_strain_old

const MaterialProperty<SymmTensor>& SolidModel::_elastic_strain_old
protectedinherited

◆ _elasticity_tensor

Real AbaqusCreepMaterial::_elasticity_tensor[3]
protected

Definition at line 77 of file AbaqusCreepMaterial.h.

Referenced by AbaqusCreepMaterial(), and computeStress().

◆ _Eshelby_tensor

MaterialProperty<RankTwoTensor>* SolidModel::_Eshelby_tensor
protectedinherited

Definition at line 160 of file SolidModel.h.

Referenced by SolidModel::computeEshelby(), and SolidModel::SolidModel().

◆ _ESW

Real AbaqusCreepMaterial::_ESW[2]
protected

Definition at line 71 of file AbaqusCreepMaterial.h.

Referenced by computeStress().

◆ _ets

MaterialProperty<Real>& AbaqusCreepMaterial::_ets
protected

Definition at line 92 of file AbaqusCreepMaterial.h.

Referenced by computeStress().

◆ _ets_old

const MaterialProperty<Real>& AbaqusCreepMaterial::_ets_old
protected

Definition at line 93 of file AbaqusCreepMaterial.h.

Referenced by computeStress().

◆ _handle

void* AbaqusCreepMaterial::_handle
protected

Definition at line 62 of file AbaqusCreepMaterial.h.

Referenced by AbaqusCreepMaterial(), and ~AbaqusCreepMaterial().

◆ _has_stress_free_temp

bool SolidModel::_has_stress_free_temp
protectedinherited

Definition at line 101 of file SolidModel.h.

Referenced by SolidModel::applyThermalStrain(), and SolidModel::SolidModel().

◆ _has_temp

const bool SolidModel::_has_temp
protectedinherited

◆ _integration_flag

unsigned int AbaqusCreepMaterial::_integration_flag
protected

Definition at line 59 of file AbaqusCreepMaterial.h.

Referenced by AbaqusCreepMaterial(), and computeStress().

◆ _J_thermal_term_vec

MaterialProperty<RealVectorValue>* SolidModel::_J_thermal_term_vec
protectedinherited

Definition at line 161 of file SolidModel.h.

Referenced by SolidModel::computeThermalJvec(), and SolidModel::SolidModel().

◆ _Jacobian_mult

MaterialProperty<SymmElasticityTensor>& SolidModel::_Jacobian_mult
protectedinherited

Definition at line 137 of file SolidModel.h.

Referenced by SolidModel::computePreconditioning().

◆ _KINC

int AbaqusCreepMaterial::_KINC
protected

Definition at line 74 of file AbaqusCreepMaterial.h.

Referenced by computeStress().

◆ _KSPT

int AbaqusCreepMaterial::_KSPT
protected

Definition at line 74 of file AbaqusCreepMaterial.h.

Referenced by computeStress().

◆ _KSTEP

int AbaqusCreepMaterial::_KSTEP
protected

Definition at line 74 of file AbaqusCreepMaterial.h.

Referenced by computeStress().

◆ _lambda

Real SolidModel::_lambda
protectedinherited

Definition at line 72 of file SolidModel.h.

Referenced by SolidModel::checkElasticConstants().

◆ _lambda_set

bool SolidModel::_lambda_set
protectedinherited

Definition at line 66 of file SolidModel.h.

Referenced by SolidModel::checkElasticConstants().

◆ _LAYER

int AbaqusCreepMaterial::_LAYER
protected

Definition at line 74 of file AbaqusCreepMaterial.h.

Referenced by computeStress().

◆ _LEND

Real AbaqusCreepMaterial::_LEND
protected

Definition at line 68 of file AbaqusCreepMaterial.h.

Referenced by AbaqusCreepMaterial(), and computeStress().

◆ _LEXIMP

Real AbaqusCreepMaterial::_LEXIMP
protected

Definition at line 68 of file AbaqusCreepMaterial.h.

Referenced by AbaqusCreepMaterial(), and computeStress().

◆ _max_cracks

const unsigned int SolidModel::_max_cracks
protectedinherited

Definition at line 89 of file SolidModel.h.

Referenced by SolidModel::crackingStressRotation().

◆ _mean_alpha_function

bool SolidModel::_mean_alpha_function
protectedinherited

◆ _mechanical_strain_increment

SymmTensor SolidModel::_mechanical_strain_increment
protectedinherited

Mechanical strain increment, which is the total strain increment minus eigenstrains.

Definition at line 148 of file SolidModel.h.

Referenced by SolidModel::computeProperties(), and SolidModel::computeStrainEnergyDensity().

◆ _models_to_free

std::set<MooseSharedPointer<ConstitutiveModel> > SolidModel::_models_to_free
protectedinherited

Definition at line 253 of file SolidModel.h.

Referenced by SolidModel::createConstitutiveModel().

◆ _NOEL

int AbaqusCreepMaterial::_NOEL
protected

Definition at line 74 of file AbaqusCreepMaterial.h.

Referenced by computeStress().

◆ _NPT

int AbaqusCreepMaterial::_NPT
protected

Definition at line 74 of file AbaqusCreepMaterial.h.

Referenced by computeStress().

◆ _NSTATV

Real AbaqusCreepMaterial::_NSTATV
protected

Definition at line 68 of file AbaqusCreepMaterial.h.

Referenced by AbaqusCreepMaterial(), and computeStress().

◆ _num_state_vars

unsigned int AbaqusCreepMaterial::_num_state_vars
protected

◆ _P

Real AbaqusCreepMaterial::_P
protected

Definition at line 68 of file AbaqusCreepMaterial.h.

Referenced by computeStress().

◆ _piecewise_linear_alpha_function

PiecewiseLinear* SolidModel::_piecewise_linear_alpha_function
protectedinherited

Definition at line 100 of file SolidModel.h.

◆ _plugin

FileName AbaqusCreepMaterial::_plugin
protected

Definition at line 57 of file AbaqusCreepMaterial.h.

Referenced by AbaqusCreepMaterial().

◆ _poissons_ratio

Real AbaqusCreepMaterial::_poissons_ratio
protected

Definition at line 58 of file AbaqusCreepMaterial.h.

Referenced by AbaqusCreepMaterial().

◆ _poissons_ratio_function

Function* SolidModel::_poissons_ratio_function
protectedinherited

◆ _poissons_ratio_set

bool SolidModel::_poissons_ratio_set
protectedinherited

◆ _PREDEF

Real AbaqusCreepMaterial::_PREDEF[1]
protected

Definition at line 71 of file AbaqusCreepMaterial.h.

Referenced by computeStress().

◆ _principal_strain

ColumnMajorMatrix SolidModel::_principal_strain
protectedinherited

◆ _QTILD

Real AbaqusCreepMaterial::_QTILD
protected

Definition at line 68 of file AbaqusCreepMaterial.h.

Referenced by computeStress().

◆ _ref_temp

Real SolidModel::_ref_temp
protectedinherited

◆ _routine_flag

unsigned int AbaqusCreepMaterial::_routine_flag
protected

Definition at line 59 of file AbaqusCreepMaterial.h.

Referenced by AbaqusCreepMaterial().

◆ _SED

MaterialProperty<Real>* SolidModel::_SED
protectedinherited

◆ _SED_old

const MaterialProperty<Real>* SolidModel::_SED_old
protectedinherited

Definition at line 159 of file SolidModel.h.

Referenced by SolidModel::computeStrainEnergyDensity(), and SolidModel::SolidModel().

◆ _SERD

Real AbaqusCreepMaterial::_SERD
protected

Definition at line 68 of file AbaqusCreepMaterial.h.

Referenced by computeStress().

◆ _shear_modulus

Real SolidModel::_shear_modulus
protectedinherited

◆ _shear_modulus_set

bool SolidModel::_shear_modulus_set
protectedinherited

Definition at line 68 of file SolidModel.h.

Referenced by SolidModel::checkElasticConstants().

◆ _solve_definition

unsigned int AbaqusCreepMaterial::_solve_definition
protected

Definition at line 59 of file AbaqusCreepMaterial.h.

Referenced by computeStress().

◆ _state_var

MaterialProperty<std::vector<Real> >& AbaqusCreepMaterial::_state_var
protected

Definition at line 86 of file AbaqusCreepMaterial.h.

Referenced by computeStress(), and initStatefulProperties().

◆ _state_var_old

const MaterialProperty<std::vector<Real> >& AbaqusCreepMaterial::_state_var_old
protected

Definition at line 87 of file AbaqusCreepMaterial.h.

Referenced by computeStress().

◆ _STATEV

Real * AbaqusCreepMaterial::_STATEV
protected

Definition at line 71 of file AbaqusCreepMaterial.h.

Referenced by AbaqusCreepMaterial(), computeStress(), and ~AbaqusCreepMaterial().

◆ _step_one

bool& SolidModel::_step_one
protectedinherited

Definition at line 263 of file SolidModel.h.

Referenced by SolidModel::applyThermalStrain(), and SolidModel::computeProperties().

◆ _step_zero

bool& SolidModel::_step_zero
protectedinherited

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

Definition at line 262 of file SolidModel.h.

Referenced by SolidModel::applyThermalStrain(), and SolidModel::computeProperties().

◆ _strain_increment

SymmTensor SolidModel::_strain_increment
protectedinherited

In most models, this is the mechanical strain increment, but for inelastic models, it has the inelastic component subtracted from it, so it is the elastic strain increment.

Definition at line 152 of file SolidModel.h.

Referenced by SolidModel::applyThermalStrain(), SolidModel::applyVolumetricStrain(), SolidModel::computeConstitutiveModelStress(), SolidModel::computeCrackStrainAndOrientation(), SolidModel::computeProperties(), PLC_LSH::computeStress(), computeStress(), AbaqusUmatMaterial::computeStress(), and SolidModel::modifyStrainIncrement().

◆ _stress

MaterialProperty<SymmTensor>& AbaqusCreepMaterial::_stress
protected

Definition at line 94 of file AbaqusCreepMaterial.h.

Referenced by computeStress().

◆ _stress_component

Real AbaqusCreepMaterial::_stress_component[6]
protected

Definition at line 77 of file AbaqusCreepMaterial.h.

Referenced by computeStress().

◆ _stress_free_temp

Real SolidModel::_stress_free_temp
protectedinherited

◆ _stress_old

const MaterialProperty<SymmTensor>& AbaqusCreepMaterial::_stress_old
protected

Definition at line 95 of file AbaqusCreepMaterial.h.

Referenced by computeStress().

◆ _swell_inc

MaterialProperty<Real>& AbaqusCreepMaterial::_swell_inc
protected

Definition at line 100 of file AbaqusCreepMaterial.h.

Referenced by computeStress().

◆ _swell_inc_old

const MaterialProperty<Real>& AbaqusCreepMaterial::_swell_inc_old
protected

Definition at line 101 of file AbaqusCreepMaterial.h.

Referenced by computeStress().

◆ _TEMP

Real AbaqusCreepMaterial::_TEMP
protected

Definition at line 68 of file AbaqusCreepMaterial.h.

Referenced by computeStress().

◆ _temp_grad

const VariableGradient& SolidModel::_temp_grad
protectedinherited

Definition at line 97 of file SolidModel.h.

Referenced by SolidModel::computeThermalJvec().

◆ _temperature

const VariableValue& SolidModel::_temperature
protectedinherited

◆ _temperature_old

const VariableValue& SolidModel::_temperature_old
protectedinherited

Definition at line 96 of file SolidModel.h.

Referenced by SolidModel::applyThermalStrain().

◆ _TIME

Real AbaqusCreepMaterial::_TIME[2]
protected

Definition at line 71 of file AbaqusCreepMaterial.h.

Referenced by computeStress().

◆ _total_creep

MaterialProperty<Real>& AbaqusCreepMaterial::_total_creep
protected

Definition at line 98 of file AbaqusCreepMaterial.h.

Referenced by computeStress().

◆ _total_creep_old

const MaterialProperty<Real>& AbaqusCreepMaterial::_total_creep_old
protected

Definition at line 99 of file AbaqusCreepMaterial.h.

Referenced by computeStress().

◆ _total_strain

MaterialProperty<SymmTensor>& SolidModel::_total_strain
protectedinherited

◆ _total_strain_increment

SymmTensor SolidModel::_total_strain_increment
protectedinherited

Total strain increment, including mechanical strains and eigenstrains.

Definition at line 146 of file SolidModel.h.

Referenced by SolidModel::computeProperties().

◆ _total_strain_old

const MaterialProperty<SymmTensor>& SolidModel::_total_strain_old
protectedinherited

Definition at line 118 of file SolidModel.h.

Referenced by SolidModel::computeProperties().

◆ _total_swell

MaterialProperty<Real>& AbaqusCreepMaterial::_total_swell
protected

Definition at line 102 of file AbaqusCreepMaterial.h.

Referenced by computeStress().

◆ _total_swell_old

const MaterialProperty<Real>& AbaqusCreepMaterial::_total_swell_old
protected

Definition at line 103 of file AbaqusCreepMaterial.h.

Referenced by computeStress().

◆ _trial_stress

MaterialProperty<SymmTensor>& AbaqusCreepMaterial::_trial_stress
protected

Definition at line 88 of file AbaqusCreepMaterial.h.

Referenced by computeStress().

◆ _trial_stress_old

const MaterialProperty<SymmTensor>& AbaqusCreepMaterial::_trial_stress_old
protected

Definition at line 89 of file AbaqusCreepMaterial.h.

Referenced by computeStress().

◆ _volumetric_models

std::map<SubdomainID, std::vector<MooseSharedPointer<VolumetricModel> > > SolidModel::_volumetric_models
protectedinherited

Definition at line 106 of file SolidModel.h.

Referenced by SolidModel::applyVolumetricStrain(), and SolidModel::initialSetup().

◆ _youngs_modulus

Real AbaqusCreepMaterial::_youngs_modulus
protected

Definition at line 58 of file AbaqusCreepMaterial.h.

Referenced by AbaqusCreepMaterial().

◆ _youngs_modulus_function

Function* SolidModel::_youngs_modulus_function
protectedinherited

◆ _youngs_modulus_set

bool SolidModel::_youngs_modulus_set
protectedinherited

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