// ------------------------------------------------------------------------ // // SPDX-License-Identifier: LGPL-2.1-or-later // Copyright (C) 2018 - 2025 by the deal.II authors // // This file is part of the deal.II library. // // Part of the source code is dual licensed under Apache-2.0 WITH // LLVM-exception OR LGPL-2.1-or-later. Detailed license information // governing the source code and code contributions can be found in // LICENSE.md and CONTRIBUTING.md at the top level directory of deal.II. // // ------------------------------------------------------------------------ for (X : TRIANGULATION_AND_DOFHANDLERS; deal_II_dimension : DIMENSIONS; deal_II_space_dimension : SPACE_DIMENSIONS) { #if deal_II_dimension <= deal_II_space_dimension namespace GridTools \{ template unsigned int find_closest_vertex(const X &, const Point &, const std::vector &); template unsigned int find_closest_vertex( const Mapping &, const X &, const Point &, const std::vector &); template std::vector< dealii::internal::ActiveCellIterator::type> find_cells_adjacent_to_vertex(const X &, const unsigned int); template dealii::internal:: ActiveCellIterator::type find_active_cell_around_point(const X &, const Point &, const std::vector &, const double); template std::pair< dealii::internal::ActiveCellIterator::type, Point> find_active_cell_around_point( const Mapping &, const X &, const Point &, const std::vector &, const double); template std::vector< std::pair::type, Point>> find_all_active_cells_around_point( const Mapping &, const X &, const Point &, const double, const std::pair> &, const std::vector> *); template std::vector< std::pair::type, Point>> find_all_active_cells_around_point( const Mapping &, const X &, const Point &, const double, const std::vector &); template std::vector< dealii::internal::ActiveCellIterator::type> compute_active_cell_halo_layer( const X &, const std::function::type &)> &); template std::vector compute_cell_halo_layer_on_level( const X &, const std::function &, const unsigned int); template std::vector< dealii::internal::ActiveCellIterator::type> compute_ghost_cell_halo_layer(const X &); template std::vector< dealii::internal::ActiveCellIterator::type> compute_active_cell_layer_within_distance( const X &, const std::function::type &)> &, const double); template std::vector< dealii::internal::ActiveCellIterator::type> compute_ghost_cell_layer_within_distance(const X &, const double); template std::pair, Point> compute_bounding_box( const X &, const std::function::type &)> &); template std::list> get_finest_common_cells(const X &mesh_1, const X &mesh_2); template bool have_same_coarse_mesh(const X &mesh_1, const X &mesh_2); \} #endif } for (deal_II_dimension : DIMENSIONS; deal_II_space_dimension : SPACE_DIMENSIONS) { #if deal_II_dimension <= deal_II_space_dimension namespace GridTools \{ template std::pair< DoFHandler::active_cell_iterator, Point> find_active_cell_around_point( const hp::MappingCollection &, const DoFHandler &, const Point &, const double); \} #endif } for (deal_II_dimension : DIMENSIONS; deal_II_space_dimension : SPACE_DIMENSIONS; Container : TRIANGULATION_AND_DOFHANDLER_TEMPLATES) { #if deal_II_dimension <= deal_II_space_dimension namespace GridTools \{ template std::vector< Container::active_cell_iterator> get_patch_around_cell< Container>( const Container::active_cell_iterator &cell); template std::vector< Container::cell_iterator> get_cells_at_coarsest_common_level< Container>( const std::vector< Container::active_cell_iterator> &patch_cells); template void build_triangulation_from_patch< Container>( const std::vector< Container::active_cell_iterator> &patch, Triangulation< Container::dimension, Container::space_dimension> &local_triangulation, std::map::active_cell_iterator, Container::active_cell_iterator> &patch_to_global_tria_map); \} #endif } for (deal_II_dimension : DIMENSIONS; deal_II_space_dimension : SPACE_DIMENSIONS) { #if deal_II_dimension <= deal_II_space_dimension namespace GridTools \{ template std::map< types::global_dof_index, std::vector::active_cell_iterator>> get_dof_to_support_patch_map( DoFHandler &dof_handler); \} #endif } // instantiate the following functions only for the "sequential" containers. // this is a misnomer here, however: the point is simply that we only // instantiate these functions for certain *iterator* types, and the iterator // types are the same for sequential and parallel containers; consequently, we // get duplicate instantiation errors if we instantiate for *all* container // types, rather than only the sequential ones for (X : SEQUENTIAL_TRIANGULATION_AND_DOFHANDLER; deal_II_dimension : DIMENSIONS; deal_II_space_dimension : SPACE_DIMENSIONS) { #if deal_II_dimension <= deal_II_space_dimension namespace GridTools \{ template std::optional orthogonal_equality( const X::active_face_iterator &, const X::active_face_iterator &, const unsigned int, const Tensor<1, deal_II_space_dimension> &, const FullMatrix &, const double); template std::optional orthogonal_equality( const X::face_iterator &, const X::face_iterator &, const unsigned int, const Tensor<1, deal_II_space_dimension> &, const FullMatrix &, const double); \} #endif } for (X : SEQUENTIAL_TRIANGULATION_AND_DOFHANDLERS; deal_II_dimension : DIMENSIONS; deal_II_space_dimension : SPACE_DIMENSIONS) { #if deal_II_dimension <= deal_II_space_dimension namespace GridTools \{ template void collect_periodic_faces( const X &, const types::boundary_id, const types::boundary_id, const unsigned int, std::vector> &, const Tensor<1, X::space_dimension> &, const FullMatrix &, const double); template void collect_periodic_faces( const X &, const types::boundary_id, const unsigned int, std::vector> &, const Tensor<1, X::space_dimension> &, const FullMatrix &, const double); \} #endif } // TODO the text above the last instantiation block implies that this should not // be necessary... is it? for (deal_II_dimension : DIMENSIONS; deal_II_space_dimension : SPACE_DIMENSIONS) { #if deal_II_dimension <= deal_II_space_dimension # if deal_II_dimension >= 2 namespace GridTools \{ template void collect_periodic_faces< parallel::distributed::Triangulation>( const parallel::distributed::Triangulation &, const types::boundary_id, const types::boundary_id, const unsigned int, std::vector::cell_iterator>> &, const Tensor<1, parallel::distributed::Triangulation< deal_II_dimension, deal_II_space_dimension>::space_dimension> &, const FullMatrix &, const double); template void collect_periodic_faces< parallel::distributed::Triangulation>( const parallel::distributed::Triangulation &, const types::boundary_id, const unsigned int, std::vector::cell_iterator>> &, const Tensor<1, parallel::distributed::Triangulation< deal_II_dimension, deal_II_space_dimension>::space_dimension> &, const FullMatrix &, const double); \} # endif #endif } // TODO the text above the last instantiation block implies that this should not // be necessary... is it? for (deal_II_dimension : DIMENSIONS; deal_II_space_dimension : SPACE_DIMENSIONS) { #if deal_II_dimension <= deal_II_space_dimension namespace GridTools \{ template void collect_periodic_faces< parallel::shared::Triangulation>( const parallel::shared::Triangulation &, const types::boundary_id, const types::boundary_id, const unsigned int, std::vector::cell_iterator>> &, const Tensor<1, parallel::shared::Triangulation< deal_II_dimension, deal_II_space_dimension>::space_dimension> &, const FullMatrix &, const double); template void collect_periodic_faces< parallel::shared::Triangulation>( const parallel::shared::Triangulation &, const types::boundary_id, const unsigned int, std::vector::cell_iterator>> &, const Tensor<1, parallel::shared::Triangulation< deal_II_dimension, deal_II_space_dimension>::space_dimension> &, const FullMatrix &, const double); \} #endif }