Enforce equilibrium with an updated Lagrangian formulation. More...

#include <UpdatedLagrangianStressDivergence.h>

Inheritance diagram for UpdatedLagrangianStressDivergenceBase< G >:

Public Types
typedef std::vector< int >	JvarMap

Public Member Functions
	UpdatedLagrangianStressDivergenceBase (const InputParameters &parameters)

virtual void	initialSetup () override

template<>
InputParameters	validParams ()

template<>
void	initialSetup ()

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	baseParams ()

static InputParameters	validParams ()

Protected Member Functions
virtual RankTwoTensor	gradTest (unsigned int component) override

virtual RankTwoTensor	gradTrial (unsigned int component) override

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

virtual Real	computeQpResidual () override

virtual Real	computeQpJacobianDisplacement (unsigned int alpha, unsigned int beta) override

virtual Real	computeQpJacobianTemperature (unsigned int cvar) override

virtual Real	computeQpJacobianOutOfPlaneStrain () override

virtual void	precalculateJacobian () override

virtual void	precalculateOffDiagJacobian (unsigned int jvar) override

virtual Real	computeQpJacobian () override

virtual Real	computeQpOffDiagJacobian (unsigned int jvar) override

Protected Attributes
const MaterialProperty< RankTwoTensor > &	_stress
	The Cauchy stress. More...

const MaterialProperty< RankFourTensor > &	_material_jacobian

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


Assembly &	_assembly_undisplaced

const VariablePhiGradient &	_grad_phi_undisplaced

const MooseArray< Real > &	_JxW_undisplaced

const MooseArray< Real > &	_coord_undisplaced

const MooseArray< Point > &	_q_point_undisplaced

Private Member Functions
virtual RankTwoTensor	gradTrialUnstabilized (unsigned int component)
	The unstabilized trial function gradient. More...

virtual RankTwoTensor	gradTrialStabilized (unsigned int component)
	The stabilized trial function gradient. More...

Detailed Description

template<class G>
class UpdatedLagrangianStressDivergenceBase< G >

Enforce equilibrium with an updated Lagrangian formulation.

This class enforces equilibrium when used in conjunction with the corresponding strain calculator (CalculateStrainLagrangianKernel) and with either a stress calculator that provides the Cauchy stress ("stress") and the appropriate "cauchy_jacobian", which needs to be the derivative of the increment in Cauchy stress with respect to the increment in the spatial velocity gradient.

This kernel should be used with the new "ComputeLagrangianStressBase" stress update system and the "ComputeLagrangianStrain" system for strains.

use_displaced_mesh must be true for large deformation kinematics The kernel enforces this with an error

Definition at line 32 of file UpdatedLagrangianStressDivergence.h.

Constructor & Destructor Documentation

◆ UpdatedLagrangianStressDivergenceBase()

template<class G >

UpdatedLagrangianStressDivergenceBase< G >::UpdatedLagrangianStressDivergenceBase ( const InputParameters & parameters )

Definition at line 15 of file UpdatedLagrangianStressDivergence.C.

   : LagrangianStressDivergenceBase(parameters),
     _stress(getMaterialPropertyByName<RankTwoTensor>(_base_name + "cauchy_stress")),
     _material_jacobian(getMaterialPropertyByName<RankFourTensor>(_base_name + "cauchy_jacobian")),
 
     // Assembly quantities in the reference frame for stabilization
     _assembly_undisplaced(_fe_problem.assembly(_tid, this->_sys.number())),
     _grad_phi_undisplaced(_assembly_undisplaced.gradPhi()),
     _JxW_undisplaced(_assembly_undisplaced.JxW()),
     _coord_undisplaced(_assembly_undisplaced.coordTransformation()),
     _q_point_undisplaced(_assembly_undisplaced.qPoints())
 {
   // This kernel requires used_displaced_mesh to be true if large kinematics
   // is on
   if (_large_kinematics && (!getParam<bool>("use_displaced_mesh")))
     mooseError("The UpdatedLagrangianStressDivergence kernels requires "
                "used_displaced_mesh = true for large_kinematics = true");
 
   // Similarly, if large kinematics is off so should use_displaced_mesh
   if (!_large_kinematics && (getParam<bool>("use_displaced_mesh")))
     mooseError("The UpdatedLagrangianStressDivergence kernels requires "
                "used_displaced_mesh = false for large_kinematics = false");
 
   // TODO: add weak plane stress support
   if (_out_of_plane_strain)
     mooseError("The UpdatedLagrangianStressDivergence kernels do not yet support the weak plane "
                "stress formulation. Please use the TotalLagrangianStressDivergecen kernels.");
 }

Member Function Documentation

◆ baseParams()

template<class G >

static InputParameters UpdatedLagrangianStressDivergenceBase< G >::baseParams ( )

inlinestatic

Definition at line 35 of file UpdatedLagrangianStressDivergence.h.

Referenced by UpdatedLagrangianStressDivergenceBase< G >::validParams().

   {
     InputParameters params = LagrangianStressDivergenceBase::validParams();
     return params;
   }

◆ computeQpJacobian()

Real LagrangianStressDivergenceBase::computeQpJacobian ( )

overrideprotectedvirtualinherited

Reimplemented in TotalLagrangianWeakPlaneStress.

Definition at line 115 of file LagrangianStressDivergenceBase.C.

 {
   return computeQpJacobianDisplacement(_alpha, _alpha);
 }

◆ computeQpJacobianDisplacement()

template<class G >

Real UpdatedLagrangianStressDivergenceBase< G >::computeQpJacobianDisplacement	(	unsigned int	alpha,
		unsigned int	beta
	)

overrideprotectedvirtual

Implements LagrangianStressDivergenceBase.

Definition at line 112 of file UpdatedLagrangianStressDivergence.C.

 {
   const auto grad_test = gradTest(alpha);
   const auto grad_trial = gradTrial(beta);
 
   //           J^{alpha beta} = J^{alpha beta}_material + J^{alpha beta}_geometric
   //  J^{alpha beta}_material = phi^alpha_{i, j} T_{ijkl} f^{-1}_{km} g^beta_{ml}
   // J^{alpha beta}_geometric = sigma_{ij} (phi^alpha_{k, k} psi^beta_{i, j} -
   //                                        phi^alpha_{k, j} psi^beta_{i, k})
 
   // The material jacobian
   Real J = grad_test.doubleContraction(_material_jacobian[_qp] * (_f_inv[_qp] * grad_trial));
 
   // The geometric jacobian
   if (_large_kinematics)
   {
     // No stablization in the geometric jacobian
     const auto grad_trial_ust = gradTrialUnstabilized(beta);
     J += _stress[_qp].doubleContraction(grad_test) * grad_trial_ust.trace() -
          _stress[_qp].doubleContraction(grad_test * grad_trial_ust);
   }
 
   return J;
 }

◆ computeQpJacobianOutOfPlaneStrain()

template<class G >

virtual Real UpdatedLagrangianStressDivergenceBase< G >::computeQpJacobianOutOfPlaneStrain ( )

inlineoverrideprotectedvirtual

Implements LagrangianStressDivergenceBase.

Definition at line 51 of file UpdatedLagrangianStressDivergence.h.

51 { return 0; }

◆ computeQpJacobianTemperature()

template<class G >

Real UpdatedLagrangianStressDivergenceBase< G >::computeQpJacobianTemperature ( unsigned int cvar )

overrideprotectedvirtual

Implements LagrangianStressDivergenceBase.

Definition at line 140 of file UpdatedLagrangianStressDivergence.C.

 {
   // Multiple eigenstrains may depend on the same coupled var
   RankTwoTensor total_deigen;
   for (const auto deigen_darg : _deigenstrain_dargs[cvar])
     total_deigen += (*deigen_darg)[_qp];
 
   RankFourTensor C = _material_jacobian[_qp];
   RankFourTensor Csym = 0.5 * (C + C.transposeMajor().transposeIj().transposeMajor());
 
   return -(Csym * total_deigen).doubleContraction(gradTest(_alpha)) * _temperature->phi()[_j][_qp];
 }

◆ computeQpOffDiagJacobian()

Real LagrangianStressDivergenceBase::computeQpOffDiagJacobian ( unsigned int jvar )

overrideprotectedvirtualinherited

Reimplemented in TotalLagrangianWeakPlaneStress.

Definition at line 121 of file LagrangianStressDivergenceBase.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;
 }

◆ computeQpResidual()

template<class G >

Real UpdatedLagrangianStressDivergenceBase< G >::computeQpResidual ( )

overrideprotectedvirtual

Definition at line 105 of file UpdatedLagrangianStressDivergence.C.

 {
   return gradTest(_alpha).doubleContraction(_stress[_qp]);
 }

◆ gradTest()

template<class G >

RankTwoTensor UpdatedLagrangianStressDivergenceBase< G >::gradTest ( unsigned int component )

overrideprotectedvirtual

Implements LagrangianStressDivergenceBase.

Definition at line 47 of file UpdatedLagrangianStressDivergence.C.

 {
   // F-bar doesn't modify the test function
   return G::gradOp(component, _grad_test[_i][_qp], _test[_i][_qp], _q_point[_qp]);
 }

◆ gradTrial()

template<class G >

RankTwoTensor UpdatedLagrangianStressDivergenceBase< G >::gradTrial ( unsigned int component )

overrideprotectedvirtual

Implements LagrangianStressDivergenceBase.

Definition at line 55 of file UpdatedLagrangianStressDivergence.C.

 {
   return _stabilize_strain ? gradTrialStabilized(component) : gradTrialUnstabilized(component);
 }

◆ gradTrialStabilized()

template<class G >

RankTwoTensor UpdatedLagrangianStressDivergenceBase< G >::gradTrialStabilized ( unsigned int component )

privatevirtual

The stabilized trial function gradient.

Definition at line 70 of file UpdatedLagrangianStressDivergence.C.

 {
   // The base unstabilized trial function gradient
   const auto Gb = G::gradOp(component, _grad_phi[_j][_qp], _phi[_j][_qp], _q_point[_qp]);
   // The average trial function gradient
   const auto Ga = _avg_grad_trial[component][_j];
   // For updated Lagrangian, the modification is always linear
   return Gb + (Ga.trace() - Gb.trace()) / 3.0 * RankTwoTensor::Identity();
 }

◆ gradTrialUnstabilized()

template<class G >

RankTwoTensor UpdatedLagrangianStressDivergenceBase< G >::gradTrialUnstabilized ( unsigned int component )

privatevirtual

The unstabilized trial function gradient.

Definition at line 62 of file UpdatedLagrangianStressDivergence.C.

 {
   // Without F-bar stabilization, simply return the gradient of the trial functions
   return G::gradOp(component, _grad_phi[_j][_qp], _phi[_j][_qp], _q_point[_qp]);
 }

◆ initialSetup() [1/2]

template<class G >

virtual void UpdatedLagrangianStressDivergenceBase< G >::initialSetup ( )

overridevirtual

◆ initialSetup() [2/2]

template<>

void UpdatedLagrangianStressDivergenceBase< GradientOperatorCartesian >::initialSetup ( )

inline

Definition at line 89 of file UpdatedLagrangianStressDivergence.h.

 {
   if (getBlockCoordSystem() != Moose::COORD_XYZ)
     mooseError("This kernel should only act in Cartesian coordinates.");
 }

◆ precalculateJacobian()

void LagrangianStressDivergenceBase::precalculateJacobian ( )

overrideprotectedvirtualinherited

Reimplemented in TotalLagrangianWeakPlaneStress.

Definition at line 85 of file LagrangianStressDivergenceBase.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()

template<class G >

void UpdatedLagrangianStressDivergenceBase< G >::precalculateJacobianDisplacement ( unsigned int component )

overrideprotectedvirtual

Prepare the average shape function gradients for stabilization.

Implements LagrangianStressDivergenceBase.

Definition at line 82 of file UpdatedLagrangianStressDivergence.C.

 {
   // For updated Lagrangian, the averaging is taken on the reference frame. If large kinematics is
   // used, the averaged gradients should be pushed forward to the current frame.
   for (auto j : make_range(_phi.size()))
   {
     _avg_grad_trial[component][j] = StabilizationUtils::elementAverage(
         [this, component, j](unsigned int qp)
         {
           return G::gradOp(
               component, _grad_phi_undisplaced[j][qp], _phi[j][qp], _q_point_undisplaced[qp]);
         },
         _JxW_undisplaced,
         _coord_undisplaced);
     if (_large_kinematics)
       // Push forward to the current frame.
       // The average deformation gradient is the same at all qps.
       _avg_grad_trial[component][j] *= _F_avg[0].inverse();
   }
 }

◆ precalculateOffDiagJacobian()

void LagrangianStressDivergenceBase::precalculateOffDiagJacobian ( unsigned int jvar )

overrideprotectedvirtualinherited

Definition at line 98 of file LagrangianStressDivergenceBase.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() [1/2]

template<class G >

static InputParameters UpdatedLagrangianStressDivergenceBase< G >::validParams ( )

static

◆ validParams() [2/2]

template<>

InputParameters UpdatedLagrangianStressDivergenceBase< GradientOperatorCartesian >::validParams ( )

inline

Definition at line 79 of file UpdatedLagrangianStressDivergence.h.

 {
   InputParameters params = UpdatedLagrangianStressDivergenceBase::baseParams();
   params.addClassDescription(
       "Enforce equilibrium with an updated Lagrangian formulation in Cartesian coordinates.");
   return params;
 }