Total Lagrangian formulation with all homogenization terms (one disp_xyz field and macro_gradient scalar) More...

#include <HomogenizedTotalLagrangianStressDivergence.h>

Inheritance diagram for HomogenizedTotalLagrangianStressDivergence:

Public Types
typedef std::vector< int >	JvarMap

Public Member Functions
	HomogenizedTotalLagrangianStressDivergence (const InputParameters &parameters)

virtual std::set< std::string >	additionalROVariables () override
	Inform moose that this kernel covers the constraint scalar variable. More...

virtual void	initialSetup () override

template<>
void	initialSetup ()

template<>
void	initialSetup ()

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

static InputParameters	baseParams ()

Protected Member Functions
virtual void	computeScalarResidual () override
	Method for computing the scalar part of residual for _kappa. More...

virtual void	computeScalarJacobian () override
	Method for computing the scalar variable part of Jacobian for d-_kappa-residual / d-_kappa. More...

virtual void	computeScalarOffDiagJacobian (const unsigned int jvar_num) override
	Method for computing an off-diagonal jacobian component d-_kappa-residual / d-jvar. More...

virtual Real	computeScalarQpOffDiagJacobian (const unsigned int jvar_num) override
	Method for computing an off-diagonal jacobian component at quadrature points. More...

virtual void	computeOffDiagJacobianScalarLocal (const unsigned int svar_num) override
	Method for computing an off-diagonal jacobian component d-_var-residual / d-svar. More...

virtual Real	computeQpOffDiagJacobianScalar (const unsigned int svar_num) override
	Method for computing d-_var-residual / d-svar at quadrature points. More...

const Homogenization::ConstraintMap &	cmap () const
	Get the constraint map. More...

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 > &	_pk1
	The 1st Piola-Kirchhoff stress. More...

const MaterialProperty< RankFourTensor > &	_dpk1
	The derivative of the PK1 stress with respect to the deformation gradient. More...

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

Private Attributes
unsigned int	_m
	Indices for off-diagonal Jacobian components. More...

unsigned int	_n

Homogenization::ConstraintType	_ctype = Homogenization::ConstraintType::None
	Type of current homogenization constraint. More...

Detailed Description

Total Lagrangian formulation with all homogenization terms (one disp_xyz field and macro_gradient scalar)

Definition at line 17 of file HomogenizedTotalLagrangianStressDivergence.h.

Constructor & Destructor Documentation

◆ HomogenizedTotalLagrangianStressDivergence()

HomogenizedTotalLagrangianStressDivergence::HomogenizedTotalLagrangianStressDivergence ( const InputParameters & parameters )

Definition at line 30 of file HomogenizedTotalLagrangianStressDivergence.C.

   : HomogenizationInterface<TotalLagrangianStressDivergence>(parameters)
 {
 }

Member Function Documentation

◆ additionalROVariables()

std::set< std::string > HomogenizedTotalLagrangianStressDivergence::additionalROVariables ( )

overridevirtual

Inform moose that this kernel covers the constraint scalar variable.

Definition at line 37 of file HomogenizedTotalLagrangianStressDivergence.C.

 {
   // Add the scalar variable to the list of variables that this kernel contributes to
   std::set<std::string> vars = TotalLagrangianStressDivergence::additionalROVariables();
   vars.insert(_kappa_var_ptr->name());
   return vars;
 }

◆ baseParams()

template<class G >

InputParameters TotalLagrangianStressDivergenceBase< G >::baseParams ( )

staticinherited

Definition at line 14 of file TotalLagrangianStressDivergenceBase.C.

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

 {
   InputParameters params = LagrangianStressDivergenceBase::validParams();
   // This kernel requires use_displaced_mesh to be off
   params.suppressParameter<bool>("use_displaced_mesh");
   return params;
 }

◆ cmap()

const Homogenization::ConstraintMap& HomogenizationInterface< TotalLagrangianStressDivergence >::cmap ( ) const

inlineprotectedinherited

Get the constraint map.

Definition at line 46 of file HomogenizationInterface.h.

Referenced by computeOffDiagJacobianScalarLocal(), computeScalarJacobian(), computeScalarOffDiagJacobian(), and computeScalarResidual().

46 { return _cmap; }

HomogenizationInterface< TotalLagrangianStressDivergence >::_cmap

Homogenization::ConstraintMap _cmap

Constraint map.

Definition: HomogenizationInterface.h:50

◆ computeOffDiagJacobianScalarLocal()

void HomogenizedTotalLagrangianStressDivergence::computeOffDiagJacobianScalarLocal ( const unsigned int svar_num )

overrideprotectedvirtual

Method for computing an off-diagonal jacobian component d-_var-residual / d-svar.

svar is looped over all scalar variables, which herein is just _kappa

Definition at line 187 of file HomogenizedTotalLagrangianStressDivergence.C.

 {
   // Just in case, skip any other scalar variables
   if (svar_num != _kappa_var)
     return;
 
   _local_ke.resize(_test.size(), _k_order);
 
   for (_qp = 0; _qp < _qrule->n_points(); _qp++)
   {
     unsigned int l = 0;
     const auto dV = _JxW[_qp] * _coord[_qp];
     for (const auto & [indices, constraint] : cmap())
     {
       // copy constraint indices to protected variables to pass to Qp routine
       std::tie(_m, _n) = indices;
       _ctype = constraint.first;
       initScalarQpJacobian(svar_num);
       for (_i = 0; _i < _test.size(); _i++)
         _local_ke(_i, l) += dV * computeQpOffDiagJacobianScalar(svar_num);
       l++;
     }
   }
 
   addJacobian(
       _assembly, _local_ke, _var.dofIndices(), _kappa_var_ptr->dofIndices(), _var.scalingFactor());
 }

◆ 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 TotalLagrangianStressDivergenceBase< G >::computeQpJacobianDisplacement	(	unsigned int	alpha,
		unsigned int	beta
	)

overrideprotectedvirtualinherited

Implements LagrangianStressDivergenceBase.

Definition at line 101 of file TotalLagrangianStressDivergenceBase.C.

 {
   // J_{alpha beta} = phi^alpha_{i, J} T_{iJkL} G^beta_{kL}
   return gradTest(alpha).doubleContraction(_dpk1[_qp] * gradTrial(beta));
 }

◆ computeQpJacobianOutOfPlaneStrain()

template<class G >

Real TotalLagrangianStressDivergenceBase< G >::computeQpJacobianOutOfPlaneStrain ( )

overrideprotectedvirtualinherited

Implements LagrangianStressDivergenceBase.

Definition at line 128 of file TotalLagrangianStressDivergenceBase.C.

 {
   return _dpk1[_qp].contractionKl(2, 2, gradTest(_alpha)) * _out_of_plane_strain->phi()[_j][_qp];
 }

◆ computeQpJacobianTemperature()

template<class G >

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

overrideprotectedvirtualinherited

Implements LagrangianStressDivergenceBase.

Definition at line 110 of file TotalLagrangianStressDivergenceBase.C.

 {
   usingTensorIndices(i_, j_, k_, l_);
   // 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];
 
   const auto A = _f_inv[_qp].inverse();
   const auto B = _F_inv[_qp].inverse();
   const auto U = 0.5 * (A.template times<i_, k_, l_, j_>(B) + A.template times<i_, l_, k_, j_>(B));
 
   return -(_dpk1[_qp] * U * 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;
 }

◆ computeQpOffDiagJacobianScalar()

Real HomogenizedTotalLagrangianStressDivergence::computeQpOffDiagJacobianScalar ( const unsigned int svar_num )

overrideprotectedvirtual

Method for computing d-_var-residual / d-svar at quadrature points.

Definition at line 217 of file HomogenizedTotalLagrangianStressDivergence.C.

Referenced by computeOffDiagJacobianScalarLocal().

 {
   return _dpk1[_qp].contractionKl(_m, _n, gradTest(_alpha));
 }

◆ computeQpResidual()

template<class G >

Real TotalLagrangianStressDivergenceBase< G >::computeQpResidual ( )

overrideprotectedvirtualinherited

Reimplemented in TotalLagrangianWeakPlaneStress.

Definition at line 94 of file TotalLagrangianStressDivergenceBase.C.

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

◆ computeScalarJacobian()

void HomogenizedTotalLagrangianStressDivergence::computeScalarJacobian ( )

overrideprotectedvirtual

Method for computing the scalar variable part of Jacobian for d-_kappa-residual / d-_kappa.

Definition at line 98 of file HomogenizedTotalLagrangianStressDivergence.C.

 {
   if (_alpha != 0)
     return;
 
   _local_ke.resize(_k_order, _k_order);
 
   // only assemble scalar residual once; i.e. when handling the first displacement component
   for (_qp = 0; _qp < _qrule->n_points(); _qp++)
   {
     initScalarQpJacobian(_kappa_var);
     const auto dV = _JxW[_qp] * _coord[_qp];
 
     // index for Jacobian row
     unsigned int h = 0;
 
     for (const auto & [indices1, constraint1] : cmap())
     {
       const auto [i, j] = indices1;
       const auto ctype = constraint1.first;
 
       // index for Jacobian col
       unsigned int m = 0;
 
       for (const auto & [indices2, constraint2] : cmap())
       {
         const auto [k, l] = indices2;
         if (ctype == Homogenization::ConstraintType::Stress)
           _local_ke(h, m++) += dV * (_dpk1[_qp](i, j, k, l));
         else if (ctype == Homogenization::ConstraintType::Strain)
         {
           if (_large_kinematics)
             _local_ke(h, m++) += dV * (Real(i == k && j == l));
           else
             _local_ke(h, m++) += dV * (0.5 * Real(i == k && j == l) + 0.5 * Real(i == l && j == k));
         }
         else
           mooseError("Unknown constraint type in Jacobian calculator!");
       }
       h++;
     }
   }
 
   addJacobian(_assembly,
               _local_ke,
               _kappa_var_ptr->dofIndices(),
               _kappa_var_ptr->dofIndices(),
               _kappa_var_ptr->scalingFactor());
 }

◆ computeScalarOffDiagJacobian()

void HomogenizedTotalLagrangianStressDivergence::computeScalarOffDiagJacobian ( const unsigned int jvar_num )

overrideprotectedvirtual

Method for computing an off-diagonal jacobian component d-_kappa-residual / d-jvar.

jvar is looped over all field variables, which herein is just disp_x and disp_y

Definition at line 149 of file HomogenizedTotalLagrangianStressDivergence.C.

 {
   // ONLY assemble the contribution from _alpha component, which is connected with _var
   // The other components are handled by other kernel instances with other _alpha
   if (jvar_num != _var.number())
     return;
 
   const auto & jvar = getVariable(jvar_num);
   const auto jvar_size = jvar.phiSize();
   _local_ke.resize(_k_order, jvar_size);
 
   for (_qp = 0; _qp < _qrule->n_points(); _qp++)
   {
     const auto dV = _JxW[_qp] * _coord[_qp];
 
     // index for Jacobian row
     unsigned int h = 0;
 
     for (const auto & [indices, constraint] : cmap())
     {
       std::tie(_m, _n) = indices;
       _ctype = constraint.first;
       initScalarQpOffDiagJacobian(jvar);
       for (_j = 0; _j < jvar_size; _j++)
         _local_ke(h, _j) += dV * computeScalarQpOffDiagJacobian(jvar_num);
       h++;
     }
   }
 
   addJacobian(_assembly,
               _local_ke,
               _kappa_var_ptr->dofIndices(),
               jvar.dofIndices(),
               _kappa_var_ptr->scalingFactor());
 }

◆ computeScalarQpOffDiagJacobian()

Real HomogenizedTotalLagrangianStressDivergence::computeScalarQpOffDiagJacobian ( const unsigned int jvar_num )

overrideprotectedvirtual

Method for computing an off-diagonal jacobian component at quadrature points.

Definition at line 224 of file HomogenizedTotalLagrangianStressDivergence.C.

Referenced by computeScalarOffDiagJacobian().

 {
   if (_ctype == Homogenization::ConstraintType::Stress)
     return _dpk1[_qp].contractionIj(_m, _n, gradTrial(_alpha));
   else if (_ctype == Homogenization::ConstraintType::Strain)
     if (_large_kinematics)
       return Real(_m == _alpha) * gradTrial(_alpha)(_m, _n);
     else
       return 0.5 * (Real(_m == _alpha) * gradTrial(_alpha)(_m, _n) +
                     Real(_n == _alpha) * gradTrial(_alpha)(_n, _m));
   else
     mooseError("Unknown constraint type in kernel calculation!");
 }

◆ computeScalarResidual()

void HomogenizedTotalLagrangianStressDivergence::computeScalarResidual ( )

overrideprotectedvirtual

Method for computing the scalar part of residual for _kappa.

Definition at line 46 of file HomogenizedTotalLagrangianStressDivergence.C.

 {
   if (_alpha != 0)
     return;
 
   std::vector<Real> scalar_residuals(_k_order);
 
   // only assemble scalar residual once; i.e. when handling the first displacement component
   for (_qp = 0; _qp < _qrule->n_points(); _qp++)
   {
     initScalarQpResidual();
     const auto dV = _JxW[_qp] * _coord[_qp];
 
     // index for residual vector
     unsigned int h = 0;
 
     for (const auto & [indices, constraint] : cmap())
     {
       const auto [i, j] = indices;
       const auto [ctype, ctarget] = constraint;
       const auto cval = ctarget->value(_t, _q_point[_qp]);
 
       // value to be constrained
       Real val;
       if (_large_kinematics)
       {
         if (ctype == Homogenization::ConstraintType::Stress)
           val = _pk1[_qp](i, j);
         else if (ctype == Homogenization::ConstraintType::Strain)
           val = _F[_qp](i, j) - (Real(i == j));
         else
           mooseError("Unknown constraint type in the integral!");
       }
       else
       {
         if (ctype == Homogenization::ConstraintType::Stress)
           val = _pk1[_qp](i, j);
         else if (ctype == Homogenization::ConstraintType::Strain)
           val = 0.5 * (_F[_qp](i, j) + _F[_qp](j, i)) - (Real(i == j));
         else
           mooseError("Unknown constraint type in the integral!");
       }
 
       scalar_residuals[h++] += (val - cval) * dV;
     }
   }
 
   addResiduals(
       _assembly, scalar_residuals, _kappa_var_ptr->dofIndices(), _kappa_var_ptr->scalingFactor());
 }

◆ gradTest()

template<class G >

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

overrideprotectedvirtualinherited

Implements LagrangianStressDivergenceBase.

Definition at line 33 of file TotalLagrangianStressDivergenceBase.C.

Referenced by computeQpOffDiagJacobianScalar().

 {
   // 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 TotalLagrangianStressDivergenceBase< G >::gradTrial ( unsigned int component )

overrideprotectedvirtualinherited

Implements LagrangianStressDivergenceBase.

Definition at line 41 of file TotalLagrangianStressDivergenceBase.C.

Referenced by TotalLagrangianWeakPlaneStress::computeQpOffDiagJacobian(), and computeScalarQpOffDiagJacobian().

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

◆ initialSetup() [1/4]

template<>

void TotalLagrangianStressDivergenceBase< GradientOperatorCartesian >::initialSetup ( )

inlineinherited

Definition at line 26 of file TotalLagrangianStressDivergence.h.

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

◆ initialSetup() [2/4]

template<>

void TotalLagrangianStressDivergenceBase< GradientOperatorAxisymmetricCylindrical >::initialSetup ( )

inherited

Definition at line 26 of file TotalLagrangianStressDivergenceAxisymmetricCylindrical.h.

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

◆ initialSetup() [3/4]

template<>

void TotalLagrangianStressDivergenceBase< GradientOperatorCentrosymmetricSpherical >::initialSetup ( )

inherited

Definition at line 26 of file TotalLagrangianStressDivergenceCentrosymmetricSpherical.h.

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

◆ initialSetup() [4/4]

template<class G >

virtual void TotalLagrangianStressDivergenceBase< G >::initialSetup ( )

overridevirtualinherited

◆ 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 TotalLagrangianStressDivergenceBase< G >::precalculateJacobianDisplacement ( unsigned int component )

overrideprotectedvirtualinherited

Prepare the average shape function gradients for stabilization.

Implements LagrangianStressDivergenceBase.

Definition at line 80 of file TotalLagrangianStressDivergenceBase.C.

 {
   // For total Lagrangian, the averaging is taken on the reference frame regardless of geometric
   // nonlinearity. Convenient!
   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[j][qp], _phi[j][qp], _q_point[qp]); },
         _JxW,
         _coord);
 }

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

InputParameters HomogenizedTotalLagrangianStressDivergence::validParams ( )

static

Definition at line 19 of file HomogenizedTotalLagrangianStressDivergence.C.

 {
   InputParameters params = HomogenizationInterface<TotalLagrangianStressDivergence>::validParams();
   params.addClassDescription("Total Lagrangian stress equilibrium kernel with "
                              "homogenization constraint Jacobian terms");
   params.renameCoupledVar(
       "scalar_variable", "macro_var", "Optional scalar field with the macro gradient");
 
   return params;
 }