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

#include <AbaqusUmatMaterial.h>

Inheritance diagram for AbaqusUmatMaterial:
[legend]

Public Types

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

Public Member Functions

 AbaqusUmatMaterial (const InputParameters &parameters)
 
virtual ~AbaqusUmatMaterial ()
 
virtual void initStatefulProperties (unsigned n_points)
 
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 initQpStatefulProperties ()
 
virtual void computeStress ()
 Compute the stress (sigma += deltaSigma) More...
 
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
 
std::vector< Real > _mechanical_constants
 
std::vector< Real > _thermal_constants
 
unsigned int _num_state_vars
 
unsigned int _num_props
 
void * _handle
 
umat_t _umat
 
Real _SSE
 
Real _SPD
 
Real _SCD
 
Real _DRPLDT
 
Real _RPL
 
Real _PNEWDT
 
Real _DTIME
 
Real _TEMP
 
Real _DTEMP
 
Real _CMNAME
 
Real _CELENT
 
int _NDI
 
int _NSHR
 
int _NTENS
 
int _NSTATV
 
int _NPROPS
 
int _NOEL
 
int _NPT
 
int _LAYER
 
int _KSPT
 
int _KSTEP
 
int _KINC
 
Real * _STATEV
 
Real * _DDSDDT
 
Real * _DRPLDE
 
Real * _STRAN
 
Real _PREDEF [1]
 
Real _DPRED [1]
 
Real _COORDS [3]
 
Real _DROT [3][3]
 
Real * _DFGRD0
 
Real * _DFGRD1
 
Real * _STRESS
 
Real * _DDSDDE
 
Real * _DSTRAN
 
Real _TIME [2]
 
Real * _PROPS
 
const VariableGradient & _grad_disp_x
 
const VariableGradient & _grad_disp_y
 
const VariableGradient & _grad_disp_z
 
const VariableGradient & _grad_disp_x_old
 
const VariableGradient & _grad_disp_y_old
 
const VariableGradient & _grad_disp_z_old
 
MaterialProperty< std::vector< Real > > & _state_var
 
const MaterialProperty< std::vector< Real > > & _state_var_old
 
MaterialProperty< ColumnMajorMatrix > & _Fbar
 
const MaterialProperty< ColumnMajorMatrix > & _Fbar_old
 
MaterialProperty< Real > & _elastic_strain_energy
 
MaterialProperty< Real > & _plastic_dissipation
 
MaterialProperty< Real > & _creep_dissipation
 
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 _poissons_ratio
 
Real _shear_modulus
 
Real _youngs_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 > & _stress
 
SymmTensor _stress_old
 
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 > & _elasticity_tensor
 
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 60 of file AbaqusUmatMaterial.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

◆ AbaqusUmatMaterial()

AbaqusUmatMaterial::AbaqusUmatMaterial ( const InputParameters &  parameters)

Definition at line 34 of file AbaqusUmatMaterial.C.

35  : SolidModel(parameters),
36  _plugin(getParam<FileName>("plugin")),
37  _mechanical_constants(getParam<std::vector<Real>>("mechanical_constants")),
38  _thermal_constants(getParam<std::vector<Real>>("thermal_constants")),
39  _num_state_vars(getParam<unsigned int>("num_state_vars")),
40  _grad_disp_x(coupledGradient("disp_x")),
41  _grad_disp_y(coupledGradient("disp_y")),
42  _grad_disp_z(coupledGradient("disp_z")),
43  _grad_disp_x_old(coupledGradientOld("disp_x")),
44  _grad_disp_y_old(coupledGradientOld("disp_y")),
45  _grad_disp_z_old(coupledGradientOld("disp_z")),
46  _state_var(declareProperty<std::vector<Real>>("state_var")),
47  _state_var_old(getMaterialPropertyOld<std::vector<Real>>("state_var")),
48  _Fbar(declareProperty<ColumnMajorMatrix>("Fbar")),
49  _Fbar_old(getMaterialPropertyOld<ColumnMajorMatrix>("Fbar")),
50  _elastic_strain_energy(declareProperty<Real>("elastic_strain_energy")),
51  _plastic_dissipation(declareProperty<Real>("plastic_dissipation")),
52  _creep_dissipation(declareProperty<Real>("creep_dissipation"))
53 {
54 #if defined(METHOD)
55  _plugin += std::string("-") + QUOTE(METHOD) + ".plugin";
56 #endif
57 
58  // Size and create full (mechanical+thermal) material property array
60  std::vector<Real> props_array(_num_props);
61  for (unsigned int i = 0; i < _mechanical_constants.size(); ++i)
62  props_array[i] = _mechanical_constants[i];
63  for (unsigned int i = _mechanical_constants.size(); i < _num_props; ++i)
64  props_array[i] = _thermal_constants[i];
65 
66  // Read mesh dimension and size UMAT arrays
67  if (_mesh.dimension() == 3) // 3D case
68  {
69  _NTENS = 6; // Size of the stress or strain component array (NDI+NSHR)
70  _NSHR = 3; // Number of engineering shear stress components
71  _NDI = 3; // Number of direct stress components (always 3)
72  }
73  else if (_mesh.dimension() == 2) // 2D case
74  {
75  _NTENS = 4;
76  _NSHR = 1;
77  _NDI = 3;
78  }
79 
80  _STATEV = new Real[_num_state_vars];
81  _DDSDDT = new Real[_NTENS];
82  _DRPLDE = new Real[_NTENS];
83  _STRAN = new Real[_NTENS];
84  _DFGRD0 = new Real[9];
85  _DFGRD1 = new Real[9];
86  _STRESS = new Real[_NTENS];
87  _DDSDDE = new Real[_NTENS * _NTENS];
88  _DSTRAN = new Real[_NTENS];
89  _PROPS = new Real[_num_props];
90 
91  for (unsigned int i = 0; i < _num_state_vars; ++i)
92  {
93  _STATEV[i] = 0.0;
94  }
95 
96  for (int i = 0; i < _NTENS; ++i)
97  {
98  _DDSDDT[i] = 0.0;
99  _DRPLDE[i] = 0.0;
100  _STRAN[i] = 0.0;
101  _STRESS[i] = 0.0;
102  _DSTRAN[i] = 0.0;
103  }
104 
105  for (unsigned int i = 0; i < 9; ++i)
106  {
107  _DFGRD0[i] = 0.0;
108  _DFGRD1[i] = 0.0;
109  }
110 
111  for (int i = 0; i < _NTENS * _NTENS; ++i)
112  {
113  _DDSDDE[i] = 0.0;
114  }
115 
116  // Assign materials properties from vector form into an array
117  for (unsigned int i = 0; i < _num_props; ++i)
118  {
119  _PROPS[i] = props_array[i];
120  }
121 
122  // Size UMAT state variable (NSTATV) and material constant (NPROPS) arrays
125 
126  // Open the library
127  _handle = dlopen(_plugin.c_str(), RTLD_LAZY);
128 
129  if (!_handle)
130  {
131  std::ostringstream error;
132  error << "Cannot open library: " << dlerror() << '\n';
133  mooseError(error.str());
134  }
135 
136  // Reset errors
137  dlerror();
138 
139  // Snag the function pointer from the library
140  {
141  void * pointer = dlsym(_handle, "umat_");
142  _umat = *reinterpret_cast<umat_t *>(&pointer);
143  }
144 
145  // Catch errors
146  const char * dlsym_error = dlerror();
147  if (dlsym_error)
148  {
149  dlclose(_handle);
150  std::ostringstream error;
151  error << "Cannot load symbol 'umat_': " << dlsym_error << '\n';
152  mooseError(error.str());
153  }
154 }
const VariableGradient & _grad_disp_z
const VariableGradient & _grad_disp_y
const VariableGradient & _grad_disp_x
MaterialProperty< std::vector< Real > > & _state_var
const MaterialProperty< std::vector< Real > > & _state_var_old
MaterialProperty< Real > & _elastic_strain_energy
std::vector< Real > _mechanical_constants
void(* umat_t)(Real STRESS[], Real STATEV[], Real DDSDDE[], Real *SSE, Real *SPD, Real *SCD, Real *RPL, Real DDSDDT[], Real DRPLDE[], Real *DRPLDT, Real STRAN[], Real DSTRAN[], Real TIME[], Real *DTIME, Real *TEMP, Real *DTEMP, Real PREDEF[], Real DPRED[], Real *CMNAME, int *NDI, int *NSHR, int *NTENS, int *NSTATV, Real PROPS[], int *NPROPS, Real COORDS[], Real DROT[][3], Real *PNEWDT, Real *CELENT, Real DFGRD0[], Real DFGRD1[], int *NOEL, int *NPT, int *LAYER, int *KSPT, int *KSTEP, int *KINC)
MaterialProperty< Real > & _plastic_dissipation
const VariableGradient & _grad_disp_x_old
std::vector< Real > _thermal_constants
const VariableGradient & _grad_disp_y_old
MaterialProperty< Real > & _creep_dissipation
unsigned int _num_state_vars
MaterialProperty< ColumnMajorMatrix > & _Fbar
SolidModel(const InputParameters &parameters)
Definition: SolidModel.C:140
const MaterialProperty< ColumnMajorMatrix > & _Fbar_old
const VariableGradient & _grad_disp_z_old

◆ ~AbaqusUmatMaterial()

AbaqusUmatMaterial::~AbaqusUmatMaterial ( )
virtual

Definition at line 156 of file AbaqusUmatMaterial.C.

157 {
158  delete _STATEV;
159  delete _DDSDDT;
160  delete _DRPLDE;
161  delete _STRAN;
162  delete _DFGRD0;
163  delete _DFGRD1;
164  delete _STRESS;
165  delete _DDSDDE;
166  delete _DSTRAN;
167  delete _PROPS;
168 
169  dlclose(_handle);
170 }

Member Function Documentation

◆ applyCracksToTensor()

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

Definition at line 1118 of file SolidModel.C.

Referenced by SolidModel::crackingStressRotation().

1119 {
1120  // Form transformation matrix R*E*R^T
1121  const ColumnMajorMatrix & R((*_crack_rotation)[_qp]);
1122 
1123  // Rotate to crack frame
1124  rotateSymmetricTensor(R.transpose(), tensor, tensor);
1125 
1126  // Reset stress if cracked
1127  if ((*_crack_flags)[_qp](0) < 1)
1128  {
1129  tensor(0, 0) = sigma(0);
1130  }
1131  if ((*_crack_flags)[_qp](1) < 1)
1132  {
1133  tensor(1, 1) = sigma(1);
1134  }
1135  if ((*_crack_flags)[_qp](2) < 1)
1136  {
1137  tensor(2, 2) = sigma(2);
1138  }
1139 
1140  // Rotate back to global frame
1141  rotateSymmetricTensor(R, tensor, tensor);
1142 }
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:658

◆ applyThermalStrain()

void SolidModel::applyThermalStrain ( )
virtualinherited

Definition at line 586 of file SolidModel.C.

Referenced by SolidModel::modifyStrainIncrement().

587 {
588  if (_has_temp && !_step_zero)
589  {
590  Real inc_thermal_strain;
591  Real d_thermal_strain_d_temp;
592 
593  Real old_temp;
595  old_temp = _stress_free_temp;
596  else
597  old_temp = _temperature_old[_qp];
598 
599  Real current_temp = _temperature[_qp];
600 
601  Real delta_t = current_temp - old_temp;
602 
603  Real alpha = _alpha;
604 
605  if (_alpha_function)
606  {
607  Point p;
608  Real alpha_current_temp = _alpha_function->value(current_temp, p);
609  Real alpha_old_temp = _alpha_function->value(old_temp, p);
610 
612  {
613  Real alpha_stress_free_temperature = _alpha_function->value(_stress_free_temp, p);
614  Real small(1e-6);
615 
616  Real numerator = alpha_current_temp * (current_temp - _ref_temp) -
617  alpha_old_temp * (old_temp - _ref_temp);
618  Real denominator = 1.0 + alpha_stress_free_temperature * (_stress_free_temp - _ref_temp);
619  if (denominator < small)
620  mooseError("Denominator too small in thermal strain calculation");
621  inc_thermal_strain = numerator / denominator;
622  d_thermal_strain_d_temp = alpha_current_temp * (current_temp - _ref_temp);
623  }
624  else
625  {
626  inc_thermal_strain = delta_t * 0.5 * (alpha_current_temp + alpha_old_temp);
627  d_thermal_strain_d_temp = alpha_current_temp;
628  }
629  }
630  else
631  {
632  inc_thermal_strain = delta_t * alpha;
633  d_thermal_strain_d_temp = alpha;
634  }
635 
636  _strain_increment.addDiag(-inc_thermal_strain);
637  _d_strain_dT.addDiag(-d_thermal_strain_d_temp);
638  }
639 }
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 644 of file SolidModel.C.

Referenced by SolidModel::modifyStrainIncrement().

645 {
646  const Real V0Vold = 1 / _element->volumeRatioOld(_qp);
647  const SubdomainID current_block = _current_elem->subdomain_id();
648  const std::vector<MooseSharedPointer<VolumetricModel>> & vm(_volumetric_models[current_block]);
649  for (unsigned int i(0); i < vm.size(); ++i)
650  {
651  vm[i]->modifyStrain(_qp, V0Vold, _strain_increment, _d_strain_dT);
652  }
653 }
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 372 of file SolidModel.C.

Referenced by SolidModel::initialSetup().

373 {
374  int num_elastic_constants = _bulk_modulus_set + _lambda_set + _poissons_ratio_set +
376 
377  if (num_elastic_constants != 2)
378  {
379  std::string err("Exactly two elastic constants must be defined for material '");
380  err += name();
381  err += "'.";
382  mooseError(err);
383  }
384 
385  if (_bulk_modulus_set && _bulk_modulus <= 0)
386  {
387  std::string err("Bulk modulus must be positive in material '");
388  err += name();
389  err += "'.";
390  mooseError(err);
391  }
392  if (_poissons_ratio_set && (_poissons_ratio <= -1.0 || _poissons_ratio >= 0.5))
393  {
394  std::string err("Poissons ratio must be greater than -1 and less than 0.5 in material '");
395  err += name();
396  err += "'.";
397  mooseError(err);
398  }
400  {
401  std::string err("Shear modulus must not be negative in material '");
402  err += name();
403  err += "'.";
404  mooseError(err);
405  }
407  {
408  std::string err("Youngs modulus must be positive in material '");
409  err += name();
410  err += "'.";
411  mooseError(err);
412  }
413 
414  // Calculate lambda, the shear modulus, and Young's modulus
415  if (_lambda_set && _shear_modulus_set) // First and second Lame
416  {
420  }
421  else if (_lambda_set && _poissons_ratio_set)
422  {
423  _shear_modulus = (_lambda * (1.0 - 2.0 * _poissons_ratio)) / (2.0 * _poissons_ratio);
426  }
427  else if (_lambda_set && _bulk_modulus_set)
428  {
429  _shear_modulus = 3.0 * (_bulk_modulus - _lambda) / 2.0;
433  }
434  else if (_lambda_set && _youngs_modulus_set)
435  {
437  ((_youngs_modulus - 3.0 * _lambda) / 4.0) +
438  (std::sqrt((_youngs_modulus - 3.0 * _lambda) * (_youngs_modulus - 3.0 * _lambda) +
439  8.0 * _lambda * _youngs_modulus) /
440  4.0);
442  }
444  {
445  _lambda = (2.0 * _shear_modulus * _poissons_ratio) / (1.0 - 2.0 * _poissons_ratio);
448  }
450  {
451  _lambda = _bulk_modulus - 2.0 * _shear_modulus / 3.0;
455  (3 * _bulk_modulus - 2 * _shear_modulus) / (2 * (3 * _bulk_modulus + _shear_modulus));
456  }
458  {
462  }
464  {
467  (3.0 * _bulk_modulus * (1.0 - 2.0 * _poissons_ratio)) / (2.0 * (1.0 + _poissons_ratio));
470  }
471  else if (_youngs_modulus_set && _poissons_ratio_set) // Young's Modulus and Poisson's Ratio
472  {
474  ((1.0 + _poissons_ratio) * (1 - 2.0 * _poissons_ratio));
475  _shear_modulus = _youngs_modulus / (2.0 * (1.0 + _poissons_ratio));
476  }
478  {
479  _lambda = 3.0 * _bulk_modulus * (3.0 * _bulk_modulus - _youngs_modulus) /
480  (9.0 * _bulk_modulus - _youngs_modulus);
484  }
485 
486  _lambda_set = true;
487  _shear_modulus_set = true;
488  _youngs_modulus_set = true;
489  _poissons_ratio_set = true;
490 }
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 836 of file SolidModel.C.

Referenced by SolidModel::computeProperties().

837 {
838  // Given the stretching, compute the stress increment and add it to the old stress. Also update
839  // the creep strain
840  // stress = stressOld + stressIncrement
841 
842  const SubdomainID current_block = _current_elem->subdomain_id();
843  MooseSharedPointer<ConstitutiveModel> cm = _constitutive_model[current_block];
844 
845  mooseAssert(_constitutive_active, "Logic error. ConstitutiveModel not active.");
846 
847  // Let's be a little careful and check for a non-existent
848  // ConstitutiveModel, which could be returned as a default value
849  // from std::map::operator[]
850  if (!cm)
851  mooseError("Logic error. No ConstitutiveModel for current_block=", current_block, ".");
852 
853  cm->setQp(_qp);
854  cm->computeStress(
855  *_current_elem, *elasticityTensor(), _stress_old, _strain_increment, _stress[_qp]);
856 }
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 1403 of file SolidModel.C.

Referenced by SolidModel::crackingStressRotation().

1404 {
1406  {
1407  if ((*_crack_max_strain)[_qp](i) < (*_crack_strain)[_qp](i))
1408  {
1409  std::stringstream err;
1410  err << "Max strain less than crack strain: " << i << " " << sigma << ", "
1411  << (*_crack_max_strain)[_qp](i) << ", " << (*_crack_strain)[_qp](i) << ", "
1412  << _principal_strain(0, 0) << ", " << _principal_strain(1, 0) << ", "
1413  << _principal_strain(2, 0) << _elastic_strain[_qp] << std::endl;
1414  mooseError(err.str());
1415  }
1416  const Real crackMaxStrain((*_crack_max_strain)[_qp](i));
1417  // Compute stress that follows exponental curve
1421  (crackMaxStrain - (*_crack_strain)[_qp](i))));
1422  // Compute ratio of current stiffness to original stiffness
1423  flagVal = sigma * (*_crack_strain)[_qp](i) / (crackMaxStrain * _cracking_stress);
1424  }
1425  else
1426  {
1427  if (_cracking_residual_stress == 0)
1428  {
1429  const Real tiny(1e-16);
1430  flagVal = tiny;
1431  sigma = tiny * (*_crack_strain)[_qp](i) * _youngs_modulus;
1432  }
1433  else
1434  {
1436  flagVal = sigma / ((*_crack_max_strain)[_qp](i) * _youngs_modulus);
1437  }
1438  }
1439  if (flagVal < 0)
1440  {
1441  std::stringstream err;
1442  err << "Negative crack flag found: " << i << " " << flagVal << ", "
1443  << (*_crack_max_strain)[_qp](i) << ", " << (*_crack_strain)[_qp](i) << ", " << std::endl;
1444  mooseError(err.str());
1445  }
1446  return flagVal;
1447 }
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 1638 of file SolidModel.C.

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

1639 {
1641  "_current_instantaneous_thermal_expansion_coef not initialized");
1642 
1643  (*_current_instantaneous_thermal_expansion_coef)[_qp] = 0.0;
1644 
1645  if (_alpha_function)
1646  {
1647  Point p;
1648  Real current_temp = _temperature[_qp];
1649 
1650  if (!_mean_alpha_function)
1651  {
1652  Real alpha = _alpha_function->value(current_temp, p);
1653  (*_current_instantaneous_thermal_expansion_coef)[_qp] = alpha;
1654  }
1655  else
1656  {
1657  Real small(1e-6);
1658  Real dalphabar_dT = _alpha_function->timeDerivative(current_temp, p);
1659  Real alphabar_Tsf = _alpha_function->value(_stress_free_temp, p);
1660  Real alphabar = _alpha_function->value(current_temp, p);
1661  Real numerator = dalphabar_dT * (current_temp - _ref_temp) + alphabar;
1662  Real denominator = 1.0 + alphabar_Tsf * (_stress_free_temp - _ref_temp);
1663  if (denominator < small)
1664  mooseError("Denominator too small in thermal strain calculation");
1665  (*_current_instantaneous_thermal_expansion_coef)[_qp] = numerator / denominator;
1666  }
1667  }
1668  else
1670 }
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 860 of file SolidModel.C.

Referenced by SolidModel::computeProperties().

861 {
862  if (_cracking_stress_function != NULL)
863  {
864  _cracking_stress = _cracking_stress_function->value(_t, _q_point[_qp]);
865  }
866 
868 
870 
872 
874 
876 
877  if (changed || _cracking_stress > 0)
878  {
880  }
881 }
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:886
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:1043

◆ computeEshelby()

void SolidModel::computeEshelby ( )
protectedvirtualinherited

Definition at line 787 of file SolidModel.C.

Referenced by SolidModel::computeProperties().

788 {
789  mooseAssert(_SED, "_SED not initialized");
790  mooseAssert(_Eshelby_tensor, "_Eshelby_tensor not initialized");
791  // Cauchy stress (sigma) in a colum major matrix:
792  ColumnMajorMatrix stress_CMM;
793  stress_CMM(0, 0) = _stress[_qp].xx();
794  stress_CMM(0, 1) = _stress[_qp].xy();
795  stress_CMM(0, 2) = _stress[_qp].xz();
796  stress_CMM(1, 0) = _stress[_qp].xy();
797  stress_CMM(1, 1) = _stress[_qp].yy();
798  stress_CMM(1, 2) = _stress[_qp].yz();
799  stress_CMM(2, 0) = _stress[_qp].xz();
800  stress_CMM(2, 1) = _stress[_qp].yz();
801  stress_CMM(2, 2) = _stress[_qp].zz();
802 
803  // Deformation gradient (F):
804  ColumnMajorMatrix F;
806  // Displacement gradient (H):
807  ColumnMajorMatrix H(F);
808  H.addDiag(-1.0);
809  Real detF = _element->detMatrix(F);
810  ColumnMajorMatrix Finv;
811  _element->invertMatrix(F, Finv);
812  ColumnMajorMatrix FinvT;
813  FinvT = Finv.transpose();
814  ColumnMajorMatrix HT;
815  HT = H.transpose();
816 
817  // 1st Piola-Kirchoff Stress (P):
818  ColumnMajorMatrix piola;
819  piola = stress_CMM * FinvT;
820  piola *= detF;
821 
822  // HTP = H^T * P = H^T * detF * sigma * FinvT;
823  ColumnMajorMatrix HTP;
824  HTP = HT * piola;
825 
826  ColumnMajorMatrix WI;
827  WI.identity();
828  WI *= (*_SED)[_qp];
829  WI *= detF;
830  (*_Eshelby_tensor)[_qp] = WI - HTP;
831 }
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 939 of file SolidModel.C.

Referenced by SolidModel::computeProperties().

940 {
941  mooseAssert(_local_elasticity_tensor, "null elasticity tensor");
942 
943  // _Jacobian_mult[_qp] = *_local_elasticity_tensor;
944  // _d_stress_dT[_qp] = *_local_elasticity_tensor * _d_strain_dT;
947 }
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 724 of file SolidModel.C.

725 {
726  if (_t_step >= 1)
727  _step_zero = false;
728 
729  if (_t_step >= 2)
730  _step_one = false;
731 
732  elementInit();
733  _element->init();
734 
735  for (_qp = 0; _qp < _qrule->n_points(); ++_qp)
736  {
739 
742 
744 
746  computeStress();
747  else
749 
750  if (_compute_JIntegral)
752 
754 
756 
757  finalizeStress();
758 
759  if (_compute_JIntegral)
760  computeEshelby();
761 
764 
767 
769  }
770 }
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:555
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:787
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:939
MaterialProperty< SymmTensor > & _total_strain
Definition: SolidModel.h:117
const MaterialProperty< SymmTensor > & _total_strain_old
Definition: SolidModel.h:118
virtual void crackingStressRotation()
Definition: SolidModel.C:1232
virtual void computeCurrentInstantaneousThermalExpansionCoefficient()
Definition: SolidModel.C:1638
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:836
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:775
virtual void finalizeStress()
Rotate stress to current configuration.
Definition: SolidModel.C:927
virtual void computeThermalJvec()
Definition: SolidModel.C:1622
virtual void init()
Definition: Element.h:49
virtual void computeStress()
Compute the stress (sigma += deltaSigma)
Definition: SolidModel.h:191
void computeElasticityTensor()
Definition: SolidModel.C:860

◆ computeStrainEnergyDensity()

void SolidModel::computeStrainEnergyDensity ( )
protectedvirtualinherited

Definition at line 775 of file SolidModel.C.

Referenced by SolidModel::computeProperties().

776 {
777  mooseAssert(_SED, "_SED not initialized");
778  mooseAssert(_SED_old, "_SED_old not initialized");
779  (*_SED)[_qp] = (*_SED_old)[_qp] +
780  _stress[_qp].doubleContraction(_mechanical_strain_increment) / 2 +
781  _stress_old_prop[_qp].doubleContraction(_mechanical_strain_increment) / 2;
782 }
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 AbaqusUmatMaterial::computeStress ( )
protectedvirtual

Compute the stress (sigma += deltaSigma)

Reimplemented from SolidModel.

Definition at line 182 of file AbaqusUmatMaterial.C.

183 {
184  // Calculate deformation gradient - modeled from "solid_mechanics/src/materials/Nonlinear3D.C"
185  // Fbar = 1 + grad(u(k))
186  ColumnMajorMatrix Fbar;
187 
188  Fbar(0, 0) = _grad_disp_x[_qp](0);
189  Fbar(0, 1) = _grad_disp_x[_qp](1);
190  Fbar(0, 2) = _grad_disp_x[_qp](2);
191  Fbar(1, 0) = _grad_disp_y[_qp](0);
192  Fbar(1, 1) = _grad_disp_y[_qp](1);
193  Fbar(1, 2) = _grad_disp_y[_qp](2);
194  Fbar(2, 0) = _grad_disp_z[_qp](0);
195  Fbar(2, 1) = _grad_disp_z[_qp](1);
196  Fbar(2, 2) = _grad_disp_z[_qp](2);
197 
198  Fbar.addDiag(1);
199  _Fbar[_qp] = Fbar;
200 
201  Real myDFGRD0[9] = {_Fbar_old[_qp](0, 0),
202  _Fbar_old[_qp](1, 0),
203  _Fbar_old[_qp](2, 0),
204  _Fbar_old[_qp](0, 1),
205  _Fbar_old[_qp](1, 1),
206  _Fbar_old[_qp](2, 1),
207  _Fbar_old[_qp](0, 2),
208  _Fbar_old[_qp](1, 2),
209  _Fbar_old[_qp](2, 2)};
210  Real myDFGRD1[9] = {_Fbar[_qp](0, 0),
211  _Fbar[_qp](1, 0),
212  _Fbar[_qp](2, 0),
213  _Fbar[_qp](0, 1),
214  _Fbar[_qp](1, 1),
215  _Fbar[_qp](2, 1),
216  _Fbar[_qp](0, 2),
217  _Fbar[_qp](1, 2),
218  _Fbar[_qp](2, 2)};
219 
220  for (unsigned int i = 0; i < 9; ++i)
221  {
222  _DFGRD0[i] = myDFGRD0[i];
223  _DFGRD1[i] = myDFGRD1[i];
224  }
225 
226  // Recover "old" state variables
227  for (unsigned int i = 0; i < _num_state_vars; ++i)
228  _STATEV[i] = _state_var_old[_qp][i];
229 
230  // Pass through updated stress, total strain, and strain increment arrays
231  for (int i = 0; i < _NTENS; ++i)
232  {
233  _STRESS[i] = _stress_old.component(i);
234  _STRAN[i] = _total_strain[_qp].component(i);
236  }
237 
238  // Pass through step , time, and coordinate system information
239  _KSTEP = _t_step; // Step number
240  _TIME[0] = _t; // Value of step time at the beginning of the current increment - Check
241  _TIME[1] = _t - _dt; // Value of total time at the beginning of the current increment - Check
242  _DTIME = _dt; // Time increment
243  for (unsigned int i = 0; i < 3; ++i) // Loop current coordinates in UMAT COORDS
244  _COORDS[i] = _coord[i];
245 
246  // Connection to extern statement
247  _umat(_STRESS,
248  _STATEV,
249  _DDSDDE,
250  &_SSE,
251  &_SPD,
252  &_SCD,
253  &_RPL,
254  _DDSDDT,
255  _DRPLDE,
256  &_DRPLDT,
257  _STRAN,
258  _DSTRAN,
259  _TIME,
260  &_DTIME,
261  &_TEMP,
262  &_DTEMP,
263  _PREDEF,
264  _DPRED,
265  &_CMNAME,
266  &_NDI,
267  &_NSHR,
268  &_NTENS,
269  &_NSTATV,
270  _PROPS,
271  &_NPROPS,
272  _COORDS,
273  _DROT,
274  &_PNEWDT,
275  &_CELENT,
276  _DFGRD0,
277  _DFGRD1,
278  &_NOEL,
279  &_NPT,
280  &_LAYER,
281  &_KSPT,
282  &_KSTEP,
283  &_KINC);
284 
285  // Energy outputs
287  _plastic_dissipation[_qp] = _SPD;
288  _creep_dissipation[_qp] = _SCD;
289 
290  // Update state variables
291  for (unsigned int i = 0; i < _num_state_vars; ++i)
292  _state_var[_qp][i] = _STATEV[i];
293 
294  // Get new stress tensor - UMAT should update stress
295  SymmTensor stressnew(_STRESS[0], _STRESS[1], _STRESS[2], _STRESS[3], _STRESS[4], _STRESS[5]);
296  _stress[_qp] = stressnew;
297 }
const VariableGradient & _grad_disp_z
const VariableGradient & _grad_disp_y
const VariableGradient & _grad_disp_x
MaterialProperty< SymmTensor > & _total_strain
Definition: SolidModel.h:117
MaterialProperty< std::vector< Real > > & _state_var
const MaterialProperty< std::vector< Real > > & _state_var_old
MaterialProperty< Real > & _elastic_strain_energy
MaterialProperty< Real > & _plastic_dissipation
Real component(unsigned int i) const
Definition: SymmTensor.h:100
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< Real > & _creep_dissipation
MaterialProperty< SymmTensor > & _stress
Definition: SolidModel.h:109
unsigned int _num_state_vars
MaterialProperty< ColumnMajorMatrix > & _Fbar
const MaterialProperty< ColumnMajorMatrix > & _Fbar_old

◆ computeThermalJvec()

void SolidModel::computeThermalJvec ( )
protectedvirtualinherited

Definition at line 1622 of file SolidModel.C.

Referenced by SolidModel::computeProperties().

1623 {
1624  mooseAssert(_J_thermal_term_vec, "_J_thermal_term_vec not initialized");
1625 
1626  Real stress_trace = _stress[_qp].xx() + _stress[_qp].yy() + _stress[_qp].zz();
1627 
1629  for (unsigned int i = 0; i < LIBMESH_DIM; ++i)
1630  {
1631  Real dthermstrain_dx =
1633  (*_J_thermal_term_vec)[_qp](i) = stress_trace * dthermstrain_dx;
1634  }
1635 }
virtual void computeCurrentInstantaneousThermalExpansionCoefficient()
Definition: SolidModel.C:1638
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 1043 of file SolidModel.C.

Referenced by SolidModel::computeElasticityTensor().

1044 {
1045  bool cracking_locally_active(false);
1046  if (_cracking_stress > 0)
1047  {
1048  // Compute whether cracking has occurred
1049  (*_crack_rotation)[_qp] = (*_crack_rotation_old)[_qp];
1050 
1051  ColumnMajorMatrix RT((*_crack_rotation)[_qp].transpose());
1052  SymmTensor ePrime;
1053  rotateSymmetricTensor(RT, _elastic_strain[_qp], ePrime);
1054 
1055  for (unsigned int i(0); i < 3; ++i)
1056  {
1057  (*_crack_max_strain)[_qp](i) = (*_crack_max_strain_old)[_qp](i);
1058 
1059  if (_cracking_neg_fraction == 0 && ePrime(i, i) < 0)
1060  {
1061  _crack_flags_local(i) = 1;
1062  }
1063  else if (_cracking_neg_fraction > 0 &&
1064  (*_crack_strain)[_qp](i) * _cracking_neg_fraction > ePrime(i, i))
1065  {
1066  if (-(*_crack_strain)[_qp](i) * _cracking_neg_fraction > ePrime(i, i))
1067  {
1068  _crack_flags_local(i) = 1;
1069  }
1070  else
1071  {
1072  // s = a*e^2 + b*e + c
1073  // a = (Ec-Eo)/(4etr)
1074  // b = (Ec+Eo)/2
1075  // c = (Ec-Eo)*etr/4
1076  // etr = _cracking_neg_fraction * strain when crack occurred
1077  const Real etr = _cracking_neg_fraction * (*_crack_strain)[_qp](i);
1078  const Real Eo = _cracking_stress / (*_crack_strain)[_qp](i);
1079  const Real Ec = Eo * (*_crack_flags_old)[_qp](i);
1080  const Real a = (Ec - Eo) / (4 * etr);
1081  const Real b = (Ec + Eo) / 2;
1082  // Compute the ratio of the current transition stiffness to the original stiffness
1083  _crack_flags_local(i) = (2 * a * etr + b) / Eo;
1084  cracking_locally_active = true;
1085  }
1086  }
1087  else
1088  {
1089  _crack_flags_local(i) = (*_crack_flags_old)[_qp](i);
1090  if (_crack_flags_local(i) < 1)
1091  {
1092  cracking_locally_active = true;
1093  }
1094  }
1095  }
1096  }
1097  if (cracking_locally_active)
1098  {
1099  // Adjust the elasticity matrix for cracking. This must be used by the
1100  // constitutive law.
1101  if (_compute_method == "ShearRetention")
1103  else
1105 
1106  ColumnMajorMatrix R_9x9(9, 9);
1107  const ColumnMajorMatrix & R((*_crack_rotation)[_qp]);
1110 
1112  }
1113 }
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:658

◆ crackingStressRotation()

void SolidModel::crackingStressRotation ( )
protectedvirtualinherited

Definition at line 1232 of file SolidModel.C.

Referenced by SolidModel::computeProperties().

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

◆ createConstitutiveModel()

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

Definition at line 1586 of file SolidModel.C.

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

1587 {
1588 
1589  Factory & factory = _app.getFactory();
1590  InputParameters params = factory.getValidParams(cm_name);
1591 
1592  params += parameters();
1593  MooseSharedPointer<ConstitutiveModel> cm =
1594  factory.create<ConstitutiveModel>(cm_name, name() + "Model", params, _tid);
1595 
1596  _models_to_free.insert(
1597  cm); // Keep track of the dynamic memory that is created internally to this object
1598 
1599  _constitutive_active = true;
1600  for (unsigned i(0); i < _block_id.size(); ++i)
1601  {
1602  _constitutive_model[_block_id[i]] = cm;
1603  }
1604 }
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 495 of file SolidModel.C.

Referenced by SolidModel::initialSetup().

496 {
497  bool constant(true);
498 
501  {
502  constant = false;
503  }
504 
506  mooseAssert(_youngs_modulus_set, "Internal error: Youngs modulus not set");
507  mooseAssert(_poissons_ratio_set, "Internal error: Poissons ratio not set");
510  iso->calculate(0);
511  elasticityTensor(iso);
512 }
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 546 of file SolidModel.C.

547 {
550 }
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 927 of file SolidModel.C.

Referenced by SolidModel::computeProperties().

928 {
929  std::vector<SymmTensor *> t(3);
930  t[0] = &_elastic_strain[_qp];
931  t[1] = &_total_strain[_qp];
932  t[2] = &_stress[_qp];
934 }
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 1450 of file SolidModel.C.

Referenced by SolidModel::computeCrackStrainAndOrientation().

1451 {
1452  const unsigned fromElement = _element->getNumKnownCrackDirs();
1453  unsigned int retVal(0);
1454  for (unsigned int i(0); i < 3 - fromElement; ++i)
1455  {
1456  retVal += ((*_crack_flags_old)[_qp](i) < 1);
1457  }
1458  return retVal + fromElement;
1459 }
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 952 of file SolidModel.C.

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

Reimplemented from SolidModel.

Definition at line 173 of file AbaqusUmatMaterial.C.

174 {
175  // Initialize state variable vector
176  _state_var[_qp].resize(_num_state_vars);
177  for (unsigned int i = 0; i < _num_state_vars; ++i)
178  _state_var[_qp][i] = 0.0;
179 }
MaterialProperty< std::vector< Real > > & _state_var
unsigned int _num_state_vars

◆ initStatefulProperties()

void SolidModel::initStatefulProperties ( unsigned  n_points)
virtualinherited

Reimplemented in AbaqusCreepMaterial.

Definition at line 1607 of file SolidModel.C.

1608 {
1609  for (_qp = 0; _qp < n_points; ++_qp)
1610  {
1612  }
1614  {
1615  const SubdomainID current_block = _current_elem->subdomain_id();
1616  MooseSharedPointer<ConstitutiveModel> cm = _constitutive_model[current_block];
1617  cm->initStatefulProperties(n_points);
1618  }
1619 }
bool _constitutive_active
Definition: SolidModel.h:254
virtual void initQpStatefulProperties()
Definition: SolidModel.C:691
std::map< SubdomainID, MooseSharedPointer< ConstitutiveModel > > _constitutive_model
Definition: SolidModel.h:251

◆ jacobianSetup()

void SolidModel::jacobianSetup ( )
protectedvirtualinherited

Definition at line 528 of file SolidModel.C.

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

◆ JxW()

Real SolidModel::JxW ( unsigned  i) const
inlineinherited

◆ modifyStrainIncrement()

void SolidModel::modifyStrainIncrement ( )
protectedvirtualinherited

Modify increment for things like thermal strain.

Definition at line 555 of file SolidModel.C.

Referenced by SolidModel::computeProperties().

556 {
557  bool modified = false;
558  _d_strain_dT.zero();
559 
560  const SubdomainID current_block = _current_elem->subdomain_id();
562  {
563  MooseSharedPointer<ConstitutiveModel> cm = _constitutive_model[current_block];
564 
565  // Let's be a little careful and check for a non-existent
566  // ConstitutiveModel, which could be returned as a default value
567  // from std::map::operator[]
568  if (!cm)
569  mooseError("ConstitutiveModel not available for block ", current_block);
570 
571  cm->setQp(_qp);
572  modified |= cm->modifyStrainIncrement(*_current_elem, _strain_increment, _d_strain_dT);
573  }
574 
575  if (!modified)
576  {
578  }
579 
581 }
bool _constitutive_active
Definition: SolidModel.h:254
void zero()
Definition: SymmTensor.h:276
virtual void applyThermalStrain()
Definition: SolidModel.C:586
SymmTensor _d_strain_dT
Definition: SolidModel.h:140
virtual void applyVolumetricStrain()
Definition: SolidModel.C:644
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 658 of file SolidModel.C.

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

661 {
662 
663  // R T Rt
664  // 00 01 02 00 01 02 00 10 20
665  // 10 11 12 * 10 11 12 * 01 11 21
666  // 20 21 22 20 21 22 02 12 22
667  //
668  const Real T00 = R(0, 0) * T.xx() + R(0, 1) * T.xy() + R(0, 2) * T.zx();
669  const Real T01 = R(0, 0) * T.xy() + R(0, 1) * T.yy() + R(0, 2) * T.yz();
670  const Real T02 = R(0, 0) * T.zx() + R(0, 1) * T.yz() + R(0, 2) * T.zz();
671 
672  const Real T10 = R(1, 0) * T.xx() + R(1, 1) * T.xy() + R(1, 2) * T.zx();
673  const Real T11 = R(1, 0) * T.xy() + R(1, 1) * T.yy() + R(1, 2) * T.yz();
674  const Real T12 = R(1, 0) * T.zx() + R(1, 1) * T.yz() + R(1, 2) * T.zz();
675 
676  const Real T20 = R(2, 0) * T.xx() + R(2, 1) * T.xy() + R(2, 2) * T.zx();
677  const Real T21 = R(2, 0) * T.xy() + R(2, 1) * T.yy() + R(2, 2) * T.yz();
678  const Real T22 = R(2, 0) * T.zx() + R(2, 1) * T.yz() + R(2, 2) * T.zz();
679 
680  result.xx(T00 * R(0, 0) + T01 * R(0, 1) + T02 * R(0, 2));
681  result.yy(T10 * R(1, 0) + T11 * R(1, 1) + T12 * R(1, 2));
682  result.zz(T20 * R(2, 0) + T21 * R(2, 1) + T22 * R(2, 2));
683  result.xy(T00 * R(1, 0) + T01 * R(1, 1) + T02 * R(1, 2));
684  result.yz(T10 * R(2, 0) + T11 * R(2, 1) + T12 * R(2, 2));
685  result.zx(T00 * R(2, 0) + T01 * R(2, 1) + T02 * R(2, 2));
686 }
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 517 of file SolidModel.C.

518 {
519  // if (_cracking_stress > 0)
520  // {
521  // _cracked_this_step_count.clear();
522  // }
523 }

◆ updateElasticityTensor()

bool SolidModel::updateElasticityTensor ( SymmElasticityTensor tensor)
protectedvirtualinherited

Return true if the elasticity tensor changed.

Reimplemented in MacroElastic.

Definition at line 886 of file SolidModel.C.

Referenced by SolidModel::computeElasticityTensor().

887 {
888  bool changed(false);
890  {
891  const SubdomainID current_block = _current_elem->subdomain_id();
892  MooseSharedPointer<ConstitutiveModel> cm = _constitutive_model[current_block];
893 
894  // Let's be a little careful and check for a non-existent
895  // ConstitutiveModel, which could be returned as a default value
896  // from std::map::operator[]
897  if (!cm)
898  mooseError("ConstitutiveModel not available for block ", current_block);
899 
900  cm->setQp(_qp);
901  changed |= cm->updateElasticityTensor(tensor);
902  }
903 
905  {
906  SymmIsotropicElasticityTensor * t = dynamic_cast<SymmIsotropicElasticityTensor *>(&tensor);
907  if (!t)
908  {
909  mooseError("Cannot use Youngs modulus or Poissons ratio functions");
910  }
911  t->unsetConstants();
912  Point p;
914  ? _youngs_modulus_function->value(_temperature[_qp], p)
915  : _youngs_modulus));
917  ? _poissons_ratio_function->value(_temperature[_qp], p)
918  : _poissons_ratio));
919  changed = true;
920  }
921  return changed;
922 }
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().

◆ _CELENT

Real AbaqusUmatMaterial::_CELENT
protected

Definition at line 80 of file AbaqusUmatMaterial.h.

Referenced by computeStress().

◆ _CMNAME

Real AbaqusUmatMaterial::_CMNAME
protected

Definition at line 80 of file AbaqusUmatMaterial.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 AbaqusUmatMaterial::_COORDS[3]
protected

Definition at line 86 of file AbaqusUmatMaterial.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_dissipation

MaterialProperty<Real>& AbaqusUmatMaterial::_creep_dissipation
protected

Definition at line 104 of file AbaqusUmatMaterial.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().

◆ _DDSDDE

Real * AbaqusUmatMaterial::_DDSDDE
protected

Definition at line 86 of file AbaqusUmatMaterial.h.

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

◆ _DDSDDT

Real * AbaqusUmatMaterial::_DDSDDT
protected

Definition at line 86 of file AbaqusUmatMaterial.h.

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

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

◆ _DFGRD0

Real * AbaqusUmatMaterial::_DFGRD0
protected

Definition at line 86 of file AbaqusUmatMaterial.h.

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

◆ _DFGRD1

Real * AbaqusUmatMaterial::_DFGRD1
protected

Definition at line 86 of file AbaqusUmatMaterial.h.

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

◆ _DPRED

Real AbaqusUmatMaterial::_DPRED[1]
protected

Definition at line 86 of file AbaqusUmatMaterial.h.

Referenced by computeStress().

◆ _DROT

Real AbaqusUmatMaterial::_DROT[3][3]
protected

Definition at line 86 of file AbaqusUmatMaterial.h.

Referenced by computeStress().

◆ _DRPLDE

Real * AbaqusUmatMaterial::_DRPLDE
protected

Definition at line 86 of file AbaqusUmatMaterial.h.

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

◆ _DRPLDT

Real AbaqusUmatMaterial::_DRPLDT
protected

Definition at line 80 of file AbaqusUmatMaterial.h.

Referenced by computeStress().

◆ _DSTRAN

Real * AbaqusUmatMaterial::_DSTRAN
protected

Definition at line 86 of file AbaqusUmatMaterial.h.

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

◆ _DTEMP

Real AbaqusUmatMaterial::_DTEMP
protected

Definition at line 80 of file AbaqusUmatMaterial.h.

Referenced by computeStress().

◆ _DTIME

Real AbaqusUmatMaterial::_DTIME
protected

Definition at line 80 of file AbaqusUmatMaterial.h.

Referenced by computeStress().

◆ _elastic_strain

MaterialProperty<SymmTensor>& SolidModel::_elastic_strain
protectedinherited

◆ _elastic_strain_energy

MaterialProperty<Real>& AbaqusUmatMaterial::_elastic_strain_energy
protected

Definition at line 102 of file AbaqusUmatMaterial.h.

Referenced by computeStress().

◆ _elastic_strain_old

const MaterialProperty<SymmTensor>& SolidModel::_elastic_strain_old
protectedinherited

◆ _elasticity_tensor

MaterialProperty<SymmElasticityTensor>& SolidModel::_elasticity_tensor
protectedinherited

◆ _Eshelby_tensor

MaterialProperty<RankTwoTensor>* SolidModel::_Eshelby_tensor
protectedinherited

Definition at line 160 of file SolidModel.h.

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

◆ _Fbar

MaterialProperty<ColumnMajorMatrix>& AbaqusUmatMaterial::_Fbar
protected

Definition at line 100 of file AbaqusUmatMaterial.h.

Referenced by computeStress().

◆ _Fbar_old

const MaterialProperty<ColumnMajorMatrix>& AbaqusUmatMaterial::_Fbar_old
protected

Definition at line 101 of file AbaqusUmatMaterial.h.

Referenced by computeStress().

◆ _grad_disp_x

const VariableGradient& AbaqusUmatMaterial::_grad_disp_x
protected

Definition at line 92 of file AbaqusUmatMaterial.h.

Referenced by computeStress().

◆ _grad_disp_x_old

const VariableGradient& AbaqusUmatMaterial::_grad_disp_x_old
protected

Definition at line 95 of file AbaqusUmatMaterial.h.

◆ _grad_disp_y

const VariableGradient& AbaqusUmatMaterial::_grad_disp_y
protected

Definition at line 93 of file AbaqusUmatMaterial.h.

Referenced by computeStress().

◆ _grad_disp_y_old

const VariableGradient& AbaqusUmatMaterial::_grad_disp_y_old
protected

Definition at line 96 of file AbaqusUmatMaterial.h.

◆ _grad_disp_z

const VariableGradient& AbaqusUmatMaterial::_grad_disp_z
protected

Definition at line 94 of file AbaqusUmatMaterial.h.

Referenced by computeStress().

◆ _grad_disp_z_old

const VariableGradient& AbaqusUmatMaterial::_grad_disp_z_old
protected

Definition at line 97 of file AbaqusUmatMaterial.h.

◆ _handle

void* AbaqusUmatMaterial::_handle
protected

Definition at line 74 of file AbaqusUmatMaterial.h.

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

◆ _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

◆ _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 AbaqusUmatMaterial::_KINC
protected

Definition at line 83 of file AbaqusUmatMaterial.h.

Referenced by computeStress().

◆ _KSPT

int AbaqusUmatMaterial::_KSPT
protected

Definition at line 83 of file AbaqusUmatMaterial.h.

Referenced by computeStress().

◆ _KSTEP

int AbaqusUmatMaterial::_KSTEP
protected

Definition at line 83 of file AbaqusUmatMaterial.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 AbaqusUmatMaterial::_LAYER
protected

Definition at line 83 of file AbaqusUmatMaterial.h.

Referenced by 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_constants

std::vector<Real> AbaqusUmatMaterial::_mechanical_constants
protected

Definition at line 68 of file AbaqusUmatMaterial.h.

Referenced by AbaqusUmatMaterial().

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

◆ _NDI

int AbaqusUmatMaterial::_NDI
protected

Definition at line 83 of file AbaqusUmatMaterial.h.

Referenced by AbaqusUmatMaterial(), and computeStress().

◆ _NOEL

int AbaqusUmatMaterial::_NOEL
protected

Definition at line 83 of file AbaqusUmatMaterial.h.

Referenced by computeStress().

◆ _NPROPS

int AbaqusUmatMaterial::_NPROPS
protected

Definition at line 83 of file AbaqusUmatMaterial.h.

Referenced by AbaqusUmatMaterial(), and computeStress().

◆ _NPT

int AbaqusUmatMaterial::_NPT
protected

Definition at line 83 of file AbaqusUmatMaterial.h.

Referenced by computeStress().

◆ _NSHR

int AbaqusUmatMaterial::_NSHR
protected

Definition at line 83 of file AbaqusUmatMaterial.h.

Referenced by AbaqusUmatMaterial(), and computeStress().

◆ _NSTATV

int AbaqusUmatMaterial::_NSTATV
protected

Definition at line 83 of file AbaqusUmatMaterial.h.

Referenced by AbaqusUmatMaterial(), and computeStress().

◆ _NTENS

int AbaqusUmatMaterial::_NTENS
protected

Definition at line 83 of file AbaqusUmatMaterial.h.

Referenced by AbaqusUmatMaterial(), and computeStress().

◆ _num_props

unsigned int AbaqusUmatMaterial::_num_props
protected

Definition at line 71 of file AbaqusUmatMaterial.h.

Referenced by AbaqusUmatMaterial().

◆ _num_state_vars

unsigned int AbaqusUmatMaterial::_num_state_vars
protected

◆ _piecewise_linear_alpha_function

PiecewiseLinear* SolidModel::_piecewise_linear_alpha_function
protectedinherited

Definition at line 100 of file SolidModel.h.

◆ _plastic_dissipation

MaterialProperty<Real>& AbaqusUmatMaterial::_plastic_dissipation
protected

Definition at line 103 of file AbaqusUmatMaterial.h.

Referenced by computeStress().

◆ _plugin

FileName AbaqusUmatMaterial::_plugin
protected

Definition at line 67 of file AbaqusUmatMaterial.h.

Referenced by AbaqusUmatMaterial().

◆ _PNEWDT

Real AbaqusUmatMaterial::_PNEWDT
protected

Definition at line 80 of file AbaqusUmatMaterial.h.

Referenced by computeStress().

◆ _poissons_ratio

Real SolidModel::_poissons_ratio
protectedinherited

◆ _poissons_ratio_function

Function* SolidModel::_poissons_ratio_function
protectedinherited

◆ _poissons_ratio_set

bool SolidModel::_poissons_ratio_set
protectedinherited

◆ _PREDEF

Real AbaqusUmatMaterial::_PREDEF[1]
protected

Definition at line 86 of file AbaqusUmatMaterial.h.

Referenced by computeStress().

◆ _principal_strain

ColumnMajorMatrix SolidModel::_principal_strain
protectedinherited

◆ _PROPS

Real * AbaqusUmatMaterial::_PROPS
protected

Definition at line 86 of file AbaqusUmatMaterial.h.

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

◆ _ref_temp

Real SolidModel::_ref_temp
protectedinherited

◆ _RPL

Real AbaqusUmatMaterial::_RPL
protected

Definition at line 80 of file AbaqusUmatMaterial.h.

Referenced by computeStress().

◆ _SCD

Real AbaqusUmatMaterial::_SCD
protected

Definition at line 80 of file AbaqusUmatMaterial.h.

Referenced by computeStress().

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

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

◆ _SPD

Real AbaqusUmatMaterial::_SPD
protected

Definition at line 80 of file AbaqusUmatMaterial.h.

Referenced by computeStress().

◆ _SSE

Real AbaqusUmatMaterial::_SSE
protected

Definition at line 80 of file AbaqusUmatMaterial.h.

Referenced by computeStress().

◆ _state_var

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

Definition at line 98 of file AbaqusUmatMaterial.h.

Referenced by computeStress(), and initQpStatefulProperties().

◆ _state_var_old

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

Definition at line 99 of file AbaqusUmatMaterial.h.

Referenced by computeStress().

◆ _STATEV

Real* AbaqusUmatMaterial::_STATEV
protected

Definition at line 86 of file AbaqusUmatMaterial.h.

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

◆ _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(), AbaqusCreepMaterial::computeStress(), computeStress(), and SolidModel::modifyStrainIncrement().

◆ _STRAN

Real * AbaqusUmatMaterial::_STRAN
protected

Definition at line 86 of file AbaqusUmatMaterial.h.

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

◆ _STRESS

Real * AbaqusUmatMaterial::_STRESS
protected

Definition at line 86 of file AbaqusUmatMaterial.h.

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

◆ _stress

MaterialProperty<SymmTensor>& SolidModel::_stress
protectedinherited

◆ _stress_free_temp

Real SolidModel::_stress_free_temp
protectedinherited

◆ _stress_old

SymmTensor SolidModel::_stress_old
protectedinherited

◆ _TEMP

Real AbaqusUmatMaterial::_TEMP
protected

Definition at line 80 of file AbaqusUmatMaterial.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().

◆ _thermal_constants

std::vector<Real> AbaqusUmatMaterial::_thermal_constants
protected

Definition at line 69 of file AbaqusUmatMaterial.h.

Referenced by AbaqusUmatMaterial().

◆ _TIME

Real AbaqusUmatMaterial::_TIME[2]
protected

Definition at line 86 of file AbaqusUmatMaterial.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().

◆ _umat

umat_t AbaqusUmatMaterial::_umat
protected

Definition at line 77 of file AbaqusUmatMaterial.h.

Referenced by AbaqusUmatMaterial(), and 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 SolidModel::_youngs_modulus
protectedinherited

◆ _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: