PenaltyWeightedGapUserObject.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 "WeightedGapUserObject.h"
#include "AugmentedLagrangeInterface.h"
 
template <typename>
class MooseVariableFE;
class AugmentedLagrangianContactProblemInterface;
 
class PenaltyWeightedGapUserObject : virtual public WeightedGapUserObject,
                                     public AugmentedLagrangeInterface
{
public:
  static InputParameters validParams();
 
  PenaltyWeightedGapUserObject(const InputParameters & parameters);
 
  virtual void timestepSetup() override;
 
  virtual const ADVariableValue & contactPressure() const override;
  virtual ADReal nodalContactPressure(const Node & node) const override;
  virtual bool usesNodalNormalDerivatives() const override { return true; }
  virtual const VariableTestValue & tractionBasis() const override;
  virtual void initialize() override;
  virtual void finalize() override;
  virtual void reinit() override;
 
  virtual Real getNormalContactPressure(const Node * const node) const override;
  virtual Real getNormalLagrangeMultiplier(const Node * const node) const;
 
  virtual Real getDeltaTangentialLagrangeMultiplier(const Node * const, const unsigned int) const
  {
    return 0.0;
  };
  virtual bool getActiveSetState(const Node * const node) const
  {
    const auto it = _dof_to_normal_pressure.find(_subproblem.mesh().nodePtr(node->id()));
    return it != _dof_to_normal_pressure.end() && it->second > 0;
  }
 
  virtual bool isAugmentedLagrangianConverged() override;
  virtual void augmentedLagrangianSetup() override;
  virtual void updateAugmentedLagrangianMultipliers() override;
 
protected:
  virtual const VariableTestValue & test() const override;
  virtual bool constrainedByOwner() const override { return false; }
 
  void selfInitialize();
  void selfFinalize();
  void selfTimestepSetup();
 
  void
  bussettaAdaptivePenalty(const Real previous_gap, const Real gap, Real & penalty, Real & eval_tn);
 
  void adaptiveNormalPenalty(const Real previous_gap, const Real gap, Real & penalty);
 
  const Real _penalty;
 
  const Real _penalty_multiplier;
 
  const Real _penetration_tolerance;
 
  ADVariableValue _contact_pressure;
 
  std::unordered_map<const DofObject *, ADReal> _dof_to_normal_pressure;
 
  AugmentedLagrangianContactProblemInterface * const _augmented_lagrange_problem;
  const static unsigned int _no_iterations;
  const unsigned int & _lagrangian_iteration_number;
 
  std::unordered_map<dof_id_type, Real> & _dof_to_lagrange_multiplier;
 
  std::unordered_map<dof_id_type, Real> _dof_to_lagrange_multiplier_start;
 
  int & _t_step_old_normal;
 
  std::unordered_map<const DofObject *, Real> _dof_to_local_penalty;
 
  std::unordered_map<const DofObject *, Real> _dof_to_previous_gap;
 
  const Real & _dt;
 
  Real _dt_old;
 
  const bool _use_physical_gap;
 
  const MooseVariable * const _aux_lm_var;
 
  const Real _max_penalty_multiplier;
 
  const enum class AdaptivityNormalPenalty { SIMPLE, BUSSETTA } _adaptivity_normal;
};