#include <GeneralizedPlaneStrainOffDiag.h>

Inheritance diagram for GeneralizedPlaneStrainOffDiag:

Public Member Functions
	GeneralizedPlaneStrainOffDiag (const InputParameters &parameters)

Static Public Member Functions
static InputParameters	validParams ()

Protected Member Functions
Real	computeQpResidual () override

void	computeOffDiagJacobianScalar (unsigned int jvar) override
	These methods are used to compute the off-diagonal jacobian for the coupling between scalar variable strain_yy or strain_zz and nonlinear variables displacements and temperature. More...

virtual void	computeDispOffDiagJacobianScalar (unsigned int component, unsigned int jvar)

virtual void	computeTempOffDiagJacobianScalar (unsigned int jvar)

Protected Attributes
const std::string	_base_name

const MaterialProperty< RankFourTensor > &	_Jacobian_mult

const std::vector< MaterialPropertyName >	_eigenstrain_names

std::vector< const MaterialProperty< RankTwoTensor > * >	_deigenstrain_dT

unsigned int	_scalar_out_of_plane_strain_var

const SubblockIndexProvider *	_subblock_id_provider

const unsigned int	_scalar_var_id

MooseVariable *	_temp_var

const unsigned int	_num_disp_var

std::vector< MooseVariable * >	_disp_var

unsigned int	_scalar_out_of_plane_strain_direction

Detailed Description

Definition at line 28 of file GeneralizedPlaneStrainOffDiag.h.

Constructor & Destructor Documentation

◆ GeneralizedPlaneStrainOffDiag()

GeneralizedPlaneStrainOffDiag::GeneralizedPlaneStrainOffDiag ( const InputParameters & parameters )

Definition at line 53 of file GeneralizedPlaneStrainOffDiag.C.

   : DerivativeMaterialInterface<Kernel>(parameters),
     _base_name(isParamValid("base_name") ? getParam<std::string>("base_name") + "_" : ""),
     _Jacobian_mult(getMaterialProperty<RankFourTensor>(_base_name + "Jacobian_mult")),
     _eigenstrain_names(getParam<std::vector<MaterialPropertyName>>("eigenstrain_names")),
     _deigenstrain_dT(_eigenstrain_names.size()),
     _scalar_out_of_plane_strain_var(coupledScalar("scalar_out_of_plane_strain")),
     _subblock_id_provider(isParamValid("subblock_index_provider")
                               ? &getUserObject<SubblockIndexProvider>("subblock_index_provider")
                               : nullptr),
     _scalar_var_id(isParamValid("scalar_out_of_plane_strain_index")
                        ? getParam<unsigned int>("scalar_out_of_plane_strain_index")
                        : 0),
     _temp_var(isParamValid("temperature")
                   ? &_subproblem.getStandardVariable(_tid, getParam<VariableName>("temperature"))
                   : NULL),
     _num_disp_var(getParam<std::vector<VariableName>>("displacements").size()),
     _scalar_out_of_plane_strain_direction(getParam<MooseEnum>("out_of_plane_direction"))
 {
   const std::vector<VariableName> & nl_vnames(getParam<std::vector<VariableName>>("displacements"));
  
   if (_scalar_out_of_plane_strain_direction == 2 && _num_disp_var > 2)
     mooseError("For 1D axisymmetric or 2D cartesian simulations where the out-of-plane direction "
                "is z, the number of supplied displacements to GeneralizedPlaneStrainOffDiag must "
                "be less than three.");
   else if (_scalar_out_of_plane_strain_direction != 2 && _num_disp_var != 3)
     mooseError("For 2D cartesian simulations where the out-of-plane direction is x or y the number "
                "of supplied displacements must be three.");
  
   for (unsigned int i = 0; i < _num_disp_var; ++i)
     _disp_var.push_back(&_subproblem.getStandardVariable(_tid, nl_vnames[i]));
  
   for (unsigned int i = 0; i < _deigenstrain_dT.size(); ++i)
     _deigenstrain_dT[i] = &getMaterialPropertyDerivative<RankTwoTensor>(
         _base_name + _eigenstrain_names[i], _temp_var->name());
  
   if (isParamValid("scalar_variable_index_provider") &&
       !isParamValid("scalar_out_of_plane_strain_index"))
     mooseError("scalar_out_of_plane_strain_index should be provided if more "
                "than one is available");
 }

Member Function Documentation

◆ computeDispOffDiagJacobianScalar()

void GeneralizedPlaneStrainOffDiag::computeDispOffDiagJacobianScalar	(	unsigned int	component,
		unsigned int	jvar
	)

protectedvirtual

Definition at line 116 of file GeneralizedPlaneStrainOffDiag.C.

 {
   if (jvar == _scalar_out_of_plane_strain_var)
   {
     DenseMatrix<Number> & ken = _assembly.jacobianBlock(_var.number(), jvar);
     DenseMatrix<Number> & kne = _assembly.jacobianBlock(jvar, _var.number());
     MooseVariableScalar & jv = _sys.getScalarVariable(_tid, jvar);
  
     // Set appropriate components for scalar kernels, including in the cases where a planar model is
     // running in planes other than the x-y plane (defined by _out_of_plane_strain_direction).
     if (_scalar_out_of_plane_strain_direction == 0)
       component += 1;
     else if (_scalar_out_of_plane_strain_direction == 1 && component == 1)
       component += 1;
  
     for (_i = 0; _i < _test.size(); ++_i)
       for (_j = 0; _j < jv.order(); ++_j)
         for (_qp = 0; _qp < _qrule->n_points(); ++_qp)
         {
           ken(_i, _j) += _JxW[_qp] * _coord[_qp] *
                          _Jacobian_mult[_qp](_scalar_out_of_plane_strain_direction,
                                              _scalar_out_of_plane_strain_direction,
                                              component,
                                              component) *
                          _grad_test[_i][_qp](component);
           kne(_j, _i) += _JxW[_qp] * _coord[_qp] *
                          _Jacobian_mult[_qp](_scalar_out_of_plane_strain_direction,
                                              _scalar_out_of_plane_strain_direction,
                                              component,
                                              component) *
                          _grad_test[_i][_qp](component);
         }
   }
 }

Referenced by computeOffDiagJacobianScalar().

◆ computeOffDiagJacobianScalar()

void GeneralizedPlaneStrainOffDiag::computeOffDiagJacobianScalar ( unsigned int jvar )

overrideprotected

These methods are used to compute the off-diagonal jacobian for the coupling between scalar variable strain_yy or strain_zz and nonlinear variables displacements and temperature.

disp indicates the coupling is between displacements and strain_yy or strain_zz and temp is for temperature and strain_yy or strain_zz

Definition at line 96 of file GeneralizedPlaneStrainOffDiag.C.

 {
   const unsigned int elem_scalar_var_id =
       _subblock_id_provider ? _subblock_id_provider->getSubblockIndex(*_current_elem) : 0;
  
   if (elem_scalar_var_id == _scalar_var_id)
   {
     if (_assembly.coordSystem() == Moose::COORD_RZ)
       _scalar_out_of_plane_strain_direction = 1;
  
     if (_var.number() == _disp_var[0]->number())
       computeDispOffDiagJacobianScalar(0, jvar);
     else if (_num_disp_var == 2 && _var.number() == _disp_var[1]->number())
       computeDispOffDiagJacobianScalar(1, jvar);
     else if (isParamValid("temperature") ? _var.number() == _temp_var->number() : 0)
       computeTempOffDiagJacobianScalar(jvar);
   }
 }

◆ computeQpResidual()

Real GeneralizedPlaneStrainOffDiag::computeQpResidual ( )

inlineoverrideprotected

Definition at line 36 of file GeneralizedPlaneStrainOffDiag.h.

36 { return 0; }

◆ computeTempOffDiagJacobianScalar()

void GeneralizedPlaneStrainOffDiag::computeTempOffDiagJacobianScalar ( unsigned int jvar )

protectedvirtual

Definition at line 153 of file GeneralizedPlaneStrainOffDiag.C.

 {
   if (jvar == _scalar_out_of_plane_strain_var)
   {
     DenseMatrix<Number> & kne = _assembly.jacobianBlock(jvar, _var.number());
     MooseVariableScalar & jv = _sys.getScalarVariable(_tid, jvar);
     unsigned int n_eigenstrains = _deigenstrain_dT.size();
  
     for (_i = 0; _i < _test.size(); ++_i)
       for (_j = 0; _j < jv.order(); ++_j)
         for (_qp = 0; _qp < _qrule->n_points(); ++_qp)
           for (unsigned int ies = 0; ies < n_eigenstrains; ++ies)
             kne(_j, _i) +=
                 _JxW[_qp] * _coord[_qp] *
                 (_Jacobian_mult[_qp] * (*_deigenstrain_dT[ies])[_qp])(
                     _scalar_out_of_plane_strain_direction, _scalar_out_of_plane_strain_direction) *
                 _test[_i][_qp];
   }
 }

Referenced by computeOffDiagJacobianScalar().

◆ validParams()

InputParameters GeneralizedPlaneStrainOffDiag::validParams ( )

static

Definition at line 27 of file GeneralizedPlaneStrainOffDiag.C.

 {
   InputParameters params = Kernel::validParams();
   params.addClassDescription("Generalized Plane Strain kernel to provide contribution of the "
                              "out-of-plane strain to other kernels");
   params.addRequiredParam<std::vector<VariableName>>("displacements",
                                                      "Variable for the displacements");
   params.addParam<VariableName>("temperature", "Variable for the temperature");
  
   params.addCoupledVar("scalar_out_of_plane_strain",
                        "Scalar variable for generalized plane strain");
   MooseEnum outOfPlaneDirection("x y z", "z");
   params.addParam<MooseEnum>(
       "out_of_plane_direction", outOfPlaneDirection, "The direction of the out-of-plane strain.");
   params.addParam<UserObjectName>("subblock_index_provider",
                                   "SubblockIndexProvider user object name");
   params.addParam<unsigned int>(
       "scalar_out_of_plane_strain_index",
       "The index number of scalar_out_of_plane_strain this kernel acts on");
   params.addParam<std::string>("base_name", "Material property base name");
   params.addParam<std::vector<MaterialPropertyName>>(
       "eigenstrain_names", "List of eigenstrains to be applied in this strain calculation");
  
   return params;
 }