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();

  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 Real getNormalContactPressure(const Node * const /*node*/) const = 0;

  virtual Real getNormalGap(const Node * const /*node*/) const;

  Real physicalGap(const std::pair<ADReal, Real> & gap) const
  {
    return MetaPhysicL::raw_value(gap.first) / gap.second;
  }

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

  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;

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