CohesiveZoneModelBase.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 "TwoVector.h"
#include "PenaltyWeightedGapUserObject.h"
#include "WeightedVelocitiesUserObject.h"
#include "AugmentedLagrangeInterface.h"
 
class CohesiveZoneModelBase : virtual public PenaltyWeightedGapUserObject,
                              virtual public WeightedVelocitiesUserObject
{
public:
  static InputParameters validParams();
 
  CohesiveZoneModelBase(const InputParameters & parameters);
 
  virtual const ADVariableValue & contactTangentialPressureDirOne() const override;
  virtual const ADVariableValue & contactTangentialPressureDirTwo() const override;
 
  virtual void initialize() override;
  virtual void finalize() override;
  virtual void reinit() override;
  virtual ADReal nodalTangentialPressure(const Node & node, unsigned int direction) const override;
  virtual bool usesNodalNormalDerivatives() const override { return false; }
  virtual void timestepSetup() override;
  virtual const ADVariableValue & czmGlobalTraction(unsigned int i) const;
 
protected:
  virtual void computeQpProperties() override;
  virtual void computeQpIProperties() override;
 
  virtual const VariableTestValue & test() const override;
  virtual bool constrainedByOwner() const override { return false; }
 
  // Compute CZM kinematics.
  virtual void prepareJumpKinematicQuantities();
  virtual void computeFandR(const Node * const node);
 
  virtual void computeCZMTraction(const Node * const /*node*/) = 0;
 
  virtual void computeDamage(const Node * const /*node*/) = 0;
 
  virtual void computeGlobalTraction(const Node * const node);
 
  template <class T>
  T normalizeQuantity(const std::unordered_map<const DofObject *, T> & map, const Node * const node)
  {
    return libmesh_map_find(map, node) / _dof_to_weighted_gap[node].second;
  }
 
  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::vector<ADVariableValue> _czm_interpolated_traction;
 
  const Real _penalty_friction;
 
  const Real _friction_coefficient;
 
  std::unordered_map<const DofObject *, std::pair<ADTwoVector, TwoVector>> _dof_to_step_slip;
 
  std::unordered_map<dof_id_type, std::pair<ADTwoVector, TwoVector>> & _dof_to_accumulated_slip;
 
  // Map from degree of freedom to current and old tangential traction
  std::unordered_map<dof_id_type, std::pair<ADTwoVector, TwoVector>> & _dof_to_tangential_traction;
 
  ADVariableValue _frictional_contact_traction_one;
 
  ADVariableValue _frictional_contact_traction_two;
 
  std::unordered_map<const DofObject *, TwoVector> _dof_to_frictional_lagrange_multipliers;
 
  std::unordered_map<const DofObject *, Real> _dof_to_local_penalty_friction;
 
  const Real _epsilon_tolerance;
 
  std::unordered_map<const DofObject *, ADRealVectorValue> _dof_to_czm_traction;
 
  std::unordered_map<const DofObject *, ADRealVectorValue> _dof_to_displacement_jump;
 
  std::unordered_map<dof_id_type, std::pair<ADReal, Real>> & _dof_to_damage;
};