WeightedGapUserObject.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 "MortarUserObject.h"
 
class WeightedGapUserObject : public MortarUserObject
{
public:
  static InputParameters validParams();
 
  static void addNodalNormalCoupling(InputParameters & params);
 
  WeightedGapUserObject(const InputParameters & parameters);
 
  virtual void initialize() override;
  virtual void execute() override;
  virtual void finalize() override;
  virtual void initialSetup() override;
 
  const std::unordered_map<const DofObject *, std::pair<ADReal, Real>> & dofToWeightedGap() const;
 
  virtual const ADVariableValue & contactPressure() const = 0;
 
  virtual ADReal nodalContactPressure(const Node & node) const;
 
  virtual const VariableTestValue & tractionBasis() const;
 
  virtual Real getNormalContactPressure(const Node * const /*node*/) const = 0;
 
  virtual Real getNormalGap(const Node * const /*node*/) const;
 
  virtual bool usesNodalNormalDerivatives() const = 0;
 
  bool shouldRecordNodalNormalDerivatives() const;
 
  const MooseVariable * dispVar(unsigned int component) const;
 
  const ADRealVectorValue & contactNormal(const Elem & lower_secondary_elem,
                                          unsigned int nodal_index) const;
 
  Real physicalGap(const std::pair<ADReal, Real> & gap) const
  {
    return MetaPhysicL::raw_value(gap.first) / gap.second;
  }
 
  virtual Real nodalScale(const DofObject * const /*dof*/) const { return 1; }
 
  virtual bool usesNodalScaling() const { return false; }
 
  virtual Real normalizeCDivisor(const DofObject * const /*dof*/,
                                 const Real covered_normalization) const
  {
    return covered_normalization;
  }
 
  ADReal adPhysicalGap(const std::pair<ADReal, Real> & gap) const { return gap.first / gap.second; }
 
  virtual Real getFrictionalContactPressure(const Node * const /*node*/,
                                            const unsigned int /*component*/) const
  {
    mooseError("Not available in base class.");
  }
 
  virtual Real getAccumulatedSlip(const Node * const /*node*/,
                                  const unsigned int /*component*/) const
  {
    mooseError("Not available in base class.");
  }
 
  virtual Real getTangentialVelocity(const Node * const /*node*/,
                                     const unsigned int /*component*/) const
  {
    mooseError("Not available in base class.");
  }
 
protected:
  virtual void computeQpProperties();
 
  virtual void computeQpIProperties();
 
  virtual const VariableTestValue & test() const = 0;
 
  virtual bool constrainedByOwner() const = 0;
 
  template <typename K, typename V>
  V
  findValue(const std::unordered_map<K, V> & map, const K & key, const V & default_value = 0) const
  {
    const auto it = map.find(key);
    if (it == map.end())
      return default_value;
    return it->second;
  }
 
  ADPoint nodalCoordinate(const Node & node) const;
 
  FEProblemBase & _fe_problem;
 
  ADReal _qp_gap;
 
  Real _qp_factor;
 
  const bool _nodal;
 
  const MooseVariable * const _disp_x_var;
  const MooseVariable * const _disp_y_var;
  const bool _has_disp_z;
  const MooseVariable * const _disp_z_var;
 
  const ADVariableValue & _secondary_disp_x;
  const ADVariableValue & _primary_disp_x;
  const ADVariableValue & _secondary_disp_y;
  const ADVariableValue & _primary_disp_y;
  const ADVariableValue * const _secondary_disp_z;
  const ADVariableValue * const _primary_disp_z;
 
  const MooseArray<Real> & _coord;
 
  ADRealVectorValue _qp_gap_nodal;
 
  ADRealVectorValue _qp_displacement_nodal;
 
  std::unordered_map<const DofObject *, std::pair<ADReal, Real>> _dof_to_weighted_gap;
 
  std::unordered_map<const DofObject *, ADRealVectorValue> _dof_to_weighted_displacements;
 
  const ADReal * _weighted_gap_ptr = nullptr;
  const Real * _normalization_ptr = nullptr;
 
  const VariableTestValue * _test = nullptr;
 
  mutable std::unordered_map<const Node *, ADRealVectorValue> _ad_nodal_normals;
 
  bool _is_weighted_gap_nodal = true;
 
  unsigned int _qp = 0;
 
  unsigned int _i = 0;
};
 
inline const std::unordered_map<const DofObject *, std::pair<ADReal, Real>> &
WeightedGapUserObject::dofToWeightedGap() const
{
  return _dof_to_weighted_gap;
}