Total Lagrangian formulation with most homogenization terms (one disp_xyz field and one scalar) The macro_gradient variable is split into two scalars: the first component called '_hvar' herein and all other components called '_avar' herein. More...

#include <HomogenizedTotalLagrangianStressDivergenceA.h>

Inheritance diagram for HomogenizedTotalLagrangianStressDivergenceA:

[legend]

Public Types
typedef std::vector< int >	JvarMap

Public Member Functions
	HomogenizedTotalLagrangianStressDivergenceA (const InputParameters &parameters)

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 Real	computeQpResidual () override

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

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 jvar is looped over all field variables, which herein is just disp_x and disp_y. 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...

virtual void	computeScalarOffDiagJacobianScalar (const unsigned int svar_num) override
	Method for computing an off-diagonal jacobian component d-_kappa-residual / d-svar svar is looped over other scalar variables, which herein is just _kappa_other. 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	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 unsigned int	_beta
	Which component of the scalar vector residual this constraint is responsible for. More...

const MooseVariableScalar *const	_kappao_var_ptr
	(Pointer to) Scalar variable this kernel operates on More...

const unsigned int	_kappao_var
	The unknown scalar variable ID. More...

const unsigned int	_ko_order
	Order of the scalar variable, used in several places. More...

const VariableValue &	_kappa_other
	Reference to the current solution at the current quadrature point. More...

HomogenizationA::ConstraintMap	_cmap
	Type of each constraint (stress or strain) for each component. More...

HomogenizationA::ConstraintType	_ctype = HomogenizationA::ConstraintType::None
	The constraint type; initialize with 'none'. More...

unsigned int	_m
	Used internally to iterate over each scalar component. More...

unsigned int	_n

unsigned int	_a

unsigned int	_b

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

Detailed Description

Total Lagrangian formulation with most homogenization terms (one disp_xyz field and one scalar) The macro_gradient variable is split into two scalars: the first component called '_hvar' herein and all other components called '_avar' herein.

For parameter _beta = 0, the primary scalar (_kappa) is _hvar and the coupled scalar is _avar. For parameter _beta = 1, the primary scalar (_kappa) is _avar and the coupled scalar is _hvar. Just like the primary field variable (_var) is either disp_x or disp_y or disp_z depending on _alpha.

Thus, each instance of HomogenizedTotalLagrangianStressDivergenceA acts on one field variable (_disp_alpha) and one scalar variable (_hvar_beta). The job of the kernel is to assemble the residual of all dofs of _disp_alpha and of all dofs of _hvar_beta (namely, selected entries). It assembles a symmetric portion of the Jacobian for _disp_alpha and _hvar_beta, with some logical checks to access only the particular desired terms (often for _alpha or _beta = 0). The entries for the other field/scalar variables are handled by other instances of the kernel, which have other values of _alpha AND _beta. The logical checks ensure the proper decomposition of the jobs.

In summary, for x=disp_x etc. and h=_hvar and a=_avar, then the contributions of the instances are _alpha=0, _beta=0 R = [Rx, 00, 00, Rh, 00 ]^T J = [Jxx, Jxy, Jxz, Jxh, 000 Jhx, 000, 000, Jhh, Jha] _alpha=1, _beta=0 R = [00, Ry, 00, 00, 00 ]^T J = [Jyx, Jyy, Jyz, Jyh, 000 000, Jhy, 000, 000, 000] _alpha=2, _beta=0 R = [00, 00, Rz, 00, 00 ]^T J = [Jzx, Jzy, Jzz, Jzh, 000 000, 000, Jhz, 000, 000] _alpha=0, _beta=1 R = [00, 00, 00, 00, Ra ]^T J = [000, 000, 000, 000, Jxa Jax, 000, 000, Jah, Jaa] _alpha=1, _beta=1 R = [00, 00, 00, 00, 00 ]^T J = [000, 000, 000, 000, Jya 000, Jay, 000, 000, 000] _alpha=2, _beta=1 R = [00, 00, 00, 00, 00 ]^T J = [000, 000, 000, 000, Jza 000, 000, Jaz, 000, 000]

In this manner, the full R and J are obtained with NO duplication of jobs: R = [Rx, Ry, Rz, Rh, Ra ]^T J = [Jxx, Jxy, Jxz, Jxh, Jxa Jyx, Jyy, Jyz, Jyh, Jya Jzx, Jzy, Jzz, Jzh, Jza Jhx, Jhy, Jhz, Jhh, Jha Jax, Jay, Jaz, Jah, Jaa]

Definition at line 80 of file HomogenizedTotalLagrangianStressDivergenceA.h.

Constructor & Destructor Documentation

◆ HomogenizedTotalLagrangianStressDivergenceA()

HomogenizedTotalLagrangianStressDivergenceA::HomogenizedTotalLagrangianStressDivergenceA ( const InputParameters & parameters )

Definition at line 45 of file HomogenizedTotalLagrangianStressDivergenceA.C.

   : TotalLagrangianStressDivergenceS(parameters),
     _beta(getParam<unsigned int>("prime_scalar")),
     _kappao_var_ptr(getScalarVar("macro_other", 0)),
     _kappao_var(coupledScalar("macro_other")),
     _ko_order(getScalarVar("macro_other", 0)->order()),
     _kappa_other(coupledScalarValue("macro_other"))
 {
   // Constraint types
   auto types = getParam<MultiMooseEnum>("constraint_types");
   if (types.size() != Moose::dim * Moose::dim)
     mooseError("Number of constraint types must equal dim * dim. ", types.size(), " are provided.");
 
   // Targets to hit
   const std::vector<FunctionName> & fnames = getParam<std::vector<FunctionName>>("targets");
 
   // Prepare the constraint map
   unsigned int fcount = 0;
   for (const auto j : make_range(Moose::dim))
     for (const auto i : make_range(Moose::dim))
     {
       const auto idx = i + Moose::dim * j;
       const auto ctype = static_cast<HomogenizationA::ConstraintType>(types.get(idx));
       if (ctype != HomogenizationA::ConstraintType::None)
       {
         const Function * const f = &getFunctionByName(fnames[fcount++]);
         _cmap[{i, j}] = {ctype, f};
       }
     }
 }

Member Function Documentation

◆ baseParams()

template<class G >

InputParameters TotalLagrangianStressDivergenceBaseS< G >::baseParams ( )

staticinherited

Definition at line 14 of file TotalLagrangianStressDivergenceBaseS.C.

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

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

◆ computeOffDiagJacobianScalarLocal()

void HomogenizedTotalLagrangianStressDivergenceA::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 and _kappa_other

Definition at line 295 of file HomogenizedTotalLagrangianStressDivergenceA.C.

 {
   // Assembly J_beta_alpha ONLY
   if (svar_num == _kappa_var)
   {
     _local_ke.resize(_test.size(), _k_order);
 
     for (_qp = 0; _qp < _qrule->n_points(); _qp++)
     {
       // single index for Jacobian row; double indices for constraint tensor component
       unsigned int l = 0;
       Real dV = _JxW[_qp] * _coord[_qp];
       for (auto && [indices, constraint] : _cmap)
       {
         // identical logic to computeScalarResidual, but for column index
         if (_beta == 0)
         {
           if (l == 1)
             break;
         }
         else
         {
           if (l == 0)
           {
             l++;
             continue;
           }
         }
         // copy constraint indices to protected variables to pass to Qp routine
         _m = indices.first;
         _n = indices.second;
         _ctype = constraint.first;
         initScalarQpJacobian(svar_num);
         for (_i = 0; _i < _test.size(); _i++)
         {
           _local_ke(_i, -_beta + l) += dV * computeQpOffDiagJacobianScalar(svar_num);
         }
         l++;
       }
     }
 
     addJacobian(_assembly,
                 _local_ke,
                 _var.dofIndices(),
                 _kappa_var_ptr->dofIndices(),
                 _var.scalingFactor());
   }
 }

◆ computeQpJacobian()

Real LagrangianStressDivergenceBaseS::computeQpJacobian ( )

overrideprotectedvirtualinherited

Definition at line 115 of file LagrangianStressDivergenceBaseS.C.

 {
   return computeQpJacobianDisplacement(_alpha, _alpha);
 }

◆ computeQpJacobianDisplacement()

Real HomogenizedTotalLagrangianStressDivergenceA::computeQpJacobianDisplacement	(	unsigned int	alpha,
		unsigned int	beta
	)

overrideprotectedvirtual

Reimplemented from TotalLagrangianStressDivergenceBaseS< G >.

Definition at line 88 of file HomogenizedTotalLagrangianStressDivergenceA.C.

 {
   // Assemble J-alpha-beta if _beta==0
   if (_beta == 0)
     return gradTest(alpha).doubleContraction(_dpk1[_qp] * gradTrial(beta));
   else
     return 0.0;
 }

◆ computeQpJacobianOutOfPlaneStrain()

template<class G >

Real TotalLagrangianStressDivergenceBaseS< G >::computeQpJacobianOutOfPlaneStrain ( )

overrideprotectedvirtualinherited

Implements LagrangianStressDivergenceBaseS.

Definition at line 128 of file TotalLagrangianStressDivergenceBaseS.C.

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

◆ computeQpJacobianTemperature()

template<class G >

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

overrideprotectedvirtualinherited

Implements LagrangianStressDivergenceBaseS.

Definition at line 110 of file TotalLagrangianStressDivergenceBaseS.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 LagrangianStressDivergenceBaseS::computeQpOffDiagJacobian ( unsigned int jvar )

overrideprotectedvirtualinherited

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;
 }

◆ computeQpOffDiagJacobianScalar()

Real HomogenizedTotalLagrangianStressDivergenceA::computeQpOffDiagJacobianScalar ( const unsigned int svar_num )

overrideprotectedvirtual

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

Definition at line 346 of file HomogenizedTotalLagrangianStressDivergenceA.C.

Referenced by computeOffDiagJacobianScalarLocal().

 {
   if (svar_num == _kappa_var)
     return _dpk1[_qp].contractionKl(_m, _n, gradTest(_alpha));
   else
     return 0.;
 }

◆ computeQpResidual()

Real HomogenizedTotalLagrangianStressDivergenceA::computeQpResidual ( )

overrideprotectedvirtual

Reimplemented from TotalLagrangianStressDivergenceBaseS< G >.

Definition at line 78 of file HomogenizedTotalLagrangianStressDivergenceA.C.

 {
   // Assemble R_alpha if _beta==0
   if (_beta == 0)
     return gradTest(_alpha).doubleContraction(_pk1[_qp]);
   else
     return 0.0;
 }

◆ computeScalarJacobian()

void HomogenizedTotalLagrangianStressDivergenceA::computeScalarJacobian ( )

overrideprotectedvirtual

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

Definition at line 165 of file HomogenizedTotalLagrangianStressDivergenceA.C.

 {
   _local_ke.resize(_k_order, _k_order);
 
   // Assemble J_beta_beta if _alpha==0
   if (_alpha == 0)
   {
     for (_qp = 0; _qp < _qrule->n_points(); _qp++)
     {
       initScalarQpJacobian(_kappa_var);
       Real dV = _JxW[_qp] * _coord[_qp];
 
       _h = 0;
       for (auto && [indices1, constraint1] : _cmap)
       {
         auto && [i, j] = indices1;
         auto && ctype = constraint1.first;
 
         // identical logic to computeScalarResidual
         if (_beta == 0)
         {
           if (_h == 1)
             break;
         }
         else
         {
           if (_h == 0)
           {
             _h++;
             continue;
           }
         }
 
         _l = 0;
         for (auto && indices2 : _cmap)
         {
           auto && [a, b] = indices2.first;
 
           // identical logic to computeScalarResidual, but for column index
           if (_beta == 0)
           {
             if (_l == 1)
               break;
           }
           else
           {
             if (_l == 0)
             {
               _l++;
               continue;
             }
           }
 
           unsigned int c_ind = -_beta + _l; // move 1 column left if _beta=1 for the other scalar
           _l++;                             // increment the index before we forget
           if (ctype == HomogenizationA::ConstraintType::Stress)
             _local_ke(-_beta + _h, c_ind) += dV * (_dpk1[_qp](i, j, a, b));
           else if (ctype == HomogenizationA::ConstraintType::Strain)
           {
             if (_large_kinematics)
               _local_ke(-_beta + _h, c_ind) += dV * (Real(i == a && j == b));
             else
               _local_ke(-_beta + _h, c_ind) +=
                   dV * (0.5 * Real(i == a && j == b) + 0.5 * Real(i == b && j == a));
           }
           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 HomogenizedTotalLagrangianStressDivergenceA::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 246 of file HomogenizedTotalLagrangianStressDivergenceA.C.

 {
   // Assembly J_alpha_beta ONLY
   if (jvar_num == _var.number())
   {
     _local_ke.resize(_k_order, _test.size());
 
     for (_qp = 0; _qp < _qrule->n_points(); _qp++)
     {
       // single index for Jacobian column; double indices for constraint tensor component
       unsigned int h = 0;
       Real dV = _JxW[_qp] * _coord[_qp];
       for (auto && [indices, constraint] : _cmap)
       {
         // identical logic to computeScalarResidual
         if (_beta == 0)
         {
           if (h == 1)
             break;
         }
         else
         {
           if (h == 0)
           {
             h++;
             continue;
           }
         }
         // copy constraint indices to protected variables to pass to Qp routine
         _m = indices.first;
         _n = indices.second;
         _ctype = constraint.first;
         initScalarQpOffDiagJacobian(_var);
         for (_j = 0; _j < _test.size(); _j++)
           _local_ke(-_beta + h, _j) += dV * computeScalarQpOffDiagJacobian(jvar_num);
         h++;
       }
     }
 
     addJacobian(_assembly,
                 _local_ke,
                 _kappa_var_ptr->dofIndices(),
                 _var.dofIndices(),
                 _kappa_var_ptr->scalingFactor());
   }
 }

◆ computeScalarOffDiagJacobianScalar()

void HomogenizedTotalLagrangianStressDivergenceA::computeScalarOffDiagJacobianScalar ( const unsigned int svar_num )

overrideprotectedvirtual

Method for computing an off-diagonal jacobian component d-_kappa-residual / d-svar svar is looped over other scalar variables, which herein is just _kappa_other.

Definition at line 375 of file HomogenizedTotalLagrangianStressDivergenceA.C.

 {
   // Only do this for the other macro variable
   if (svar_num == _kappao_var)
   {
     _local_ke.resize(_k_order, _ko_order);
 
     // Assemble J-kappa-kappa_other if _alpha==0
     if (_alpha == 0)
     {
       for (_qp = 0; _qp < _qrule->n_points(); _qp++)
       {
         initScalarQpJacobian(_kappa_var);
         Real dV = _JxW[_qp] * _coord[_qp];
 
         _h = 0;
         for (auto && [indices1, constraint1] : _cmap)
         {
           auto && [i, j] = indices1;
           auto && ctype = constraint1.first;
 
           // identical logic to computeScalarResidual
           if (_beta == 0)
           {
             if (_h == 1)
               break;
           }
           else
           {
             if (_h == 0)
             {
               _h++;
               continue;
             }
           }
 
           _l = 0;
           for (auto && indices2 : _cmap)
           {
             auto && [a, b] = indices2.first;
 
             // OPPOSITE logic/scalar from computeScalarResidual, AND for column index
             if (_beta == 1)
             {
               if (_l == 1) // only assemble first=0 component of _hvar, then break the loop
                 break;
             }
             else
             {
               if (_l == 0) // skip first component (_hvar) & continue to "first" component of _avar
               {
                 _l++;
                 continue;
               }
             }
 
             unsigned int c_ind =
                 -(1 - _beta) + _l; // DON'T move 1 column left if _beta=1 for the other scalar
             _l++;
             if (ctype == HomogenizationA::ConstraintType::Stress)
               _local_ke(-_beta + _h, c_ind) += dV * (_dpk1[_qp](i, j, a, b));
             else if (ctype == HomogenizationA::ConstraintType::Strain)
             {
               if (_large_kinematics)
                 _local_ke(-_beta + _h, c_ind) += dV * (Real(i == a && j == b));
               else
                 _local_ke(-_beta + _h, c_ind) +=
                     dV * (0.5 * Real(i == a && j == b) + 0.5 * Real(i == b && j == a));
             }
             else
               mooseError("Unknown constraint type in Jacobian calculator!");
           }
           _h++;
         }
       }
     }
 
     addJacobian(_assembly,
                 _local_ke,
                 _kappa_var_ptr->dofIndices(),
                 _kappao_var_ptr->dofIndices(),
                 _kappa_var_ptr->scalingFactor());
   }
 }

◆ computeScalarQpOffDiagJacobian()

Real HomogenizedTotalLagrangianStressDivergenceA::computeScalarQpOffDiagJacobian ( const unsigned int jvar_num )

overrideprotectedvirtual

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

Definition at line 355 of file HomogenizedTotalLagrangianStressDivergenceA.C.

Referenced by computeScalarOffDiagJacobian().

 {
   if (jvar_num == _var.number())
   {
     if (_ctype == HomogenizationA::ConstraintType::Stress)
       return _dpk1[_qp].contractionIj(_m, _n, gradTrial(_alpha));
     else if (_ctype == HomogenizationA::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!");
   }
   else
     return 0.;
 }

◆ computeScalarResidual()

void HomogenizedTotalLagrangianStressDivergenceA::computeScalarResidual ( )

overrideprotectedvirtual

Method for computing the scalar part of residual for _kappa.

Definition at line 99 of file HomogenizedTotalLagrangianStressDivergenceA.C.

 {
   std::vector<Real> scalar_residuals(_k_order);
 
   // Assemble R_beta if _alpha==0
   if (_alpha == 0)
   {
     for (_qp = 0; _qp < _qrule->n_points(); _qp++)
     {
       initScalarQpResidual();
       Real dV = _JxW[_qp] * _coord[_qp];
       _h = 0; // single index for residual vector; double indices for constraint tensor component
       for (auto && [indices, constraint] : _cmap)
       {
         auto && [i, j] = indices;
         auto && [ctype, ctarget] = constraint;
 
         // ONLY the component(s) that this constraint will contribute here;
         // other one is handled in the other constraint
         if (_beta == 0)
         {
           if (_h == 1) // only assemble first=0 component of _hvar, then break the loop
             break;
         }
         else
         {
           // skip the first component (_hvar) and continue to "first" component of _avar
           if (_h == 0)
           {
             _h++;
             continue;
           }
         }
 
         // I am not great with C++ precedence; so, store the index
         unsigned int r_ind = -_beta + _h; // move 1 row up if _beta=1 for the other scalar
         _h++;                             // increment the index before we forget
         if (_large_kinematics)
         {
           if (ctype == HomogenizationA::ConstraintType::Stress)
             scalar_residuals[r_ind] += dV * (_pk1[_qp](i, j) - ctarget->value(_t, _q_point[_qp]));
           else if (ctype == HomogenizationA::ConstraintType::Strain)
             scalar_residuals[r_ind] +=
                 dV * (_F[_qp](i, j) - (Real(i == j) + ctarget->value(_t, _q_point[_qp])));
           else
             mooseError("Unknown constraint type in the integral!");
         }
         else
         {
           if (ctype == HomogenizationA::ConstraintType::Stress)
             scalar_residuals[r_ind] += dV * (_pk1[_qp](i, j) - ctarget->value(_t, _q_point[_qp]));
           else if (ctype == HomogenizationA::ConstraintType::Strain)
             scalar_residuals[r_ind] += dV * (0.5 * (_F[_qp](i, j) + _F[_qp](j, i)) -
                                              (Real(i == j) + ctarget->value(_t, _q_point[_qp])));
           else
             mooseError("Unknown constraint type in the integral!");
         }
       }
     }
   }
 
   addResiduals(
       _assembly, scalar_residuals, _kappa_var_ptr->dofIndices(), _kappa_var_ptr->scalingFactor());
 }

◆ gradTest()

template<class G >

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

overrideprotectedvirtualinherited

Implements LagrangianStressDivergenceBaseS.

Definition at line 33 of file TotalLagrangianStressDivergenceBaseS.C.

Referenced by HomogenizedTotalLagrangianStressDivergenceR::computeQpJacobianDisplacement(), computeQpJacobianDisplacement(), HomogenizedTotalLagrangianStressDivergenceS::computeQpOffDiagJacobianScalar(), HomogenizedTotalLagrangianStressDivergenceR::computeQpOffDiagJacobianScalar(), computeQpOffDiagJacobianScalar(), HomogenizedTotalLagrangianStressDivergenceR::computeQpResidual(), and computeQpResidual().

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

overrideprotectedvirtualinherited

Implements LagrangianStressDivergenceBaseS.

Definition at line 41 of file TotalLagrangianStressDivergenceBaseS.C.

Referenced by HomogenizedTotalLagrangianStressDivergenceR::computeQpJacobianDisplacement(), computeQpJacobianDisplacement(), HomogenizedTotalLagrangianStressDivergenceS::computeScalarQpOffDiagJacobian(), HomogenizedTotalLagrangianStressDivergenceR::computeScalarQpOffDiagJacobian(), and computeScalarQpOffDiagJacobian().

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

◆ initialSetup() [1/4]

template<>

void TotalLagrangianStressDivergenceBaseS< GradientOperatorCartesian >::initialSetup ( )

inlineinherited

Definition at line 26 of file TotalLagrangianStressDivergenceS.h.

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

◆ initialSetup() [2/4]

template<>

void TotalLagrangianStressDivergenceBaseS< GradientOperatorCentrosymmetricSpherical >::initialSetup ( )

inherited

Definition at line 26 of file TotalLagrangianStressDivergenceCentrosymmetricSphericalS.h.

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

◆ initialSetup() [3/4]

template<>

void TotalLagrangianStressDivergenceBaseS< GradientOperatorAxisymmetricCylindrical >::initialSetup ( )

inherited

Definition at line 26 of file TotalLagrangianStressDivergenceAxisymmetricCylindricalS.h.

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

◆ initialSetup() [4/4]

template<class G >

virtual void TotalLagrangianStressDivergenceBaseS< G >::initialSetup ( )

overridevirtualinherited

◆ precalculateJacobian()

void LagrangianStressDivergenceBaseS::precalculateJacobian ( )

overrideprotectedvirtualinherited

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

template<class G >

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

overrideprotectedvirtualinherited

Prepare the average shape function gradients for stabilization.

Implements LagrangianStressDivergenceBaseS.

Definition at line 80 of file TotalLagrangianStressDivergenceBaseS.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 LagrangianStressDivergenceBaseS::precalculateOffDiagJacobian ( unsigned int jvar )

overrideprotectedvirtualinherited

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

static

Definition at line 25 of file HomogenizedTotalLagrangianStressDivergenceA.C.

 {
   InputParameters params = TotalLagrangianStressDivergenceS::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");
   params.addRequiredCoupledVar("macro_other", "Other components of coupled scalar variable");
   params.addRequiredParam<unsigned int>("prime_scalar", "Either 0=_var or 1=_other scalar");
   params.addRequiredParam<MultiMooseEnum>(
       "constraint_types",
       HomogenizationA::constraintType,
       "Type of each constraint: strain, stress, or none. The types are specified in the "
       "column-major order, and there must be 9 entries in total.");
   params.addRequiredParam<std::vector<FunctionName>>(
       "targets", "Functions giving the targets to hit for constraint types that are not none.");
 
   return params;
 }