MechanicalContactConstraint.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

// MOOSE includes
#include "NodeFaceConstraint.h"
#include "PenetrationLocator.h"

// Forward Declarations
class ContactLineSearchBase;
class AugmentedLagrangianContactProblemInterface;
enum class ContactModel;
enum class ContactFormulation;
class DisplacedProblem;

class MechanicalContactConstraint : public NodeFaceConstraint
{
public:
  static InputParameters validParams();

  MechanicalContactConstraint(const InputParameters & parameters);

  virtual void timestepSetup() override;
  virtual void jacobianSetup() override;
  virtual void residualEnd() override;

  virtual bool AugmentedLagrangianContactConverged();

  virtual void updateAugmentedLagrangianMultiplier(bool beginning_of_step);
  virtual void updateContactStatefulData(bool beginning_of_step);

  virtual Real computeQpSecondaryValue() override;

  virtual Real computeQpResidual(Moose::ConstraintType type) override;

  virtual void computeJacobian() override;

  virtual void computeOffDiagJacobian(unsigned int jvar) override;

  virtual Real computeQpJacobian(Moose::ConstraintJacobianType type) override;

  virtual Real computeQpOffDiagJacobian(Moose::ConstraintJacobianType type,
                                        unsigned int jvar) override;

  virtual void getConnectedDofIndices(unsigned int var_num) override;

  bool getCoupledVarComponent(unsigned int var_num, unsigned int & component);

  virtual bool addCouplingEntriesToJacobian() override { return _primary_secondary_jacobian; }

  bool shouldApply() override;
  void computeContactForce(const Node & node, PenetrationInfo * pinfo, bool update_contact_set);

protected:
  MooseSharedPointer<DisplacedProblem> _displaced_problem;
  Real gapOffset(const Node & node);
  Real nodalArea(const Node & node);
  Real getPenalty(const Node & node);
  Real getTangentialPenalty(const Node & node);

  const unsigned int _component;
  const ContactModel _model;
  const ContactFormulation _formulation;
  const bool _normalize_penalty;

  const Real _penalty;
  const Real _penalty_multiplier;
  Real _penalty_tangential;
  const Real _friction_coefficient;
  const Real _tension_release;
  const Real _capture_tolerance;
  const unsigned int _stick_lock_iterations;
  const Real _stick_unlock_factor;
  bool _update_stateful_data;

  NumericVector<Number> & _residual_copy;
  //  std::map<Point, PenetrationInfo *> _point_to_info;

  const unsigned int _mesh_dimension;

  std::vector<unsigned int> _vars;
  std::vector<MooseVariable *> _var_objects;

  const bool _has_secondary_gap_offset;
  const MooseVariable * const _secondary_gap_offset_var;
  const bool _has_mapped_primary_gap_offset;
  const MooseVariable * const _mapped_primary_gap_offset_var;

  MooseVariable * _nodal_area_var;
  SystemBase & _aux_system;
  const NumericVector<Number> * const _aux_solution;

  const bool _primary_secondary_jacobian;
  const bool _connected_secondary_nodes_jacobian;
  const bool _non_displacement_vars_jacobian;

  Real _al_penetration_tolerance;
  Real _al_incremental_slip_tolerance;
  Real _al_frictional_force_tolerance;

  ContactLineSearchBase * _contact_linesearch;
  std::set<dof_id_type> _current_contact_state;
  std::set<dof_id_type> _old_contact_state;

  const bool _print_contact_nodes;
  static Threads::spin_mutex _contact_set_mutex;

  AugmentedLagrangianContactProblemInterface * const _augmented_lagrange_problem;
  const static unsigned int _no_iterations;
  const unsigned int & _lagrangian_iteration_number;

  DenseMatrix<Number> _Knn;
  DenseMatrix<Number> _Ken;
};