One or more constitutive models coupled together. More...

#include <CombinedCreepPlasticity.h>

Inheritance diagram for CombinedCreepPlasticity:

Public Member Functions
	CombinedCreepPlasticity (const InputParameters &parameters)

virtual	~CombinedCreepPlasticity ()

virtual void	computeStress (const Elem &current_elem, const SymmElasticityTensor &elasticityTensor, const SymmTensor &stress_old, SymmTensor &strain_increment, SymmTensor &stress_new)
	Compute the stress (sigma += deltaSigma) More...

virtual bool	modifyStrainIncrement (const Elem &current_elem, SymmTensor &strain_increment, SymmTensor &d_strain_dT)

void	setQp (unsigned int qp)
	Sets the value of the variable _qp for inheriting classes. More...

virtual bool	updateElasticityTensor (SymmElasticityTensor &)

virtual bool	applyThermalStrain (SymmTensor &strain_increment, SymmTensor &d_strain_dT)

Protected Member Functions
virtual void	initialSetup ()

Protected Attributes
std::map< SubdomainID, std::vector< MooseSharedPointer< ReturnMappingModel > > >	_submodels

unsigned int	_max_its

bool	_internal_solve_full_iteration_history

Real	_relative_tolerance

Real	_absolute_tolerance

MaterialProperty< Real > &	_matl_timestep_limit

const bool	_has_temp

const VariableValue &	_temperature

const VariableValue &	_temperature_old

const Real	_alpha

const Function *	_alpha_function

bool	_has_stress_free_temp

Real	_stress_free_temp

bool	_mean_alpha_function

Real	_ref_temp


bool &	_step_zero_cm
	Restartable data to check for the zeroth and first time steps. More...

bool &	_step_one_cm

Detailed Description

One or more constitutive models coupled together.

Definition at line 25 of file CombinedCreepPlasticity.h.

Constructor & Destructor Documentation

◆ CombinedCreepPlasticity()

CombinedCreepPlasticity::CombinedCreepPlasticity ( const InputParameters & parameters )

Definition at line 39 of file CombinedCreepPlasticity.C.

   : ConstitutiveModel(parameters),
     _submodels(),
     _max_its(parameters.get<unsigned int>("max_its")),
     _internal_solve_full_iteration_history(getParam<bool>("internal_solve_full_iteration_history")),
     _relative_tolerance(parameters.get<Real>("relative_tolerance")),
     _absolute_tolerance(parameters.get<Real>("absolute_tolerance")),
     _matl_timestep_limit(declareProperty<Real>("matl_timestep_limit"))
 {
 }

◆ ~CombinedCreepPlasticity()

virtual CombinedCreepPlasticity::~CombinedCreepPlasticity ( )

inlinevirtual

Definition at line 29 of file CombinedCreepPlasticity.h.

29 {}

Member Function Documentation

◆ applyThermalStrain()

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

virtualinherited

Definition at line 106 of file ConstitutiveModel.C.

 {
   if (_t_step >= 1)
     _step_zero_cm = false;
  
   if (_t_step >= 2)
     _step_one_cm = false;
  
   if (_has_temp && !_step_zero_cm)
   {
     Real inc_thermal_strain;
     Real d_thermal_strain_d_temp;
  
     Real old_temp;
     if (_step_one_cm && _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);
       Real alpha_stress_free_temperature = _alpha_function->value(_stress_free_temp, p);
  
       if (_mean_alpha_function)
       {
         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);
   }
  
   bool modified = true;
   return modified;
 }

Referenced by ConstitutiveModel::modifyStrainIncrement().

◆ computeStress()

void CombinedCreepPlasticity::computeStress	(	const Elem &	current_elem,
		const SymmElasticityTensor &	elasticityTensor,
		const SymmTensor &	stress_old,
		SymmTensor &	strain_increment,
		SymmTensor &	stress_new
	)

virtual

Compute the stress (sigma += deltaSigma)

Reimplemented from ConstitutiveModel.

Definition at line 95 of file CombinedCreepPlasticity.C.

 {
   // Given the stretching, compute the stress increment and add it to the old stress. Also update
   // the creep strain
   // stress = stressOld + stressIncrement
   // creep_strain = creep_strainOld + creep_strainIncrement
  
   if (_t_step == 0 && !_app.isRestarting())
   {
     _matl_timestep_limit[_qp] = std::numeric_limits<Real>::max();
     return;
   }
  
   if (_internal_solve_full_iteration_history == true)
   {
     _console << std::endl
              << "iteration output for CombinedCreepPlasticity solve:"
              << " time=" << _t << " temperature=" << _temperature[_qp] << " int_pt=" << _qp
              << std::endl;
   }
  
   // compute trial stress
   stress_new = elasticityTensor * strain_increment;
   stress_new += stress_old;
  
   const SubdomainID current_block = current_elem.subdomain_id();
   const std::vector<MooseSharedPointer<ReturnMappingModel>> & rmm(_submodels[current_block]);
   const unsigned num_submodels = rmm.size();
  
   SymmTensor inelastic_strain_increment;
  
   SymmTensor elastic_strain_increment;
   SymmTensor stress_new_last(stress_new);
   Real delS(_absolute_tolerance + 1);
   Real first_delS(delS);
   unsigned int counter(0);
  
   for (unsigned i_rmm(0); i_rmm < num_submodels; ++i_rmm)
     rmm[i_rmm]->setQp(_qp);
  
   while (counter < _max_its && delS > _absolute_tolerance &&
          (delS / first_delS) > _relative_tolerance && (num_submodels != 1 || counter < 1))
   {
     elastic_strain_increment = strain_increment;
     stress_new = elasticityTensor * (elastic_strain_increment - inelastic_strain_increment);
     stress_new += stress_old;
  
     for (unsigned i_rmm(0); i_rmm < num_submodels; ++i_rmm)
     {
       rmm[i_rmm]->computeStress(current_elem,
                                 elasticityTensor,
                                 stress_old,
                                 elastic_strain_increment,
                                 stress_new,
                                 inelastic_strain_increment);
     }
  
     // now check convergence
     SymmTensor deltaS(stress_new_last - stress_new);
     delS = std::sqrt(deltaS.doubleContraction(deltaS));
     if (counter == 0)
     {
       first_delS = delS;
     }
     stress_new_last = stress_new;
  
     if (_internal_solve_full_iteration_history == true)
     {
       _console << "stress_it=" << counter
                << " rel_delS=" << (0 == first_delS ? 0 : delS / first_delS)
                << " rel_tol=" << _relative_tolerance << " abs_delS=" << delS
                << " abs_tol=" << _absolute_tolerance << std::endl;
     }
  
     ++counter;
   }
  
   if (counter == _max_its && delS > _absolute_tolerance &&
       (delS / first_delS) > _relative_tolerance)
   {
     mooseError("Max stress iteration hit during CombinedCreepPlasticity solve!");
   }
  
   strain_increment = elastic_strain_increment;
  
   _matl_timestep_limit[_qp] = 0.0;
   for (unsigned i_rmm(0); i_rmm < num_submodels; ++i_rmm)
     _matl_timestep_limit[_qp] += 1.0 / rmm[i_rmm]->computeTimeStepLimit();
  
   if (MooseUtils::absoluteFuzzyEqual(_matl_timestep_limit[_qp], 0.0))
   {
     _matl_timestep_limit[_qp] = std::numeric_limits<Real>::max();
   }
   else
   {
     _matl_timestep_limit[_qp] = 1.0 / _matl_timestep_limit[_qp];
   }
 }

◆ initialSetup()

void CombinedCreepPlasticity::initialSetup ( )

protectedvirtual

Definition at line 51 of file CombinedCreepPlasticity.C.

 {
   std::vector<SubdomainID> block_id =
       std::vector<SubdomainID>(blockIDs().begin(), blockIDs().end());
   const std::vector<std::string> & submodels = getParam<std::vector<std::string>>("submodels");
   for (unsigned i(0); i < block_id.size(); ++i)
   {
     std::string suffix;
     std::vector<MooseSharedPointer<MaterialBase>> const * mats_p;
     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 i_name(0); i_name < submodels.size(); ++i_name)
     {
       bool found = false;
       for (unsigned int j = 0; j < mats.size(); ++j)
       {
         MooseSharedPointer<ReturnMappingModel> rmm =
             MooseSharedNamespace::dynamic_pointer_cast<ReturnMappingModel>(mats[j]);
         if (rmm && rmm->name() == submodels[i_name] + suffix)
         {
           _submodels[block_id[i]].push_back(rmm);
           found = true;
           break;
         }
       }
       if (!found)
       {
         mooseError("Unable to find submodel " + submodels[i_name]);
       }
     }
   }
  
   ConstitutiveModel::initialSetup();
 }

◆ modifyStrainIncrement()

bool CombinedCreepPlasticity::modifyStrainIncrement	(	const Elem &	current_elem,
		SymmTensor &	strain_increment,
		SymmTensor &	d_strain_dT
	)

virtual

Reimplemented from ConstitutiveModel.

Definition at line 199 of file CombinedCreepPlasticity.C.

 {
   bool modified = false;
   const SubdomainID current_block = current_elem.subdomain_id();
   const std::vector<MooseSharedPointer<ReturnMappingModel>> & rmm(_submodels[current_block]);
   const unsigned num_submodels = rmm.size();
  
   for (unsigned i_rmm(0); i_rmm < num_submodels; ++i_rmm)
   {
     rmm[i_rmm]->setQp(_qp);
     modified |= rmm[i_rmm]->modifyStrainIncrement(current_elem, strain_increment, d_strain_dT);
   }
   return modified;
 }

◆ setQp()

void ConstitutiveModel::setQp ( unsigned int qp )

inherited

Sets the value of the variable _qp for inheriting classes.

Definition at line 89 of file ConstitutiveModel.C.

 {
   _qp = qp;
 }

Referenced by computeStress().

◆ updateElasticityTensor()

virtual bool ConstitutiveModel::updateElasticityTensor ( SymmElasticityTensor & )

inlinevirtualinherited

Definition at line 44 of file ConstitutiveModel.h.

44 { return false; }

Member Data Documentation

◆ _absolute_tolerance

Real CombinedCreepPlasticity::_absolute_tolerance

protected

Definition at line 50 of file CombinedCreepPlasticity.h.

Referenced by computeStress().

◆ _alpha

const Real ConstitutiveModel::_alpha

protectedinherited

Definition at line 52 of file ConstitutiveModel.h.

Referenced by ConstitutiveModel::applyThermalStrain().

◆ _alpha_function

const Function* ConstitutiveModel::_alpha_function

protectedinherited

Definition at line 53 of file ConstitutiveModel.h.

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

◆ _has_stress_free_temp

bool ConstitutiveModel::_has_stress_free_temp

protectedinherited

Definition at line 54 of file ConstitutiveModel.h.

Referenced by ConstitutiveModel::applyThermalStrain().

◆ _has_temp

const bool ConstitutiveModel::_has_temp

protectedinherited

Definition at line 49 of file ConstitutiveModel.h.

Referenced by ConstitutiveModel::applyThermalStrain(), PowerLawCreepModel::computeStressInitialize(), and ConstitutiveModel::ConstitutiveModel().

◆ _internal_solve_full_iteration_history

bool CombinedCreepPlasticity::_internal_solve_full_iteration_history

protected

Definition at line 48 of file CombinedCreepPlasticity.h.

Referenced by computeStress().

◆ _matl_timestep_limit

MaterialProperty<Real>& CombinedCreepPlasticity::_matl_timestep_limit

protected

Definition at line 51 of file CombinedCreepPlasticity.h.

Referenced by computeStress().

◆ _max_its

unsigned int CombinedCreepPlasticity::_max_its

protected

Definition at line 47 of file CombinedCreepPlasticity.h.

Referenced by computeStress().

◆ _mean_alpha_function

bool ConstitutiveModel::_mean_alpha_function

protectedinherited

Definition at line 56 of file ConstitutiveModel.h.

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

◆ _ref_temp

Real ConstitutiveModel::_ref_temp

protectedinherited

Definition at line 57 of file ConstitutiveModel.h.

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

◆ _relative_tolerance

Real CombinedCreepPlasticity::_relative_tolerance

protected

Definition at line 49 of file CombinedCreepPlasticity.h.

Referenced by computeStress().

◆ _step_one_cm

bool& ConstitutiveModel::_step_one_cm

protectedinherited

Definition at line 61 of file ConstitutiveModel.h.

Referenced by ConstitutiveModel::applyThermalStrain().

◆ _step_zero_cm

bool& ConstitutiveModel::_step_zero_cm

protectedinherited

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

Definition at line 60 of file ConstitutiveModel.h.

Referenced by ConstitutiveModel::applyThermalStrain().

◆ _stress_free_temp

Real ConstitutiveModel::_stress_free_temp

protectedinherited

Definition at line 55 of file ConstitutiveModel.h.

Referenced by ConstitutiveModel::applyThermalStrain().

◆ _submodels

std::map<SubdomainID, std::vector<MooseSharedPointer<ReturnMappingModel> > > CombinedCreepPlasticity::_submodels

protected

Definition at line 45 of file CombinedCreepPlasticity.h.

Referenced by computeStress(), initialSetup(), and modifyStrainIncrement().

◆ _temperature

const VariableValue& ConstitutiveModel::_temperature

protectedinherited

Definition at line 50 of file ConstitutiveModel.h.

Referenced by ConstitutiveModel::applyThermalStrain(), computeStress(), PowerLawCreepModel::computeStressInitialize(), IsotropicTempDepHardening::computeYieldStress(), IsotropicPlasticity::computeYieldStress(), and IsotropicTempDepHardening::initializeHardeningFunctions().

◆ _temperature_old

const VariableValue& ConstitutiveModel::_temperature_old

protectedinherited

Definition at line 51 of file ConstitutiveModel.h.

Referenced by ConstitutiveModel::applyThermalStrain().

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

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

Public Member Functions

Protected Member Functions

Protected Attributes

Detailed Description

Constructor & Destructor Documentation

◆ CombinedCreepPlasticity()

◆ ~CombinedCreepPlasticity()

Member Function Documentation

◆ applyThermalStrain()

◆ computeStress()

◆ initialSetup()

◆ modifyStrainIncrement()

◆ setQp()

◆ updateElasticityTensor()

Member Data Documentation

◆ _absolute_tolerance

◆ _alpha

◆ _alpha_function

◆ _has_stress_free_temp

◆ _has_temp

◆ _internal_solve_full_iteration_history

◆ _matl_timestep_limit

◆ _max_its

◆ _mean_alpha_function

◆ _ref_temp

◆ _relative_tolerance

◆ _step_one_cm

◆ _step_zero_cm

◆ _stress_free_temp

◆ _submodels

◆ _temperature

◆ _temperature_old