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 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;
};