BilinearMixedModeCohesiveZoneModel.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 "PenaltySimpleCohesiveZoneModel.h"
#include "TwoVector.h"

class BilinearMixedModeCohesiveZoneModel : virtual public PenaltyWeightedGapUserObject,
                                           virtual public WeightedVelocitiesUserObject,
                                           virtual public PenaltySimpleCohesiveZoneModel
{
public:
  static InputParameters validParams();

  BilinearMixedModeCohesiveZoneModel(const InputParameters & parameters);

  virtual const ADVariableValue & czmGlobalTraction(unsigned int i) const;

  virtual void initialize() override;
  virtual void finalize() override;
  virtual void reinit() override;
  virtual void timestepSetup() override;

  // Getters for analysis output
  Real getModeMixityRatio(const Node * const node) const;
  Real getCohesiveDamage(const Node * const node) const;
  Real getLocalDisplacementNormal(const Node * const node) const;
  Real getLocalDisplacementTangential(const Node * const node) const;

protected:
  virtual void computeQpProperties() override;
  virtual void computeQpIProperties() override;

  virtual bool constrainedByOwner() const override { return false; }

  // Compute CZM kinematics.
  virtual void prepareJumpKinematicQuantities() override;
  virtual void computeFandR(const Node * const node) override;

  // @{
  // Compute CZM bilinear traction law.
  virtual void computeModeMixity(const Node * const node);
  virtual void computeCriticalDisplacementJump(const Node * const node);
  virtual void computeFinalDisplacementJump(const Node * const node);
  virtual void computeEffectiveDisplacementJump(const Node * const node);
  virtual void computeDamage(const Node * const node);
  // @}

  virtual void computeBilinearMixedModeTraction(const Node * const node) override;

  virtual void computeGlobalTraction(const Node * const node) override;

  template <class T>
  T normalizeQuantity(const std::unordered_map<const DofObject *, T> & map,
                      const Node * const node);

  const unsigned int _ndisp;

  std::vector<const GenericVariableGradient<true> *> _grad_disp;

  std::vector<const GenericVariableGradient<true> *> _grad_disp_neighbor;

  std::unordered_map<const DofObject *, ADRankTwoTensor> _dof_to_rotation_matrix;

  std::unordered_map<const DofObject *, ADRealVectorValue> _dof_to_interface_displacement_jump;

  ADRankTwoTensor _F_interpolation;

  ADRankTwoTensor _F_neighbor_interpolation;

  std::unordered_map<const DofObject *, ADRankTwoTensor> _dof_to_F;

  std::unordered_map<const DofObject *, ADRankTwoTensor> _dof_to_F_neighbor;

  std::unordered_map<const DofObject *, ADRankTwoTensor> _dof_to_interface_F;

  std::unordered_map<const DofObject *, ADRankTwoTensor> _dof_to_interface_R;

  std::unordered_map<const DofObject *, ADReal> _dof_to_mode_mixity_ratio;

  const MaterialProperty<Real> & _normal_strength;

  const MaterialProperty<Real> & _shear_strength;

  const MaterialProperty<Real> & _GI_c;

  const MaterialProperty<Real> & _GII_c;

  ADReal _normal_strength_interpolation;

  ADReal _shear_strength_interpolation;

  ADReal _GI_c_interpolation;

  ADReal _GII_c_interpolation;

  // Penalty stiffness for bilinear traction model
  const Real _penalty_stiffness_czm;

  enum class MixedModeCriterion
  {
    POWER_LAW,
    BK
  } _mix_mode_criterion;

  const Real _power_law_parameter;

  const Real _viscosity;

  const Real _regularization_alpha;

  std::vector<ADVariableValue> _czm_interpolated_traction;

  // @{
  // Strength material properties at the nodes
  std::unordered_map<const DofObject *, ADReal> _dof_to_normal_strength;
  std::unordered_map<const DofObject *, ADReal> _dof_to_shear_strength;
  // @}

  // @{
  // Fracture properties at the nodes
  std::unordered_map<const DofObject *, ADReal> _dof_to_GI_c;
  std::unordered_map<const DofObject *, ADReal> _dof_to_GII_c;
  // @}

  // @{
  // The parameters in the damage evolution law: Maps node to damage
  std::unordered_map<const DofObject *, ADReal> _dof_to_delta_initial;
  std::unordered_map<const DofObject *, ADReal> _dof_to_delta_final;
  std::unordered_map<const DofObject *, ADReal> _dof_to_delta_max;
  std::unordered_map<const DofObject *, std::pair<ADReal, Real>> _dof_to_damage;
  // @}

  std::unordered_map<const DofObject *, ADRealVectorValue> _dof_to_czm_traction;

  std::unordered_map<const DofObject *, ADRealVectorValue> _dof_to_displacement_jump;
};