Line data    Source code

       1             : //* This file is part of the MOOSE framework
       2             : //* https://mooseframework.inl.gov
       3             : //*
       4             : //* All rights reserved, see COPYRIGHT for full restrictions
       5             : //* https://github.com/idaholab/moose/blob/master/COPYRIGHT
       6             : //*
       7             : //* Licensed under LGPL 2.1, please see LICENSE for details
       8             : //* https://www.gnu.org/licenses/lgpl-2.1.html
       9             : 
      10             : #pragma once
      11             : 
      12             : #include "PenaltySimpleCohesiveZoneModel.h"
      13             : #include "TwoVector.h"
      14             : 
      15             : /**
      16             :  * User object that interface pressure resulting from a simple traction separation law.
      17             :  */
      18             : class BilinearMixedModeCohesiveZoneModel : virtual public PenaltyWeightedGapUserObject,
      19             :                                            virtual public WeightedVelocitiesUserObject,
      20             :                                            virtual public PenaltySimpleCohesiveZoneModel
      21             : {
      22             : public:
      23             :   static InputParameters validParams();
      24             : 
      25             :   BilinearMixedModeCohesiveZoneModel(const InputParameters & parameters);
      26             : 
      27             :   virtual const ADVariableValue & czmGlobalTraction(unsigned int i) const;
      28             : 
      29             :   virtual void initialize() override;
      30             :   virtual void finalize() override;
      31             :   virtual void reinit() override;
      32             :   virtual void timestepSetup() override;
      33             : 
      34             :   // Getters for analysis output
      35             :   Real getModeMixityRatio(const Node * const node) const;
      36             :   Real getCohesiveDamage(const Node * const node) const;
      37             :   Real getLocalDisplacementNormal(const Node * const node) const;
      38             :   Real getLocalDisplacementTangential(const Node * const node) const;
      39             : 
      40             : protected:
      41             :   virtual void computeQpProperties() override;
      42             :   virtual void computeQpIProperties() override;
      43             : 
      44       21273 :   virtual bool constrainedByOwner() const override { return false; }
      45             : 
      46             :   // Compute CZM kinematics.
      47             :   virtual void prepareJumpKinematicQuantities() override;
      48             :   virtual void computeFandR(const Node * const node) override;
      49             : 
      50             :   // @{
      51             :   // Compute CZM bilinear traction law.
      52             :   virtual void computeModeMixity(const Node * const node);
      53             :   virtual void computeCriticalDisplacementJump(const Node * const node);
      54             :   virtual void computeFinalDisplacementJump(const Node * const node);
      55             :   virtual void computeEffectiveDisplacementJump(const Node * const node);
      56             :   virtual void computeDamage(const Node * const node);
      57             :   // @}
      58             : 
      59             :   /// Encapsulate the CZM constitutive behavior.
      60             :   virtual void computeBilinearMixedModeTraction(const Node * const node) override;
      61             : 
      62             :   /// Compute global traction for mortar application
      63             :   virtual void computeGlobalTraction(const Node * const node) override;
      64             : 
      65             :   /// Normalize mortar quantities (remove mortar integral scaling)
      66             :   template <class T>
      67             :   T normalizeQuantity(const std::unordered_map<const DofObject *, T> & map,
      68             :                       const Node * const node);
      69             : 
      70             :   /// Number of displacement components
      71             :   const unsigned int _ndisp;
      72             : 
      73             :   /// Coupled displacement gradients
      74             :   std::vector<const GenericVariableGradient<true> *> _grad_disp;
      75             : 
      76             :   /// Coupled displacement and neighbor displacement gradient
      77             :   std::vector<const GenericVariableGradient<true> *> _grad_disp_neighbor;
      78             : 
      79             :   /// *** Kinematics/displacement jump quantities ***
      80             :   /// Map from degree of freedom to rotation matrix
      81             :   std::unordered_map<const DofObject *, ADRankTwoTensor> _dof_to_rotation_matrix;
      82             : 
      83             :   /// Map from degree of freedom to local displacement jump
      84             :   std::unordered_map<const DofObject *, ADRealVectorValue> _dof_to_interface_displacement_jump;
      85             : 
      86             :   /// Deformation gradient for interpolation
      87             :   ADRankTwoTensor _F_interpolation;
      88             : 
      89             :   /// Deformation gradient for interpolation of the neighbor projection
      90             :   ADRankTwoTensor _F_neighbor_interpolation;
      91             : 
      92             :   /// Map from degree of freedom to secondary, interpolated deformation gradient tensor
      93             :   std::unordered_map<const DofObject *, ADRankTwoTensor> _dof_to_F;
      94             : 
      95             :   /// Map from degree of freedom to neighbor, interpolated deformation gradient tensor
      96             :   std::unordered_map<const DofObject *, ADRankTwoTensor> _dof_to_F_neighbor;
      97             : 
      98             :   /// Map from degree of freedom to interface deformation gradient tensor
      99             :   std::unordered_map<const DofObject *, ADRankTwoTensor> _dof_to_interface_F;
     100             : 
     101             :   /// Map from degree of freedom to interface rotation tensor
     102             :   std::unordered_map<const DofObject *, ADRankTwoTensor> _dof_to_interface_R;
     103             : 
     104             :   /// Map from degree of freedom to mode mixity ratio (AD needed?)
     105             :   std::unordered_map<const DofObject *, ADReal> _dof_to_mode_mixity_ratio;
     106             : 
     107             :   /// The normal strength material property
     108             :   const MaterialProperty<Real> & _normal_strength;
     109             : 
     110             :   /// The shear strength material property
     111             :   const MaterialProperty<Real> & _shear_strength;
     112             : 
     113             :   /// Fracture parameter mode I
     114             :   const MaterialProperty<Real> & _GI_c;
     115             : 
     116             :   /// Fracture parameter mode II
     117             :   const MaterialProperty<Real> & _GII_c;
     118             : 
     119             :   /// Interpolated value of normal_strength
     120             :   ADReal _normal_strength_interpolation;
     121             : 
     122             :   /// Interpolated value of shear_strength
     123             :   ADReal _shear_strength_interpolation;
     124             : 
     125             :   /// Interpolated value of fracture paramter mode I
     126             :   ADReal _GI_c_interpolation;
     127             : 
     128             :   /// Interpolated value of fracture paramter mode II
     129             :   ADReal _GII_c_interpolation;
     130             : 
     131             :   // Penalty stiffness for bilinear traction model
     132             :   const Real _penalty_stiffness_czm;
     133             : 
     134             :   /// Mixed-mode propagation criterion
     135             :   enum class MixedModeCriterion
     136             :   {
     137             :     POWER_LAW,
     138             :     BK
     139             :   } _mix_mode_criterion;
     140             : 
     141             :   /// Power law parameter for bilinear traction model
     142             :   const Real _power_law_parameter;
     143             : 
     144             :   /// Viscosity for damage model
     145             :   const Real _viscosity;
     146             : 
     147             :   /// Parameter for the regularization of the Macaulay bracket
     148             :   const Real _regularization_alpha;
     149             : 
     150             :   /// The global traction
     151             :   std::vector<ADVariableValue> _czm_interpolated_traction;
     152             : 
     153             :   // @{
     154             :   // Strength material properties at the nodes
     155             :   std::unordered_map<const DofObject *, ADReal> _dof_to_normal_strength;
     156             :   std::unordered_map<const DofObject *, ADReal> _dof_to_shear_strength;
     157             :   // @}
     158             : 
     159             :   // @{
     160             :   // Fracture properties at the nodes
     161             :   std::unordered_map<const DofObject *, ADReal> _dof_to_GI_c;
     162             :   std::unordered_map<const DofObject *, ADReal> _dof_to_GII_c;
     163             :   // @}
     164             : 
     165             :   // @{
     166             :   // The parameters in the damage evolution law: Maps node to damage
     167             :   std::unordered_map<const DofObject *, ADReal> _dof_to_delta_initial;
     168             :   std::unordered_map<const DofObject *, ADReal> _dof_to_delta_final;
     169             :   std::unordered_map<const DofObject *, ADReal> _dof_to_delta_max;
     170             :   std::unordered_map<const DofObject *, std::pair<ADReal, Real>> _dof_to_damage;
     171             :   // @}
     172             : 
     173             :   /// Total Lagrangian stress to be applied on CZM interface
     174             :   std::unordered_map<const DofObject *, ADRealVectorValue> _dof_to_czm_traction;
     175             : 
     176             :   std::unordered_map<const DofObject *, ADRealVectorValue> _dof_to_displacement_jump;
     177             : };