Plastic material. More...

#include <CLSHPlasticMaterial.h>

Inheritance diagram for CLSHPlasticMaterial:

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

Public Member Functions
	CLSHPlasticMaterial (const InputParameters &parameters)

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	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	computeStress ()
	Compute the stress (sigma += deltaSigma) More...

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)

SymmElasticityTensor *	elasticityTensor () const

const SolidMechanics::Element *	element () 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
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

Plastic material.

Definition at line 23 of file CLSHPlasticMaterial.h.

Member Enumeration Documentation

◆ CRACKING_RELEASE

enum SolidModel::CRACKING_RELEASE

inherited

Enumerator
CR_ABRUPT
CR_EXPONENTIAL
CR_POWER
CR_UNKNOWN

Definition at line 48 of file SolidModel.h.

   {
     CR_ABRUPT = 0,
     CR_EXPONENTIAL,
     CR_POWER,
     CR_UNKNOWN
   };

Constructor & Destructor Documentation

◆ CLSHPlasticMaterial()

CLSHPlasticMaterial::CLSHPlasticMaterial ( const InputParameters & parameters )

Definition at line 24 of file CLSHPlasticMaterial.C.

   : SolidModel(parameters)
 {
 
   createConstitutiveModel("CLSHPlasticModel");
 }

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

 {
   // Form transformation matrix R*E*R^T
   const ColumnMajorMatrix & R((*_crack_rotation)[_qp]);
 
   // Rotate to crack frame
   rotateSymmetricTensor(R.transpose(), tensor, tensor);
 
   // Reset stress if cracked
   if ((*_crack_flags)[_qp](0) < 1)
   {
     tensor(0, 0) = sigma(0);
   }
   if ((*_crack_flags)[_qp](1) < 1)
   {
     tensor(1, 1) = sigma(1);
   }
   if ((*_crack_flags)[_qp](2) < 1)
   {
     tensor(2, 2) = sigma(2);
   }
 
   // Rotate back to global frame
   rotateSymmetricTensor(R, tensor, tensor);
 }

◆ applyThermalStrain()

void SolidModel::applyThermalStrain ( )

virtualinherited

Definition at line 591 of file SolidModel.C.

Referenced by SolidModel::modifyStrainIncrement().

 {
   if (_has_temp && !_step_zero)
   {
     Real inc_thermal_strain;
     Real d_thermal_strain_d_temp;
 
     Real old_temp;
     if (_step_one && _has_stress_free_temp)
       old_temp = _stress_free_temp;
     else
       old_temp = _temperature_old[_qp];
 
     Real current_temp = _temperature[_qp];
 
     Real delta_t = current_temp - old_temp;
 
     Real alpha = _alpha;
 
     if (_alpha_function)
     {
       Point p;
       Real alpha_current_temp = _alpha_function->value(current_temp, p);
       Real alpha_old_temp = _alpha_function->value(old_temp, p);
 
       if (_mean_alpha_function)
       {
         Real alpha_stress_free_temperature = _alpha_function->value(_stress_free_temp, p);
         Real small(1e-6);
 
         Real numerator = alpha_current_temp * (current_temp - _ref_temp) -
                          alpha_old_temp * (old_temp - _ref_temp);
         Real denominator = 1.0 + alpha_stress_free_temperature * (_stress_free_temp - _ref_temp);
         if (denominator < small)
           mooseError("Denominator too small in thermal strain calculation");
         inc_thermal_strain = numerator / denominator;
         d_thermal_strain_d_temp = alpha_current_temp * (current_temp - _ref_temp);
       }
       else
       {
         inc_thermal_strain = delta_t * 0.5 * (alpha_current_temp + alpha_old_temp);
         d_thermal_strain_d_temp = alpha_current_temp;
       }
     }
     else
     {
       inc_thermal_strain = delta_t * alpha;
       d_thermal_strain_d_temp = alpha;
     }
 
     _strain_increment.addDiag(-inc_thermal_strain);
     _d_strain_dT.addDiag(-d_thermal_strain_d_temp);
   }
 }

◆ applyVolumetricStrain()

void SolidModel::applyVolumetricStrain ( )

virtualinherited

Definition at line 649 of file SolidModel.C.

Referenced by SolidModel::modifyStrainIncrement().

 {
   const Real V0Vold = 1 / _element->volumeRatioOld(_qp);
   const SubdomainID current_block = _current_elem->subdomain_id();
   const std::vector<MooseSharedPointer<VolumetricModel>> & vm(_volumetric_models[current_block]);
   for (unsigned int i(0); i < vm.size(); ++i)
   {
     vm[i]->modifyStrain(_qp, V0Vold, _strain_increment, _d_strain_dT);
   }
 }

◆ checkElasticConstants()

void SolidModel::checkElasticConstants ( )

protectedvirtualinherited

Reimplemented in MacroElastic.

Definition at line 377 of file SolidModel.C.

Referenced by SolidModel::initialSetup().

 {
   int num_elastic_constants = _bulk_modulus_set + _lambda_set + _poissons_ratio_set +
                               _shear_modulus_set + _youngs_modulus_set;
 
   if (num_elastic_constants != 2)
   {
     std::string err("Exactly two elastic constants must be defined for material '");
     err += name();
     err += "'.";
     mooseError(err);
   }
 
   if (_bulk_modulus_set && _bulk_modulus <= 0)
   {
     std::string err("Bulk modulus must be positive in material '");
     err += name();
     err += "'.";
     mooseError(err);
   }
   if (_poissons_ratio_set && (_poissons_ratio <= -1.0 || _poissons_ratio >= 0.5))
   {
     std::string err("Poissons ratio must be greater than -1 and less than 0.5 in material '");
     err += name();
     err += "'.";
     mooseError(err);
   }
   if (_shear_modulus_set && _shear_modulus < 0)
   {
     std::string err("Shear modulus must not be negative in material '");
     err += name();
     err += "'.";
     mooseError(err);
   }
   if (_youngs_modulus_set && _youngs_modulus <= 0)
   {
     std::string err("Youngs modulus must be positive in material '");
     err += name();
     err += "'.";
     mooseError(err);
   }
 
   // Calculate lambda, the shear modulus, and Young's modulus
   if (_lambda_set && _shear_modulus_set) // First and second Lame
   {
     _youngs_modulus =
         _shear_modulus * (3 * _lambda + 2 * _shear_modulus) / (_lambda + _shear_modulus);
     _poissons_ratio = 0.5 * _lambda / (_lambda + _shear_modulus);
   }
   else if (_lambda_set && _poissons_ratio_set)
   {
     _shear_modulus = (_lambda * (1.0 - 2.0 * _poissons_ratio)) / (2.0 * _poissons_ratio);
     _youngs_modulus =
         _shear_modulus * (3 * _lambda + 2 * _shear_modulus) / (_lambda + _shear_modulus);
   }
   else if (_lambda_set && _bulk_modulus_set)
   {
     _shear_modulus = 3.0 * (_bulk_modulus - _lambda) / 2.0;
     _youngs_modulus =
         _shear_modulus * (3 * _lambda + 2 * _shear_modulus) / (_lambda + _shear_modulus);
     _poissons_ratio = _lambda / (3 * _bulk_modulus - _lambda);
   }
   else if (_lambda_set && _youngs_modulus_set)
   {
     _shear_modulus =
         ((_youngs_modulus - 3.0 * _lambda) / 4.0) +
         (std::sqrt((_youngs_modulus - 3.0 * _lambda) * (_youngs_modulus - 3.0 * _lambda) +
                    8.0 * _lambda * _youngs_modulus) /
          4.0);
     _poissons_ratio = _lambda / (3 * _bulk_modulus - _lambda);
   }
   else if (_shear_modulus_set && _poissons_ratio_set)
   {
     _lambda = (2.0 * _shear_modulus * _poissons_ratio) / (1.0 - 2.0 * _poissons_ratio);
     _youngs_modulus =
         _shear_modulus * (3 * _lambda + 2 * _shear_modulus) / (_lambda + _shear_modulus);
   }
   else if (_shear_modulus_set && _bulk_modulus_set)
   {
     _lambda = _bulk_modulus - 2.0 * _shear_modulus / 3.0;
     _youngs_modulus =
         _shear_modulus * (3 * _lambda + 2 * _shear_modulus) / (_lambda + _shear_modulus);
     _poissons_ratio =
         (3 * _bulk_modulus - 2 * _shear_modulus) / (2 * (3 * _bulk_modulus + _shear_modulus));
   }
   else if (_shear_modulus_set && _youngs_modulus_set)
   {
     _lambda = ((2.0 * _shear_modulus - _youngs_modulus) * _shear_modulus) /
               (_youngs_modulus - 3.0 * _shear_modulus);
     _poissons_ratio = 0.5 * _youngs_modulus / _shear_modulus - 1;
   }
   else if (_poissons_ratio_set && _bulk_modulus_set)
   {
     _lambda = (3.0 * _bulk_modulus * _poissons_ratio) / (1.0 + _poissons_ratio);
     _shear_modulus =
         (3.0 * _bulk_modulus * (1.0 - 2.0 * _poissons_ratio)) / (2.0 * (1.0 + _poissons_ratio));
     _youngs_modulus =
         _shear_modulus * (3 * _lambda + 2 * _shear_modulus) / (_lambda + _shear_modulus);
   }
   else if (_youngs_modulus_set && _poissons_ratio_set) // Young's Modulus and Poisson's Ratio
   {
     _lambda = (_poissons_ratio * _youngs_modulus) /
               ((1.0 + _poissons_ratio) * (1 - 2.0 * _poissons_ratio));
     _shear_modulus = _youngs_modulus / (2.0 * (1.0 + _poissons_ratio));
   }
   else if (_youngs_modulus_set && _bulk_modulus_set)
   {
     _lambda = 3.0 * _bulk_modulus * (3.0 * _bulk_modulus - _youngs_modulus) /
               (9.0 * _bulk_modulus - _youngs_modulus);
     _shear_modulus =
         3.0 * _youngs_modulus * _bulk_modulus / (9.0 * _bulk_modulus - _youngs_modulus);
     _poissons_ratio = (3 * _bulk_modulus - _youngs_modulus) / (6 * _bulk_modulus);
   }
 
   _lambda_set = true;
   _shear_modulus_set = true;
   _youngs_modulus_set = true;
   _poissons_ratio_set = true;
 }

◆ computeConstitutiveModelStress()

void SolidModel::computeConstitutiveModelStress ( )

protectedvirtualinherited

Compute the stress (sigma += deltaSigma)

Definition at line 841 of file SolidModel.C.

Referenced by SolidModel::computeProperties().

 {
   // Given the stretching, compute the stress increment and add it to the old stress. Also update
   // the creep strain
   // stress = stressOld + stressIncrement
 
   const SubdomainID current_block = _current_elem->subdomain_id();
   MooseSharedPointer<ConstitutiveModel> cm = _constitutive_model[current_block];
 
   mooseAssert(_constitutive_active, "Logic error.  ConstitutiveModel not active.");
 
   // Let's be a little careful and check for a non-existent
   // ConstitutiveModel, which could be returned as a default value
   // from std::map::operator[]
   if (!cm)
     mooseError("Logic error.  No ConstitutiveModel for current_block=", current_block, ".");
 
   cm->setQp(_qp);
   cm->computeStress(
       *_current_elem, *elasticityTensor(), _stress_old, _strain_increment, _stress[_qp]);
 }

◆ computeCrackFactor()

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

protectedvirtualinherited

Definition at line 1408 of file SolidModel.C.

Referenced by SolidModel::crackingStressRotation().

 {
   if (_cracking_release == CR_EXPONENTIAL)
   {
     if ((*_crack_max_strain)[_qp](i) < (*_crack_strain)[_qp](i))
     {
       std::stringstream err;
       err << "Max strain less than crack strain: " << i << " " << sigma << ", "
           << (*_crack_max_strain)[_qp](i) << ", " << (*_crack_strain)[_qp](i) << ", "
           << _principal_strain(0, 0) << ", " << _principal_strain(1, 0) << ", "
           << _principal_strain(2, 0) << _elastic_strain[_qp] << std::endl;
       mooseError(err.str());
     }
     const Real crackMaxStrain((*_crack_max_strain)[_qp](i));
     // Compute stress that follows exponental curve
     sigma = _cracking_stress * (_cracking_residual_stress +
                                 (1 - _cracking_residual_stress) *
                                     std::exp(_cracking_alpha * _cracking_beta / _cracking_stress *
                                              (crackMaxStrain - (*_crack_strain)[_qp](i))));
     // Compute ratio of current stiffness to original stiffness
     flagVal = sigma * (*_crack_strain)[_qp](i) / (crackMaxStrain * _cracking_stress);
   }
   else
   {
     if (_cracking_residual_stress == 0)
     {
       const Real tiny(1e-16);
       flagVal = tiny;
       sigma = tiny * (*_crack_strain)[_qp](i) * _youngs_modulus;
     }
     else
     {
       sigma = _cracking_residual_stress * _cracking_stress;
       flagVal = sigma / ((*_crack_max_strain)[_qp](i) * _youngs_modulus);
     }
   }
   if (flagVal < 0)
   {
     std::stringstream err;
     err << "Negative crack flag found: " << i << " " << flagVal << ", "
         << (*_crack_max_strain)[_qp](i) << ", " << (*_crack_strain)[_qp](i) << ", " << std::endl;
     mooseError(err.str());
   }
   return flagVal;
 }

◆ computeCurrentInstantaneousThermalExpansionCoefficient()

void SolidModel::computeCurrentInstantaneousThermalExpansionCoefficient ( )

protectedvirtualinherited

Definition at line 1644 of file SolidModel.C.

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

 {
   mooseAssert(_current_instantaneous_thermal_expansion_coef,
               "_current_instantaneous_thermal_expansion_coef not initialized");
 
   (*_current_instantaneous_thermal_expansion_coef)[_qp] = 0.0;
 
   if (_alpha_function)
   {
     Point p;
     Real current_temp = _temperature[_qp];
 
     if (!_mean_alpha_function)
     {
       Real alpha = _alpha_function->value(current_temp, p);
       (*_current_instantaneous_thermal_expansion_coef)[_qp] = alpha;
     }
     else
     {
       Real small(1e-6);
       Real dalphabar_dT = _alpha_function->timeDerivative(current_temp, p);
       Real alphabar_Tsf = _alpha_function->value(_stress_free_temp, p);
       Real alphabar = _alpha_function->value(current_temp, p);
       Real numerator = dalphabar_dT * (current_temp - _ref_temp) + alphabar;
       Real denominator = 1.0 + alphabar_Tsf * (_stress_free_temp - _ref_temp);
       if (denominator < small)
         mooseError("Denominator too small in thermal strain calculation");
       (*_current_instantaneous_thermal_expansion_coef)[_qp] = numerator / denominator;
     }
   }
   else
     (*_current_instantaneous_thermal_expansion_coef)[_qp] = _alpha;
 }

◆ computeElasticityTensor()

void SolidModel::computeElasticityTensor ( )

protectedinherited

Definition at line 865 of file SolidModel.C.

Referenced by SolidModel::computeProperties().

 {
   if (_cracking_stress_function != NULL)
   {
     _cracking_stress = _cracking_stress_function->value(_t, _q_point[_qp]);
   }
 
   _stress_old = _stress_old_prop[_qp];
 
   bool changed = updateElasticityTensor(*_local_elasticity_tensor);
 
   _local_elasticity_tensor->calculate(_qp);
 
   _elasticity_tensor[_qp] = *_local_elasticity_tensor;
 
   crackingStrainDirections();
 
   if (changed || _cracking_stress > 0)
   {
     _stress_old = _elasticity_tensor[_qp] * _elastic_strain_old[_qp];
   }
 }

◆ computeEshelby()

void SolidModel::computeEshelby ( )

protectedvirtualinherited

Definition at line 792 of file SolidModel.C.

Referenced by SolidModel::computeProperties().

 {
   mooseAssert(_SED, "_SED not initialized");
   mooseAssert(_Eshelby_tensor, "_Eshelby_tensor not initialized");
   // Cauchy stress (sigma) in a colum major matrix:
   ColumnMajorMatrix stress_CMM;
   stress_CMM(0, 0) = _stress[_qp].xx();
   stress_CMM(0, 1) = _stress[_qp].xy();
   stress_CMM(0, 2) = _stress[_qp].xz();
   stress_CMM(1, 0) = _stress[_qp].xy();
   stress_CMM(1, 1) = _stress[_qp].yy();
   stress_CMM(1, 2) = _stress[_qp].yz();
   stress_CMM(2, 0) = _stress[_qp].xz();
   stress_CMM(2, 1) = _stress[_qp].yz();
   stress_CMM(2, 2) = _stress[_qp].zz();
 
   // Deformation gradient (F):
   ColumnMajorMatrix F;
   _element->computeDeformationGradient(_qp, F);
   // Displacement gradient (H):
   ColumnMajorMatrix H(F);
   H.addDiag(-1.0);
   Real detF = _element->detMatrix(F);
   ColumnMajorMatrix Finv;
   _element->invertMatrix(F, Finv);
   ColumnMajorMatrix FinvT;
   FinvT = Finv.transpose();
   ColumnMajorMatrix HT;
   HT = H.transpose();
 
   // 1st Piola-Kirchoff Stress (P):
   ColumnMajorMatrix piola;
   piola = stress_CMM * FinvT;
   piola *= detF;
 
   // HTP = H^T * P = H^T * detF * sigma * FinvT;
   ColumnMajorMatrix HTP;
   HTP = HT * piola;
 
   ColumnMajorMatrix WI;
   WI.identity();
   WI *= (*_SED)[_qp];
   WI *= detF;
   (*_Eshelby_tensor)[_qp] = WI - HTP;
 }

◆ computePreconditioning()

void SolidModel::computePreconditioning ( )

protectedvirtualinherited

Definition at line 944 of file SolidModel.C.

Referenced by SolidModel::computeProperties().

 {
   mooseAssert(_local_elasticity_tensor, "null elasticity tensor");
 
   //  _Jacobian_mult[_qp] = *_local_elasticity_tensor;
   //  _d_stress_dT[_qp] = *_local_elasticity_tensor * _d_strain_dT;
   _Jacobian_mult[_qp] = _elasticity_tensor[_qp];
   _d_stress_dT[_qp] = _elasticity_tensor[_qp] * _d_strain_dT;
 }

◆ computeProperties()

void SolidModel::computeProperties ( )

protectedvirtualinherited

Definition at line 729 of file SolidModel.C.

 {
   if (_t_step >= 1)
     _step_zero = false;
 
   if (_t_step >= 2)
     _step_one = false;
 
   elementInit();
   _element->init();
 
   for (_qp = 0; _qp < _qrule->n_points(); ++_qp)
   {
     _element->computeStrain(_qp, _total_strain_old[_qp], _total_strain[_qp], _strain_increment);
     _total_strain_increment = _strain_increment;
 
     modifyStrainIncrement();
     _mechanical_strain_increment = _strain_increment;
 
     computeElasticityTensor();
 
     if (!_constitutive_active)
       computeStress();
     else
       computeConstitutiveModelStress();
 
     if (_compute_JIntegral)
       computeStrainEnergyDensity();
 
     _elastic_strain[_qp] = _elastic_strain_old[_qp] + _strain_increment;
 
     crackingStressRotation();
 
     finalizeStress();
 
     if (_compute_JIntegral)
       computeEshelby();
 
     if (_compute_JIntegral && _has_temp)
       computeThermalJvec();
 
     if (_compute_InteractionIntegral && _has_temp)
       computeCurrentInstantaneousThermalExpansionCoefficient();
 
     computePreconditioning();
   }
 }

◆ computeStrainEnergyDensity()

void SolidModel::computeStrainEnergyDensity ( )

protectedvirtualinherited

Definition at line 780 of file SolidModel.C.

Referenced by SolidModel::computeProperties().

 {
   mooseAssert(_SED, "_SED not initialized");
   mooseAssert(_SED_old, "_SED_old not initialized");
   (*_SED)[_qp] = (*_SED_old)[_qp] +
                  _stress[_qp].doubleContraction(_mechanical_strain_increment) / 2 +
                  _stress_old_prop[_qp].doubleContraction(_mechanical_strain_increment) / 2;
 }

◆ computeStress()

virtual void SolidModel::computeStress ( )

inlineprotectedvirtualinherited

Compute the stress (sigma += deltaSigma)

Reimplemented in AbaqusUmatMaterial, AbaqusCreepMaterial, and PLC_LSH.

Definition at line 191 of file SolidModel.h.

Referenced by SolidModel::computeProperties().

   {
     mooseError("SolidModel::computeStress must be defined by the derived class");
   }

◆ computeThermalJvec()

void SolidModel::computeThermalJvec ( )

protectedvirtualinherited

Definition at line 1628 of file SolidModel.C.

Referenced by SolidModel::computeProperties().

 {
   mooseAssert(_J_thermal_term_vec, "_J_thermal_term_vec not initialized");
 
   Real stress_trace = _stress[_qp].xx() + _stress[_qp].yy() + _stress[_qp].zz();
 
   computeCurrentInstantaneousThermalExpansionCoefficient();
   for (unsigned int i = 0; i < LIBMESH_DIM; ++i)
   {
     Real dthermstrain_dx =
         _temp_grad[_qp](i) * (*_current_instantaneous_thermal_expansion_coef)[_qp];
     (*_J_thermal_term_vec)[_qp](i) = stress_trace * dthermstrain_dx;
   }
 }

◆ crackingStrainDirections()

void SolidModel::crackingStrainDirections ( )

protectedvirtualinherited

Determine cracking directions. Rotate elasticity tensor.

Definition at line 1048 of file SolidModel.C.

Referenced by SolidModel::computeElasticityTensor().

 {
   bool cracking_locally_active(false);
   if (_cracking_stress > 0)
   {
     // Compute whether cracking has occurred
     (*_crack_rotation)[_qp] = (*_crack_rotation_old)[_qp];
 
     ColumnMajorMatrix RT((*_crack_rotation)[_qp].transpose());
     SymmTensor ePrime;
     rotateSymmetricTensor(RT, _elastic_strain[_qp], ePrime);
 
     for (unsigned int i(0); i < 3; ++i)
     {
       (*_crack_max_strain)[_qp](i) = (*_crack_max_strain_old)[_qp](i);
 
       if (_cracking_neg_fraction == 0 && ePrime(i, i) < 0)
       {
         _crack_flags_local(i) = 1;
       }
       else if (_cracking_neg_fraction > 0 &&
                (*_crack_strain)[_qp](i) * _cracking_neg_fraction > ePrime(i, i))
       {
         if (-(*_crack_strain)[_qp](i) * _cracking_neg_fraction > ePrime(i, i))
         {
           _crack_flags_local(i) = 1;
         }
         else
         {
           // s = a*e^2 + b*e + c
           // a = (Ec-Eo)/(4etr)
           // b = (Ec+Eo)/2
           // c = (Ec-Eo)*etr/4
           // etr = _cracking_neg_fraction * strain when crack occurred
           const Real etr = _cracking_neg_fraction * (*_crack_strain)[_qp](i);
           const Real Eo = _cracking_stress / (*_crack_strain)[_qp](i);
           const Real Ec = Eo * (*_crack_flags_old)[_qp](i);
           const Real a = (Ec - Eo) / (4 * etr);
           const Real b = (Ec + Eo) / 2;
           // Compute the ratio of the current transition stiffness to the original stiffness
           _crack_flags_local(i) = (2 * a * etr + b) / Eo;
           cracking_locally_active = true;
         }
       }
       else
       {
         _crack_flags_local(i) = (*_crack_flags_old)[_qp](i);
         if (_crack_flags_local(i) < 1)
         {
           cracking_locally_active = true;
         }
       }
     }
   }
   if (cracking_locally_active)
   {
     // Adjust the elasticity matrix for cracking.  This must be used by the
     // constitutive law.
     if (_compute_method == "ShearRetention")
       _local_elasticity_tensor->adjustForCracking(_crack_flags_local);
     else
       _local_elasticity_tensor->adjustForCrackingWithShearRetention(_crack_flags_local);
 
     ColumnMajorMatrix R_9x9(9, 9);
     const ColumnMajorMatrix & R((*_crack_rotation)[_qp]);
     _local_elasticity_tensor->form9x9Rotation(R, R_9x9);
     _local_elasticity_tensor->rotateFromLocalToGlobal(R_9x9);
 
     _elasticity_tensor[_qp] = *_local_elasticity_tensor;
   }
 }

◆ crackingStressRotation()

void SolidModel::crackingStressRotation ( )

protectedvirtualinherited

Definition at line 1237 of file SolidModel.C.

Referenced by SolidModel::computeProperties().

 {
   if (_cracking_stress_function != NULL)
   {
     _cracking_stress = _cracking_stress_function->value(_t, _q_point[_qp]);
   }
 
   if (_cracking_stress > 0)
   {
 
     computeCrackStrainAndOrientation(_principal_strain);
 
     for (unsigned i(0); i < 3; ++i)
     {
       if (_principal_strain(i, 0) > (*_crack_max_strain_old)[_qp](i))
       {
         (*_crack_max_strain)[_qp](i) = _principal_strain(i, 0);
       }
     }
 
     // Check for new cracks.
     // This must be done in the crack-local coordinate frame.
 
     // Rotate stress to cracked orientation.
     ColumnMajorMatrix R((*_crack_rotation)[_qp]);
     ColumnMajorMatrix RT((*_crack_rotation)[_qp].transpose());
     SymmTensor sigmaPrime;
     rotateSymmetricTensor(RT, _stress[_qp], sigmaPrime);
 
     unsigned int num_cracks(0);
     for (unsigned i(0); i < 3; ++i)
     {
       _crack_flags_local(i) = 1;
       (*_crack_strain)[_qp](i) = (*_crack_strain_old)[_qp](i);
       if ((*_crack_flags_old)[_qp](i) < 1)
       {
         ++num_cracks;
       }
     }
 
     bool new_crack(false);
     bool cracked(false);
     RealVectorValue sigma;
     for (unsigned i(0); i < 3; ++i)
     {
       sigma(i) = sigmaPrime(i, i);
       (*_crack_flags)[_qp](i) = (*_crack_flags_old)[_qp](i);
       if (sigma(i) <= 1e-4)
       {
         if ((*_crack_flags)[_qp](i) == 1)
         {
           (*_crack_max_strain)[_qp](i) = _principal_strain(i, 0);
         }
       }
 
       // _cracked_this_step[_q_point[_qp]] = 0;
       Real crackFactor(1);
       if (_cracking_release == CR_POWER)
       {
         (*_crack_count)[_qp](i) = (*_crack_count_old)[_qp](i);
       }
       if ((_cracking_release == CR_POWER && sigma(i) > _cracking_stress &&
            _active_crack_planes[i] == 1
            // && (*_crack_count)[_qp](i) == 0
            )
           // || _cracked_this_step_count[_q_point[_qp]] > 5
       )
       {
         cracked = true;
         ++((*_crack_count)[_qp](i));
         // _cracked_this_step[_q_point[_qp]] = 1;
         // Assume Poisson's ratio drops to zero for this direction.  Stiffness is then Young's
         // modulus.
         const Real stiff = _youngs_modulus_function
                                ? _youngs_modulus_function->value(_temperature[_qp], Point())
                                : _youngs_modulus;
 
         if ((*_crack_count_old)[_qp](i) == 0)
         {
           new_crack = true;
           ++num_cracks;
 
           (*_crack_strain)[_qp](i) = _cracking_stress / stiff;
         }
         // Compute stress, factor....
         (*_crack_flags)[_qp](i) *= 1. / 3.;
 
         if ((*_crack_max_strain)[_qp](i) < (*_crack_strain)[_qp](i))
         {
           (*_crack_max_strain)[_qp](i) = (*_crack_strain)[_qp](i);
         }
         sigma(i) = (*_crack_flags)[_qp](i) * stiff * _principal_strain(i, 0);
       }
       else if ((_cracking_release != CR_POWER && (*_crack_flags_old)[_qp](i) == 1 &&
                 sigma(i) > _cracking_stress && num_cracks < _max_cracks &&
                 _active_crack_planes[i] == 1)
                // || _cracked_this_step_count[_q_point[_qp]] > 5
       )
       {
         // A new crack
         // _cracked_this_step[_q_point[_qp]] = 1;
 
         cracked = true;
         new_crack = true;
         ++num_cracks;
 
         // Assume Poisson's ratio drops to zero for this direction.  Stiffness is then Young's
         // modulus.
         const Real stiff = _youngs_modulus_function
                                ? _youngs_modulus_function->value(_temperature[_qp], Point())
                                : _youngs_modulus;
 
         (*_crack_strain)[_qp](i) = _cracking_stress / stiff;
         if ((*_crack_max_strain)[_qp](i) < (*_crack_strain)[_qp](i))
         {
           (*_crack_max_strain)[_qp](i) = (*_crack_strain)[_qp](i);
         }
 
         crackFactor = computeCrackFactor(i, sigma(i), (*_crack_flags)[_qp](i));
 
         (*_crack_flags)[_qp](i) = crackFactor;
         _crack_flags_local(i) = crackFactor;
 
         // May want to set the old value.  This may help with the nonlinear solve
         // since the stress cannot bounce between just below the critical stress and
         // effectively zero.  However, this may set allow cracking prematurely.
         //        (*_crack_flags_old)[_qp](i) = crackFactor;
         //        (*_crack_strain_old)[_qp](i) = _principal_strain(i,0);
       }
       else if (_cracking_release != CR_POWER && (*_crack_flags_old)[_qp](i) < 1 &&
                std::abs(_principal_strain(i, 0) - (*_crack_max_strain)[_qp](i)) < 1e-10)
       {
         // Previously cracked,
         // Crack opening
         cracked = true;
         crackFactor = computeCrackFactor(i, sigma(i), (*_crack_flags)[_qp](i));
         (*_crack_flags)[_qp](i) = crackFactor;
         _crack_flags_local(i) = crackFactor;
       }
       else if (_cracking_neg_fraction > 0 &&
                (*_crack_strain)[_qp](i) * _cracking_neg_fraction > _principal_strain(i, 0) &&
                -(*_crack_strain)[_qp](i) * _cracking_neg_fraction < _principal_strain(i, 0))
       {
         // s = a*e^2 + b*e + c
         // a = (Ec-Eo)/(4etr)
         // b = (Ec+Eo)/2
         // c = (Ec-Eo)*etr/4
         // etr = _cracking_neg_fraction * strain when crack occurred
         cracked = true;
         const Real etr = _cracking_neg_fraction * (*_crack_strain)[_qp](i);
         const Real Eo = _cracking_stress / (*_crack_strain)[_qp](i);
         const Real Ec = Eo * (*_crack_flags_old)[_qp](i);
         const Real a = (Ec - Eo) / (4 * etr);
         const Real b = (Ec + Eo) / 2;
         const Real c = (Ec - Eo) * etr / 4;
         sigma(i) = (a * _principal_strain(i, 0) + b) * _principal_strain(i, 0) + c;
       }
     }
 
     if (!new_crack)
     {
       (*_crack_rotation)[_qp] = (*_crack_rotation_old)[_qp];
     }
     if (cracked)
     {
       applyCracksToTensor(_stress[_qp], sigma);
     }
   }
 }

◆ createConstitutiveModel()

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

protectedinherited

Definition at line 1591 of file SolidModel.C.

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

 {
 
   Factory & factory = _app.getFactory();
   InputParameters params = factory.getValidParams(cm_name);
 
   params.applyParameters(parameters());
   params.set<SubProblem *>("_subproblem") = &_subproblem;
   MooseSharedPointer<ConstitutiveModel> cm =
       factory.create<ConstitutiveModel>(cm_name, name() + "Model", params, _tid);
 
   _models_to_free.insert(
       cm); // Keep track of the dynamic memory that is created internally to this object
 
   _constitutive_active = true;
   for (unsigned i(0); i < _block_id.size(); ++i)
   {
     _constitutive_model[_block_id[i]] = cm;
   }
 }

◆ createElasticityTensor()

void SolidModel::createElasticityTensor ( )

protectedvirtualinherited

Reimplemented in MacroElastic.

Definition at line 500 of file SolidModel.C.

Referenced by SolidModel::initialSetup().

 {
   bool constant(true);
 
   if (_cracking_stress > 0 || _youngs_modulus_function || _poissons_ratio_function ||
       _cracking_stress_function)
   {
     constant = false;
   }
 
   SymmIsotropicElasticityTensor * iso = new SymmIsotropicElasticityTensor(constant);
   mooseAssert(_youngs_modulus_set, "Internal error:  Youngs modulus not set");
   mooseAssert(_poissons_ratio_set, "Internal error:  Poissons ratio not set");
   iso->setYoungsModulus(_youngs_modulus);
   iso->setPoissonsRatio(_poissons_ratio);
   iso->calculate(0);
   elasticityTensor(iso);
 }

◆ createProperty()

template<typename T >

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

inlineprotectedinherited

Definition at line 232 of file SolidModel.h.

   {
     std::string name(prop_name + _appended_property_name);
     return declareProperty<T>(name);
   }

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

 {
   delete _local_elasticity_tensor;
   _local_elasticity_tensor = e;
 }

◆ elasticityTensor() [2/2]

SymmElasticityTensor* SolidModel::elasticityTensor ( ) const

inlineprotectedinherited

Definition at line 225 of file SolidModel.h.

Referenced by SolidModel::computeConstitutiveModelStress(), PLC_LSH::computeCreep(), PLC_LSH::computeLSH(), PLC_LSH::computeStress(), MacroElastic::createElasticityTensor(), and SolidModel::createElasticityTensor().

225 { return _local_elasticity_tensor; }

SolidModel::_local_elasticity_tensor

SymmElasticityTensor * _local_elasticity_tensor

Definition: SolidModel.h:273

◆ element()

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

inlineprotectedinherited

Definition at line 227 of file SolidModel.h.

Referenced by SolidModel::createElement().

227 { return _element; }

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

 {
   std::vector<SymmTensor *> t(3);
   t[0] = &_elastic_strain[_qp];
   t[1] = &_total_strain[_qp];
   t[2] = &_stress[_qp];
   _element->finalizeStress(t);
 }

◆ getNumKnownCrackDirs()

unsigned int SolidModel::getNumKnownCrackDirs ( ) const

protectedvirtualinherited

Definition at line 1455 of file SolidModel.C.

Referenced by SolidModel::computeCrackStrainAndOrientation().

 {
   const unsigned fromElement = _element->getNumKnownCrackDirs();
   unsigned int retVal(0);
   for (unsigned int i(0); i < 3 - fromElement; ++i)
   {
     retVal += ((*_crack_flags_old)[_qp](i) < 1);
   }
   return retVal + fromElement;
 }

◆ getPropertyOld()

template<typename T >

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

inlineprotectedinherited

Definition at line 239 of file SolidModel.h.

   {
     std::string name(prop_name + _appended_property_name);
     return getMaterialPropertyOld<T>(name);
   }

◆ initialSetup()

void SolidModel::initialSetup ( )

protectedvirtualinherited

Definition at line 957 of file SolidModel.C.

 {
 
   checkElasticConstants();
 
   createElasticityTensor();
 
   // Load in the volumetric models and constitutive models
   bool set_constitutive_active = false;
   for (unsigned i(0); i < _block_id.size(); ++i)
   {
 
     //    const std::vector<Material*> * mats_p;
     std::vector<MooseSharedPointer<Material>> const * mats_p;
     std::string suffix;
     if (_bnd)
     {
       mats_p = &_fe_problem.getMaterialWarehouse()[Moose::FACE_MATERIAL_DATA].getActiveBlockObjects(
           _block_id[i], _tid);
       suffix = "_face";
     }
     else
       mats_p = &_fe_problem.getMaterialWarehouse().getActiveBlockObjects(_block_id[i], _tid);
 
     const std::vector<MooseSharedPointer<Material>> & mats = *mats_p;
 
     for (unsigned int j = 0; j < mats.size(); ++j)
     {
       MooseSharedPointer<VolumetricModel> vm =
           MooseSharedNamespace::dynamic_pointer_cast<VolumetricModel>(mats[j]);
       if (vm)
       {
         const std::vector<std::string> & dep_matl_props = vm->getDependentMaterialProperties();
         for (unsigned k = 0; k < dep_matl_props.size(); ++k)
         {
           if ("" != dep_matl_props[k] &&
               _dep_matl_props.find(dep_matl_props[k]) == _dep_matl_props.end())
           {
             mooseError("A VolumetricModel depends on " + dep_matl_props[k] +
                        ", but that material property was not given in the dep_matl_props line.");
           }
         }
         _volumetric_models[_block_id[i]].push_back(vm);
       }
     }
 
     for (std::map<SubdomainID, MooseSharedPointer<ConstitutiveModel>>::iterator iter =
              _constitutive_model.begin();
          iter != _constitutive_model.end();
          ++iter)
     {
       iter->second->initialSetup();
     }
 
     if (isParamValid("constitutive_model") && !_constitutive_active)
     {
       // User-defined name of the constitutive model (a Material object)
       std::string constitutive_model = getParam<std::string>("constitutive_model") + suffix;
 
       for (unsigned int j = 0; j < mats.size(); ++j)
       {
         MooseSharedPointer<ConstitutiveModel> cm =
             MooseSharedNamespace::dynamic_pointer_cast<ConstitutiveModel>(mats[j]);
 
         if (cm && cm->name() == constitutive_model)
         {
           _constitutive_model[_block_id[i]] = cm;
           set_constitutive_active = true;
           break;
         }
       }
 
       if (!set_constitutive_active)
         mooseError("Unable to find constitutive model " + constitutive_model);
     }
   }
   if (set_constitutive_active)
     _constitutive_active = true;
 
   if (_compute_JIntegral && _alpha_function)
   {
     // Make sure that timeDerivative is supported for _alpha_function.  If not, it will error out.
     Point dummy_point;
     Real dummy_temp = 0;
     _alpha_function->timeDerivative(dummy_temp, dummy_point);
   }
 }

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

 {
   if (isParamValid("initial_stress"))
   {
     const std::vector<Real> & s = getParam<std::vector<Real>>("initial_stress");
     if (6 != s.size())
     {
       mooseError("initial_stress must give six values");
     }
     _stress[_qp].fillFromInputVector(s);
   }
 
   if (_cracking_stress_function != NULL)
   {
     _cracking_stress = _cracking_stress_function->value(_t, _q_point[_qp]);
   }
   if (_cracking_stress > 0)
   {
     (*_crack_flags)[_qp](0) = (*_crack_flags)[_qp](1) = (*_crack_flags)[_qp](2) = 1;
     if (_crack_count)
     {
       (*_crack_count)[_qp](0) = (*_crack_count)[_qp](1) = (*_crack_count)[_qp](2) = 0;
     }
 
     (*_crack_rotation)[_qp].identity();
   }
   if (_SED)
     (*_SED)[_qp] = 0;
 }

◆ initStatefulProperties()

void SolidModel::initStatefulProperties ( unsigned n_points )

virtualinherited

Reimplemented in AbaqusCreepMaterial.

Definition at line 1613 of file SolidModel.C.

 {
   for (_qp = 0; _qp < n_points; ++_qp)
   {
     initQpStatefulProperties();
   }
   if (_constitutive_active)
   {
     const SubdomainID current_block = _current_elem->subdomain_id();
     MooseSharedPointer<ConstitutiveModel> cm = _constitutive_model[current_block];
     cm->initStatefulProperties(n_points);
   }
 }

◆ jacobianSetup()

void SolidModel::jacobianSetup ( )

protectedvirtualinherited

Definition at line 533 of file SolidModel.C.

 {
   // if (_cracking_stress > 0)
   // {
   //   for (std::map<Point, unsigned>::iterator i = _cracked_this_step.begin();
   //        i != _cracked_this_step.end(); ++i)
   //   {
   //     if (i->second)
   //     {
   //       ++_cracked_this_step_count[i->first];
   //     }
   //   }
   // }
 }

◆ JxW()

Real SolidModel::JxW ( unsigned i ) const

inlineinherited

Definition at line 58 of file SolidModel.h.

Referenced by SolidMechanics::Nonlinear3D::computeIncrementalDeformationGradient(), SolidMechanics::NonlinearRZ::computeIncrementalDeformationGradient(), SolidMechanics::NonlinearPlaneStrain::computeIncrementalDeformationGradient(), SolidMechanics::PlaneStrain::computeStrain(), SolidMechanics::Linear::computeStrain(), and SolidMechanics::AxisymmetricRZ::computeStrain().

58 { return _JxW[i]; }

◆ modifyStrainIncrement()

void SolidModel::modifyStrainIncrement ( )

protectedvirtualinherited

Modify increment for things like thermal strain.

Definition at line 560 of file SolidModel.C.

Referenced by SolidModel::computeProperties().

 {
   bool modified = false;
   _d_strain_dT.zero();
 
   const SubdomainID current_block = _current_elem->subdomain_id();
   if (_constitutive_active)
   {
     MooseSharedPointer<ConstitutiveModel> cm = _constitutive_model[current_block];
 
     // Let's be a little careful and check for a non-existent
     // ConstitutiveModel, which could be returned as a default value
     // from std::map::operator[]
     if (!cm)
       mooseError("ConstitutiveModel not available for block ", current_block);
 
     cm->setQp(_qp);
     modified |= cm->modifyStrainIncrement(*_current_elem, _strain_increment, _d_strain_dT);
   }
 
   if (!modified)
   {
     applyThermalStrain();
   }
 
   applyVolumetricStrain();
 }

◆ q_point()

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

inlineinherited

Definition at line 57 of file SolidModel.h.

Referenced by SolidMechanics::NonlinearRZ::computeDeformationGradient(), SolidMechanics::NonlinearRZ::computeIncrementalDeformationGradient(), SolidMechanics::AxisymmetricRZ::computeStrain(), SolidMechanics::SphericalR::computeStrain(), and SolidMechanics::NonlinearRZ::fillMatrix().

57 { return _q_point[i]; }

◆ qrule()

QBase* SolidModel::qrule ( )

inlineinherited

Definition at line 56 of file SolidModel.h.

Referenced by SolidMechanics::Nonlinear3D::computeIncrementalDeformationGradient(), SolidMechanics::NonlinearRZ::computeIncrementalDeformationGradient(), SolidMechanics::NonlinearPlaneStrain::computeIncrementalDeformationGradient(), SolidMechanics::Linear::computeStrain(), SolidMechanics::PlaneStrain::computeStrain(), SolidMechanics::AxisymmetricRZ::computeStrain(), and SolidMechanics::Nonlinear::init().

56 { return _qrule; }

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

 {
 
   //     R           T         Rt
   //  00 01 02   00 01 02   00 10 20
   //  10 11 12 * 10 11 12 * 01 11 21
   //  20 21 22   20 21 22   02 12 22
   //
   const Real T00 = R(0, 0) * T.xx() + R(0, 1) * T.xy() + R(0, 2) * T.zx();
   const Real T01 = R(0, 0) * T.xy() + R(0, 1) * T.yy() + R(0, 2) * T.yz();
   const Real T02 = R(0, 0) * T.zx() + R(0, 1) * T.yz() + R(0, 2) * T.zz();
 
   const Real T10 = R(1, 0) * T.xx() + R(1, 1) * T.xy() + R(1, 2) * T.zx();
   const Real T11 = R(1, 0) * T.xy() + R(1, 1) * T.yy() + R(1, 2) * T.yz();
   const Real T12 = R(1, 0) * T.zx() + R(1, 1) * T.yz() + R(1, 2) * T.zz();
 
   const Real T20 = R(2, 0) * T.xx() + R(2, 1) * T.xy() + R(2, 2) * T.zx();
   const Real T21 = R(2, 0) * T.xy() + R(2, 1) * T.yy() + R(2, 2) * T.yz();
   const Real T22 = R(2, 0) * T.zx() + R(2, 1) * T.yz() + R(2, 2) * T.zz();
 
   result.xx(T00 * R(0, 0) + T01 * R(0, 1) + T02 * R(0, 2));
   result.yy(T10 * R(1, 0) + T11 * R(1, 1) + T12 * R(1, 2));
   result.zz(T20 * R(2, 0) + T21 * R(2, 1) + T22 * R(2, 2));
   result.xy(T00 * R(1, 0) + T01 * R(1, 1) + T02 * R(1, 2));
   result.yz(T10 * R(2, 0) + T11 * R(2, 1) + T12 * R(2, 2));
   result.zx(T00 * R(2, 0) + T01 * R(2, 1) + T02 * R(2, 2));
 }

◆ timestepSetup()

void SolidModel::timestepSetup ( )

protectedvirtualinherited

Definition at line 522 of file SolidModel.C.

 {
   // if (_cracking_stress > 0)
   // {
   //   _cracked_this_step_count.clear();
   // }
 }

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

 {
   bool changed(false);
   if (_constitutive_active)
   {
     const SubdomainID current_block = _current_elem->subdomain_id();
     MooseSharedPointer<ConstitutiveModel> cm = _constitutive_model[current_block];
 
     // Let's be a little careful and check for a non-existent
     // ConstitutiveModel, which could be returned as a default value
     // from std::map::operator[]
     if (!cm)
       mooseError("ConstitutiveModel not available for block ", current_block);
 
     cm->setQp(_qp);
     changed |= cm->updateElasticityTensor(tensor);
   }
 
   if (!changed && (_youngs_modulus_function || _poissons_ratio_function))
   {
     SymmIsotropicElasticityTensor * t = dynamic_cast<SymmIsotropicElasticityTensor *>(&tensor);
     if (!t)
     {
       mooseError("Cannot use Youngs modulus or Poissons ratio functions");
     }
     t->unsetConstants();
     Point p;
     t->setYoungsModulus((_youngs_modulus_function
                              ? _youngs_modulus_function->value(_temperature[_qp], p)
                              : _youngs_modulus));
     t->setPoissonsRatio((_poissons_ratio_function
                              ? _poissons_ratio_function->value(_temperature[_qp], p)
                              : _poissons_ratio));
     changed = true;
   }
   return changed;
 }

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

Definition at line 98 of file SolidModel.h.

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

◆ _alpha_function

Function* SolidModel::_alpha_function

protectedinherited

Definition at line 99 of file SolidModel.h.

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

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

Definition at line 249 of file SolidModel.h.

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

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

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

Definition at line 154 of file SolidModel.h.

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

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

Definition at line 254 of file SolidModel.h.

Referenced by SolidModel::computeConstitutiveModelStress(), SolidModel::computeProperties(), SolidModel::createConstitutiveModel(), SolidModel::initialSetup(), SolidModel::initStatefulProperties(), SolidModel::modifyStrainIncrement(), and SolidModel::updateElasticityTensor().

◆ _constitutive_model

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

protectedinherited

Definition at line 251 of file SolidModel.h.

Referenced by SolidModel::computeConstitutiveModelStress(), SolidModel::createConstitutiveModel(), SolidModel::initialSetup(), SolidModel::initStatefulProperties(), SolidModel::modifyStrainIncrement(), and SolidModel::updateElasticityTensor().

◆ _coord_type

Moose::CoordinateSystemType SolidModel::_coord_type

protectedinherited

Definition at line 61 of file SolidModel.h.

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

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

Definition at line 123 of file SolidModel.h.

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

◆ _crack_flags_local

RealVectorValue SolidModel::_crack_flags_local

protectedinherited

Definition at line 125 of file SolidModel.h.

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

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

Definition at line 132 of file SolidModel.h.

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

◆ _crack_max_strain_old

const MaterialProperty<RealVectorValue>* SolidModel::_crack_max_strain_old

protectedinherited

Definition at line 133 of file SolidModel.h.

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

◆ _crack_rotation

MaterialProperty<ColumnMajorMatrix>* SolidModel::_crack_rotation

protectedinherited

Definition at line 128 of file SolidModel.h.

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

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

Definition at line 130 of file SolidModel.h.

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

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

Definition at line 90 of file SolidModel.h.

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

◆ _cracking_release

const CRACKING_RELEASE SolidModel::_cracking_release

protectedinherited

Definition at line 80 of file SolidModel.h.

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

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

Definition at line 81 of file SolidModel.h.

Referenced by SolidModel::computeCrackFactor(), SolidModel::computeElasticityTensor(), SolidModel::crackingStrainDirections(), SolidModel::crackingStressRotation(), SolidModel::createElasticityTensor(), SolidModel::initQpStatefulProperties(), and SolidModel::SolidModel().

◆ _cracking_stress_function

Function* const SolidModel::_cracking_stress_function

protectedinherited

Definition at line 85 of file SolidModel.h.

Referenced by SolidModel::computeElasticityTensor(), SolidModel::crackingStressRotation(), SolidModel::createElasticityTensor(), and SolidModel::initQpStatefulProperties().

◆ _current_instantaneous_thermal_expansion_coef

MaterialProperty<Real>* SolidModel::_current_instantaneous_thermal_expansion_coef

protectedinherited

Definition at line 164 of file SolidModel.h.

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

◆ _d_strain_dT

SymmTensor SolidModel::_d_strain_dT

protectedinherited

Definition at line 140 of file SolidModel.h.

Referenced by SolidModel::applyThermalStrain(), SolidModel::applyVolumetricStrain(), SolidModel::computePreconditioning(), and SolidModel::modifyStrainIncrement().

◆ _d_stress_dT

MaterialProperty<SymmTensor>& SolidModel::_d_stress_dT

protectedinherited

Definition at line 143 of file SolidModel.h.

Referenced by SolidModel::computePreconditioning().

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

◆ _elastic_strain

MaterialProperty<SymmTensor>& SolidModel::_elastic_strain

protectedinherited

Definition at line 120 of file SolidModel.h.

Referenced by SolidModel::computeCrackFactor(), SolidModel::computeCrackStrainAndOrientation(), SolidModel::computeProperties(), SolidModel::crackingStrainDirections(), and SolidModel::finalizeStress().

◆ _elastic_strain_old

const MaterialProperty<SymmTensor>& SolidModel::_elastic_strain_old

protectedinherited

Definition at line 121 of file SolidModel.h.

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

◆ _elasticity_tensor

MaterialProperty<SymmElasticityTensor>& SolidModel::_elasticity_tensor

protectedinherited

Definition at line 136 of file SolidModel.h.

Referenced by SolidModel::computeElasticityTensor(), SolidModel::computePreconditioning(), and SolidModel::crackingStrainDirections().

◆ _Eshelby_tensor

MaterialProperty<RankTwoTensor>* SolidModel::_Eshelby_tensor

protectedinherited

Definition at line 160 of file SolidModel.h.

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

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

Definition at line 94 of file SolidModel.h.

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

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

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

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

Definition at line 103 of file SolidModel.h.

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

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

◆ _piecewise_linear_alpha_function

PiecewiseLinear* SolidModel::_piecewise_linear_alpha_function

protectedinherited

Definition at line 100 of file SolidModel.h.

◆ _poissons_ratio

Real SolidModel::_poissons_ratio

protectedinherited

Definition at line 73 of file SolidModel.h.

Referenced by SolidModel::checkElasticConstants(), SolidModel::createElasticityTensor(), and SolidModel::updateElasticityTensor().

◆ _poissons_ratio_function

Function* SolidModel::_poissons_ratio_function

protectedinherited

Definition at line 78 of file SolidModel.h.

Referenced by SolidModel::createElasticityTensor(), and SolidModel::updateElasticityTensor().

◆ _poissons_ratio_set

bool SolidModel::_poissons_ratio_set

protectedinherited

Definition at line 67 of file SolidModel.h.

Referenced by SolidModel::checkElasticConstants(), and SolidModel::createElasticityTensor().

◆ _principal_strain

ColumnMajorMatrix SolidModel::_principal_strain

protectedinherited

Definition at line 134 of file SolidModel.h.

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

◆ _ref_temp

Real SolidModel::_ref_temp

protectedinherited

Definition at line 104 of file SolidModel.h.

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

◆ _SED

MaterialProperty<Real>* SolidModel::_SED

protectedinherited

Definition at line 158 of file SolidModel.h.

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

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

Definition at line 74 of file SolidModel.h.

Referenced by SolidModel::checkElasticConstants(), PLC_LSH::computeCreep(), and PLC_LSH::computeLSH().

◆ _shear_modulus_set

bool SolidModel::_shear_modulus_set

protectedinherited

Definition at line 68 of file SolidModel.h.

Referenced by SolidModel::checkElasticConstants().

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

◆ _stress

MaterialProperty<SymmTensor>& SolidModel::_stress

protectedinherited

Definition at line 109 of file SolidModel.h.

Referenced by SolidModel::computeConstitutiveModelStress(), SolidModel::computeEshelby(), SolidModel::computeStrainEnergyDensity(), PLC_LSH::computeStress(), AbaqusUmatMaterial::computeStress(), SolidModel::computeThermalJvec(), SolidModel::crackingStressRotation(), SolidModel::finalizeStress(), and SolidModel::initQpStatefulProperties().

◆ _stress_free_temp

Real SolidModel::_stress_free_temp

protectedinherited

Definition at line 102 of file SolidModel.h.

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

◆ _stress_old

SymmTensor SolidModel::_stress_old

protectedinherited

Definition at line 115 of file SolidModel.h.

Referenced by SolidModel::computeConstitutiveModelStress(), PLC_LSH::computeCreep(), SolidModel::computeElasticityTensor(), PLC_LSH::computeLSH(), PLC_LSH::computeStress(), and AbaqusUmatMaterial::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

Definition at line 95 of file SolidModel.h.

Referenced by SolidModel::applyThermalStrain(), PLC_LSH::computeCreep(), SolidModel::computeCurrentInstantaneousThermalExpansionCoefficient(), PLC_LSH::computeStress(), SolidModel::crackingStressRotation(), and SolidModel::updateElasticityTensor().

◆ _temperature_old

const VariableValue& SolidModel::_temperature_old

protectedinherited

Definition at line 96 of file SolidModel.h.

Referenced by SolidModel::applyThermalStrain().

◆ _total_strain

MaterialProperty<SymmTensor>& SolidModel::_total_strain

protectedinherited

Definition at line 117 of file SolidModel.h.

Referenced by SolidModel::computeProperties(), AbaqusUmatMaterial::computeStress(), and SolidModel::finalizeStress().

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

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

Definition at line 75 of file SolidModel.h.

Referenced by SolidModel::checkElasticConstants(), SolidModel::computeCrackFactor(), SolidModel::crackingStressRotation(), SolidModel::createElasticityTensor(), SolidModel::SolidModel(), and SolidModel::updateElasticityTensor().

◆ _youngs_modulus_function

Function* SolidModel::_youngs_modulus_function

protectedinherited

Definition at line 77 of file SolidModel.h.

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

◆ _youngs_modulus_set

bool SolidModel::_youngs_modulus_set

protectedinherited

Definition at line 69 of file SolidModel.h.

Referenced by SolidModel::checkElasticConstants(), and SolidModel::createElasticityTensor().

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

solid_mechanics/include/materials/CLSHPlasticMaterial.h
solid_mechanics/src/materials/CLSHPlasticMaterial.C

Public Types

Public Member Functions

Static Public Member Functions

Protected Member Functions

Protected Attributes

Detailed Description

Member Enumeration Documentation

◆ CRACKING_RELEASE

Constructor & Destructor Documentation

◆ CLSHPlasticMaterial()

Member Function Documentation

◆ applyCracksToTensor()

◆ applyThermalStrain()

◆ applyVolumetricStrain()

◆ checkElasticConstants()

◆ computeConstitutiveModelStress()

◆ computeCrackFactor()

◆ computeCurrentInstantaneousThermalExpansionCoefficient()

◆ computeElasticityTensor()

◆ computeEshelby()

◆ computePreconditioning()

◆ computeProperties()

◆ computeStrainEnergyDensity()

◆ computeStress()

◆ computeThermalJvec()

◆ crackingStrainDirections()

◆ crackingStressRotation()

◆ createConstitutiveModel()

◆ createElasticityTensor()

◆ createProperty()

◆ delta()

◆ elasticityTensor() [1/2]

◆ elasticityTensor() [2/2]

◆ element()

◆ elementInit()

◆ finalizeStress()

◆ getNumKnownCrackDirs()

◆ getPropertyOld()

◆ initialSetup()

◆ initQpStatefulProperties()

◆ initStatefulProperties()

◆ jacobianSetup()

◆ JxW()

◆ modifyStrainIncrement()

◆ q_point()

◆ qrule()

◆ rotateSymmetricTensor()

◆ timestepSetup()

◆ updateElasticityTensor()

Member Data Documentation

◆ _active_crack_planes

◆ _alpha

◆ _alpha_function

◆ _appended_property_name

◆ _block_id

◆ _bulk_modulus

◆ _bulk_modulus_set

◆ _compute_InteractionIntegral

◆ _compute_JIntegral

◆ _compute_method

◆ _constitutive_active

◆ _constitutive_model

◆ _coord_type

◆ _crack_count

◆ _crack_count_old

◆ _crack_flags

◆ _crack_flags_local

◆ _crack_flags_old

◆ _crack_max_strain

◆ _crack_max_strain_old

◆ _crack_rotation

◆ _crack_rotation_old

◆ _crack_strain

◆ _crack_strain_old

◆ _cracking_alpha

◆ _cracking_beta

◆ _cracking_neg_fraction

◆ _cracking_release

◆ _cracking_residual_stress

◆ _cracking_stress