#include <PlasticTruss.h>

Inheritance diagram for PlasticTruss:

Public Member Functions
	PlasticTruss (const InputParameters &parameters)

Static Public Member Functions
static InputParameters	validParams ()

Protected Member Functions
virtual void	computeQpStrain ()

virtual void	computeQpStress ()

virtual void	initQpStatefulProperties ()

virtual Real	computeHardeningValue (Real scalar)

virtual Real	computeHardeningDerivative (Real scalar)

virtual void	computeProperties ()

Protected Attributes
Real	_yield_stress

const Real	_hardening_constant

const Function *	_hardening_function

Real	_absolute_tolerance
	convergence tolerance More...

Real	_relative_tolerance

const MaterialProperty< Real > &	_total_stretch_old

MaterialProperty< Real > &	_plastic_strain

const MaterialProperty< Real > &	_plastic_strain_old

const MaterialProperty< Real > &	_stress_old

MaterialProperty< Real > &	_hardening_variable

const MaterialProperty< Real > &	_hardening_variable_old

const unsigned int	_max_its
	maximum no. of iterations More...

std::vector< MooseVariable * >	_disp_var

const std::string	_base_name

unsigned int	_ndisp

const VariableValue &	_youngs_modulus

MaterialProperty< Real > &	_total_stretch

MaterialProperty< Real > &	_elastic_stretch

MaterialProperty< Real > &	_axial_stress

MaterialProperty< Real > &	_e_over_l

Real	_origin_length

Real	_current_length

Private Attributes
const VariableValue &	_T

Real	_T0

Real	_thermal_expansion_coeff

Detailed Description

Definition at line 19 of file PlasticTruss.h.

Constructor & Destructor Documentation

◆ PlasticTruss()

PlasticTruss::PlasticTruss ( const InputParameters & parameters )

Definition at line 38 of file PlasticTruss.C.

   : LinearElasticTruss(parameters),
     _yield_stress(getParam<Real>("yield_stress")), // Read from input file
     _hardening_constant(getParam<Real>("hardening_constant")),
     _hardening_function(isParamValid("hardening_function") ? &getFunction("hardening_function")
                                                            : NULL),
     _absolute_tolerance(parameters.get<Real>("absolute_tolerance")),
     _relative_tolerance(parameters.get<Real>("relative_tolerance")),
     _total_stretch_old(getMaterialPropertyOld<Real>(_base_name + "total_stretch")),
     _plastic_strain(declareProperty<Real>(_base_name + "plastic_stretch")),
     _plastic_strain_old(getMaterialPropertyOld<Real>(_base_name + "plastic_stretch")),
     _stress_old(getMaterialPropertyOld<Real>(_base_name + "axial_stress")),
     _hardening_variable(declareProperty<Real>(_base_name + "hardening_variable")),
     _hardening_variable_old(getMaterialPropertyOld<Real>(_base_name + "hardening_variable")),
     _max_its(1000)
 {
   if (!parameters.isParamSetByUser("hardening_constant") && !isParamValid("hardening_function"))
     mooseError("PlasticTruss: Either hardening_constant or hardening_function must be defined");
  
   if (parameters.isParamSetByUser("hardening_constant") && isParamValid("hardening_function"))
     mooseError("PlasticTruss: Only the hardening_constant or only the hardening_function can be "
                "defined but not both");
 }

Member Function Documentation

◆ computeHardeningDerivative()

Real PlasticTruss::computeHardeningDerivative ( Real scalar )

protectedvirtual

Definition at line 140 of file PlasticTruss.C.

 {
   if (_hardening_function)
   {
     const Real strain_old = _plastic_strain_old[_qp];
     const Point p;
  
     return _hardening_function->timeDerivative(std::abs(strain_old), p);
   }
  
   return _hardening_constant;
 }

Referenced by computeQpStress().

◆ computeHardeningValue()

Real PlasticTruss::computeHardeningValue ( Real scalar )

protectedvirtual

Definition at line 127 of file PlasticTruss.C.

 {
   if (_hardening_function)
   {
     const Real strain_old = _plastic_strain_old[_qp];
     const Point p;
  
     return _hardening_function->value(std::abs(strain_old) + scalar, p) - _yield_stress;
   }
  
   return _hardening_variable_old[_qp] + _hardening_constant * scalar;
 }

Referenced by computeQpStress().

◆ computeProperties()

void TrussMaterial::computeProperties ( )

protectedvirtualinherited

Definition at line 63 of file TrussMaterial.C.

 {
   // check for consistency of the number of element nodes
   mooseAssert(_current_elem->n_nodes() == 2, "Truss element needs to have exactly two nodes.");
  
   // fetch the two end nodes for _current_elem
   std::vector<const Node *> node;
   for (unsigned int i = 0; i < 2; ++i)
     node.push_back(_current_elem->node_ptr(i));
  
   // calculate original length of a truss element
   RealGradient dxyz;
   for (unsigned int i = 0; i < _ndisp; ++i)
     dxyz(i) = (*node[1])(i) - (*node[0])(i);
   _origin_length = dxyz.norm();
  
   // fetch the solution for the two end nodes
   NonlinearSystemBase & nonlinear_sys = _fe_problem.getNonlinearSystemBase();
   const NumericVector<Number> & sol = *nonlinear_sys.currentSolution();
  
   std::vector<Real> disp0, disp1;
   for (unsigned int i = 0; i < _ndisp; ++i)
   {
     disp0.push_back(sol(node[0]->dof_number(nonlinear_sys.number(), _disp_var[i]->number(), 0)));
     disp1.push_back(sol(node[1]->dof_number(nonlinear_sys.number(), _disp_var[i]->number(), 0)));
   }
  
   // calculate current length of a truss element
   for (unsigned int i = 0; i < _ndisp; ++i)
     dxyz(i) += disp1[i] - disp0[i];
   _current_length = dxyz.norm();
  
   for (_qp = 0; _qp < _qrule->n_points(); ++_qp)
   {
     _e_over_l[_qp] = _youngs_modulus[_qp] / _origin_length;
  
     computeQpStrain();
     computeQpStress();
   }
 }

◆ computeQpStrain()

void PlasticTruss::computeQpStrain ( )

protectedvirtual

Reimplemented from LinearElasticTruss.

Definition at line 71 of file PlasticTruss.C.

 {
   _total_stretch[_qp] = _current_length / _origin_length - 1.0;
 }

◆ computeQpStress()

void PlasticTruss::computeQpStress ( )

protectedvirtual

Reimplemented from LinearElasticTruss.

Definition at line 77 of file PlasticTruss.C.

 {
   Real strain_increment = _total_stretch[_qp] - _total_stretch_old[_qp];
   Real trial_stress = _stress_old[_qp] + _youngs_modulus[_qp] * strain_increment;
  
   _hardening_variable[_qp] = _hardening_variable_old[_qp];
   _plastic_strain[_qp] = _plastic_strain_old[_qp];
  
   Real yield_condition = std::abs(trial_stress) - _hardening_variable[_qp] - _yield_stress;
   Real iteration = 0;
   Real plastic_strain_increment = 0.0;
   Real elastic_strain_increment = strain_increment;
  
   if (yield_condition > 0.0)
   {
     Real residual = std::abs(trial_stress) - _hardening_variable[_qp] - _yield_stress -
                     _youngs_modulus[_qp] * plastic_strain_increment;
  
     Real reference_residual =
         std::abs(trial_stress) - _youngs_modulus[_qp] * plastic_strain_increment;
  
     while (std::abs(residual) > _absolute_tolerance ||
            std::abs(residual / reference_residual) > _relative_tolerance)
     {
       _hardening_variable[_qp] = computeHardeningValue(plastic_strain_increment);
       Real hardening_slope = computeHardeningDerivative(plastic_strain_increment);
  
       Real scalar = (std::abs(trial_stress) - _hardening_variable[_qp] - _yield_stress -
                      _youngs_modulus[_qp] * plastic_strain_increment) /
                     (_youngs_modulus[_qp] + hardening_slope);
       plastic_strain_increment += scalar;
  
       residual = std::abs(trial_stress) - _hardening_variable[_qp] - _yield_stress -
                  _youngs_modulus[_qp] * plastic_strain_increment;
  
       reference_residual = std::abs(trial_stress) - _youngs_modulus[_qp] * plastic_strain_increment;
  
       ++iteration;
       if (iteration > _max_its) // not converging
         throw MooseException("PlasticTruss: Plasticity model did not converge");
     }
     plastic_strain_increment *= MathUtils::sign(trial_stress);
     _plastic_strain[_qp] += plastic_strain_increment;
     elastic_strain_increment = strain_increment - plastic_strain_increment;
   }
   _elastic_stretch[_qp] = _total_stretch[_qp] - _plastic_strain[_qp];
   _axial_stress[_qp] = _stress_old[_qp] + _youngs_modulus[_qp] * elastic_strain_increment;
 }

◆ initQpStatefulProperties()

void PlasticTruss::initQpStatefulProperties ( )

protectedvirtual

Reimplemented from TrussMaterial.

Definition at line 63 of file PlasticTruss.C.

 {
   TrussMaterial::initQpStatefulProperties();
   _plastic_strain[_qp] = 0.0;
   _hardening_variable[_qp] = 0.0;
 }

◆ validParams()

InputParameters PlasticTruss::validParams ( )

static

Definition at line 20 of file PlasticTruss.C.

 {
   InputParameters params = LinearElasticTruss::validParams();
   params.addClassDescription(
       "Computes the stress and strain for a truss element with plastic behavior defined by either "
       "linear hardening or a user-defined hardening function.");
   params.addRequiredParam<Real>("yield_stress",
                                 "Yield stress after which plastic strain starts accumulating");
   params.addParam<Real>("hardening_constant", 0.0, "Hardening slope");
   params.addParam<FunctionName>("hardening_function",
                                 "Engineering stress as a function of plastic strain");
   params.addParam<Real>(
       "absolute_tolerance", 1e-10, "Absolute convergence tolerance for Newton iteration");
   params.addParam<Real>(
       "relative_tolerance", 1e-8, "Relative convergence tolerance for Newton iteration");
   return params;
 }