Line data    Source code

       1             : //* This file is part of the MOOSE framework
       2             : //* https://mooseframework.inl.gov
       3             : //*
       4             : //* All rights reserved, see COPYRIGHT for full restrictions
       5             : //* https://github.com/idaholab/moose/blob/master/COPYRIGHT
       6             : //*
       7             : //* Licensed under LGPL 2.1, please see LICENSE for details
       8             : //* https://www.gnu.org/licenses/lgpl-2.1.html
       9             : 
      10             : #pragma once
      11             : 
      12             : #include "MortarUserObject.h"
      13             : 
      14             : /**
      15             :  * Creates dof object to weighted gap map
      16             :  */
      17             : class WeightedGapUserObject : public MortarUserObject
      18             : {
      19             : public:
      20             :   static InputParameters validParams();
      21             : 
      22             :   WeightedGapUserObject(const InputParameters & parameters);
      23             : 
      24             :   virtual void initialize() override;
      25             :   virtual void execute() override;
      26             :   virtual void finalize() override;
      27             :   virtual void initialSetup() override;
      28             : 
      29             :   /**
      30             :    * Get the degree of freedom to weighted gap information
      31             :    */
      32             :   const std::unordered_map<const DofObject *, std::pair<ADReal, Real>> & dofToWeightedGap() const;
      33             : 
      34             :   /**
      35             :    * @return The contact force at quadrature points on the mortar segment
      36             :    */
      37             :   virtual const ADVariableValue & contactPressure() const = 0;
      38             : 
      39             :   /**
      40             :    * @param node Node pointer
      41             :    * @return The normal contact pressure at the node
      42             :    */
      43             :   virtual Real getNormalContactPressure(const Node * const /*node*/) const = 0;
      44             : 
      45             :   /**
      46             :    * @param node Node pointer
      47             :    * @return The normal gap at the node
      48             :    */
      49             :   virtual Real getNormalGap(const Node * const /*node*/) const;
      50             : 
      51             :   /**
      52             :    * Compute physical gap from integration gap quantity
      53             :    */
      54             :   Real physicalGap(const std::pair<ADReal, Real> & gap) const
      55             :   {
      56       29951 :     return MetaPhysicL::raw_value(gap.first) / gap.second;
      57             :   }
      58             : 
      59      108742 :   ADReal adPhysicalGap(const std::pair<ADReal, Real> & gap) const { return gap.first / gap.second; }
      60             : 
      61             :   /**
      62             :    * @param node Node pointer
      63             :    * @param component Component of the frictional pressure vector
      64             :    * @return The frictional contact pressure at the node
      65             :    */
      66           0 :   virtual Real getFrictionalContactPressure(const Node * const /*node*/,
      67             :                                             const unsigned int /*component*/) const
      68             :   {
      69           0 :     mooseError("Not available in base class.");
      70             :   }
      71             : 
      72             :   /**
      73             :    * @param node Node pointer
      74             :    * @param component Component of the local slip vector
      75             :    * @return The accumulated slip at the node
      76             :    */
      77           0 :   virtual Real getAccumulatedSlip(const Node * const /*node*/,
      78             :                                   const unsigned int /*component*/) const
      79             :   {
      80           0 :     mooseError("Not available in base class.");
      81             :   }
      82             : 
      83             :   /**
      84             :    * @param node Node pointer
      85             :    * @param component Component of the local slip vector
      86             :    * @return The tangential velocity at the node with local components
      87             :    */
      88           0 :   virtual Real getTangentialVelocity(const Node * const /*node*/,
      89             :                                      const unsigned int /*component*/) const
      90             :   {
      91           0 :     mooseError("Not available in base class.");
      92             :   }
      93             : 
      94             : protected:
      95             :   /**
      96             :    * Computes properties that are functions only of the current quadrature point (\p _qp), e.g.
      97             :    * indepedent of shape functions
      98             :    */
      99             :   virtual void computeQpProperties();
     100             : 
     101             :   /**
     102             :    * Computes properties that are functions both of \p _qp and \p _i, for example the weighted gap
     103             :    */
     104             :   virtual void computeQpIProperties();
     105             : 
     106             :   /**
     107             :    * @return The test function associated with the weighted gap
     108             :    */
     109             :   virtual const VariableTestValue & test() const = 0;
     110             : 
     111             :   /**
     112             :    * @return Whether the gap constraint will be enforced solely by the owner of the weighted gap or
     113             :    * will be enforced in a distributed way (like in a penalty method)
     114             :    */
     115             :   virtual bool constrainedByOwner() const = 0;
     116             : 
     117             :   /**
     118             :    * Find a value in a map or return a default if the key doesn't exist
     119             :    */
     120             :   template <typename K, typename V>
     121             :   V
     122      494958 :   findValue(const std::unordered_map<K, V> & map, const K & key, const V & default_value = 0) const
     123             :   {
     124             :     const auto it = map.find(key);
     125      494958 :     if (it == map.end())
     126      443430 :       return default_value;
     127       51528 :     return it->second;
     128             :   }
     129             : 
     130             :   /// The base finite element problem
     131             :   FEProblemBase & _fe_problem;
     132             : 
     133             :   /// The value of the gap at the current quadrature point
     134             :   ADReal _qp_gap;
     135             : 
     136             :   /// The value of the LM at the current quadrature point
     137             :   Real _qp_factor;
     138             : 
     139             :   /// Whether the dof objects are nodal; if they're not, then they're elemental
     140             :   const bool _nodal;
     141             : 
     142             :   /// The x displacement variable
     143             :   const MooseVariable * const _disp_x_var;
     144             :   /// The y displacement variable
     145             :   const MooseVariable * const _disp_y_var;
     146             :   /// For 2D mortar contact no displacement will be specified, so const pointers used
     147             :   const bool _has_disp_z;
     148             :   /// The z displacement variable
     149             :   const MooseVariable * const _disp_z_var;
     150             : 
     151             :   /// x-displacement on the secondary face
     152             :   const ADVariableValue & _secondary_disp_x;
     153             :   /// x-displacement on the primary face
     154             :   const ADVariableValue & _primary_disp_x;
     155             :   /// y-displacement on the secondary face
     156             :   const ADVariableValue & _secondary_disp_y;
     157             :   /// y-displacement on the primary face
     158             :   const ADVariableValue & _primary_disp_y;
     159             :   /// z-displacement on the secondary face
     160             :   const ADVariableValue * const _secondary_disp_z;
     161             :   /// z-displacement on the primary face
     162             :   const ADVariableValue * const _primary_disp_z;
     163             : 
     164             :   /// Member for handling change of coordinate systems (xyz, rz, spherical)
     165             :   const MooseArray<Real> & _coord;
     166             : 
     167             :   /// Vector for computation of weighted gap with nodal normals
     168             :   ADRealVectorValue _qp_gap_nodal;
     169             : 
     170             :   /// Vector for computation of relative displacement (determines mixity ratio in interface problems)
     171             :   ADRealVectorValue _qp_displacement_nodal;
     172             : 
     173             :   /// A map from node to weighted gap and normalization (if requested)
     174             :   std::unordered_map<const DofObject *, std::pair<ADReal, Real>> _dof_to_weighted_gap;
     175             : 
     176             :   /// A map from node to weighted displacements
     177             :   std::unordered_map<const DofObject *, ADRealVectorValue> _dof_to_weighted_displacements;
     178             : 
     179             :   /// A pointer members that can be used to help avoid copying ADReals
     180             :   const ADReal * _weighted_gap_ptr = nullptr;
     181             :   const Real * _normalization_ptr = nullptr;
     182             : 
     183             :   /// A pointer to the test function associated with the weighted gap. We have this member so that
     184             :   /// we don't do virtual calls during inner quadrature-point/test-function loops
     185             :   const VariableTestValue * _test = nullptr;
     186             : 
     187             :   /// Whether the weighted gap is associated with nodes or elements (like for a CONSTANT MONOMIAL
     188             :   /// Lagrange multiplier). We have this member so that we don't do virtual calls during inner
     189             :   /// quadrature-point/test-function loops
     190             :   bool _is_weighted_gap_nodal = true;
     191             : 
     192             :   /// Quadrature point index for the mortar segments
     193             :   unsigned int _qp = 0;
     194             : 
     195             :   /// Test function index
     196             :   unsigned int _i = 0;
     197             : };
     198             : 
     199             : inline const std::unordered_map<const DofObject *, std::pair<ADReal, Real>> &
     200             : WeightedGapUserObject::dofToWeightedGap() const
     201             : {
     202       34301 :   return _dof_to_weighted_gap;
     203             : }