ADComputeIncrementalShellStrain< compute_stage > Class Template Reference

#include <ADComputeIncrementalShellStrain.h>

Inheritance diagram for ADComputeIncrementalShellStrain< compute_stage >:

Public Member Functions
	ADComputeIncrementalShellStrain (const InputParameters &parameters)

Protected Member Functions
virtual void	initQpStatefulProperties () override
virtual void	computeProperties () override
virtual void	computeSolnVector ()
	Computes the 20x1 soln vector and its derivatives for each shell element. More...
virtual void	computeBMatrix ()
	Computes the B matrix that connects strains to nodal displacements and rotations. More...
virtual void	computeNodeNormal ()
	Computes the node normal at each node. More...
virtual void	updateGVectors ()
	Updates the vectors required for shear locking computation for finite rotations. More...
virtual void	updatedxyz ()
	Updates covariant vectors at each qp for finite rotations. More...
virtual void	computeGMatrix ()
	Computes the transformation matrix from natural coordinates to local cartesian coordinates for elasticity tensor transformation. More...
	ADMaterialProperty (RealVectorValue) &_node_normal
	Material property storing the normal to the element at the 4 nodes. Stored as a material property for convinience. More...
template<>
void	computeSolnVector ()
template<>
void	computeSolnVector ()

Protected Attributes
unsigned int	_nrot
	Number of coupled rotational variables. More...
unsigned int	_ndisp
	Number of coupled displacement variables. More...
std::vector< unsigned int >	_rot_num
	Variable numbers corresponding to the rotational variables. More...
std::vector< unsigned int >	_disp_num
	Variable numbers corresponding to the displacement variables. More...
const VariableValue &	_thickness
	Coupled variable for the shell thickness. More...
const bool	_large_strain
	Flag to compute large strains. More...
std::vector< ADMaterialProperty(RankTwoTensor) * >	_strain_increment
	Strain increment in the covariant coordinate system. More...
std::vector< ADMaterialProperty(RankTwoTensor) * >	_total_strain
	Total strain increment in the covariant coordinate system. More...
std::vector< const MaterialProperty< RankTwoTensor > * >	_total_strain_old
	Old total strain increment in the covariant coordinate system. More...
NonlinearSystemBase &	_nonlinear_sys
	Reference to the nonlinear system object. More...
std::vector< std::vector< unsigned int > >	_soln_disp_index
	Indices of solution vector corresponding to displacement DOFs in 3 directions at the 4 nodes. More...
std::vector< std::vector< unsigned int > >	_soln_rot_index
	Indices of solution vector corresponding to rotation DOFs in 2 directions at the 4 nodes. More...
ADDenseVector	_soln_vector
	Vector that stores the incremental solution at all the 20 DOFs in the 4 noded element. More...
ADDenseVector	_strain_vector
	Vector that stores the strain in the the 2 axial and 3 shear directions. More...
std::vector< const Node * >	_nodes
	Vector storing pointers to the nodes of the shell element. More...
const MaterialProperty< RealVectorValue > &	_node_normal_old
	Material property storing the old normal to the element at the 4 nodes. More...
std::unique_ptr< QGauss >	_t_qrule
	Quadrature rule in the out of plane direction. More...
std::vector< Point >	_t_points
	Quadrature points in the out of plane direction in isoparametric coordinate system. More...
std::vector< Point >	_2d_points
	Quadrature points in the in-plane direction in isoparametric coordinate system. More...
std::vector< std::vector< Real > >	_dphidxi_map
	Derivatives of shape functions w.r.t isoparametric coordinates xi. More...
std::vector< std::vector< Real > >	_dphideta_map
	Derivatives of shape functions w.r.t isoparametric coordinates eta. More...
std::vector< std::vector< Real > >	_phi_map
	Shape function value. More...
std::vector< ADMaterialProperty(RealVectorValue) * >	_dxyz_dxi
	Derivative of global x, y and z w.r.t isoparametric coordinate xi. More...
std::vector< ADMaterialProperty(RealVectorValue) * >	_dxyz_deta
	Derivative of global x, y and z w.r.t isoparametric coordinate eta. More...
std::vector< ADMaterialProperty(RealVectorValue) * >	_dxyz_dzeta
	Derivative of global x, y and z w.r.t isoparametric coordinate zeta. More...
std::vector< const MaterialProperty< RealVectorValue > * >	_dxyz_dxi_old
	Old derivative of global x, y and z w.r.t isoparametric coordinate xi. More...
std::vector< const MaterialProperty< RealVectorValue > * >	_dxyz_deta_old
	Old derivative of global x, y and z w.r.t isoparametric coordinate eta. More...
std::vector< const MaterialProperty< RealVectorValue > * >	_dxyz_dzeta_old
	Old derivative of global x, y and z w.r.t isoparametric coordinate zeta. More...
std::vector< ADRealVectorValue >	_v1
	First tangential vectors at nodes. More...
std::vector< ADRealVectorValue >	_v2
	First tangential vectors at nodes. More...
std::vector< ADMaterialProperty(DenseMatrix< Real >) * >	_B
	B_matrix for small strain. More...
std::vector< const MaterialProperty< DenseMatrix< Real > > * >	_B_old
	Old B_matrix for small strain. More...
std::vector< ADMaterialProperty(RankTwoTensor) * >	_ge
	ge matrix for elasticity tensor conversion More...
std::vector< const MaterialProperty< RankTwoTensor > * >	_ge_old
	Old ge matrix for elasticity tensor conversion. More...
std::vector< ADMaterialProperty(Real) * >	_J_map
	Material property containing jacobian of transformation. More...
std::vector< const MaterialProperty< Real > * >	_J_map_old
	Old material property containing jacobian of transformation. More...
std::vector< MaterialProperty< RankTwoTensor > * >	_rotation_matrix
	Rotation matrix material property. More...
std::vector< MaterialProperty< RankTwoTensor > * >	_total_global_strain
	Total strain in global coordinate system. More...
ADRealVectorValue	_x2
	simulation variables More...
ADRealVectorValue	_x3
const NumericVector< Number > *const &	_sol
const NumericVector< Number > &	_sol_old
ADRealVectorValue	_g3_a
ADRealVectorValue	_g3_c
ADRealVectorValue	_g3_b
ADRealVectorValue	_g3_d
ADRealVectorValue	_g1_a
ADRealVectorValue	_g1_c
ADRealVectorValue	_g2_b
ADRealVectorValue	_g2_d
RankTwoTensor	_unrotated_total_strain
	usingMaterialMembers

Detailed Description

template<ComputeStage compute_stage>
class ADComputeIncrementalShellStrain< compute_stage >

Definition at line 56 of file ADComputeIncrementalShellStrain.h.

Constructor & Destructor Documentation

ADComputeIncrementalShellStrain()

template<ComputeStage compute_stage>

ADComputeIncrementalShellStrain< compute_stage >::ADComputeIncrementalShellStrain

(

const InputParameters &

parameters

)

Definition at line 46 of file ADComputeIncrementalShellStrain.C.

  : ADMaterial<compute_stage>(parameters),
    _nrot(coupledComponents("rotations")),
    _ndisp(coupledComponents("displacements")),
    _rot_num(_nrot),
    _disp_num(_ndisp),
    _thickness(coupledValue("thickness")),
    _large_strain(getParam<bool>("large_strain")),
    _strain_increment(),
    _total_strain(),
    _total_strain_old(),
    _nonlinear_sys(_fe_problem.getNonlinearSystemBase()),
    _soln_disp_index(4),
    _soln_rot_index(4),
    _soln_vector(20, 1),
    _strain_vector(5, 1),
    _nodes(4),
    _node_normal(declareADProperty<RealVectorValue>("node_normal")),
    _node_normal_old(getMaterialPropertyOldByName<RealVectorValue>("node_normal")),
    _dxyz_dxi(),
    _dxyz_deta(),
    _dxyz_dzeta(),
    _dxyz_dxi_old(),
    _dxyz_deta_old(),
    _dxyz_dzeta_old(),
    _v1(4),
    _v2(4),
    _B(),
    _B_old(),
    _ge(),
    _ge_old(),
    _J_map(),
    _J_map_old(),
    _rotation_matrix(),
    _total_global_strain(),
    _sol(_nonlinear_sys.currentSolution()),
    _sol_old(_nonlinear_sys.solutionOld())
{
  // Checking for consistency between length of the provided displacements and rotations vector
  if (_ndisp != 3 || _nrot != 2)
    mooseError(
        "ADComputeIncrementalShellStrain: The number of variables supplied in 'displacements' "
        "must be 3 and that in 'rotations' must be 2.");
 
  if (_mesh.hasSecondOrderElements())
    mooseError(
        "ADComputeIncrementalShellStrain: Shell element is implemented only for linear elements.");
 
  // fetch coupled variables and gradients (as stateful properties if necessary)
  for (unsigned int i = 0; i < _ndisp; ++i)
  {
    MooseVariable * disp_variable = getVar("displacements", i);
    _disp_num[i] = disp_variable->number();
 
    if (i < _nrot)
    {
      MooseVariable * rot_variable = getVar("rotations", i);
      _rot_num[i] = rot_variable->number();
    }
  }
 
  _t_qrule = libmesh_make_unique<QGauss>(
      1, Utility::string_to_enum<Order>(getParam<std::string>("through_thickness_order")));
  _t_points = _t_qrule->get_points();
  _strain_increment.resize(_t_points.size());
  _total_strain.resize(_t_points.size());
  _total_strain_old.resize(_t_points.size());
  _B.resize(_t_points.size());
  _B_old.resize(_t_points.size());
  _ge.resize(_t_points.size());
  _ge_old.resize(_t_points.size());
  _J_map.resize(_t_points.size());
  _J_map_old.resize(_t_points.size());
  _dxyz_dxi.resize(_t_points.size());
  _dxyz_deta.resize(_t_points.size());
  _dxyz_dzeta.resize(_t_points.size());
  _dxyz_dxi_old.resize(_t_points.size());
  _dxyz_deta_old.resize(_t_points.size());
  _dxyz_dzeta_old.resize(_t_points.size());
  _rotation_matrix.resize(_t_points.size());
  _total_global_strain.resize(_t_points.size());
  for (unsigned int i = 0; i < _t_points.size(); ++i)
  {
    _strain_increment[i] =
        &declareADProperty<RankTwoTensor>("strain_increment_t_points_" + std::to_string(i));
    _total_strain[i] =
        &declareADProperty<RankTwoTensor>("total_strain_t_points_" + std::to_string(i));
    _total_strain_old[i] =
        &getMaterialPropertyOldByName<RankTwoTensor>("total_strain_t_points_" + std::to_string(i));
    _B[i] = &declareADProperty<DenseMatrix<Real>>("B_t_points_" + std::to_string(i));
    _B_old[i] = &getMaterialPropertyOldByName<DenseMatrix<Real>>("B_t_points_" + std::to_string(i));
    _ge[i] = &declareADProperty<RankTwoTensor>("ge_t_points_" + std::to_string(i));
    _ge_old[i] = &getMaterialPropertyOldByName<RankTwoTensor>("ge_t_points_" + std::to_string(i));
    _J_map[i] = &declareADProperty<Real>("J_mapping_t_points_" + std::to_string(i));
    _J_map_old[i] = &getMaterialPropertyOldByName<Real>("J_mapping_t_points_" + std::to_string(i));
    _dxyz_dxi[i] = &declareADProperty<RealVectorValue>("dxyz_dxi_t_points_" + std::to_string(i));
    _dxyz_dxi_old[i] =
        &getMaterialPropertyOldByName<RealVectorValue>("dxyz_dxi_t_points_" + std::to_string(i));
    _dxyz_deta[i] = &declareADProperty<RealVectorValue>("dxyz_deta_t_points_" + std::to_string(i));
    _dxyz_deta_old[i] =
        &getMaterialPropertyOldByName<RealVectorValue>("dxyz_deta_t_points_" + std::to_string(i));
    _dxyz_dzeta[i] =
        &declareADProperty<RealVectorValue>("dxyz_dzeta_t_points_" + std::to_string(i));
    _dxyz_dzeta_old[i] =
        &getMaterialPropertyOldByName<RealVectorValue>("dxyz_dzeta_t_points_" + std::to_string(i));
    // Create rotation matrix and total strain global for output purposes only
    _rotation_matrix[i] = &declareProperty<RankTwoTensor>("rotation_t_points_" + std::to_string(i));
    _total_global_strain[i] =
        &declareProperty<RankTwoTensor>("total_global_strain_t_points_" + std::to_string(i));
  }
 
  // used later for computing local coordinate system
  _x2(1) = 1;
  _x3(2) = 1;
}

Member Function Documentation

ADMaterialProperty()

template<ComputeStage compute_stage>

ADComputeIncrementalShellStrain< compute_stage >::ADMaterialProperty ( RealVectorValue  ) &

protected

Material property storing the normal to the element at the 4 nodes. Stored as a material property for convinience.

computeBMatrix()

template<ComputeStage compute_stage>

void ADComputeIncrementalShellStrain< compute_stage >::computeBMatrix ( )

protectedvirtual

Computes the B matrix that connects strains to nodal displacements and rotations.

Definition at line 391 of file ADComputeIncrementalShellStrain.C.

{
  // compute nodal local axis
  for (unsigned int k = 0; k < _nodes.size(); ++k)
  {
    _v1[k] = _x2.cross(_node_normal[k]);
    _v1[k] /= _x2.norm() * _node_normal[k].norm();
 
    // If x2 is parallel to node normal, set V1 to x3
    if (MooseUtils::absoluteFuzzyEqual(_v1[k].norm(), 0.0, 1e-6))
      _v1[k] = _x3;
 
    _v2[k] = _node_normal[k].cross(_v1[k]);
  }
 
  // compute B matrix rows correspond to [ux1, ux2, ux3, ux4, uy1, uy2, uy3, uy4, uz1, uz2, uz3,
  // uz4, a1, a2, a3, a4, b1, b2, b3, b4]
  for (unsigned int i = 0; i < _2d_points.size(); ++i)
  {
    for (unsigned int j = 0; j < _t_points.size(); ++j)
    {
      (*_B[j])[i].resize(5, 20);
      (*_B[j])[i].zero();
      for (unsigned int k = 0; k < _nodes.size(); ++k)
      {
        // corresponding to strain(0,0)
        (*_B[j])[i](0, k) += _dphidxi_map[k][i] * (*_dxyz_dxi[j])[i](0);
        (*_B[j])[i](0, 4 + k) = _dphidxi_map[k][i] * (*_dxyz_dxi[j])[i](1);
        (*_B[j])[i](0, 8 + k) = _dphidxi_map[k][i] * (*_dxyz_dxi[j])[i](2);
        (*_B[j])[i](0, 12 + k) = _dphidxi_map[k][i] * _t_points[j](0) / 2.0 * _thickness[i] *
                                 (-_v2[k] * (*_dxyz_dxi[j])[i]);
        (*_B[j])[i](0, 16 + k) = _dphidxi_map[k][i] * _t_points[j](0) / 2.0 * _thickness[i] *
                                 (_v1[k] * (*_dxyz_dxi[j])[i]);
 
        // corresponding to strain(1,1)
        (*_B[j])[i](1, k) = _dphideta_map[k][i] * (*_dxyz_deta[j])[i](0);
        (*_B[j])[i](1, 4 + k) = _dphideta_map[k][i] * (*_dxyz_deta[j])[i](1);
        (*_B[j])[i](1, 8 + k) = _dphideta_map[k][i] * (*_dxyz_deta[j])[i](2);
        (*_B[j])[i](1, 12 + k) = _dphideta_map[k][i] * _t_points[j](0) / 2.0 * _thickness[i] *
                                 (-_v2[k] * (*_dxyz_deta[j])[i]);
        (*_B[j])[i](1, 16 + k) = _dphideta_map[k][i] * _t_points[j](0) / 2.0 * _thickness[i] *
                                 (_v1[k] * (*_dxyz_deta[j])[i]);
 
        // corresponding to strain(2,2) = 0
 
        // corresponding to strain(0,1)
        (*_B[j])[i](2, k) = 0.5 * (_dphideta_map[k][i] * (*_dxyz_dxi[j])[i](0) +
                                   _dphidxi_map[k][i] * (*_dxyz_deta[j])[i](0));
        (*_B[j])[i](2, 4 + k) = 0.5 * (_dphideta_map[k][i] * (*_dxyz_dxi[j])[i](1) +
                                       _dphidxi_map[k][i] * (*_dxyz_deta[j])[i](1));
        (*_B[j])[i](2, 8 + k) = 0.5 * (_dphideta_map[k][i] * (*_dxyz_dxi[j])[i](2) +
                                       _dphidxi_map[k][i] * (*_dxyz_deta[j])[i](2));
        (*_B[j])[i](2, 12 + k) =
            0.25 * _t_points[j](0) * _thickness[i] * -_v2[k] *
            (_dphideta_map[k][i] * (*_dxyz_dxi[j])[i] + _dphidxi_map[k][i] * (*_dxyz_deta[j])[i]);
        (*_B[j])[i](2, 16 + k) =
            0.25 * _t_points[j](0) * _thickness[i] * _v1[k] *
            ((*_dxyz_deta[j])[i] * _dphidxi_map[k][i] + (*_dxyz_dxi[j])[i] * _dphideta_map[k][i]);
      }
 
      _g3_a = _thickness[i] / 4.0 * (_node_normal[2] + _node_normal[3]);
      _g3_c = _thickness[i] / 4.0 * (_node_normal[0] + _node_normal[1]);
      _g3_b = _thickness[i] / 4.0 * (_node_normal[0] + _node_normal[3]);
      _g3_d = _thickness[i] / 4.0 * (_node_normal[1] + _node_normal[2]);
 
      _g1_a = 0.5 * ((*_nodes[2]) - (*_nodes[3])) +
              _t_points[j](0) / 4.0 * _thickness[i] * (_node_normal[2] - _node_normal[3]);
      _g1_c = 0.5 * ((*_nodes[1]) - (*_nodes[0])) +
              _t_points[j](0) / 4.0 * _thickness[i] * (_node_normal[1] - _node_normal[0]);
      _g2_b = 0.5 * ((*_nodes[3]) - (*_nodes[0])) +
              _t_points[j](0) / 4.0 * _thickness[i] * (_node_normal[3] - _node_normal[0]);
      _g2_d = 0.5 * ((*_nodes[2]) - (*_nodes[1])) +
              _t_points[j](0) / 4.0 * _thickness[i] * (_node_normal[2] - _node_normal[1]);
 
      updateGVectors(); // for large strain problems
 
      // corresponding to strain(0,2)
      for (unsigned int component = 0; component < 3; component++)
      {
        (*_B[j])[i](3, 2 + component * 4) = 0.125 * (1.0 + _2d_points[i](1)) * _g3_a(component);
        (*_B[j])[i](3, 3 + component * 4) = 0.125 * (1.0 + _2d_points[i](1)) * -_g3_a(component);
        (*_B[j])[i](3, 1 + component * 4) = 0.125 * (1.0 - _2d_points[i](1)) * _g3_c(component);
        (*_B[j])[i](3, component * 4) = 0.125 * (1.0 - _2d_points[i](1)) * -_g3_c(component);
      }
      (*_B[j])[i](3, 14) = 0.125 * (1.0 + _2d_points[i](1)) * 0.5 * _thickness[i] * _g1_a * -_v2[2];
      (*_B[j])[i](3, 18) = 0.125 * (1.0 + _2d_points[i](1)) * 0.5 * _thickness[i] * _g1_a * _v1[2];
      (*_B[j])[i](3, 15) = 0.125 * (1.0 + _2d_points[i](1)) * 0.5 * _thickness[i] * _g1_a * -_v2[3];
      (*_B[j])[i](3, 19) = 0.125 * (1.0 + _2d_points[i](1)) * 0.5 * _thickness[i] * _g1_a * _v1[3];
 
      (*_B[j])[i](3, 13) = 0.125 * (1.0 - _2d_points[i](1)) * 0.5 * _thickness[i] * _g1_c * -_v2[1];
      (*_B[j])[i](3, 17) = 0.125 * (1.0 - _2d_points[i](1)) * 0.5 * _thickness[i] * _g1_c * _v1[1];
      (*_B[j])[i](3, 12) = 0.125 * (1.0 - _2d_points[i](1)) * 0.5 * _thickness[i] * _g1_c * -_v2[0];
      (*_B[j])[i](3, 16) = 0.125 * (1.0 - _2d_points[i](1)) * 0.5 * _thickness[i] * _g1_c * _v1[0];
 
      // corresponding to strain(1,2)
      for (unsigned int component = 0; component < 3; component++)
      {
        (*_B[j])[i](4, 2 + component * 4) = 0.125 * (1.0 + _2d_points[i](0)) * _g3_d(component);
        (*_B[j])[i](4, 1 + component * 4) = 0.125 * (1.0 + _2d_points[i](0)) * -_g3_d(component);
        (*_B[j])[i](4, 3 + component * 4) = 0.125 * (1.0 - _2d_points[i](0)) * _g3_b(component);
        (*_B[j])[i](4, component * 4) = 0.125 * (1.0 - _2d_points[i](0)) * -_g3_b(component);
      }
      (*_B[j])[i](4, 14) = 0.125 * (1.0 + _2d_points[i](0)) * 0.5 * _thickness[i] * _g2_d * -_v2[2];
      (*_B[j])[i](4, 18) = 0.125 * (1.0 + _2d_points[i](0)) * 0.5 * _thickness[i] * _g2_d * _v1[2];
      (*_B[j])[i](4, 13) = 0.125 * (1.0 + _2d_points[i](0)) * 0.5 * _thickness[i] * _g2_d * -_v2[1];
      (*_B[j])[i](4, 17) = 0.125 * (1.0 + _2d_points[i](0)) * 0.5 * _thickness[i] * _g2_d * _v1[1];
 
      (*_B[j])[i](4, 15) = 0.125 * (1.0 - _2d_points[i](0)) * 0.5 * _thickness[i] * _g2_b * -_v2[3];
      (*_B[j])[i](4, 19) = 0.125 * (1.0 - _2d_points[i](0)) * 0.5 * _thickness[i] * _g2_b * _v1[3];
      (*_B[j])[i](4, 12) = 0.125 * (1.0 - _2d_points[i](0)) * 0.5 * _thickness[i] * _g2_b * -_v2[0];
      (*_B[j])[i](4, 16) = 0.125 * (1.0 - _2d_points[i](0)) * 0.5 * _thickness[i] * _g2_b * _v1[0];
    }
  }
}

computeGMatrix()

template<ComputeStage compute_stage>

void ADComputeIncrementalShellStrain< compute_stage >::computeGMatrix ( )

protectedvirtual

Computes the transformation matrix from natural coordinates to local cartesian coordinates for elasticity tensor transformation.

Definition at line 248 of file ADComputeIncrementalShellStrain.C.

{
  // quadrature points in isoparametric space
  _2d_points = _qrule->get_points(); // would be in 2D
 
  unsigned int dim = _current_elem->dim();
 
  // derivatives of shape functions (dphidxi, dphideta and dphidzeta) evaluated at quadrature points
  // (in isoparametric space).
  FEType fe_type(Utility::string_to_enum<Order>("First"),
                 Utility::string_to_enum<FEFamily>("LAGRANGE"));
  auto & fe = _fe_problem.assembly(_tid).getFE(fe_type, dim);
  _dphidxi_map = fe->get_fe_map().get_dphidxi_map();
  _dphideta_map = fe->get_fe_map().get_dphideta_map();
  _phi_map = fe->get_fe_map().get_phi_map();
 
  for (unsigned int i = 0; i < 4; ++i)
    _nodes[i] = _current_elem->node_ptr(i);
 
  ADRealVectorValue x = (*_nodes[1] - *_nodes[0]);
  ADRealVectorValue y = (*_nodes[3] - *_nodes[0]);
  ADRealVectorValue normal = x.cross(y);
  normal /= normal.norm();
 
  for (unsigned int k = 0; k < 4; ++k)
    _node_normal[k] = normal;
 
  ADRankTwoTensor a;
  ADDenseMatrix b(5, 20);
  ADRealVectorValue c;
  RankTwoTensor d;
  for (unsigned int t = 0; t < _t_points.size(); ++t)
  {
    (*_strain_increment[t])[_qp] = a;
    (*_total_strain[t])[_qp] = a;
    (*_B[t])[_qp] = b;
    (*_ge[t])[_qp] = a;
    (*_J_map[t])[_qp] = 0;
    (*_dxyz_dxi[t])[_qp] = c;
    (*_dxyz_deta[t])[_qp] = c;
    (*_dxyz_dzeta[t])[_qp] = c;
    (*_rotation_matrix[t])[_qp] = d;
  }
 
  // calculating derivatives of shape function in physical space (dphi/dx, dphi/dy, dphi/dz) at
  // quadrature points these are g_{i} in Dvorkin's paper
  for (unsigned int i = 0; i < _2d_points.size(); ++i)
  {
    for (unsigned int j = 0; j < _t_points.size(); ++j)
    {
      (*_dxyz_dxi[j])[i].zero();
      for (unsigned int component = 0; component < 3; ++component)
      {
        (*_dxyz_dxi[j])[i](component) = 0.0;
        (*_dxyz_deta[j])[i](component) = 0.0;
        (*_dxyz_dzeta[j])[i](component) = 0.0;
 
        for (unsigned int k = 0; k < _nodes.size(); ++k)
        {
          (*_dxyz_dxi[j])[i](component) += _dphidxi_map[k][i] * ((*_nodes[k])(component)) +
                                           _t_points[j](0) / 2.0 * _thickness[i] *
                                               _dphidxi_map[k][i] * _node_normal[k](component);
          (*_dxyz_deta[j])[i](component) += _dphideta_map[k][i] * ((*_nodes[k])(component)) +
                                            _t_points[j](0) / 2.0 * _thickness[i] *
                                                _dphideta_map[k][i] * _node_normal[k](component);
          (*_dxyz_dzeta[j])[i](component) +=
              _thickness[i] * _phi_map[k][i] * _node_normal[k](component) / 2.0;
        }
      }
    }
  }
 
  for (unsigned int i = 0; i < _2d_points.size(); ++i)
  {
    for (unsigned int j = 0; j < _t_points.size(); ++j)
    {
      // calculate gij for elasticity tensor
      ADRankTwoTensor gmn;
      RankTwoTensor J;
      for (unsigned int component = 0; component < 3; ++component)
      {
        gmn(0, 0) += (*_dxyz_dxi[j])[i](component) * (*_dxyz_dxi[j])[i](component);
        gmn(1, 1) += (*_dxyz_deta[j])[i](component) * (*_dxyz_deta[j])[i](component);
        gmn(2, 2) += (*_dxyz_dzeta[j])[i](component) * (*_dxyz_dzeta[j])[i](component);
        gmn(0, 1) += (*_dxyz_dxi[j])[i](component) * (*_dxyz_deta[j])[i](component);
        gmn(0, 2) += (*_dxyz_dxi[j])[i](component) * (*_dxyz_dzeta[j])[i](component);
        gmn(1, 2) += (*_dxyz_deta[j])[i](component) * (*_dxyz_dzeta[j])[i](component);
 
        J(0, component) = MetaPhysicL::raw_value((*_dxyz_dxi[j])[i](component));
        J(1, component) = MetaPhysicL::raw_value((*_dxyz_deta[j])[i](component));
        J(2, component) = MetaPhysicL::raw_value((*_dxyz_dzeta[j])[i](component));
      }
      gmn(1, 0) = gmn(0, 1);
      gmn(2, 0) = gmn(0, 2);
      gmn(2, 1) = gmn(1, 2);
 
      ADRankTwoTensor gmninv_temp = gmn.inverse();
      (*_J_map[j])[i] = std::sqrt(gmn.det());
      (*_rotation_matrix[j])[i] = J;
 
      // calculate ge
      ADRealVectorValue e3 = (*_dxyz_dzeta[j])[i] / (*_dxyz_dzeta[j])[i].norm();
      ADRealVectorValue e1 = (*_dxyz_deta[j])[i].cross(e3);
      e1 /= e1.norm();
      ADRealVectorValue e2 = e3.cross(e1);
      e2 /= e2.norm();
 
      ADRankTwoTensor local_rotation_mat;
      local_rotation_mat(0, 0) = e1(0);
      local_rotation_mat(0, 1) = e1(1);
      local_rotation_mat(0, 2) = e1(2);
      local_rotation_mat(1, 0) = e2(0);
      local_rotation_mat(1, 1) = e2(1);
      local_rotation_mat(1, 2) = e2(2);
      local_rotation_mat(2, 0) = e3(0);
      local_rotation_mat(2, 1) = e3(1);
      local_rotation_mat(2, 2) = e3(2);
 
      ADRankTwoTensor gmninv = local_rotation_mat.transpose() * gmninv_temp * local_rotation_mat;
 
      (*_ge[j])[i](0, 0) = (gmninv * (*_dxyz_dxi[j])[i]) * e1;
      (*_ge[j])[i](0, 1) = (gmninv * (*_dxyz_dxi[j])[i]) * e2;
      (*_ge[j])[i](0, 2) = (gmninv * (*_dxyz_dxi[j])[i]) * e3;
      (*_ge[j])[i](1, 0) = (gmninv * (*_dxyz_deta[j])[i]) * e1;
      (*_ge[j])[i](1, 1) = (gmninv * (*_dxyz_deta[j])[i]) * e2;
      (*_ge[j])[i](1, 2) = (gmninv * (*_dxyz_deta[j])[i]) * e3;
      (*_ge[j])[i](2, 0) = (gmninv * (*_dxyz_dzeta[j])[i]) * e1;
      (*_ge[j])[i](2, 1) = (gmninv * (*_dxyz_dzeta[j])[i]) * e2;
      (*_ge[j])[i](2, 2) = (gmninv * (*_dxyz_dzeta[j])[i]) * e3;
    }
  }
}

computeNodeNormal()

template<ComputeStage compute_stage>

void ADComputeIncrementalShellStrain< compute_stage >::computeNodeNormal ( )

protectedvirtual

Computes the node normal at each node.

Reimplemented in ADComputeFiniteShellStrain< compute_stage >.

Definition at line 383 of file ADComputeIncrementalShellStrain.C.

{
  for (unsigned int k = 0; k < _nodes.size(); ++k)
    _node_normal[k] = _node_normal_old[k];
}

computeProperties()

template<ComputeStage compute_stage>

void ADComputeIncrementalShellStrain< compute_stage >::computeProperties ( )

overrideprotectedvirtual

Reimplemented in ADComputeFiniteShellStrain< compute_stage >.

Definition at line 179 of file ADComputeIncrementalShellStrain.C.

{
  // quadrature points in isoparametric space
  _2d_points = _qrule->get_points(); // would be in 2D
 
  // derivatives of shape functions (dphidxi, dphideta and dphidzeta) evaluated at quadrature points
  // (in isoparametric space).
  unsigned int dim = _current_elem->dim();
  FEType fe_type(Utility::string_to_enum<Order>("First"),
                 Utility::string_to_enum<FEFamily>("LAGRANGE"));
  auto & fe = _fe_problem.assembly(_tid).getFE(fe_type, dim);
  _dphidxi_map = fe->get_fe_map().get_dphidxi_map();
  _dphideta_map = fe->get_fe_map().get_dphideta_map();
  _phi_map = fe->get_fe_map().get_phi_map();
 
  for (unsigned int i = 0; i < 4; ++i)
    _nodes[i] = _current_elem->node_ptr(i);
 
  for (unsigned int i = 0; i < _2d_points.size(); ++i)
  {
    for (unsigned int j = 0; j < _t_points.size(); ++j)
    {
      (*_ge[j])[i] = (*_ge_old[j])[i];
      (*_J_map[j])[i] = (*_J_map_old[j])[i];
      (*_dxyz_dxi[j])[i] = (*_dxyz_dxi_old[j])[i];
      (*_dxyz_deta[j])[i] = (*_dxyz_deta_old[j])[i];
      (*_dxyz_dzeta[j])[i] = (*_dxyz_dzeta_old[j])[i];
      (*_B[j])[i] = (*_B_old[j])[i];
    }
  }
 
  computeSolnVector();
 
  computeNodeNormal();
 
  for (unsigned int i = 0; i < _2d_points.size(); ++i)
  {
    for (unsigned int j = 0; j < _t_points.size(); ++j)
    {
      // compute strain increment in covariant coordinate system using B and _soln_vector
      for (unsigned int temp1 = 0; temp1 < 5; ++temp1)
      {
        _strain_vector(temp1) = 0.0;
        for (unsigned int temp2 = 0; temp2 < 20; ++temp2)
          _strain_vector(temp1) += (*_B[j])[i](temp1, temp2) * _soln_vector(temp2);
      }
      (*_strain_increment[j])[i](0, 0) = _strain_vector(0);
      (*_strain_increment[j])[i](1, 1) = _strain_vector(1);
      (*_strain_increment[j])[i](0, 1) = _strain_vector(2);
      (*_strain_increment[j])[i](0, 2) = _strain_vector(3);
      (*_strain_increment[j])[i](1, 2) = _strain_vector(4);
      (*_strain_increment[j])[i](1, 0) = (*_strain_increment[j])[i](0, 1);
      (*_strain_increment[j])[i](2, 0) = (*_strain_increment[j])[i](0, 2);
      (*_strain_increment[j])[i](2, 1) = (*_strain_increment[j])[i](1, 2);
 
      (*_total_strain[j])[i] = (*_total_strain_old[j])[i] + (*_strain_increment[j])[i];
 
      for (unsigned int ii = 0; ii < 3; ++ii)
        for (unsigned int jj = 0; jj < 3; ++jj)
          _unrotated_total_strain(ii, jj) = MetaPhysicL::raw_value((*_total_strain[j])[i](ii, jj));
      (*_total_global_strain[j])[i] = (*_rotation_matrix[j])[i].transpose() *
                                      _unrotated_total_strain * (*_rotation_matrix[j])[i];
    }
  }
  copyDualNumbersToValues();
}

computeSolnVector() [1/3]

template<ComputeStage compute_stage>

virtual void ADComputeIncrementalShellStrain< compute_stage >::computeSolnVector ( )

protectedvirtual

Computes the 20x1 soln vector and its derivatives for each shell element.

computeSolnVector() [2/3]

template<>

void ADComputeIncrementalShellStrain< RESIDUAL >::computeSolnVector ( )

protected

Definition at line 508 of file ADComputeIncrementalShellStrain.C.

{
  _soln_vector.zero();
 
  for (unsigned int j = 0; j < 4; ++j)
  {
    _soln_disp_index[j].resize(_ndisp);
    _soln_rot_index[j].resize(_nrot);
 
    for (unsigned int i = 0; i < _ndisp; ++i)
    {
      _soln_disp_index[j][i] = _nodes[j]->dof_number(_nonlinear_sys.number(), _disp_num[i], 0);
      _soln_vector(j + i * _nodes.size()) =
          (*_sol)(_soln_disp_index[j][i]) - _sol_old(_soln_disp_index[j][i]);
    }
 
    for (unsigned int i = 0; i < _nrot; ++i)
    {
      _soln_rot_index[j][i] = _nodes[j]->dof_number(_nonlinear_sys.number(), _rot_num[i], 0);
      _soln_vector(j + 12 + i * _nodes.size()) =
          (*_sol)(_soln_rot_index[j][i]) - _sol_old(_soln_rot_index[j][i]);
    }
  }
}

computeSolnVector() [3/3]

template<>

void ADComputeIncrementalShellStrain< JACOBIAN >::computeSolnVector ( )

protected

Definition at line 535 of file ADComputeIncrementalShellStrain.C.

{
  _soln_vector.zero();
 
  for (unsigned int j = 0; j < 4; ++j)
  {
    _soln_disp_index[j].resize(_ndisp);
    _soln_rot_index[j].resize(_nrot);
 
    for (unsigned int i = 0; i < _ndisp; ++i)
    {
      size_t ad_offset = _disp_num[i] * _nonlinear_sys.getMaxVarNDofsPerElem();
      _soln_disp_index[j][i] = _nodes[j]->dof_number(_nonlinear_sys.number(), _disp_num[i], 0);
      _soln_vector(j + i * _nodes.size()) =
          (*_sol)(_soln_disp_index[j][i]) - _sol_old(_soln_disp_index[j][i]);
      Moose::derivInsert(_soln_vector(j + i * _nodes.size()).derivatives(), ad_offset + j, 1.);
    }
 
    for (unsigned int i = 0; i < _nrot; ++i)
    {
      size_t ad_offset = _rot_num[i] * _nonlinear_sys.getMaxVarNDofsPerElem();
      _soln_rot_index[j][i] = _nodes[j]->dof_number(_nonlinear_sys.number(), _rot_num[i], 0);
      _soln_vector(j + 12 + i * _nodes.size()) =
          (*_sol)(_soln_rot_index[j][i]) - _sol_old(_soln_rot_index[j][i]);
      Moose::derivInsert(_soln_vector(j + 12 + i * _nodes.size()).derivatives(), ad_offset + j, 1.);
    }
  }
}

initQpStatefulProperties()

template<ComputeStage compute_stage>

void ADComputeIncrementalShellStrain< compute_stage >::initQpStatefulProperties ( )

overrideprotectedvirtual

Reimplemented in ADComputeFiniteShellStrain< compute_stage >.

Definition at line 165 of file ADComputeIncrementalShellStrain.C.

{
  unsigned int dim = _current_elem->dim();
  if ((dim != 2))
    mooseError(
        "ADComputeIncrementalShellStrain: Shell element is implemented only for 2D elements");
  if (_current_elem->n_nodes() != 4)
    mooseError("ADComputeIncrementalShellStrain: Shell element needs to have exactly four nodes.");
  computeGMatrix();
  computeBMatrix();
}

updatedxyz()

template<ComputeStage compute_stage>

virtual void ADComputeIncrementalShellStrain< compute_stage >::updatedxyz ( )

inlineprotectedvirtual

Updates covariant vectors at each qp for finite rotations.

Reimplemented in ADComputeFiniteShellStrain< compute_stage >.

Definition at line 93 of file ADComputeIncrementalShellStrain.h.

{};

updateGVectors()

template<ComputeStage compute_stage>

virtual void ADComputeIncrementalShellStrain< compute_stage >::updateGVectors ( )

inlineprotectedvirtual

Updates the vectors required for shear locking computation for finite rotations.

Reimplemented in ADComputeFiniteShellStrain< compute_stage >.

Definition at line 90 of file ADComputeIncrementalShellStrain.h.

{};

Member Data Documentation

_2d_points

template<ComputeStage compute_stage>

std::vector<Point> ADComputeIncrementalShellStrain< compute_stage >::_2d_points

protected

Quadrature points in the in-plane direction in isoparametric coordinate system.

Definition at line 156 of file ADComputeIncrementalShellStrain.h.

_B

template<ComputeStage compute_stage>

std::vector<ADMaterialProperty(DenseMatrix<Real>) *> ADComputeIncrementalShellStrain< compute_stage >::_B

protected

B_matrix for small strain.

Definition at line 192 of file ADComputeIncrementalShellStrain.h.

Referenced by ADComputeIncrementalShellStrain< compute_stage >::ADComputeIncrementalShellStrain().

_B_old

template<ComputeStage compute_stage>

std::vector<const MaterialProperty<DenseMatrix<Real> > *> ADComputeIncrementalShellStrain< compute_stage >::_B_old

protected

Old B_matrix for small strain.

Definition at line 195 of file ADComputeIncrementalShellStrain.h.

Referenced by ADComputeIncrementalShellStrain< compute_stage >::ADComputeIncrementalShellStrain().

_disp_num

template<ComputeStage compute_stage>

std::vector<unsigned int> ADComputeIncrementalShellStrain< compute_stage >::_disp_num

protected

Variable numbers corresponding to the displacement variables.

Definition at line 108 of file ADComputeIncrementalShellStrain.h.

Referenced by ADComputeIncrementalShellStrain< compute_stage >::ADComputeIncrementalShellStrain().

_dphideta_map

template<ComputeStage compute_stage>

std::vector<std::vector<Real> > ADComputeIncrementalShellStrain< compute_stage >::_dphideta_map

protected

Derivatives of shape functions w.r.t isoparametric coordinates eta.

Definition at line 162 of file ADComputeIncrementalShellStrain.h.

_dphidxi_map

template<ComputeStage compute_stage>

std::vector<std::vector<Real> > ADComputeIncrementalShellStrain< compute_stage >::_dphidxi_map

protected

Derivatives of shape functions w.r.t isoparametric coordinates xi.

Definition at line 159 of file ADComputeIncrementalShellStrain.h.

_dxyz_deta

template<ComputeStage compute_stage>

std::vector<ADMaterialProperty(RealVectorValue) *> ADComputeIncrementalShellStrain< compute_stage >::_dxyz_deta

protected

Derivative of global x, y and z w.r.t isoparametric coordinate eta.

Definition at line 171 of file ADComputeIncrementalShellStrain.h.

Referenced by ADComputeIncrementalShellStrain< compute_stage >::ADComputeIncrementalShellStrain().

_dxyz_deta_old

template<ComputeStage compute_stage>

std::vector<const MaterialProperty<RealVectorValue> *> ADComputeIncrementalShellStrain< compute_stage >::_dxyz_deta_old

protected

Old derivative of global x, y and z w.r.t isoparametric coordinate eta.

Definition at line 180 of file ADComputeIncrementalShellStrain.h.

Referenced by ADComputeIncrementalShellStrain< compute_stage >::ADComputeIncrementalShellStrain().

_dxyz_dxi

template<ComputeStage compute_stage>

std::vector<ADMaterialProperty(RealVectorValue) *> ADComputeIncrementalShellStrain< compute_stage >::_dxyz_dxi

protected

Derivative of global x, y and z w.r.t isoparametric coordinate xi.

Definition at line 168 of file ADComputeIncrementalShellStrain.h.

Referenced by ADComputeIncrementalShellStrain< compute_stage >::ADComputeIncrementalShellStrain().

_dxyz_dxi_old

template<ComputeStage compute_stage>

std::vector<const MaterialProperty<RealVectorValue> *> ADComputeIncrementalShellStrain< compute_stage >::_dxyz_dxi_old

protected

Old derivative of global x, y and z w.r.t isoparametric coordinate xi.

Definition at line 177 of file ADComputeIncrementalShellStrain.h.

Referenced by ADComputeIncrementalShellStrain< compute_stage >::ADComputeIncrementalShellStrain().

_dxyz_dzeta

template<ComputeStage compute_stage>

std::vector<ADMaterialProperty(RealVectorValue) *> ADComputeIncrementalShellStrain< compute_stage >::_dxyz_dzeta

protected

Derivative of global x, y and z w.r.t isoparametric coordinate zeta.

Definition at line 174 of file ADComputeIncrementalShellStrain.h.

Referenced by ADComputeIncrementalShellStrain< compute_stage >::ADComputeIncrementalShellStrain().

_dxyz_dzeta_old

template<ComputeStage compute_stage>

std::vector<const MaterialProperty<RealVectorValue> *> ADComputeIncrementalShellStrain< compute_stage >::_dxyz_dzeta_old

protected

Old derivative of global x, y and z w.r.t isoparametric coordinate zeta.

Definition at line 183 of file ADComputeIncrementalShellStrain.h.

Referenced by ADComputeIncrementalShellStrain< compute_stage >::ADComputeIncrementalShellStrain().

_g1_a

template<ComputeStage compute_stage>

ADRealVectorValue ADComputeIncrementalShellStrain< compute_stage >::_g1_a

protected

Definition at line 224 of file ADComputeIncrementalShellStrain.h.

_g1_c

template<ComputeStage compute_stage>

ADRealVectorValue ADComputeIncrementalShellStrain< compute_stage >::_g1_c

protected

Definition at line 225 of file ADComputeIncrementalShellStrain.h.

_g2_b

template<ComputeStage compute_stage>

ADRealVectorValue ADComputeIncrementalShellStrain< compute_stage >::_g2_b

protected

Definition at line 226 of file ADComputeIncrementalShellStrain.h.

_g2_d

template<ComputeStage compute_stage>

ADRealVectorValue ADComputeIncrementalShellStrain< compute_stage >::_g2_d

protected

Definition at line 227 of file ADComputeIncrementalShellStrain.h.

_g3_a

template<ComputeStage compute_stage>

ADRealVectorValue ADComputeIncrementalShellStrain< compute_stage >::_g3_a

protected

Definition at line 220 of file ADComputeIncrementalShellStrain.h.

_g3_b

template<ComputeStage compute_stage>

ADRealVectorValue ADComputeIncrementalShellStrain< compute_stage >::_g3_b

protected

Definition at line 222 of file ADComputeIncrementalShellStrain.h.

_g3_c

template<ComputeStage compute_stage>

ADRealVectorValue ADComputeIncrementalShellStrain< compute_stage >::_g3_c

protected

Definition at line 221 of file ADComputeIncrementalShellStrain.h.

_g3_d

template<ComputeStage compute_stage>

ADRealVectorValue ADComputeIncrementalShellStrain< compute_stage >::_g3_d

protected

Definition at line 223 of file ADComputeIncrementalShellStrain.h.

_ge

template<ComputeStage compute_stage>

std::vector<ADMaterialProperty(RankTwoTensor) *> ADComputeIncrementalShellStrain< compute_stage >::_ge

protected

ge matrix for elasticity tensor conversion

Definition at line 198 of file ADComputeIncrementalShellStrain.h.

Referenced by ADComputeIncrementalShellStrain< compute_stage >::ADComputeIncrementalShellStrain().

_ge_old

template<ComputeStage compute_stage>

std::vector<const MaterialProperty<RankTwoTensor> *> ADComputeIncrementalShellStrain< compute_stage >::_ge_old

protected

Old ge matrix for elasticity tensor conversion.

Definition at line 201 of file ADComputeIncrementalShellStrain.h.

Referenced by ADComputeIncrementalShellStrain< compute_stage >::ADComputeIncrementalShellStrain().

_J_map

template<ComputeStage compute_stage>

std::vector<ADMaterialProperty(Real) *> ADComputeIncrementalShellStrain< compute_stage >::_J_map

protected

Material property containing jacobian of transformation.

Definition at line 204 of file ADComputeIncrementalShellStrain.h.

Referenced by ADComputeIncrementalShellStrain< compute_stage >::ADComputeIncrementalShellStrain().

_J_map_old

template<ComputeStage compute_stage>

std::vector<const MaterialProperty<Real> *> ADComputeIncrementalShellStrain< compute_stage >::_J_map_old

protected

Old material property containing jacobian of transformation.

Definition at line 207 of file ADComputeIncrementalShellStrain.h.

Referenced by ADComputeIncrementalShellStrain< compute_stage >::ADComputeIncrementalShellStrain().

_large_strain

template<ComputeStage compute_stage>

const bool ADComputeIncrementalShellStrain< compute_stage >::_large_strain

protected

Flag to compute large strains.

Definition at line 114 of file ADComputeIncrementalShellStrain.h.

_ndisp

template<ComputeStage compute_stage>

unsigned int ADComputeIncrementalShellStrain< compute_stage >::_ndisp

protected

Number of coupled displacement variables.

Definition at line 102 of file ADComputeIncrementalShellStrain.h.

Referenced by ADComputeIncrementalShellStrain< compute_stage >::ADComputeIncrementalShellStrain().

_node_normal_old

template<ComputeStage compute_stage>

const MaterialProperty<RealVectorValue>& ADComputeIncrementalShellStrain< compute_stage >::_node_normal_old

protected

Material property storing the old normal to the element at the 4 nodes.

Definition at line 147 of file ADComputeIncrementalShellStrain.h.

_nodes

template<ComputeStage compute_stage>

std::vector<const Node *> ADComputeIncrementalShellStrain< compute_stage >::_nodes

protected

Vector storing pointers to the nodes of the shell element.

Definition at line 141 of file ADComputeIncrementalShellStrain.h.

_nonlinear_sys

template<ComputeStage compute_stage>

NonlinearSystemBase& ADComputeIncrementalShellStrain< compute_stage >::_nonlinear_sys

protected

Reference to the nonlinear system object.

Definition at line 126 of file ADComputeIncrementalShellStrain.h.

_nrot

template<ComputeStage compute_stage>

unsigned int ADComputeIncrementalShellStrain< compute_stage >::_nrot

protected

Number of coupled rotational variables.

Definition at line 99 of file ADComputeIncrementalShellStrain.h.

Referenced by ADComputeIncrementalShellStrain< compute_stage >::ADComputeIncrementalShellStrain().

_phi_map

template<ComputeStage compute_stage>

std::vector<std::vector<Real> > ADComputeIncrementalShellStrain< compute_stage >::_phi_map

protected

Shape function value.

Definition at line 165 of file ADComputeIncrementalShellStrain.h.

_rot_num

template<ComputeStage compute_stage>

std::vector<unsigned int> ADComputeIncrementalShellStrain< compute_stage >::_rot_num

protected

Variable numbers corresponding to the rotational variables.

Definition at line 105 of file ADComputeIncrementalShellStrain.h.

Referenced by ADComputeIncrementalShellStrain< compute_stage >::ADComputeIncrementalShellStrain().

_rotation_matrix

template<ComputeStage compute_stage>

std::vector<MaterialProperty<RankTwoTensor> *> ADComputeIncrementalShellStrain< compute_stage >::_rotation_matrix

protected

Rotation matrix material property.

Definition at line 210 of file ADComputeIncrementalShellStrain.h.

Referenced by ADComputeIncrementalShellStrain< compute_stage >::ADComputeIncrementalShellStrain().

_sol

template<ComputeStage compute_stage>

const NumericVector<Number>* const & ADComputeIncrementalShellStrain< compute_stage >::_sol

protected

Definition at line 218 of file ADComputeIncrementalShellStrain.h.

_sol_old

template<ComputeStage compute_stage>

const NumericVector<Number>& ADComputeIncrementalShellStrain< compute_stage >::_sol_old

protected

Definition at line 219 of file ADComputeIncrementalShellStrain.h.

_soln_disp_index

template<ComputeStage compute_stage>

std::vector<std::vector<unsigned int> > ADComputeIncrementalShellStrain< compute_stage >::_soln_disp_index

protected

Indices of solution vector corresponding to displacement DOFs in 3 directions at the 4 nodes.

Definition at line 129 of file ADComputeIncrementalShellStrain.h.

_soln_rot_index

template<ComputeStage compute_stage>

std::vector<std::vector<unsigned int> > ADComputeIncrementalShellStrain< compute_stage >::_soln_rot_index

protected

Indices of solution vector corresponding to rotation DOFs in 2 directions at the 4 nodes.

Definition at line 132 of file ADComputeIncrementalShellStrain.h.

_soln_vector

template<ComputeStage compute_stage>

ADDenseVector ADComputeIncrementalShellStrain< compute_stage >::_soln_vector

protected

Vector that stores the incremental solution at all the 20 DOFs in the 4 noded element.

Definition at line 135 of file ADComputeIncrementalShellStrain.h.

_strain_increment

template<ComputeStage compute_stage>

std::vector<ADMaterialProperty(RankTwoTensor) *> ADComputeIncrementalShellStrain< compute_stage >::_strain_increment

protected

Strain increment in the covariant coordinate system.

Definition at line 117 of file ADComputeIncrementalShellStrain.h.

Referenced by ADComputeIncrementalShellStrain< compute_stage >::ADComputeIncrementalShellStrain().

_strain_vector

template<ComputeStage compute_stage>

ADDenseVector ADComputeIncrementalShellStrain< compute_stage >::_strain_vector

protected

Vector that stores the strain in the the 2 axial and 3 shear directions.

Definition at line 138 of file ADComputeIncrementalShellStrain.h.

_t_points

template<ComputeStage compute_stage>

std::vector<Point> ADComputeIncrementalShellStrain< compute_stage >::_t_points

protected

Quadrature points in the out of plane direction in isoparametric coordinate system.

Definition at line 153 of file ADComputeIncrementalShellStrain.h.

Referenced by ADComputeFiniteShellStrain< compute_stage >::ADComputeFiniteShellStrain(), and ADComputeIncrementalShellStrain< compute_stage >::ADComputeIncrementalShellStrain().

_t_qrule

template<ComputeStage compute_stage>

std::unique_ptr<QGauss> ADComputeIncrementalShellStrain< compute_stage >::_t_qrule

protected

Quadrature rule in the out of plane direction.

Definition at line 150 of file ADComputeIncrementalShellStrain.h.

Referenced by ADComputeIncrementalShellStrain< compute_stage >::ADComputeIncrementalShellStrain().

_thickness

template<ComputeStage compute_stage>

const VariableValue& ADComputeIncrementalShellStrain< compute_stage >::_thickness

protected

Coupled variable for the shell thickness.

Definition at line 111 of file ADComputeIncrementalShellStrain.h.

_total_global_strain

template<ComputeStage compute_stage>

std::vector<MaterialProperty<RankTwoTensor> *> ADComputeIncrementalShellStrain< compute_stage >::_total_global_strain

protected

Total strain in global coordinate system.

Definition at line 213 of file ADComputeIncrementalShellStrain.h.

Referenced by ADComputeIncrementalShellStrain< compute_stage >::ADComputeIncrementalShellStrain().

_total_strain

template<ComputeStage compute_stage>

std::vector<ADMaterialProperty(RankTwoTensor) *> ADComputeIncrementalShellStrain< compute_stage >::_total_strain

protected

Total strain increment in the covariant coordinate system.

Definition at line 120 of file ADComputeIncrementalShellStrain.h.

Referenced by ADComputeIncrementalShellStrain< compute_stage >::ADComputeIncrementalShellStrain().

_total_strain_old

template<ComputeStage compute_stage>

std::vector<const MaterialProperty<RankTwoTensor> *> ADComputeIncrementalShellStrain< compute_stage >::_total_strain_old

protected

Old total strain increment in the covariant coordinate system.

Definition at line 123 of file ADComputeIncrementalShellStrain.h.

Referenced by ADComputeIncrementalShellStrain< compute_stage >::ADComputeIncrementalShellStrain().

_unrotated_total_strain

template<ComputeStage compute_stage>

RankTwoTensor ADComputeIncrementalShellStrain< compute_stage >::_unrotated_total_strain

protected

Definition at line 228 of file ADComputeIncrementalShellStrain.h.

_v1

template<ComputeStage compute_stage>

std::vector<ADRealVectorValue> ADComputeIncrementalShellStrain< compute_stage >::_v1

protected

First tangential vectors at nodes.

Definition at line 186 of file ADComputeIncrementalShellStrain.h.

_v2

template<ComputeStage compute_stage>

std::vector<ADRealVectorValue> ADComputeIncrementalShellStrain< compute_stage >::_v2

protected

First tangential vectors at nodes.

Definition at line 189 of file ADComputeIncrementalShellStrain.h.

_x2

template<ComputeStage compute_stage>

ADRealVectorValue ADComputeIncrementalShellStrain< compute_stage >::_x2

protected

simulation variables

Definition at line 216 of file ADComputeIncrementalShellStrain.h.

Referenced by ADComputeIncrementalShellStrain< compute_stage >::ADComputeIncrementalShellStrain().

_x3

template<ComputeStage compute_stage>

ADRealVectorValue ADComputeIncrementalShellStrain< compute_stage >::_x3

protected

Definition at line 217 of file ADComputeIncrementalShellStrain.h.

Referenced by ADComputeIncrementalShellStrain< compute_stage >::ADComputeIncrementalShellStrain().

usingMaterialMembers

template<ComputeStage compute_stage>

ADComputeIncrementalShellStrain< compute_stage >::usingMaterialMembers

protected

Definition at line 230 of file ADComputeIncrementalShellStrain.h.

---

The documentation for this class was generated from the following files:

• tensor_mechanics/include/materials/ADComputeIncrementalShellStrain.h
• tensor_mechanics/src/materials/ADComputeIncrementalShellStrain.C