PenetrationThread.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 "MooseTypes.h"
#include "PenetrationLocator.h"
 
#include "libmesh/elem_side_builder.h"
 
// Forward declarations
template <typename>
class MooseVariableFE;
typedef MooseVariableFE<Real> MooseVariable;
typedef MooseVariableFE<libMesh::VectorValue<Real>> VectorMooseVariable;
 
class PenetrationThread
{
public:
  PenetrationThread(
      SubProblem & subproblem,
      const MooseMesh & mesh,
      BoundaryID primary_boundary,
      BoundaryID secondary_boundary,
      std::map<dof_id_type, PenetrationInfo *> & penetration_info,
      bool check_whether_reasonable,
      bool update_location,
      Real tangential_tolerance,
      bool do_normal_smoothing,
      Real normal_smoothing_distance,
      PenetrationLocator::NORMAL_SMOOTHING_METHOD normal_smoothing_method,
      bool use_point_locator,
      std::vector<std::vector<libMesh::FEBase *>> & fes,
      libMesh::FEType & fe_type,
      NearestNodeLocator & nearest_node,
      const std::unordered_map<dof_id_type, std::vector<dof_id_type>> & node_to_elem_map);
 
  // Splitting Constructor
  PenetrationThread(PenetrationThread & x, Threads::split split);
 
  void operator()(const NodeIdRange & range);
 
  void join(const PenetrationThread & other);
 
  std::vector<dof_id_type> _recheck_secondary_nodes;
 
protected:
  SubProblem & _subproblem;
  // The Mesh
  const MooseMesh & _mesh;
  BoundaryID _primary_boundary;
  BoundaryID _secondary_boundary;
 
  // This is the info map we're actually filling here
  std::map<dof_id_type, PenetrationInfo *> & _penetration_info;
 
  bool _check_whether_reasonable;
  bool _update_location;
  Real _tangential_tolerance;
  bool _do_normal_smoothing;
  Real _normal_smoothing_distance;
  PenetrationLocator::NORMAL_SMOOTHING_METHOD _normal_smoothing_method;
  bool _use_point_locator;
  MooseVariable * _nodal_normal_x;
  MooseVariable * _nodal_normal_y;
  MooseVariable * _nodal_normal_z;
 
  std::vector<std::vector<libMesh::FEBase *>> & _fes;
 
  libMesh::FEType & _fe_type;
 
  NearestNodeLocator & _nearest_node;
 
  const std::unordered_map<dof_id_type, std::vector<dof_id_type>> & _node_to_elem_map;
 
  THREAD_ID _tid;
 
  libMesh::ElemSideBuilder _elem_side_builder;
 
  enum CompeteInteractionResult
  {
    FIRST_WINS,
    SECOND_WINS,
    NEITHER_WINS
  };
 
  enum CommonEdgeResult
  {
    NO_COMMON,
    COMMON_EDGE,
    COMMON_NODE,
    EDGE_AND_COMMON_NODE
  };
 
  CompeteInteractionResult competeInteractions(PenetrationInfo * pi1, PenetrationInfo * pi2);
 
  CompeteInteractionResult competeInteractionsBothOnFace(PenetrationInfo * pi1,
                                                         PenetrationInfo * pi2);
 
  CommonEdgeResult interactionsOffCommonEdge(PenetrationInfo * pi1, PenetrationInfo * pi2);
 
  bool findRidgeContactPoint(libMesh::Point & contact_point,
                             Real & tangential_distance,
                             const Node *& closest_node,
                             unsigned int & index,
                             libMesh::Point & contact_point_ref,
                             std::vector<PenetrationInfo *> & p_info,
                             const unsigned int index1,
                             const unsigned int index2);
 
  void getSideCornerNodes(const Elem * side, std::vector<const Node *> & corner_nodes);
 
  bool restrictPointToSpecifiedEdgeOfFace(libMesh::Point & p,
                                          const Node *& closest_node,
                                          const Elem * side,
                                          const std::vector<const Node *> & edge_nodes);
  bool restrictPointToFace(libMesh::Point & p, const Node *& closest_node, const Elem * side);
 
  bool isFaceReasonableCandidate(const Elem * primary_elem,
                                 const Elem * side,
                                 libMesh::FEBase * fe,
                                 const libMesh::Point * secondary_point,
                                 const Real tangential_tolerance);
 
  void
  smoothNormal(PenetrationInfo * info, std::vector<PenetrationInfo *> & p_info, const Node & node);
 
  void getSmoothingFacesAndWeights(PenetrationInfo * info,
                                   std::vector<PenetrationInfo *> & edge_face_info,
                                   std::vector<Real> & edge_face_weights,
                                   std::vector<PenetrationInfo *> & p_info,
                                   const Node & secondary_node);
  void getSmoothingEdgeNodesAndWeights(const libMesh::Point & p,
                                       const Elem * side,
                                       std::vector<std::vector<const Node *>> & edge_nodes,
                                       std::vector<Real> & edge_face_weights);
 
  void getInfoForFacesWithCommonNodes(const Node * secondary_node,
                                      const std::set<dof_id_type> & elems_to_exclude,
                                      const std::vector<const Node *> edge_nodes,
                                      std::vector<PenetrationInfo *> & face_info_comm_edge,
                                      std::vector<PenetrationInfo *> & p_info);
 
  void getInfoForElem(std::vector<PenetrationInfo *> & thisElemInfo,
                      std::vector<PenetrationInfo *> & p_info,
                      const Elem * elem);
 
  void createInfoForElem(std::vector<PenetrationInfo *> & thisElemInfo,
                         std::vector<PenetrationInfo *> & p_info,
                         const Node * secondary_node,
                         const Elem * elem,
                         const std::vector<const Node *> & nodes_that_must_be_on_side,
                         const bool check_whether_reasonable = false);
 
  void getSidesOnPrimaryBoundary(std::vector<unsigned int> & sides, const Elem * const elem);
 
  void computeSlip(libMesh::FEBase & fe, PenetrationInfo & info);
 
  void switchInfo(PenetrationInfo *& info, PenetrationInfo *& infoNew);
 
  struct RidgeData
  {
    unsigned int _index;
    libMesh::Point _closest_coor;
    libMesh::Point _closest_coor_ref;
    Real _tangential_distance;
    const Node * _closest_node;
  };
 
  struct RidgeSetData
  {
    Real _distance;
    libMesh::Point _closest_coor;
    const Node * _closest_node;
    std::vector<RidgeData> _ridge_data_vec;
  };
};