Base class of the "Lagrangian" kernel system. More...

#include <LagrangianStressDivergenceBaseS.h>

Inheritance diagram for LagrangianStressDivergenceBaseS:

Public Types
typedef std::vector< int >	JvarMap

Public Member Functions
	LagrangianStressDivergenceBaseS (const InputParameters &parameters)

virtual void	computeOffDiagJacobian (unsigned int jvar) override

unsigned int	mapJvarToCvar (unsigned int jvar)

int	mapJvarToCvar (unsigned int jvar, const JvarMap &jvar_map)

bool	mapJvarToCvar (unsigned int jvar, unsigned int &cvar)

const JvarMap &	getJvarMap ()

const JvarMap &	getParameterJvarMap (std::string parameter_name)

Static Public Member Functions
static InputParameters	validParams ()

Protected Member Functions
virtual RankTwoTensor	gradTest (unsigned int component)=0

virtual RankTwoTensor	gradTrial (unsigned int component)=0

virtual void	precalculateJacobian () override

virtual void	precalculateOffDiagJacobian (unsigned int jvar) override

virtual void	precalculateJacobianDisplacement (unsigned int component)=0
	Prepare the average shape function gradients for stabilization. More...

virtual Real	computeQpJacobian () override

virtual Real	computeQpOffDiagJacobian (unsigned int jvar) override

virtual Real	computeQpJacobianDisplacement (unsigned int alpha, unsigned int beta)=0

virtual Real	computeQpJacobianTemperature (unsigned int cvar)=0

virtual Real	computeQpJacobianOutOfPlaneStrain ()=0

Protected Attributes
const bool	_large_kinematics
	If true use large deformation kinematics. More...

const bool	_stabilize_strain
	If true calculate the deformation gradient derivatives for F_bar. More...

const std::string	_base_name
	Prepend to the material properties. More...

const unsigned int	_alpha
	Which component of the vector residual this kernel is responsible for. More...

const unsigned int	_ndisp
	Total number of displacements/size of residual vector. More...

std::vector< unsigned int >	_disp_nums
	The displacement numbers. More...

std::vector< std::vector< RankTwoTensor > >	_avg_grad_trial

const MaterialProperty< RankTwoTensor > &	_F_ust
	The unmodified deformation gradient. More...

const MaterialProperty< RankTwoTensor > &	_F_avg
	The element-average deformation gradient. More...

const MaterialProperty< RankTwoTensor > &	_f_inv
	The inverse increment deformation gradient. More...

const MaterialProperty< RankTwoTensor > &	_F_inv
	The inverse deformation gradient. More...

const MaterialProperty< RankTwoTensor > &	_F
	The actual (stabilized) deformation gradient. More...

const MooseVariable *	_temperature
	Temperature, if provided. This is used only to get the trial functions. More...

const MooseVariable *	_out_of_plane_strain
	Out-of-plane strain, if provided. More...

std::vector< std::vector< const MaterialProperty< RankTwoTensor > * > >	_deigenstrain_dargs
	Eigenstrain derivatives wrt generate coupleds. More...

const unsigned int	_n_args

Detailed Description

Base class of the "Lagrangian" kernel system.

This class provides a common structure for the "new" tensor_mechanics kernel system. The goals for this new system are 1) Always-correct jacobians 2) A cleaner material interface

This class provides common input properties and helper methods, most of the math has to be done in the subclasses

Definition at line 27 of file LagrangianStressDivergenceBaseS.h.

Constructor & Destructor Documentation

◆ LagrangianStressDivergenceBaseS()

LagrangianStressDivergenceBaseS::LagrangianStressDivergenceBaseS ( const InputParameters & parameters )

Definition at line 42 of file LagrangianStressDivergenceBaseS.C.

   : JvarMapKernelInterface<DerivativeMaterialInterface<KernelScalarBase>>(parameters),
     _large_kinematics(getParam<bool>("large_kinematics")),
     _stabilize_strain(getParam<bool>("stabilize_strain")),
     _base_name(isParamValid("base_name") ? getParam<std::string>("base_name") + "_" : ""),
     _alpha(getParam<unsigned int>("component")),
     _ndisp(coupledComponents("displacements")),
     _disp_nums(_ndisp),
     _avg_grad_trial(_ndisp),
     _F_ust(
         getMaterialPropertyByName<RankTwoTensor>(_base_name + "unstabilized_deformation_gradient")),
     _F_avg(getMaterialPropertyByName<RankTwoTensor>(_base_name + "average_deformation_gradient")),
     _f_inv(getMaterialPropertyByName<RankTwoTensor>(_base_name +
                                                     "inverse_incremental_deformation_gradient")),
     _F_inv(getMaterialPropertyByName<RankTwoTensor>(_base_name + "inverse_deformation_gradient")),
     _F(getMaterialPropertyByName<RankTwoTensor>(_base_name + "deformation_gradient")),
     _temperature(isCoupled("temperature") ? getVar("temperature", 0) : nullptr),
     _out_of_plane_strain(isCoupled("out_of_plane_strain") ? getVar("out_of_plane_strain", 0)
                                                           : nullptr)
 {
   // Do the vector coupling of the displacements
   for (unsigned int i = 0; i < _ndisp; i++)
     _disp_nums[i] = coupled("displacements", i);
 
   // We need to use identical discretizations for all displacement components
   auto order_x = getVar("displacements", 0)->order();
   for (unsigned int i = 1; i < _ndisp; i++)
   {
     if (getVar("displacements", i)->order() != order_x)
       mooseError("The Lagrangian StressDivergence kernels require equal "
                  "order interpolation for all displacements.");
   }
 
   // fetch eigenstrain derivatives
   const auto nvar = _coupled_moose_vars.size();
   _deigenstrain_dargs.resize(nvar);
   for (std::size_t i = 0; i < nvar; ++i)
     for (auto eigenstrain_name : getParam<std::vector<MaterialPropertyName>>("eigenstrain_names"))
       _deigenstrain_dargs[i].push_back(&getMaterialPropertyDerivative<RankTwoTensor>(
           eigenstrain_name, _coupled_moose_vars[i]->name()));
 }

Member Function Documentation

◆ computeQpJacobian()

Real LagrangianStressDivergenceBaseS::computeQpJacobian ( )

overrideprotectedvirtual

Definition at line 115 of file LagrangianStressDivergenceBaseS.C.

 {
   return computeQpJacobianDisplacement(_alpha, _alpha);
 }

◆ computeQpJacobianDisplacement()

virtual Real LagrangianStressDivergenceBaseS::computeQpJacobianDisplacement	(	unsigned int	alpha,
		unsigned int	beta
	)

protectedpure virtual

Implemented in HomogenizedTotalLagrangianStressDivergenceA, HomogenizedTotalLagrangianStressDivergenceR, and TotalLagrangianStressDivergenceBaseS< G >.

Referenced by computeQpJacobian(), and computeQpOffDiagJacobian().

◆ computeQpJacobianOutOfPlaneStrain()

virtual Real LagrangianStressDivergenceBaseS::computeQpJacobianOutOfPlaneStrain ( )

protectedpure virtual

Implemented in TotalLagrangianStressDivergenceBaseS< G >.

Referenced by computeQpOffDiagJacobian().

◆ computeQpJacobianTemperature()

virtual Real LagrangianStressDivergenceBaseS::computeQpJacobianTemperature ( unsigned int cvar )

protectedpure virtual

Implemented in TotalLagrangianStressDivergenceBaseS< G >.

Referenced by computeQpOffDiagJacobian().

◆ computeQpOffDiagJacobian()

Real LagrangianStressDivergenceBaseS::computeQpOffDiagJacobian ( unsigned int jvar )

overrideprotectedvirtual

Definition at line 121 of file LagrangianStressDivergenceBaseS.C.

 {
   // Bail if jvar not coupled
   if (getJvarMap()[jvar] < 0)
     return 0.0;
 
   // Off diagonal terms for other displacements
   for (auto beta : make_range(_ndisp))
     if (jvar == _disp_nums[beta])
       return computeQpJacobianDisplacement(_alpha, beta);
 
   // Off diagonal temperature term due to eigenstrain
   if (_temperature && jvar == _temperature->number())
     return computeQpJacobianTemperature(mapJvarToCvar(jvar));
 
   // Off diagonal term due to weak plane stress
   if (_out_of_plane_strain && jvar == _out_of_plane_strain->number())
     return computeQpJacobianOutOfPlaneStrain();
 
   return 0;
 }

◆ gradTest()

virtual RankTwoTensor LagrangianStressDivergenceBaseS::gradTest ( unsigned int component )

protectedpure virtual

Implemented in TotalLagrangianStressDivergenceBaseS< G >.

◆ gradTrial()

virtual RankTwoTensor LagrangianStressDivergenceBaseS::gradTrial ( unsigned int component )

protectedpure virtual

Implemented in TotalLagrangianStressDivergenceBaseS< G >.

◆ precalculateJacobian()

void LagrangianStressDivergenceBaseS::precalculateJacobian ( )

overrideprotectedvirtual

Definition at line 85 of file LagrangianStressDivergenceBaseS.C.

 {
   // Skip if we are not doing stabilization
   if (!_stabilize_strain)
     return;
 
   // We need the gradients of shape functions in the reference frame
   _fe_problem.prepareShapes(_var.number(), _tid);
   _avg_grad_trial[_alpha].resize(_phi.size());
   precalculateJacobianDisplacement(_alpha);
 }

◆ precalculateJacobianDisplacement()

virtual void LagrangianStressDivergenceBaseS::precalculateJacobianDisplacement ( unsigned int component )

protectedpure virtual

Prepare the average shape function gradients for stabilization.

Implemented in TotalLagrangianStressDivergenceBaseS< G >.

Referenced by precalculateJacobian(), and precalculateOffDiagJacobian().

◆ precalculateOffDiagJacobian()

void LagrangianStressDivergenceBaseS::precalculateOffDiagJacobian ( unsigned int jvar )

overrideprotectedvirtual

Definition at line 98 of file LagrangianStressDivergenceBaseS.C.

 {
   // Skip if we are not doing stabilization
   if (!_stabilize_strain)
     return;
 
   for (auto beta : make_range(_ndisp))
     if (jvar == _disp_nums[beta])
     {
       // We need the gradients of shape functions in the reference frame
       _fe_problem.prepareShapes(jvar, _tid);
       _avg_grad_trial[beta].resize(_phi.size());
       precalculateJacobianDisplacement(beta);
     }
 }

◆ validParams()

InputParameters LagrangianStressDivergenceBaseS::validParams ( )

static

Definition at line 13 of file LagrangianStressDivergenceBaseS.C.

Referenced by TotalLagrangianStressDivergenceBaseS< G >::baseParams().

 {
   InputParameters params = KernelScalarBase::validParams();
 
   params.addRequiredParam<unsigned int>("component", "Which direction this kernel acts in");
   params.addRequiredCoupledVar("displacements", "The displacement components");
 
   params.addParam<bool>("large_kinematics", false, "Use large displacement kinematics");
   params.addParam<bool>("stabilize_strain", false, "Average the volumetric strains");
 
   params.addParam<std::string>("base_name", "Material property base name");
 
   params.addCoupledVar("temperature",
                        "The name of the temperature variable used in the "
                        "ComputeThermalExpansionEigenstrain.  (Not required for "
                        "simulations without temperature coupling.)");
 
   params.addParam<std::vector<MaterialPropertyName>>(
       "eigenstrain_names",
       {},
       "List of eigenstrains used in the strain calculation. Used for computing their derivatives "
       "for off-diagonal Jacobian terms.");
 
   params.addCoupledVar("out_of_plane_strain",
                        "The out-of-plane strain variable for weak plane stress formulation.");
 
   return params;
 }