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,
      std::vector<std::vector<libMesh::FEBase *>> & fes,
      libMesh::FEType & fe_type,
      NearestNodeLocator & nearest_node,
      const std::map<dof_id_type, std::vector<dof_id_type>> & node_to_elem_map,
      const std::vector<std::tuple<dof_id_type, unsigned short int, boundary_id_type>> & bc_tuples);

  // 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;
  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::map<dof_id_type, std::vector<dof_id_type>> & _node_to_elem_map;

  // Each boundary condition tuple has three entries, (0=elem-id, 1=side-id, 2=bc-id)
  const std::vector<std::tuple<dof_id_type, unsigned short int, boundary_id_type>> & _bc_tuples;

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