AdaptiveRayContainmentCheck.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 "MooseMesh.h"
#include "libmesh/point.h"
#include "SurfaceElement.h"
#include "SurfaceSide.h"
#include "KDTree.h"
#include "OrientedBoundingBox.h"
#include "RayDirectionOptions.h"
#include "MooseError.h"
 
#include <array>
#include <optional>
 
class Ball;
 
class AdaptiveRayContainmentCheck final
{
public:
  AdaptiveRayContainmentCheck(const std::vector<std::unique_ptr<SurfaceElement>> & bd_elements,
                              const std::vector<Point> & centroids,
                              const SurfaceGeometry::RayDirectionOptions & ray_options,
                              const Real eps_on_surface = libMesh::TOLERANCE,
                              const int leaf_max_size = 10,
                              const FileName & obb_file_name = "",
                              const FileName & ray_file_name = "",
                              const libMesh::Parallel::Communicator * comm = nullptr);
 
  SurfaceGeometry::SurfaceSide sideness(const Point & p) const;
 
  const Point & rayDirection() const { return _ray_direction; }
 
private:
  Point _centroid_nodal_points;
 
  std::vector<Point> _projected_centroids;
 
  std::unique_ptr<KDTree> _kd_tree;
 
  Real _max_projected_diag_length;
 
  const std::vector<std::unique_ptr<SurfaceElement>> & _bd_elements;
 
  const std::vector<Point> & _centroids;
 
  int _dim = -1;
 
  std::size_t _num_elements = 0;
 
  Point _ray_direction;
 
  Real _eps_on_surface;
 
  int _leaf_max_size;
 
  FileName _obb_file_name;
 
  FileName _ray_file_name;
 
  const libMesh::Parallel::Communicator * _comm = nullptr;
 
  OrientedBoundingBox _obb_bounds;
 
  BoundingBox _bounds;
 
  bool _auto_ray_direction = false;
 
  bool _build_obb = false;
 
  Point _plane_origin = Point(0.0, 0.0, 0.0);
 
  Point _max_variance_vector;
 
  Point _second_variance_vector;
 
  Point _min_variance_vector;
 
  bool rayIntersectGeometry(const Point & ray_start,
                            const Point & ray_end,
                            const SurfaceElement * elem) const;
 
  bool isOutsideBoundingBox(const Point & query_point) const;
 
  bool isOutsideRayBBox(const Point & orig, const Point & dir, const Ball & ball) const;
 
  bool isOutsideBoundingRegion(const Point & orig, const Point & dir, const Ball & ball) const;
 
  BoundingBox computeGlobalBoundingBox();
 
  // Perform Principal Component Analysis (PCA) using Singular Value Decomposition (SVD)
  // to compute the principal directions:
  // - _max_variance_vector: Direction with the largest variance (first principal component).
  // - _second_variance_vector: Direction with the second-largest variance (second principal
  // component).
  // - _min_variance_vector: Direction with the smallest variance (typically the surface normal).
  void preparePCASVD();
 
  void initializeRayDirection();
 
  std::optional<SurfaceGeometry::SurfaceSide>
  sidenessFromRayPair(const Point & p, const std::array<Point, 2> & ray_starts) const;
 
  bool isOnSurface(const Point & p) const;
 
  int countCrossings(const Point & ray_start,
                     const Point & ray_end,
                     const bool use_primary_direction = true) const;
 
  template <typename CrossingTest>
  int countFilteredCrossings(const Point & ray_start,
                             const Point & ray_end,
                             const bool use_primary_direction,
                             CrossingTest is_crossing) const;
 
  int countCrossings2D(const Point & ray_start,
                       const Point & ray_end,
                       const bool use_primary_direction) const;
 
  Point
  rayStartOutsideAABB(const Point & point, const Point & unit_direction, const bool inverted) const;
 
  Point rayStartOutsideOBB(const Point & point,
                           const Point & ray_direction,
                           const unsigned int obb_axis,
                           const bool inverted = false) const;
 
  Point projectPointOntoPlane(const Point & point_to_project,
                              const Point & plane_point,
                              const Point & plane_normal) const;
 
  void buildObbKdtreeAndMaxProjectedDiagonal(const Real expand_box_length);
 
  std::vector<unsigned int> collectCandidateElementIDs(const Point & query_point) const;
};