ComputeLagrangianStrainBase.h

Go to the documentation of this file.

//* This file is part of the MOOSE framework
//* https://mooseframework.inl.gov
//*
//* 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 "Material.h"
#include "RankFourTensorForward.h"
#include "RankTwoTensorForward.h"
#include "StabilizationUtils.h"
#include "GradientOperator.h"
#include "GuaranteeProvider.h"

template <class G>
class ComputeLagrangianStrainBase : public Material, public G, public GuaranteeProvider
{
public:
  static InputParameters baseParams();
  static InputParameters validParams();
  ComputeLagrangianStrainBase(const InputParameters & parameters);
  virtual void initialSetup() override;

  enum class KinematicApproximation
  {
    Linear,            
    Quadratic,         
    RashidApproximate, 
    RashidEigen        
  };

  enum class FBarMode
  {
    Total,
    Incremental
  };

protected:
  virtual void initQpStatefulProperties() override;
  virtual void computeProperties() override;
  virtual void computeQpProperties() override;
  virtual void computeQpIncrementalStrains(const RankTwoTensor & dL);
  void setQpIncrementalStrains(const RankTwoTensor & dd, const RankTwoTensor & dw);
  void computeQpLargeKinematicIncrement(const RankTwoTensor & f_inv,
                                        RankTwoTensor & dd,
                                        RankTwoTensor & dw,
                                        RankFourTensor & d_dL_d_f_inv,
                                        RankFourTensor & d_dw_d_f_inv,
                                        bool need_jacobian);
  void computeQpPolarDecomposition(bool need_jacobian);
  virtual void subtractQpEigenstrainIncrement(RankTwoTensor & strain);
  virtual void computeQpUnstabilizedDeformationGradient();
  virtual void computeQpActualDeformationGradient();
  virtual void computeDeformationGradient();

  // Displacements and displacement gradients
  const unsigned int _ndisp;
  std::vector<const VariableValue *> _disp;
  std::vector<const VariableGradient *> _grad_disp;
  std::vector<const VariableValue *> _disp_old;
  std::vector<const VariableGradient *> _grad_disp_old;

  const std::string _base_name;

  const bool _large_kinematics;

  const bool _stabilize_strain;

  const FBarMode _F_bar_mode;

  const bool _publish_rotation_increment;

  const Real _alpha;

  const KinematicApproximation _kinematic_approximation;

  // The eigenstrains
  std::vector<MaterialPropertyName> _eigenstrain_names;
  std::vector<const MaterialProperty<RankTwoTensor> *> _eigenstrains;
  std::vector<const MaterialProperty<RankTwoTensor> *> _eigenstrains_old;

  // The total strains
  MaterialProperty<RankTwoTensor> & _total_strain;
  const MaterialProperty<RankTwoTensor> & _total_strain_old;
  MaterialProperty<RankTwoTensor> & _mechanical_strain;
  const MaterialProperty<RankTwoTensor> & _mechanical_strain_old;

  MaterialProperty<RankTwoTensor> & _rotated_mechanical_strain;
  const MaterialProperty<RankTwoTensor> & _rotated_mechanical_strain_old;

  MaterialProperty<RankTwoTensor> & _strain_increment;

  MaterialProperty<RankTwoTensor> & _deformation_gradient_increment;

  MaterialProperty<RankTwoTensor> & _vorticity_increment;

  MaterialProperty<RankTwoTensor> & _F_ust;

  const MaterialProperty<RankTwoTensor> & _F_ust_old;

  MaterialProperty<RankTwoTensor> & _F_actual;

  // The average deformation gradient over the element for F-bar stabilization. Note that the
  // average deformation gradient is undefined if stabilization is not active.
  MaterialProperty<RankTwoTensor> & _F_avg;

  // The deformation gradient. If stabilization is active, this will be the stabilized deformation
  // gradient. Otherwise this will be equal to the unstabilized deformation gradient.
  MaterialProperty<RankTwoTensor> & _F;

  const MaterialProperty<RankTwoTensor> & _F_old;

  MaterialProperty<RankTwoTensor> & _F_inv;
  MaterialProperty<RankTwoTensor> & _f_inv;

  MaterialProperty<RankTwoTensor> & _F_ust_inv;
  MaterialProperty<Real> & _F_ust_det;

  MaterialProperty<RankFourTensor> & _d_deformation_gradient_increment_d_F;

  MaterialProperty<RankFourTensor> & _d_vorticity_increment_d_F;

  MaterialProperty<RankFourTensor> & _d_F_d_grad_u;

  MaterialProperty<RankTwoTensor> & _rotation;
  MaterialProperty<RankTwoTensor> & _stretch;
  MaterialProperty<RankFourTensor> & _d_rotation_d_F;

  MaterialProperty<RankFourTensor> & _d_F_stab_d_F_ust;

  MaterialProperty<RankFourTensor> & _d_F_stab_d_F_avg;

  std::vector<MaterialPropertyName> _homogenization_gradient_names;

  std::vector<const MaterialProperty<RankTwoTensor> *> _homogenization_contributions;

  MaterialProperty<RankTwoTensor> & _rotation_increment;

private:
  void computeLinearIncrement(const RankTwoTensor & f_inv,
                              RankTwoTensor & dd,
                              RankTwoTensor & dw,
                              RankFourTensor & d_dL_d_f_inv,
                              RankFourTensor & d_dw_d_f_inv,
                              bool need_jacobian) const;
  void computeQuadraticIncrement(const RankTwoTensor & f_inv,
                                 RankTwoTensor & dd,
                                 RankTwoTensor & dw,
                                 RankFourTensor & d_dL_d_f_inv,
                                 RankFourTensor & d_dw_d_f_inv,
                                 bool need_jacobian) const;
  void computeRashidApproximateIncrement(const RankTwoTensor & f_inv,
                                         RankTwoTensor & dd,
                                         RankTwoTensor & dw,
                                         RankFourTensor & d_dL_d_f_inv,
                                         RankFourTensor & d_dw_d_f_inv,
                                         bool need_jacobian) const;
  void computeRashidEigenIncrement(const RankTwoTensor & f_inv,
                                   RankTwoTensor & dd,
                                   RankTwoTensor & dw,
                                   RankFourTensor & d_dL_d_f_inv,
                                   RankFourTensor & d_dw_d_f_inv,
                                   bool need_jacobian) const;

  RankTwoTensor computeQpRotationIncrement(const RankTwoTensor & f_inv,
                                           const RankTwoTensor & dw) const;
};