#include <MacroElastic.h>

Inheritance diagram for MacroElastic:

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

Public Member Functions
	MacroElastic (const InputParameters &parameters)

virtual	~MacroElastic ()

virtual void	initStatefulProperties (unsigned n_points)

virtual void	applyThermalStrain ()

virtual void	applyVolumetricStrain ()

const 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	createElasticityTensor ()

virtual bool	updateElasticityTensor (SymmElasticityTensor &tensor)
	Return true if the elasticity tensor changed. More...

virtual void	checkElasticConstants ()

virtual void	initQpStatefulProperties ()

virtual void	initialSetup ()

virtual void	timestepSetup ()

virtual void	jacobianSetup ()

virtual void	computeProperties ()

void	computeElasticityTensor ()

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

const Function *	_youngs_modulus_function

const 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

const 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

const 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

Private Member Functions
void	computeCrackStrainAndOrientation (ColumnMajorMatrix &principal_strain)

SolidMechanics::Element *	createElement ()

Private Attributes
const PostprocessorValue &	_C1111

const PostprocessorValue &	_C1122

const PostprocessorValue &	_C1133

const PostprocessorValue &	_C2222

const PostprocessorValue &	_C2233

const PostprocessorValue &	_C3333

const PostprocessorValue &	_C1212

const PostprocessorValue &	_C2323

const PostprocessorValue &	_C3131

const MaterialProperty< SymmTensor > &	_stress_old_prop

SolidMechanics::Element *	_element

SymmElasticityTensor *	_local_elasticity_tensor

Detailed Description

Definition at line 19 of file MacroElastic.h.

Member Enumeration Documentation

◆ CRACKING_RELEASE

enum SolidModel::CRACKING_RELEASE

inherited

Enumerator
CR_ABRUPT
CR_EXPONENTIAL
CR_POWER
CR_UNKNOWN

Definition at line 47 of file SolidModel.h.

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

Constructor & Destructor Documentation

◆ MacroElastic()

MacroElastic::MacroElastic ( const InputParameters & parameters )

Definition at line 42 of file MacroElastic.C.

   : Elastic(parameters),
     _C1111(getPostprocessorValue("C1111")),
     _C1122(getPostprocessorValue("C1122")),
     _C1133(getPostprocessorValue("C1133")),
     _C2222(getPostprocessorValue("C2222")),
     _C2233(getPostprocessorValue("C2233")),
     _C3333(getPostprocessorValue("C3333")),
     _C1212(getPostprocessorValue("C1212")),
     _C2323(getPostprocessorValue("C2323")),
     _C3131(getPostprocessorValue("C3131"))
 {
 }

◆ ~MacroElastic()

MacroElastic::~MacroElastic ( )

virtual

Definition at line 58 of file MacroElastic.C.

58 {}

Member Function Documentation

◆ applyCracksToTensor()

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

protectedinherited

Definition at line 1123 of file SolidModel.C.

 {
   // 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);
 }

Referenced by SolidModel::crackingStressRotation().

◆ applyThermalStrain()

void SolidModel::applyThermalStrain ( )

virtualinherited

Definition at line 591 of file SolidModel.C.

 {
   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);
   }
 }

Referenced by SolidModel::modifyStrainIncrement().

◆ applyVolumetricStrain()

void SolidModel::applyVolumetricStrain ( )

virtualinherited

Definition at line 649 of file SolidModel.C.

 {
   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);
   }
 }

Referenced by SolidModel::modifyStrainIncrement().

◆ checkElasticConstants()

virtual void MacroElastic::checkElasticConstants ( )

inlineprotectedvirtual

Reimplemented from SolidModel.

Definition at line 30 of file MacroElastic.h.

30 {}

◆ computeConstitutiveModelStress()

void SolidModel::computeConstitutiveModelStress ( )

protectedvirtualinherited

Compute the stress (sigma += deltaSigma)

Definition at line 841 of file SolidModel.C.

 {
   // 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]);
 }

Referenced by SolidModel::computeProperties().

◆ computeCrackFactor()

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

protectedvirtualinherited

Definition at line 1408 of file SolidModel.C.

 {
   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;
 }

Referenced by SolidModel::crackingStressRotation().

◆ computeCrackStrainAndOrientation()

void SolidModel::computeCrackStrainAndOrientation ( ColumnMajorMatrix & principal_strain )

privateinherited

Definition at line 1152 of file SolidModel.C.

 {
   // The rotation tensor is ordered such that known dirs appear last in the list of
   // columns.  So, if one dir is known, it corresponds with the last column in the
   // rotation tensor.
   //
   // This convention is based on the eigen routine returning eigen values in
   // ascending order.
   const unsigned int numKnownDirs = getNumKnownCrackDirs();
  
   _elastic_strain[_qp] = _elastic_strain_old[_qp] + _strain_increment;
  
   (*_crack_rotation)[_qp] = (*_crack_rotation_old)[_qp];
  
   if (numKnownDirs == 0)
   {
     ColumnMajorMatrix e_vec(3, 3);
     _elastic_strain[_qp].columnMajorMatrix().eigen(principal_strain, e_vec);
     // If the elastic strain is beyond the cracking strain, save the eigen vectors as
     // the rotation tensor.
     (*_crack_rotation)[_qp] = e_vec;
   }
   else if (numKnownDirs == 1)
   {
     // This is easily the most complicated case.
     // 1.  Rotate the elastic strain to the orientation associated with the known
     //     crack.
     // 2.  Extract the upper 2x2 diagonal block into a separate tensor.
     // 3.  Run the eigen solver on the result.
     // 4.  Update the rotation tensor to reflect the effect of the 2 eigenvectors.
  
     // 1.
     ColumnMajorMatrix RT((*_crack_rotation)[_qp].transpose());
     SymmTensor ePrime;
     rotateSymmetricTensor(RT, _elastic_strain[_qp], ePrime);
  
     // 2.
     ColumnMajorMatrix e2x2(2, 2);
     e2x2(0, 0) = ePrime(0, 0);
     e2x2(1, 0) = ePrime(1, 0);
     e2x2(0, 1) = ePrime(0, 1);
     e2x2(1, 1) = ePrime(1, 1);
  
     // 3.
     ColumnMajorMatrix e_val2x1(2, 1);
     ColumnMajorMatrix e_vec2x2(2, 2);
     e2x2.eigen(e_val2x1, e_vec2x2);
  
     // 4.
     ColumnMajorMatrix e_vec(3, 3);
     e_vec(0, 0) = e_vec2x2(0, 0);
     e_vec(1, 0) = e_vec2x2(1, 0);
     e_vec(2, 0) = 0;
     e_vec(0, 1) = e_vec2x2(0, 1);
     e_vec(1, 1) = e_vec2x2(1, 1);
     e_vec(2, 1) = 0;
     e_vec(2, 0) = 0;
     e_vec(2, 1) = 0;
     e_vec(2, 2) = 1;
     (*_crack_rotation)[_qp] = (*_crack_rotation_old)[_qp] * e_vec;
  
     principal_strain(0, 0) = e_val2x1(0, 0);
     principal_strain(1, 0) = e_val2x1(1, 0);
     principal_strain(2, 0) = ePrime(2, 2);
   }
   else if (numKnownDirs == 2 || numKnownDirs == 3)
   {
     // Rotate to cracked orientation and pick off the strains in the rotated
     // coordinate directions.
     ColumnMajorMatrix RT((*_crack_rotation)[_qp].transpose());
     SymmTensor ePrime;
     rotateSymmetricTensor(RT, _elastic_strain[_qp], ePrime);
     principal_strain(0, 0) = ePrime.xx();
     principal_strain(1, 0) = ePrime.yy();
     principal_strain(2, 0) = ePrime.zz();
   }
   else
   {
     mooseError("Invalid number of known crack directions");
   }
 }

Referenced by SolidModel::crackingStressRotation().

◆ computeCurrentInstantaneousThermalExpansionCoefficient()

void SolidModel::computeCurrentInstantaneousThermalExpansionCoefficient ( )

protectedvirtualinherited

Definition at line 1646 of file SolidModel.C.

 {
   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;
 }

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

◆ computeElasticityTensor()

void SolidModel::computeElasticityTensor ( )

protectedinherited

Definition at line 865 of file SolidModel.C.

 {
   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];
   }
 }

Referenced by SolidModel::computeProperties().

◆ computeEshelby()

void SolidModel::computeEshelby ( )

protectedvirtualinherited

Definition at line 792 of file SolidModel.C.

 {
   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;
 }

Referenced by SolidModel::computeProperties().

◆ computePreconditioning()

void SolidModel::computePreconditioning ( )

protectedvirtualinherited

Definition at line 944 of file SolidModel.C.

 {
   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;
 }

Referenced by SolidModel::computeProperties().

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

 {
   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;
 }

Referenced by SolidModel::computeProperties().

◆ computeStress()

virtual void SolidModel::computeStress ( )

inlineprotectedvirtualinherited

Compute the stress (sigma += deltaSigma)

Reimplemented in AbaqusUmatMaterial, AbaqusCreepMaterial, and PLC_LSH.

Definition at line 190 of file SolidModel.h.

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

Referenced by SolidModel::computeProperties().

◆ computeThermalJvec()

void SolidModel::computeThermalJvec ( )

protectedvirtualinherited

Definition at line 1630 of file SolidModel.C.

 {
   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;
   }
 }

Referenced by SolidModel::computeProperties().

◆ crackingStrainDirections()

void SolidModel::crackingStrainDirections ( )

protectedvirtualinherited

Determine cracking directions. Rotate elasticity tensor.

Definition at line 1048 of file SolidModel.C.

 {
   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;
   }
 }

Referenced by SolidModel::computeElasticityTensor().

◆ crackingStressRotation()

void SolidModel::crackingStressRotation ( )

protectedvirtualinherited

Definition at line 1237 of file SolidModel.C.

 {
   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);
     }
   }
 }

Referenced by SolidModel::computeProperties().

◆ createConstitutiveModel()

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

protectedinherited

Definition at line 1591 of file SolidModel.C.

 {
  
   Factory & factory = _app.getFactory();
   InputParameters params = factory.getValidParams(cm_name);
  
   params.applyParameters(parameters());
   params.set<SubProblem *>("_subproblem") = &_subproblem;
   params.applySpecificParameters(parameters(), {"_material_data_type", "_neighbor"}, true);
  
   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;
   }
 }

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

◆ createElasticityTensor()

void MacroElastic::createElasticityTensor ( )

protectedvirtual

Reimplemented from SolidModel.

Definition at line 82 of file MacroElastic.C.

 {
   elasticityTensor(new SymmElasticityTensor(false));
 }

◆ createElement()

SolidMechanics::Element * SolidModel::createElement ( )

privateinherited

Definition at line 1467 of file SolidModel.C.

 {
   std::string mat_name = name();
   InputParameters parameters = emptyInputParameters();
   parameters += this->parameters();
  
   SolidMechanics::Element * element(NULL);
  
   std::string formulation = getParam<MooseEnum>("formulation");
   std::transform(formulation.begin(), formulation.end(), formulation.begin(), ::tolower);
   if (formulation == "nonlinear3d")
   {
     if (!isCoupled("disp_x") || !isCoupled("disp_y") || !isCoupled("disp_z"))
       mooseError("Nonlinear3D requires all three displacements");
  
     if (isCoupled("disp_r"))
       mooseError("Linear must not define disp_r");
  
     if (_coord_type == Moose::COORD_RZ)
       mooseError("Nonlinear3D formulation requested for coord_type = RZ problem");
  
     element = new SolidMechanics::Nonlinear3D(*this, mat_name, parameters);
   }
   else if (formulation == "nonlinearrz")
   {
     if (!isCoupled("disp_r") || !isCoupled("disp_z"))
       mooseError("NonlinearRZ must define disp_r and disp_z");
  
     element = new SolidMechanics::NonlinearRZ(*this, mat_name, parameters);
   }
   else if (formulation == "axisymmetricrz")
   {
     if (!isCoupled("disp_r") || !isCoupled("disp_z"))
       mooseError("AxisymmetricRZ must define disp_r and disp_z");
     element = new SolidMechanics::AxisymmetricRZ(*this, mat_name, parameters);
   }
   else if (formulation == "sphericalr")
   {
     if (!isCoupled("disp_r"))
       mooseError("SphericalR must define disp_r");
     element = new SolidMechanics::SphericalR(*this, mat_name, parameters);
   }
   else if (formulation == "planestrain")
   {
     if (!isCoupled("disp_x") || !isCoupled("disp_y"))
       mooseError("PlaneStrain must define disp_x and disp_y");
     element = new SolidMechanics::PlaneStrain(*this, mat_name, parameters);
   }
   else if (formulation == "nonlinearplanestrain")
   {
     if (!isCoupled("disp_x") || !isCoupled("disp_y"))
       mooseError("NonlinearPlaneStrain must define disp_x and disp_y");
     element = new SolidMechanics::NonlinearPlaneStrain(*this, mat_name, parameters);
   }
   else if (formulation == "linear")
   {
     if (isCoupled("disp_r"))
       mooseError("Linear must not define disp_r");
     if (_coord_type == Moose::COORD_RZ)
       mooseError("Linear formulation requested for coord_type = RZ problem");
     element = new SolidMechanics::Linear(*this, mat_name, parameters);
   }
   else if (formulation != "")
     mooseError("Unknown formulation: " + formulation);
  
   if (!element && _coord_type == Moose::COORD_RZ)
   {
     if (!isCoupled("disp_r") || !isCoupled("disp_z"))
     {
       std::string err(name());
       err += ": RZ coord sys requires disp_r and disp_z for AxisymmetricRZ formulation";
       mooseError(err);
     }
     element = new SolidMechanics::AxisymmetricRZ(*this, mat_name, parameters);
   }
   else if (!element && _coord_type == Moose::COORD_RSPHERICAL)
   {
     if (!isCoupled("disp_r"))
     {
       std::string err(name());
       err += ": RSPHERICAL coord sys requires disp_r for SphericalR formulation";
       mooseError(err);
     }
     element = new SolidMechanics::SphericalR(*this, mat_name, parameters);
   }
  
   if (!element)
   {
     if (isCoupled("disp_x") && isCoupled("disp_y") && isCoupled("disp_z"))
     {
       if (isCoupled("disp_r"))
         mooseError("Error with displacement specification in material " + mat_name);
       element = new SolidMechanics::Nonlinear3D(*this, mat_name, parameters);
     }
     else if (isCoupled("disp_x") && isCoupled("disp_y"))
     {
       if (isCoupled("disp_r"))
         mooseError("Error with displacement specification in material " + mat_name);
       element = new SolidMechanics::PlaneStrain(*this, mat_name, parameters);
     }
     else if (isCoupled("disp_r") && isCoupled("disp_z"))
     {
       if (_coord_type != Moose::COORD_RZ)
         mooseError("RZ coord system not specified, but disp_r and disp_z are");
       element = new SolidMechanics::AxisymmetricRZ(*this, mat_name, parameters);
     }
     else if (isCoupled("disp_r"))
     {
       if (_coord_type != Moose::COORD_RSPHERICAL)
         mooseError("RSPHERICAL coord system not specified, but disp_r is");
       element = new SolidMechanics::SphericalR(*this, mat_name, parameters);
     }
     else if (isCoupled("disp_x"))
       element = new SolidMechanics::Linear(*this, mat_name, parameters);
     else
       mooseError("Unable to determine formulation for material " + mat_name);
   }
  
   mooseAssert(element, "No Element created for material " + mat_name);
  
   return element;
 }

Referenced by SolidModel::SolidModel().

◆ createProperty()

template<typename T >

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

inlineprotectedinherited

Definition at line 231 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 228 of file SolidModel.h.

228 { return i == j; }

◆ elasticityTensor() [1/2]

SymmElasticityTensor* SolidModel::elasticityTensor ( ) const

inlineprotectedinherited

Definition at line 224 of file SolidModel.h.

224 { return _local_elasticity_tensor; }

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

◆ elasticityTensor() [2/2]

void SolidModel::elasticityTensor ( SymmElasticityTensor * e )

protectedinherited

Definition at line 551 of file SolidModel.C.

 {
   delete _local_elasticity_tensor;
   _local_elasticity_tensor = e;
 }

◆ element()

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

inlineprotectedinherited

Definition at line 226 of file SolidModel.h.

226 { return _element; }

Referenced by SolidModel::createElement().

◆ elementInit()

virtual void SolidModel::elementInit ( )

inlineprotectedvirtualinherited

Definition at line 179 of file SolidModel.h.

179 {}

Referenced by SolidModel::computeProperties().

◆ finalizeStress()

void SolidModel::finalizeStress ( )

protectedvirtualinherited

Rotate stress to current configuration.

Definition at line 932 of file SolidModel.C.

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

Referenced by SolidModel::computeProperties().

◆ getNumKnownCrackDirs()

unsigned int SolidModel::getNumKnownCrackDirs ( ) const

protectedvirtualinherited

Definition at line 1455 of file SolidModel.C.

 {
   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;
 }

Referenced by SolidModel::computeCrackStrainAndOrientation().

◆ getPropertyOld()

template<typename T >

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

inlineprotectedinherited

Definition at line 238 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<MaterialBase*> * mats_p;
     std::vector<MooseSharedPointer<MaterialBase>> 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<MaterialBase>> & 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.

 {
   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;
 }

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

◆ initStatefulProperties()

void SolidModel::initStatefulProperties ( unsigned n_points )

virtualinherited

Reimplemented in AbaqusCreepMaterial.

Definition at line 1615 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 57 of file SolidModel.h.

57 { return _JxW[i]; }

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

◆ modifyStrainIncrement()

void SolidModel::modifyStrainIncrement ( )

protectedvirtualinherited

Modify increment for things like thermal strain.

Definition at line 560 of file SolidModel.C.

 {
   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();
 }

Referenced by SolidModel::computeProperties().

◆ q_point()

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

inlineinherited

Definition at line 56 of file SolidModel.h.

56 { return _q_point[i]; }

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

◆ qrule()

const QBase* SolidModel::qrule ( )

inlineinherited

Definition at line 55 of file SolidModel.h.

55 { return _qrule; }

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

◆ rotateSymmetricTensor()

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

staticinherited

Definition at line 663 of file SolidModel.C.

 {
  
   //     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));
 }

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

◆ timestepSetup()

void SolidModel::timestepSetup ( )

protectedvirtualinherited

Definition at line 522 of file SolidModel.C.

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

◆ updateElasticityTensor()

bool MacroElastic::updateElasticityTensor ( SymmElasticityTensor & tensor )

protectedvirtual

Return true if the elasticity tensor changed.

Reimplemented from SolidModel.

Definition at line 63 of file MacroElastic.C.

 {
   std::vector<Real> v(9);
   v[0] = _C1111;
   v[1] = _C1122;
   v[2] = _C1133;
   v[3] = _C2222;
   v[4] = _C2233;
   v[5] = _C3333;
   v[6] = _C1212;
   v[7] = _C2323;
   v[8] = _C3131;
  
   tensor.fillFromInputVector(v, false);
  
   return true;
 }

Member Data Documentation

◆ _active_crack_planes

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

protectedinherited

Definition at line 87 of file SolidModel.h.

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

◆ _alpha

const Real SolidModel::_alpha

protectedinherited

Definition at line 97 of file SolidModel.h.

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

◆ _alpha_function

const Function* SolidModel::_alpha_function

protectedinherited

Definition at line 98 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 62 of file SolidModel.h.

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

◆ _block_id

std::vector<SubdomainID> SolidModel::_block_id

protectedinherited

Definition at line 248 of file SolidModel.h.

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

◆ _bulk_modulus

Real SolidModel::_bulk_modulus

protectedinherited

Definition at line 70 of file SolidModel.h.

Referenced by SolidModel::checkElasticConstants().

◆ _bulk_modulus_set

bool SolidModel::_bulk_modulus_set

protectedinherited

Definition at line 64 of file SolidModel.h.

Referenced by SolidModel::checkElasticConstants().

◆ _C1111

const PostprocessorValue& MacroElastic::_C1111

private

Definition at line 33 of file MacroElastic.h.

Referenced by updateElasticityTensor().

◆ _C1122

const PostprocessorValue& MacroElastic::_C1122

private

Definition at line 34 of file MacroElastic.h.

Referenced by updateElasticityTensor().

◆ _C1133

const PostprocessorValue& MacroElastic::_C1133

private

Definition at line 35 of file MacroElastic.h.

Referenced by updateElasticityTensor().

◆ _C1212

const PostprocessorValue& MacroElastic::_C1212

private

Definition at line 39 of file MacroElastic.h.

Referenced by updateElasticityTensor().

◆ _C2222

const PostprocessorValue& MacroElastic::_C2222

private

Definition at line 36 of file MacroElastic.h.

Referenced by updateElasticityTensor().

◆ _C2233

const PostprocessorValue& MacroElastic::_C2233

private

Definition at line 37 of file MacroElastic.h.

Referenced by updateElasticityTensor().

◆ _C2323

const PostprocessorValue& MacroElastic::_C2323

private

Definition at line 40 of file MacroElastic.h.

Referenced by updateElasticityTensor().

◆ _C3131

const PostprocessorValue& MacroElastic::_C3131

private

Definition at line 41 of file MacroElastic.h.

Referenced by updateElasticityTensor().

◆ _C3333

const PostprocessorValue& MacroElastic::_C3333

private

Definition at line 38 of file MacroElastic.h.

Referenced by updateElasticityTensor().

◆ _compute_InteractionIntegral

const bool SolidModel::_compute_InteractionIntegral

protectedinherited

Definition at line 154 of file SolidModel.h.

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

◆ _compute_JIntegral

const bool SolidModel::_compute_JIntegral

protectedinherited

Definition at line 153 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 83 of file SolidModel.h.

Referenced by SolidModel::crackingStrainDirections().

◆ _constitutive_active

bool SolidModel::_constitutive_active

protectedinherited

Definition at line 253 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 250 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 60 of file SolidModel.h.

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

◆ _crack_count

MaterialProperty<RealVectorValue>* SolidModel::_crack_count

protectedinherited

Definition at line 125 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 126 of file SolidModel.h.

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

◆ _crack_flags

MaterialProperty<RealVectorValue>* SolidModel::_crack_flags

protectedinherited

Definition at line 122 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 124 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 123 of file SolidModel.h.

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

◆ _crack_max_strain

MaterialProperty<RealVectorValue>* SolidModel::_crack_max_strain

protectedinherited

Definition at line 131 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 132 of file SolidModel.h.

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

◆ _crack_rotation

MaterialProperty<ColumnMajorMatrix>* SolidModel::_crack_rotation

protectedinherited

Definition at line 127 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 128 of file SolidModel.h.

Referenced by SolidModel::SolidModel().

◆ _crack_strain

MaterialProperty<RealVectorValue>* SolidModel::_crack_strain

protectedinherited

Definition at line 129 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 130 of file SolidModel.h.

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

◆ _cracking_alpha

Real SolidModel::_cracking_alpha

protectedinherited

Definition at line 86 of file SolidModel.h.

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

◆ _cracking_beta

const Real SolidModel::_cracking_beta

protectedinherited

Definition at line 82 of file SolidModel.h.

Referenced by SolidModel::computeCrackFactor().

◆ _cracking_neg_fraction

const Real SolidModel::_cracking_neg_fraction

protectedinherited

Definition at line 89 of file SolidModel.h.

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

◆ _cracking_release

const CRACKING_RELEASE SolidModel::_cracking_release

protectedinherited

Definition at line 79 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 81 of file SolidModel.h.

Referenced by SolidModel::computeCrackFactor().

◆ _cracking_stress

Real SolidModel::_cracking_stress

protectedinherited

Definition at line 80 of file SolidModel.h.

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

◆ _cracking_stress_function

const Function* const SolidModel::_cracking_stress_function

protectedinherited

Definition at line 84 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 163 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 139 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 142 of file SolidModel.h.

Referenced by SolidModel::computePreconditioning().

◆ _dep_matl_props

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

protectedinherited

Definition at line 106 of file SolidModel.h.

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

◆ _elastic_strain

MaterialProperty<SymmTensor>& SolidModel::_elastic_strain

protectedinherited

Definition at line 119 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 120 of file SolidModel.h.

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

◆ _elasticity_tensor

MaterialProperty<SymmElasticityTensor>& SolidModel::_elasticity_tensor

protectedinherited

Definition at line 135 of file SolidModel.h.

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

◆ _element

SolidMechanics::Element* SolidModel::_element

privateinherited

Definition at line 270 of file SolidModel.h.

Referenced by SolidModel::applyVolumetricStrain(), SolidModel::computeEshelby(), SolidModel::computeProperties(), SolidModel::element(), SolidModel::finalizeStress(), SolidModel::getNumKnownCrackDirs(), SolidModel::SolidModel(), and SolidModel::~SolidModel().

◆ _Eshelby_tensor

MaterialProperty<RankTwoTensor>* SolidModel::_Eshelby_tensor

protectedinherited

Definition at line 159 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 100 of file SolidModel.h.

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

◆ _has_temp

const bool SolidModel::_has_temp

protectedinherited

Definition at line 93 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 160 of file SolidModel.h.

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

◆ _Jacobian_mult

MaterialProperty<SymmElasticityTensor>& SolidModel::_Jacobian_mult

protectedinherited

Definition at line 136 of file SolidModel.h.

Referenced by SolidModel::computePreconditioning().

◆ _lambda

Real SolidModel::_lambda

protectedinherited

Definition at line 71 of file SolidModel.h.

Referenced by SolidModel::checkElasticConstants().

◆ _lambda_set

bool SolidModel::_lambda_set

protectedinherited

Definition at line 65 of file SolidModel.h.

Referenced by SolidModel::checkElasticConstants().

◆ _local_elasticity_tensor

SymmElasticityTensor* SolidModel::_local_elasticity_tensor

privateinherited

Definition at line 272 of file SolidModel.h.

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

◆ _max_cracks

const unsigned int SolidModel::_max_cracks

protectedinherited

Definition at line 88 of file SolidModel.h.

Referenced by SolidModel::crackingStressRotation().

◆ _mean_alpha_function

bool SolidModel::_mean_alpha_function

protectedinherited

Definition at line 102 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 147 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 252 of file SolidModel.h.

Referenced by SolidModel::createConstitutiveModel().

◆ _piecewise_linear_alpha_function

PiecewiseLinear* SolidModel::_piecewise_linear_alpha_function

protectedinherited

Definition at line 99 of file SolidModel.h.

◆ _poissons_ratio

Real SolidModel::_poissons_ratio

protectedinherited

Definition at line 72 of file SolidModel.h.

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

◆ _poissons_ratio_function

const Function* SolidModel::_poissons_ratio_function

protectedinherited

Definition at line 77 of file SolidModel.h.

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

◆ _poissons_ratio_set

bool SolidModel::_poissons_ratio_set

protectedinherited

Definition at line 66 of file SolidModel.h.

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

◆ _principal_strain

ColumnMajorMatrix SolidModel::_principal_strain

protectedinherited

Definition at line 133 of file SolidModel.h.

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

◆ _ref_temp

Real SolidModel::_ref_temp

protectedinherited

Definition at line 103 of file SolidModel.h.

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

◆ _SED

MaterialProperty<Real>* SolidModel::_SED

protectedinherited

Definition at line 157 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 158 of file SolidModel.h.

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

◆ _shear_modulus

Real SolidModel::_shear_modulus

protectedinherited

Definition at line 73 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 67 of file SolidModel.h.

Referenced by SolidModel::checkElasticConstants().

◆ _step_one

bool& SolidModel::_step_one

protectedinherited

Definition at line 262 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 261 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 151 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 108 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 101 of file SolidModel.h.

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

◆ _stress_old

SymmTensor SolidModel::_stress_old

protectedinherited

Definition at line 114 of file SolidModel.h.

Referenced by SolidModel::computeConstitutiveModelStress(), PLC_LSH::computeCreep(), SolidModel::computeElasticityTensor(), PLC_LSH::computeLSH(), PLC_LSH::computeStress(), and AbaqusUmatMaterial::computeStress().

◆ _stress_old_prop

const MaterialProperty<SymmTensor>& SolidModel::_stress_old_prop

privateinherited

Definition at line 111 of file SolidModel.h.

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

◆ _temp_grad

const VariableGradient& SolidModel::_temp_grad

protectedinherited

Definition at line 96 of file SolidModel.h.

Referenced by SolidModel::computeThermalJvec().

◆ _temperature

const VariableValue& SolidModel::_temperature

protectedinherited

Definition at line 94 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 95 of file SolidModel.h.

Referenced by SolidModel::applyThermalStrain().

◆ _total_strain

MaterialProperty<SymmTensor>& SolidModel::_total_strain

protectedinherited

Definition at line 116 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 145 of file SolidModel.h.

Referenced by SolidModel::computeProperties().

◆ _total_strain_old

const MaterialProperty<SymmTensor>& SolidModel::_total_strain_old

protectedinherited

Definition at line 117 of file SolidModel.h.

Referenced by SolidModel::computeProperties().

◆ _volumetric_models

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

protectedinherited

Definition at line 105 of file SolidModel.h.

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

◆ _youngs_modulus

Real SolidModel::_youngs_modulus

protectedinherited

Definition at line 74 of file SolidModel.h.

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

◆ _youngs_modulus_function

const Function* SolidModel::_youngs_modulus_function

protectedinherited

Definition at line 76 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 68 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/MacroElastic.h
solid_mechanics/src/materials/MacroElastic.C

Public Types

Public Member Functions

Static Public Member Functions

Protected Member Functions

Protected Attributes

Private Member Functions

Private Attributes

Detailed Description

Member Enumeration Documentation

◆ CRACKING_RELEASE

Constructor & Destructor Documentation

◆ MacroElastic()

◆ ~MacroElastic()

Member Function Documentation

◆ applyCracksToTensor()

◆ applyThermalStrain()

◆ applyVolumetricStrain()

◆ checkElasticConstants()

◆ computeConstitutiveModelStress()

◆ computeCrackFactor()

◆ computeCrackStrainAndOrientation()

◆ computeCurrentInstantaneousThermalExpansionCoefficient()

◆ computeElasticityTensor()

◆ computeEshelby()

◆ computePreconditioning()

◆ computeProperties()

◆ computeStrainEnergyDensity()

◆ computeStress()

◆ computeThermalJvec()

◆ crackingStrainDirections()

◆ crackingStressRotation()

◆ createConstitutiveModel()

◆ createElasticityTensor()

◆ createElement()

◆ 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

◆ _C1111

◆ _C1122

◆ _C1133

◆ _C1212

◆ _C2222

◆ _C2233

◆ _C2323

◆ _C3131

◆ _C3333

◆ _compute_InteractionIntegral

◆ _compute_JIntegral

◆ _compute_method

◆ _constitutive_active

◆ _constitutive_model

◆ _coord_type

◆ _crack_count

◆ _crack_count_old

◆ _crack_flags