GeometricSearchData.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"
 
// libMesh includes
#include "libmesh/enum_order.h"
 
// C++ includes
#include <map>
 
// Forward Declarations
class MooseMesh;
class SubProblem;
class PenetrationLocator;
class NearestNodeLocator;
class ElementPairLocator;
 
class GeometricSearchData
{
public:
  enum GeometricSearchType
  {
    ALL,
    NEAREST_NODE,
    PENETRATION,
    QUADRATURE,
    ELEMENTPAIR
  };
 
  GeometricSearchData(SubProblem & subproblem, MooseMesh & mesh);
  virtual ~GeometricSearchData();
 
  PenetrationLocator & getPenetrationLocator(const BoundaryName & primary,
                                             const BoundaryName & secondary,
                                             libMesh::Order order = libMesh::FIRST);
  PenetrationLocator & getQuadraturePenetrationLocator(const BoundaryName & primary,
                                                       const BoundaryName & secondary,
                                                       libMesh::Order order = libMesh::FIRST);
 
  NearestNodeLocator & getNearestNodeLocator(const BoundaryName & primary,
                                             const BoundaryName & secondary);
  NearestNodeLocator & getNearestNodeLocator(const BoundaryID primary_id,
                                             const BoundaryID secondary_id);
 
  NearestNodeLocator & getQuadratureNearestNodeLocator(const BoundaryName & primary,
                                                       const BoundaryName & secondary);
  NearestNodeLocator & getQuadratureNearestNodeLocator(const BoundaryID primary_id,
                                                       const BoundaryID secondary_id);
 
  const std::map<std::pair<BoundaryID, BoundaryID>, PenetrationLocator *> &
  getPenetrationLocators() const
  {
    return _penetration_locators;
  }
 
  void addElementPairLocator(BoundaryID interface_id, std::shared_ptr<ElementPairLocator> epl);
 
  void setSearchUsingPointLocator(bool state);
 
  void update(GeometricSearchType type = ALL);
 
  void reinit();
 
  void clearNearestNodeLocators();
 
  Real maxPatchPercentage();
 
  void updateGhostedElems();
 
  // protected:
  SubProblem & _subproblem;
  MooseMesh & _mesh;
  std::map<std::pair<BoundaryID, BoundaryID>, PenetrationLocator *> _penetration_locators;
  std::map<std::pair<BoundaryID, BoundaryID>, NearestNodeLocator *> _nearest_node_locators;
  std::map<BoundaryID, std::shared_ptr<ElementPairLocator>> _element_pair_locators;
 
protected:
  std::set<BoundaryID> _quadrature_boundaries;
 
  std::map<BoundaryID, BoundaryID> _secondary_to_qsecondary;
 
private:
  void generateQuadratureNodes(const BoundaryID secondary_id,
                               const BoundaryID qsecondary_id,
                               bool reiniting = false);
 
  void updateQuadratureNodes(const BoundaryID secondary_id);
 
  void reinitQuadratureNodes(const BoundaryID secondary_id);
 
  bool _first;
 
  bool _search_using_point_locator;
};