ADComputeIncrementalShellStrain.h

Go to the documentation of this file.

//* This file is part of the MOOSE framework
//* https://www.mooseframework.org
//*
//* All rights reserved, see COPYRIGHT for full restrictions
//* https://github.com/idaholab/moose/blob/master/COPYRIGHT
//*
//* Licensed under LGPL 2.1, please see LICENSE for details
//* https://www.gnu.org/licenses/lgpl-2.1.html
 
#pragma once
 
#include "ADMaterial.h"
#include "libmesh/dense_matrix.h"
 
#define usingComputeIncrementalShellStrainMembers                                                  \
  usingMaterialMembers;                                                                            \
  using ADComputeIncrementalShellStrain<compute_stage>::_t_points;                                 \
  using ADComputeIncrementalShellStrain<compute_stage>::_2d_points;                                \
  using ADComputeIncrementalShellStrain<compute_stage>::_nodes;                                    \
  using ADComputeIncrementalShellStrain<compute_stage>::_ge;                                       \
  using ADComputeIncrementalShellStrain<compute_stage>::_ge_old;                                   \
  using ADComputeIncrementalShellStrain<compute_stage>::_J_map;                                    \
  using ADComputeIncrementalShellStrain<compute_stage>::_J_map_old;                                \
  using ADComputeIncrementalShellStrain<compute_stage>::_node_normal;                              \
  using ADComputeIncrementalShellStrain<compute_stage>::_node_normal_old;                          \
  using ADComputeIncrementalShellStrain<compute_stage>::_strain_vector;                            \
  using ADComputeIncrementalShellStrain<compute_stage>::_soln_vector;                              \
  using ADComputeIncrementalShellStrain<compute_stage>::_B;                                        \
  using ADComputeIncrementalShellStrain<compute_stage>::_strain_increment;                         \
  using ADComputeIncrementalShellStrain<compute_stage>::_total_strain;                             \
  using ADComputeIncrementalShellStrain<compute_stage>::_total_strain_old;                         \
  using ADComputeIncrementalShellStrain<compute_stage>::_v1;                                       \
  using ADComputeIncrementalShellStrain<compute_stage>::_v2;                                       \
  using ADComputeIncrementalShellStrain<compute_stage>::_dxyz_dxi;                                 \
  using ADComputeIncrementalShellStrain<compute_stage>::_dxyz_deta;                                \
  using ADComputeIncrementalShellStrain<compute_stage>::_dxyz_dzeta;                               \
  using ADComputeIncrementalShellStrain<compute_stage>::_thickness;                                \
  using ADComputeIncrementalShellStrain<compute_stage>::_dphidxi_map;                              \
  using ADComputeIncrementalShellStrain<compute_stage>::_dphideta_map;                             \
  using ADComputeIncrementalShellStrain<compute_stage>::_phi_map;                                  \
  using ADComputeIncrementalShellStrain<compute_stage>::_g1_a;                                     \
  using ADComputeIncrementalShellStrain<compute_stage>::_g1_c;                                     \
  using ADComputeIncrementalShellStrain<compute_stage>::_g2_b;                                     \
  using ADComputeIncrementalShellStrain<compute_stage>::_g2_d;                                     \
  using ADComputeIncrementalShellStrain<compute_stage>::_soln_disp_index;                          \
  using ADComputeIncrementalShellStrain<compute_stage>::_soln_rot_index;                           \
  using ADComputeIncrementalShellStrain<compute_stage>::_sol_old;                                  \
  using ADComputeIncrementalShellStrain<compute_stage>::computeBMatrix;                            \
  using ADComputeIncrementalShellStrain<compute_stage>::computeSolnVector;                         \
  using ADComputeIncrementalShellStrain<compute_stage>::updateGVectors;                            \
  using ADComputeIncrementalShellStrain<compute_stage>::updatedxyz;                                \
  using ADComputeIncrementalShellStrain<compute_stage>::computeGMatrix
 
// Forward Declarations
template <ComputeStage>
class ADComputeIncrementalShellStrain;
 
namespace libMesh
{
class QGauss;
}
 
template <typename>
class RankTwoTensorTempl;
typedef RankTwoTensorTempl<Real> RankTwoTensor;
typedef RankTwoTensorTempl<DualReal> DualRankTwoTensor;
 
declareADValidParams(ADComputeIncrementalShellStrain);
 
template <ComputeStage compute_stage>
class ADComputeIncrementalShellStrain : public ADMaterial<compute_stage>
{
public:
  ADComputeIncrementalShellStrain(const InputParameters & parameters);
 
protected:
  virtual void initQpStatefulProperties() override;
  virtual void computeProperties() override;
 
  virtual void computeSolnVector();
 
  virtual void computeBMatrix();
 
  virtual void computeNodeNormal();
 
  virtual void updateGVectors(){};
 
  virtual void updatedxyz(){};
 
  virtual void computeGMatrix();
 
  unsigned int _nrot;
 
  unsigned int _ndisp;
 
  std::vector<unsigned int> _rot_num;
 
  std::vector<unsigned int> _disp_num;
 
  const VariableValue & _thickness;
 
  const bool _large_strain;
 
  std::vector<ADMaterialProperty(RankTwoTensor) *> _strain_increment;
 
  std::vector<ADMaterialProperty(RankTwoTensor) *> _total_strain;
 
  std::vector<const MaterialProperty<RankTwoTensor> *> _total_strain_old;
 
  NonlinearSystemBase & _nonlinear_sys;
 
  std::vector<std::vector<unsigned int>> _soln_disp_index;
 
  std::vector<std::vector<unsigned int>> _soln_rot_index;
 
  ADDenseVector _soln_vector;
 
  ADDenseVector _strain_vector;
 
  std::vector<const Node *> _nodes;
 
  ADMaterialProperty(RealVectorValue) & _node_normal;
 
  const MaterialProperty<RealVectorValue> & _node_normal_old;
 
  std::unique_ptr<QGauss> _t_qrule;
 
  std::vector<Point> _t_points;
 
  std::vector<Point> _2d_points;
 
  std::vector<std::vector<Real>> _dphidxi_map;
 
  std::vector<std::vector<Real>> _dphideta_map;
 
  std::vector<std::vector<Real>> _phi_map;
 
  std::vector<ADMaterialProperty(RealVectorValue) *> _dxyz_dxi;
 
  std::vector<ADMaterialProperty(RealVectorValue) *> _dxyz_deta;
 
  std::vector<ADMaterialProperty(RealVectorValue) *> _dxyz_dzeta;
 
  std::vector<const MaterialProperty<RealVectorValue> *> _dxyz_dxi_old;
 
  std::vector<const MaterialProperty<RealVectorValue> *> _dxyz_deta_old;
 
  std::vector<const MaterialProperty<RealVectorValue> *> _dxyz_dzeta_old;
 
  std::vector<ADRealVectorValue> _v1;
 
  std::vector<ADRealVectorValue> _v2;
 
  std::vector<ADMaterialProperty(DenseMatrix<Real>) *> _B;
 
  std::vector<const MaterialProperty<DenseMatrix<Real>> *> _B_old;
 
  std::vector<ADMaterialProperty(RankTwoTensor) *> _ge;
 
  std::vector<const MaterialProperty<RankTwoTensor> *> _ge_old;
 
  std::vector<ADMaterialProperty(Real) *> _J_map;
 
  std::vector<const MaterialProperty<Real> *> _J_map_old;
 
  std::vector<MaterialProperty<RankTwoTensor> *> _rotation_matrix;
 
  std::vector<MaterialProperty<RankTwoTensor> *> _total_global_strain;
 
  ADRealVectorValue _x2;
  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;
};