utils.h

// Copyright (C) 2019-2021 Garth N. Wells and Jørgen S. Dokken
//
// This file is part of DOLFINx (https://www.fenicsproject.org)
//
// SPDX-License-Identifier:    LGPL-3.0-or-later
 
#pragma once
 
#include <array>
#include <cstdint>
#include <dolfinx/graph/AdjacencyList.h>
#include <span>
#include <vector>
 
namespace dolfinx::mesh
{
class Mesh;
}
 
namespace dolfinx::geometry
{
class BoundingBoxTree;
 
BoundingBoxTree
create_midpoint_tree(const mesh::Mesh& mesh, int tdim,
                     std::span<const std::int32_t> entity_indices);
 
std::vector<std::int32_t> compute_collisions(const BoundingBoxTree& tree0,
                                             const BoundingBoxTree& tree1);
 
graph::AdjacencyList<std::int32_t>
compute_collisions(const BoundingBoxTree& tree, std::span<const double> points);
 
int compute_first_colliding_cell(const mesh::Mesh& mesh,
                                 const BoundingBoxTree& tree,
                                 const std::array<double, 3>& point);
 
std::vector<std::int32_t>
compute_closest_entity(const BoundingBoxTree& tree,
                       const BoundingBoxTree& midpoint_tree,
                       const mesh::Mesh& mesh, std::span<const double> points);
 
double compute_squared_distance_bbox(std::span<const double, 6> b,
                                     std::span<const double, 3> x);
 
std::vector<double> shortest_vector(const mesh::Mesh& mesh, int dim,
                                    std::span<const std::int32_t> entities,
                                    std::span<const double> points);
 
std::vector<double> squared_distance(const mesh::Mesh& mesh, int dim,
                                     std::span<const std::int32_t> entities,
                                     std::span<const double> points);
 
graph::AdjacencyList<std::int32_t> compute_colliding_cells(
    const mesh::Mesh& mesh,
    const graph::AdjacencyList<std::int32_t>& candidate_cells,
    std::span<const double> points);
 
std::tuple<std::vector<std::int32_t>, std::vector<std::int32_t>,
           std::vector<double>, std::vector<std::int32_t>>
determine_point_ownership(const mesh::Mesh& mesh,
                          std::span<const double> points);
 
} // namespace dolfinx::geometry