#include <GeneralizedPlaneStrainUserObject.h>

Inheritance diagram for GeneralizedPlaneStrainUserObject:

Public Member Functions
	GeneralizedPlaneStrainUserObject (const InputParameters &parameters)

void	initialize () override

void	execute () override

void	threadJoin (const UserObject &uo) override

void	finalize () override

virtual Real	returnResidual (unsigned int scalar_var_id=0) const

virtual Real	returnReferenceResidual (unsigned int scalar_var_id=0) const

virtual Real	returnJacobian (unsigned int scalar_var_id=0) const

Static Public Member Functions
static InputParameters	validParams ()

Protected Attributes
const std::string	_base_name

const MaterialProperty< RankFourTensor > &	_Cijkl

const MaterialProperty< RankTwoTensor > &	_stress

const SubblockIndexProvider *	_subblock_id_provider

const Function &	_out_of_plane_pressure

const Real	_factor

unsigned int	_scalar_out_of_plane_strain_direction

std::vector< Real >	_residual

std::vector< Real >	_reference_residual

std::vector< Real >	_jacobian

Detailed Description

Definition at line 27 of file GeneralizedPlaneStrainUserObject.h.

Constructor & Destructor Documentation

◆ GeneralizedPlaneStrainUserObject()

GeneralizedPlaneStrainUserObject::GeneralizedPlaneStrainUserObject ( const InputParameters & parameters )

Definition at line 44 of file GeneralizedPlaneStrainUserObject.C.

   : ElementUserObject(parameters),
     _base_name(isParamValid("base_name") ? getParam<std::string>("base_name") + "_" : ""),
     _Cijkl(getMaterialProperty<RankFourTensor>(_base_name + "elasticity_tensor")),
     _stress(getMaterialProperty<RankTwoTensor>(_base_name + "stress")),
     _subblock_id_provider(nullptr),
     _out_of_plane_pressure(getFunction("out_of_plane_pressure")),
     _factor(getParam<Real>("factor"))
 {
 }

Member Function Documentation

◆ execute()

void GeneralizedPlaneStrainUserObject::execute ( )

override

Definition at line 75 of file GeneralizedPlaneStrainUserObject.C.

 {
   const unsigned int subblock_id =
       _subblock_id_provider ? _subblock_id_provider->getSubblockIndex(*_current_elem) : 0;
  
   for (unsigned int _qp = 0; _qp < _qrule->n_points(); _qp++)
   {
     // residual, integral of stress_zz for COORD_XYZ
     _residual[subblock_id] += _JxW[_qp] * _coord[_qp] *
                               (_stress[_qp](_scalar_out_of_plane_strain_direction,
                                             _scalar_out_of_plane_strain_direction) +
                                _out_of_plane_pressure.value(_t, _q_point[_qp]) * _factor);
  
     _reference_residual[subblock_id] += std::abs(
         _JxW[_qp] * _coord[_qp] *
         _stress[_qp](_scalar_out_of_plane_strain_direction, _scalar_out_of_plane_strain_direction));
  
     // diagonal jacobian, integral of C(2, 2, 2, 2) for COORD_XYZ
     _jacobian[subblock_id] += _JxW[_qp] * _coord[_qp] *
                               _Cijkl[_qp](_scalar_out_of_plane_strain_direction,
                                           _scalar_out_of_plane_strain_direction,
                                           _scalar_out_of_plane_strain_direction,
                                           _scalar_out_of_plane_strain_direction);
   }
 }

◆ finalize()

void GeneralizedPlaneStrainUserObject::finalize ( )

override

Definition at line 115 of file GeneralizedPlaneStrainUserObject.C.

 {
   gatherSum(_residual);
   gatherSum(_reference_residual);
   gatherSum(_jacobian);
 }

◆ initialize()

void GeneralizedPlaneStrainUserObject::initialize ( )

override

Definition at line 57 of file GeneralizedPlaneStrainUserObject.C.

 {
   if (isParamValid("subblock_index_provider"))
     _subblock_id_provider = &getUserObject<SubblockIndexProvider>("subblock_index_provider");
   if (_assembly.coordSystem() == Moose::COORD_XYZ)
     _scalar_out_of_plane_strain_direction = getParam<MooseEnum>("out_of_plane_direction");
   else if (_assembly.coordSystem() == Moose::COORD_RZ)
     _scalar_out_of_plane_strain_direction = 1;
   else
     mooseError("Unsupported coordinate system for generalized plane strain formulation");
  
   unsigned int max_size = _subblock_id_provider ? _subblock_id_provider->getMaxSubblockIndex() : 1;
   _residual.assign(max_size, 0.0);
   _reference_residual.assign(max_size, 0.0);
   _jacobian.assign(max_size, 0.0);
 }

◆ returnJacobian()

Real GeneralizedPlaneStrainUserObject::returnJacobian ( unsigned int scalar_var_id = 0 ) const

virtual

Definition at line 147 of file GeneralizedPlaneStrainUserObject.C.

 {
   if (_jacobian.size() <= scalar_var_id)
     mooseError("Index out of bounds!");
  
   return _jacobian[scalar_var_id];
 }

Referenced by GeneralizedPlaneStrain::computeJacobian().

◆ returnReferenceResidual()

Real GeneralizedPlaneStrainUserObject::returnReferenceResidual ( unsigned int scalar_var_id = 0 ) const

virtual

Definition at line 132 of file GeneralizedPlaneStrainUserObject.C.

 {
   // At startup, the GeneralizedPlaneStrainReferenceResidual class can ask for this value
   // before it has been computed.  Return 0.0 in this case.  The only way size will stay
   // zero is if initialize is never called.
   if (_reference_residual.size() == 0)
     return 0.0;
  
   if (_residual.size() <= scalar_var_id)
     mooseError("Index out of bounds!");
  
   return _reference_residual[scalar_var_id];
 }

Referenced by GeneralizedPlaneStrain::computeResidual(), and GeneralizedPlaneStrainReferenceResidual::computeValue().

◆ returnResidual()

Real GeneralizedPlaneStrainUserObject::returnResidual ( unsigned int scalar_var_id = 0 ) const

virtual

Definition at line 123 of file GeneralizedPlaneStrainUserObject.C.

 {
   if (_residual.size() <= scalar_var_id)
     mooseError("Index out of bounds!");
  
   return _residual[scalar_var_id];
 }

Referenced by GeneralizedPlaneStrain::computeResidual().

◆ threadJoin()

void GeneralizedPlaneStrainUserObject::threadJoin ( const UserObject & uo )

override

Definition at line 102 of file GeneralizedPlaneStrainUserObject.C.

 {
   const GeneralizedPlaneStrainUserObject & gpsuo =
       static_cast<const GeneralizedPlaneStrainUserObject &>(uo);
   for (unsigned int i = 0; i < _residual.size(); ++i)
   {
     _residual[i] += gpsuo._residual[i];
     _reference_residual[i] += gpsuo._reference_residual[i];
     _jacobian[i] += gpsuo._jacobian[i];
   }
 }

◆ validParams()

InputParameters GeneralizedPlaneStrainUserObject::validParams ( )

static

Definition at line 23 of file GeneralizedPlaneStrainUserObject.C.

 {
   InputParameters params = ElementUserObject::validParams();
   params.addClassDescription(
       "Generalized plane strain UserObject to provide residual and diagonal Jacobian entries.");
   params.addParam<UserObjectName>("subblock_index_provider",
                                   "SubblockIndexProvider user object name");
   params.addParam<FunctionName>(
       "out_of_plane_pressure",
       "0",
       "Function used to prescribe pressure in the out-of-plane direction");
   MooseEnum outOfPlaneDirection("x y z", "z");
   params.addParam<MooseEnum>(
       "out_of_plane_direction", outOfPlaneDirection, "The direction of the out-of-plane strain.");
   params.addParam<Real>("factor", 1.0, "Scale factor applied to prescribed pressure");
   params.addParam<std::string>("base_name", "Material properties base name");
   params.set<ExecFlagEnum>("execute_on") = EXEC_LINEAR;
  
   return params;
 }