8#include <deal.II/fe/fe_q.h>
9#include <deal.II/fe/mapping_manifold.h>
10#include <deal.II/fe/mapping_q1.h>
11#include <deal.II/fe/mapping_q_cache.h>
13#include <deal.II/grid/grid_tools.h>
23 const DoFHandler<dim> &dof_handler,
24 std::map<
unsigned int,
25 std::set<
typename DoFHandler<dim>::active_cell_iterator>>
28 vertices_cell_map.clear();
29 const auto &cell_iterator = dof_handler.active_cell_iterators();
33 for (
const auto &cell : cell_iterator)
35 if (cell->is_locally_owned() || cell->is_ghost())
37 const unsigned int vertices_per_cell =
38 GeometryInfo<dim>::vertices_per_cell;
39 for (
unsigned int i = 0; i < vertices_per_cell; i++)
42 unsigned int v_index = cell->vertex_index(i);
45 vertices_cell_map[v_index].insert(cell);
54 const DoFHandler<dim> &dof_handler,
55 std::map<
unsigned int,
56 std::set<
typename DoFHandler<dim>::active_cell_iterator>>
59 vertices_cell_map.clear();
60 const auto &cell_iterator = dof_handler.active_cell_iterators();
61 const auto &triangulation = dof_handler.get_triangulation();
65 std::map<unsigned int, std::vector<unsigned int>> coinciding_vertex_groups;
69 std::map<unsigned int, unsigned int> vertex_to_coinciding_vertex_group;
71 auto v_to_c = GridTools::vertex_to_cell_map(triangulation);
72 GridTools::collect_coinciding_vertices(triangulation,
73 coinciding_vertex_groups,
74 vertex_to_coinciding_vertex_group);
76 std::set<unsigned int> explored_vertices;
77 for (
const auto &cell : cell_iterator)
79 if (cell->is_locally_owned() || cell->is_ghost())
81 const unsigned int vertices_per_cell =
82 GeometryInfo<dim>::vertices_per_cell;
83 for (
unsigned int i = 0; i < vertices_per_cell; i++)
86 unsigned int v_index = cell->vertex_index(i);
93 if (!explored_vertices.insert(v_index).second)
97 std::set<typename DoFHandler<dim>::active_cell_iterator>
98 periodic_neighbor_cells;
103 auto coinciding_vertex_key_iterator =
104 vertex_to_coinciding_vertex_group.find(v_index);
105 if (coinciding_vertex_key_iterator !=
106 vertex_to_coinciding_vertex_group.end())
109 for (
auto coinciding_vertex : coinciding_vertex_groups.at(
110 coinciding_vertex_key_iterator->second))
114 if (coinciding_vertex != v_index)
117 for (
const auto &neighbor_id :
118 v_to_c[coinciding_vertex])
123 typename DoFHandler<dim>::active_cell_iterator
124 neighbor_cell(&(triangulation),
125 neighbor_id->level(),
126 neighbor_id->index(),
130 periodic_neighbor_cells.insert(neighbor_cell);
138 vertices_cell_map.insert({v_index, periodic_neighbor_cells});
145typename DoFHandler<dim>::active_cell_iterator
147 const DoFHandler<dim> &dof_handler,
148 const Point<dim> &point)
152 MappingQ1<dim> mapping;
153 typename DoFHandler<dim>::cell_iterator best_cell_iter;
155 bool cell_found_on_level_search =
false;
156 unsigned int lvl = 0;
157 unsigned int max_lvl_search = dof_handler.get_triangulation().n_levels() - 2;
159 if (max_lvl_search < 4)
160 max_lvl_search = dof_handler.get_triangulation().n_levels();
162 while (lvl < max_lvl_search)
164 const auto &cell_iterator = dof_handler.cell_iterators_on_level(lvl);
167 for (
const auto &cell : cell_iterator)
171 const Point<dim, double> p_cell =
172 mapping.transform_real_to_unit_cell(cell, point);
175 GeometryInfo<dim>::distance_to_unit_cell(p_cell);
180 cell_found_on_level_search =
true;
181 best_cell_iter = cell;
185 catch (
const typename MappingQGeneric<dim>::ExcTransformationFailed &)
191 double best_dist_last = DBL_MAX;
192 if (cell_found_on_level_search)
200 unsigned int max_childs = GeometryInfo<dim>::max_children_per_cell;
201 while (best_cell_iter->is_active() ==
false)
203 bool cell_found =
false;
204 double best_dist = DBL_MAX;
205 unsigned int best_index = 0;
206 for (
unsigned int i = 0; i < max_childs; ++i)
210 const Point<dim, double> p_cell =
211 mapping.transform_real_to_unit_cell(
212 best_cell_iter->child(i), point);
214 GeometryInfo<dim>::distance_to_unit_cell(p_cell);
218 if (dist <= best_dist and inside)
228 const typename MappingQGeneric<dim>::ExcTransformationFailed &)
232 best_cell_iter = best_cell_iter->child(best_index);
239 best_dist_last = best_dist;
243 if (best_dist_last >= 1e-9 && !cell_found_on_level_search)
245 throw std::runtime_error(
"The point is not inside the mesh");
247 return best_cell_iter;
252std::vector<typename DoFHandler<dim>::active_cell_iterator>
254 const DoFHandler<dim> &dof_handler,
255 const Point<dim> ¢er,
258 MappingQ1<dim> mapping;
259 const auto &cell_iterator = dof_handler.cell_iterators_on_level(0);
260 unsigned int max_childs = GeometryInfo<dim>::max_children_per_cell;
262 std::set<typename DoFHandler<dim>::cell_iterator> boundary_cells_candidates;
263 std::set<typename DoFHandler<dim>::cell_iterator>
264 last_boundary_cells_candidates;
265 std::set<typename DoFHandler<dim>::cell_iterator> cells_at_boundary;
267 for (
const auto &cell : cell_iterator)
269 if (cell->at_boundary())
271 for (
unsigned int i = 0; i < GeometryInfo<dim>::vertices_per_cell;
274 if ((cell->vertex(i) - center).norm() <= radius ||
275 cell->point_inside(center))
277 boundary_cells_candidates.insert(cell);
284 last_boundary_cells_candidates = boundary_cells_candidates;
285 if (boundary_cells_candidates.size() != 0)
287 bool all_cell_are_active =
false;
288 while (!all_cell_are_active)
291 all_cell_are_active =
true;
292 boundary_cells_candidates.clear();
294 for (
auto cell : last_boundary_cells_candidates)
296 if (cell->at_boundary())
298 for (
unsigned int i = 0;
299 i < GeometryInfo<dim>::vertices_per_cell;
303 if ((cell->vertex(i) - center).norm() <= radius ||
304 cell->point_inside(center))
306 if (cell->is_active())
308 cells_at_boundary.insert(cell);
313 all_cell_are_active =
false;
314 for (
unsigned int j = 0; j < max_childs; ++j)
318 boundary_cells_candidates.insert(
327 last_boundary_cells_candidates.clear();
328 last_boundary_cells_candidates = boundary_cells_candidates;
331 std::vector<typename DoFHandler<dim>::active_cell_iterator>
332 cells_at_boundary_v(cells_at_boundary.begin(), cells_at_boundary.end());
334 return cells_at_boundary_v;
339typename DoFHandler<dim>::active_cell_iterator
341 const DoFHandler<dim> &dof_handler,
342 std::map<
unsigned int,
343 std::set<
typename DoFHandler<dim>::active_cell_iterator>>
345 const typename DoFHandler<dim>::active_cell_iterator &cell,
346 const Point<dim> &point)
349 std::vector<typename DoFHandler<dim>::active_cell_iterator>
350 active_neighbors_set =
353 for (
unsigned int i = 0; i < active_neighbors_set.size(); ++i)
355 if (active_neighbors_set[i]->point_inside(point))
357 return active_neighbors_set[i];
366std::vector<typename DoFHandler<dim>::active_cell_iterator>
368 std::map<
unsigned int,
369 std::set<
typename DoFHandler<dim>::active_cell_iterator>>
371 const typename DoFHandler<dim>::active_cell_iterator &cell)
375 std::set<typename DoFHandler<dim>::active_cell_iterator> neighbors_cells;
379 for (
unsigned int i = 0; i < GeometryInfo<dim>::vertices_per_cell; i++)
381 unsigned int v_index = cell->vertex_index(i);
382 neighbors_cells.insert(vertices_cell_map[v_index].begin(),
383 vertices_cell_map[v_index].end());
387 std::vector<typename DoFHandler<dim>::active_cell_iterator>
388 cells_sharing_vertices(neighbors_cells.begin(), neighbors_cells.end());
389 return cells_sharing_vertices;
393std::vector<typename DoFHandler<dim>::active_cell_iterator>
395 const DoFHandler<dim> &dof_handler,
396 const typename DoFHandler<dim>::active_cell_iterator &cell)
398 std::vector<typename DoFHandler<dim>::active_cell_iterator> cells_inside;
404 for (
const auto &cell_iter : dof_handler.active_cell_iterators())
406 for (
unsigned int i = 0; i < GeometryInfo<dim>::vertices_per_cell; ++i)
408 if (cell->point_inside(cell_iter->vertex(i)))
410 cells_inside.push_back(cell_iter);
414 for (
unsigned int i = 0; i < GeometryInfo<dim>::vertices_per_cell; ++i)
416 if (cell_iter->point_inside(cell->vertex(i)))
418 cells_inside.push_back(cell_iter);
431 const typename DoFHandler<dim>::active_cell_iterator &cell,
432 const TriaIterator<CellAccessor<1, dim>> &cell_edge)
434 std::vector<Point<dim>> manifold_points(GeometryInfo<1>::vertices_per_cell);
436 for (
unsigned int i = 0; i < GeometryInfo<1>::vertices_per_cell; ++i)
438 manifold_points[i] = cell_edge->vertex(i);
448 for (
const auto face : cell->face_indices())
450 bool condition_a1 =
false;
451 bool condition_a2 =
true;
452 auto local_face = cell->face(face);
453 std::vector<Tensor<1, dim>> normals_of_face_vertex(
454 GeometryInfo<dim>::vertices_per_face);
455 for (
unsigned int i = 0; i < GeometryInfo<dim>::vertices_per_face; ++i)
457 Point<dim> projected_point =
458 GridTools::project_to_object(cell_edge, local_face->vertex(i));
460 if (cell_edge->point_inside(projected_point) &&
461 cell->point_inside(projected_point))
465 if ((local_face->vertex(i) - projected_point).norm() != 0)
466 normals_of_face_vertex[i] =
467 (local_face->vertex(i) - projected_point) /
468 (local_face->vertex(i) - projected_point).norm();
473 for (
unsigned int i = 0; i < 3; ++i)
477 Tensor<1, dim> temp = normals_of_face_vertex[1];
478 normals_of_face_vertex[1] = normals_of_face_vertex[0];
479 normals_of_face_vertex[0] = temp;
483 Tensor<1, dim> temp = normals_of_face_vertex[3];
484 normals_of_face_vertex[3] = normals_of_face_vertex[1];
485 normals_of_face_vertex[1] = temp;
488 for (
unsigned int j = 0; j < GeometryInfo<dim>::vertices_per_face;
492 for (
unsigned int k = 0; k < 3; ++k)
494 unsigned int index_1 = j + k;
495 unsigned int index_2 = j + k + 1;
496 if ((j + k) >= GeometryInfo<dim>::vertices_per_face)
498 index_1 = j + k - GeometryInfo<dim>::vertices_per_face;
500 if ((j + k + 1) >= GeometryInfo<dim>::vertices_per_face)
503 j + k + 1 - GeometryInfo<dim>::vertices_per_face;
506 double dot = scalar_product(normals_of_face_vertex[index_1],
507 normals_of_face_vertex[index_2]);
508 s += std::acos(std::clamp(dot, -1.0, 1.0));
512 condition_a2 =
false;
518 if (condition_a1 && condition_a2)
532 const typename DoFHandler<dim>::active_cell_iterator &cell,
536 Triangulation<1, dim> local_edge_triangulation;
537 std::vector<Point<dim>> vertices_of_edge(2);
538 std::vector<CellData<1>> local_edge_cell_data(1);
540 vertices_of_edge[0] = point_1;
541 vertices_of_edge[1] = point_2;
542 local_edge_cell_data[0].vertices[0] = 0;
543 local_edge_cell_data[0].vertices[1] = 1;
545 local_edge_triangulation.create_triangulation(vertices_of_edge,
546 local_edge_cell_data,
549 for (
const auto &edge_cell : local_edge_triangulation.active_cell_iterators())
560template <
int spacedim,
int structdim>
561std::pair<std::pair<Point<spacedim>,
bool>, Tensor<1, spacedim>>
563 const typename DoFHandler<structdim, spacedim>::active_cell_iterator &
object,
564 const Point<spacedim> &trial_point)
598 for (
unsigned int d = 0; std::cmp_less(d, structdim); ++d)
602 for (
const unsigned int i : GeometryInfo<structdim>::vertex_indices())
603 x_k +=
object->vertex(i) *
604 GeometryInfo<structdim>::d_linear_shape_function(xi, i);
608 Tensor<1, structdim> F_k;
609 for (
const unsigned int i : GeometryInfo<structdim>::vertex_indices())
610 F_k += (x_k - trial_point) * object->vertex(i) *
611 GeometryInfo<structdim>::d_linear_shape_function_gradient(xi, i);
613 Tensor<2, structdim> H_k;
614 for (
const unsigned int i : GeometryInfo<structdim>::vertex_indices())
615 for (
const unsigned int j : GeometryInfo<structdim>::vertex_indices())
617 Tensor<2, structdim> tmp = outer_product(
618 GeometryInfo<structdim>::d_linear_shape_function_gradient(xi, i),
619 GeometryInfo<structdim>::d_linear_shape_function_gradient(xi, j));
620 H_k += (
object->vertex(i) * object->vertex(j)) * tmp;
623 const Tensor<1, structdim> delta_xi = -invert(H_k) * F_k;
626 x_k = Point<spacedim>();
627 for (
const unsigned int i : GeometryInfo<structdim>::vertex_indices())
628 x_k +=
object->vertex(i) *
629 GeometryInfo<structdim>::d_linear_shape_function(xi, i);
631 if (delta_xi.norm() < 1e-7)
637 Tensor<1, spacedim> normal;
641 Point<structdim> xi_dx = xi;
642 Point<structdim> xi_dy = xi;
643 xi_dx[0] = xi[0] + dx;
644 xi_dy[1] = xi[1] - dx;
645 Point<spacedim> x_k_dx(0, 0, 0);
646 Point<spacedim> x_k_dy(0, 0, 0);
647 for (
const unsigned int i : GeometryInfo<structdim>::vertex_indices())
649 x_k_dx +=
object->vertex(i) *
650 GeometryInfo<structdim>::d_linear_shape_function(xi_dx, i);
651 x_k_dy +=
object->vertex(i) *
652 GeometryInfo<structdim>::d_linear_shape_function(xi_dy, i);
655 normal = cross_product_3d((x_k_dx - x_k), (x_k_dy - x_k));
656 normal = normal / normal.norm();
661 Tensor<1, spacedim> temp =
object->vertex(1) -
object->vertex(0);
662 normal[0] = -temp[1];
666 for (
int i = 0; i < structdim; ++i)
668 if (xi[i] < 0 || xi[i] > 1)
672 std::pair<Point<spacedim>,
bool> point = std::make_pair(x_k, inside);
673 std::pair<std::pair<Point<spacedim>,
bool>, Tensor<1, spacedim>> output =
674 std::make_pair(point, normal);
682std::vector<typename DoFHandler<dim>::active_cell_iterator>
684 const DoFHandler<dim> &dof_handler,
685 std::map<
unsigned int,
686 std::set<
typename DoFHandler<dim>::active_cell_iterator>>
688 [[maybe_unused]]
const typename DoFHandler<dim>::active_cell_iterator &cell,
692 std::set<typename DoFHandler<dim>::active_cell_iterator> cells_pierced_set;
693 DoFHandler<1, dim> local_edge_dof_handler;
694 Triangulation<1, dim> local_edge_triangulation;
695 std::vector<Point<dim>> vertices_of_edge(2);
696 std::vector<CellData<1>> local_edge_cell_data(1);
697 FESystem<dim - 1, dim> local_face_fe(FE_Q<dim - 1, dim>(1));
699 vertices_of_edge[0] = point_1;
700 vertices_of_edge[1] = point_2;
701 local_edge_cell_data[0].vertices[0] = 0;
702 local_edge_cell_data[0].vertices[1] = 1;
704 local_edge_triangulation.create_triangulation(vertices_of_edge,
705 local_edge_cell_data,
707 local_edge_dof_handler.reinit(local_edge_triangulation);
708 local_edge_dof_handler.distribute_dofs(local_face_fe);
710 const typename DoFHandler<1, dim>::active_cell_iterator edge_cell;
711 edge_cell = local_edge_dof_handler.active_cell_iterators().begin();
719 auto &starting_cell =
721 Tensor<1, dim> unit_direction =
722 (point_2 - point_1) / (point_2 - point_1).norm();
727 std::unordered_set<typename DoFHandler<dim>::active_cell_iterator,
730 previous_candidate_cells;
732 std::unordered_set<typename DoFHandler<dim>::active_cell_iterator,
735 current_candidate_cells;
737 std::unordered_set<typename DoFHandler<dim>::active_cell_iterator,
742 previous_candidate_cells.insert(starting_cell);
743 current_candidate_cells.insert(starting_cell);
744 intersected_cells.insert(starting_cell);
746 int n_previous_intersected = 0;
748 while (intersected_cells.size() > n_previous_intersected)
750 n_previous_intersected = intersected_cells.size();
752 for (
const typename DoFHandler<dim>::active_cell_iterator &cell_iter :
753 previous_candidate_cells)
755 current_candidate_cells.insert(
761 previous_candidate_cells.clear();
767 for (
const typename DoFHandler<dim>::active_cell_iterator &cell_iter :
768 current_candidate_cells)
773 if (intersected_cells.insert(cell_iter).second)
775 previous_candidate_cells.insert(cell_iter);
779 current_candidate_cells.clear();
784 std::vector<typename DoFHandler<dim>::active_cell_iterator> cells_pierced(
785 cells_pierced_set.begin(), cells_pierced_set.end());
787 return cells_pierced;
793 const typename DoFHandler<dim>::active_cell_iterator &cell,
794 const typename DoFHandler<dim - 1, dim>::active_cell_iterator &cell_flat)
796 std::vector<Point<dim>> manifold_points(
797 GeometryInfo<dim - 1>::vertices_per_cell);
798 for (
unsigned int i = 0; i < GeometryInfo<dim - 1>::vertices_per_cell; ++i)
800 manifold_points[i] = cell_flat->vertex(i);
817 for (
unsigned int i = 0; i < GeometryInfo<dim - 1>::vertices_per_cell; ++i)
819 if (cell->point_inside(cell_flat->vertex(i)))
823 if constexpr (dim == 3)
826 for (
const auto face : cell_flat->face_indices())
828 auto local_face = cell_flat->face(face);
830 local_face->vertex(0),
831 local_face->vertex(1)))
837 bool condition_B1 =
false;
838 bool condition_B2 =
false;
839 Tensor<1, dim> last_normal;
841 double last_scalar_prod = 0;
843 for (
unsigned int i = 0; i < GeometryInfo<dim>::vertices_per_cell; ++i)
845 auto projected_point =
847 cell_flat, cell->vertex(i));
849 Tensor<1, dim> normal = cell->vertex(i) - projected_point.first.first;
853 if (projected_point.first.second &&
854 cell->point_inside(projected_point.first.first))
861 double scalar_prod = scalar_product(normal, projected_point.second);
863 if (scalar_prod * last_scalar_prod < 0)
867 last_scalar_prod = scalar_prod;
868 if (condition_B1 && condition_B2)
877 bool condition_C2 =
false;
878 for (
const auto face : cell->face_indices())
880 auto face_iter = cell->face(face);
882 auto &local_face_manifold = face_iter->get_manifold();
884 for (
unsigned int i = 0; i < GeometryInfo<dim - 1>::vertices_per_cell;
887 manifold_points[i] = face_iter->vertex(i);
889 auto surrounding_points_face =
890 make_array_view(manifold_points.begin(), manifold_points.end());
892 for (
unsigned int i = 0; i < GeometryInfo<dim>::vertices_per_face;
895 Point<dim> projected_point =
896 local_face_manifold.project_to_manifold(surrounding_points_face,
897 cell_flat->vertex(i));
898 Tensor<1, dim> normal = cell->vertex(i) - projected_point;
899 double scalar_prod = scalar_product(normal, last_normal);
900 last_normal = normal;
904 if (condition_B1 && condition_C2)
913std::vector<typename DoFHandler<dim>::active_cell_iterator>
915 const DoFHandler<dim> &dof_handler,
916 const typename DoFHandler<dim - 1, dim>::active_cell_iterator &cell,
917 std::map<
unsigned int,
918 std::set<
typename DoFHandler<dim>::active_cell_iterator>>
921 TriaActiveIterator<DoFCellAccessor<dim, dim, false>> starting_cell =
924 std::unordered_set<typename DoFHandler<dim>::active_cell_iterator,
927 previous_candidate_cells;
929 std::unordered_set<typename DoFHandler<dim>::active_cell_iterator,
932 current_candidate_cells;
934 std::unordered_set<typename DoFHandler<dim>::active_cell_iterator,
939 previous_candidate_cells.insert(starting_cell);
940 current_candidate_cells.insert(starting_cell);
941 intersected_cells.insert(starting_cell);
943 size_t n_previous_intersected = 0;
945 while (intersected_cells.size() > n_previous_intersected)
947 n_previous_intersected = intersected_cells.size();
949 for (
const typename DoFHandler<dim>::active_cell_iterator &cell_iter :
950 previous_candidate_cells)
955 for (
unsigned int i = 0; i < new_cells.size(); ++i)
957 current_candidate_cells.insert(new_cells[i]);
962 previous_candidate_cells.clear();
968 for (
const typename DoFHandler<dim>::active_cell_iterator &cell_iter :
969 current_candidate_cells)
973 previous_candidate_cells.insert(cell_iter);
974 intersected_cells.insert(cell_iter);
978 current_candidate_cells.clear();
981 std::vector<typename DoFHandler<dim>::active_cell_iterator> cells_cut(
982 intersected_cells.begin(), intersected_cells.end());
988template <
int spacedim,
int structdim>
990 typename DoFHandler<spacedim>::active_cell_iterator,
991 std::map<
unsigned int,
992 typename DoFHandler<structdim, spacedim>::active_cell_iterator>>
994 const DoFHandler<spacedim> &dof_handler,
995 std::map<
unsigned int,
996 std::set<
typename DoFHandler<spacedim>::active_cell_iterator>>
1001 typename DoFHandler<spacedim>::active_cell_iterator,
1002 std::map<
unsigned int,
1003 typename DoFHandler<structdim, spacedim>::active_cell_iterator>>
1004 cells_cut_by_object;
1005 if constexpr (structdim == spacedim - 1)
1007 for (
unsigned int i = 0; i < list_of_objects.size(); ++i)
1009 const auto &
object = list_of_objects[i].get_dof_handler();
1011 const auto &object_cell_iterator =
object.active_cell_iterators();
1014 for (
const auto &cell : object_cell_iterator)
1016 std::vector<typename DoFHandler<spacedim>::active_cell_iterator>
1018 dof_handler, cell, vertices_cell_map);
1019 for (
unsigned int j = 0; j < cells_cut.size(); ++j)
1021 cells_cut_by_object[cells_cut[j]]
1022 [list_of_objects[i].get_solid_id()] = cell;
1026 return cells_cut_by_object;
1030 for (
unsigned int i = 0; i < list_of_objects.size(); ++i)
1032 auto &
object = list_of_objects[i].get_dof_handler();
1034 const auto &object_cell_iterator =
object.active_cell_iterators();
1037 for (
const auto &cell : object_cell_iterator)
1039 if (cell->at_boundary())
1042 typename DoFHandler<spacedim>::active_cell_iterator>
1044 dof_handler, cell, vertices_cell_map);
1045 for (
unsigned int j = 0; j < cells_cut.size(); ++j)
1047 cells_cut_by_object[cells_cut[j]]
1048 [list_of_objects[i].get_solid_id()] =
1054 return cells_cut_by_object;
1059template DoFHandler<3>::active_cell_iterator
1061 const DoFHandler<3> &dof_handler,
1062 const Point<3> &point);
1063template DoFHandler<2>::active_cell_iterator
1065 const DoFHandler<2> &dof_handler,
1066 const Point<2> &point);
1070 const DoFHandler<2> &dof_handler,
1071 std::map<
unsigned int, std::set<DoFHandler<2>::active_cell_iterator>>
1072 &vertices_cell_map);
1075 const DoFHandler<3> &dof_handler,
1076 std::map<
unsigned int, std::set<DoFHandler<3>::active_cell_iterator>>
1077 &vertices_cell_map);
1081 const DoFHandler<2> &dof_handler,
1082 std::map<
unsigned int, std::set<DoFHandler<2>::active_cell_iterator>>
1083 &vertices_cell_map);
1086 const DoFHandler<3> &dof_handler,
1087 std::map<
unsigned int, std::set<DoFHandler<3>::active_cell_iterator>>
1088 &vertices_cell_map);
1090template typename DoFHandler<2>::active_cell_iterator
1092 const DoFHandler<2> &dof_handler,
1093 std::map<
unsigned int, std::set<DoFHandler<2>::active_cell_iterator>>
1095 const DoFHandler<2>::active_cell_iterator &cell,
1096 const Point<2> &point);
1098template typename DoFHandler<3>::active_cell_iterator
1100 const DoFHandler<3> &dof_handler,
1101 std::map<
unsigned int, std::set<DoFHandler<3>::active_cell_iterator>>
1103 const DoFHandler<3>::active_cell_iterator &cell,
1104 const Point<3> &point);
1106template std::vector<DoFHandler<2>::active_cell_iterator>
1108 std::map<
unsigned int, std::set<DoFHandler<2>::active_cell_iterator>>
1110 const DoFHandler<2>::active_cell_iterator &cell);
1112template std::vector<DoFHandler<3>::active_cell_iterator>
1114 std::map<
unsigned int, std::set<DoFHandler<3>::active_cell_iterator>>
1116 const DoFHandler<3>::active_cell_iterator &cell);
1118template std::vector<DoFHandler<2>::active_cell_iterator>
1120 const DoFHandler<2> &dof_handler,
1121 const DoFHandler<2>::active_cell_iterator &cell);
1123template std::vector<DoFHandler<3>::active_cell_iterator>
1125 const DoFHandler<3> &dof_handler,
1126 const DoFHandler<3>::active_cell_iterator &cell);
1130 const DoFHandler<2>::active_cell_iterator &cell,
1131 const DoFHandler<2 - 1, 2>::active_cell_iterator &cell_flat);
1135 const DoFHandler<3>::active_cell_iterator &cell,
1136 const DoFHandler<3 - 1, 3>::active_cell_iterator &cell_flat);
1139template std::vector<DoFHandler<2>::active_cell_iterator>
1141 const DoFHandler<2> &dof_handler,
1142 const DoFHandler<2 - 1, 2>::active_cell_iterator &cell,
1143 std::map<
unsigned int, std::set<DoFHandler<2>::active_cell_iterator>>
1144 &vertices_cell_map);
1146template std::vector<DoFHandler<3>::active_cell_iterator>
1148 const DoFHandler<3> &dof_handler,
1149 const DoFHandler<3 - 1, 3>::active_cell_iterator &cell,
1150 std::map<
unsigned int, std::set<DoFHandler<3>::active_cell_iterator>>
1151 &vertices_cell_map);
1153template std::pair<std::pair<Point<2>,
bool>, Tensor<1, 2>>
1155 const DoFHandler<1, 2>::active_cell_iterator &
object,
1156 const Point<2> &trial_point);
1158template std::pair<std::pair<Point<3>,
bool>, Tensor<1, 3>>
1160 const DoFHandler<2, 3>::active_cell_iterator &
object,
1161 const Point<3> &trial_point);
1166 const DoFHandler<3>::active_cell_iterator &cell,
1167 const TriaIterator<CellAccessor<1, 3>> &cell_edge);
1171 const DoFHandler<3>::active_cell_iterator &cell,
1175template std::vector<DoFHandler<2>::active_cell_iterator>
1177 const Point<2> ¢er,
1178 const double radius);
1179template std::vector<DoFHandler<3>::active_cell_iterator>
1181 const Point<3> ¢er,
1182 const double radius);
1186 DoFHandler<3>::active_cell_iterator,
1187 std::map<unsigned int, DoFHandler<3, 3>::active_cell_iterator>>
1189 const DoFHandler<3> &dof_handler,
1190 std::map<
unsigned int, std::set<DoFHandler<3>::active_cell_iterator>>
1195 DoFHandler<2>::active_cell_iterator,
1196 std::map<unsigned int, DoFHandler<2, 2>::active_cell_iterator>>
1198 const DoFHandler<2> &dof_handler,
1199 std::map<
unsigned int, std::set<DoFHandler<2>::active_cell_iterator>>
1204 DoFHandler<3>::active_cell_iterator,
1205 std::map<unsigned int, DoFHandler<2, 3>::active_cell_iterator>>
1207 const DoFHandler<3> &dof_handler,
1208 std::map<
unsigned int, std::set<DoFHandler<3>::active_cell_iterator>>
1213 DoFHandler<2>::active_cell_iterator,
1214 std::map<unsigned int, DoFHandler<1, 2>::active_cell_iterator>>
1216 const DoFHandler<2> &dof_handler,
1217 std::map<
unsigned int, std::set<DoFHandler<2>::active_cell_iterator>>
1225 const std::vector<Point<dim>> &triangle)
1227 const auto &p_0 = triangle[0];
1228 const auto &p_1 = triangle[1];
1229 const auto &p_2 = triangle[2];
1231 TriangleProjectionData<dim> triangle_data;
1232 triangle_data.
p_0 = p_0;
1233 triangle_data.e_0 = p_1 - p_0;
1234 triangle_data.e_1 = p_2 - p_0;
1236 const Tensor<1, dim> normal =
1237 cross_product_3d(triangle_data.e_0, triangle_data.e_1);
1238 triangle_data.unit_normal = normal / normal.norm();
1240 triangle_data.a = triangle_data.e_0.norm_square();
1241 triangle_data.b = scalar_product(triangle_data.e_0, triangle_data.e_1);
1242 triangle_data.c = triangle_data.e_1.norm_square();
1244 triangle_data.a * triangle_data.c - triangle_data.b * triangle_data.b;
1246 return triangle_data;
1255 const TriangleProjectionData<dim> &triangle_data,
1256 const Point<dim> &particle_position,
1257 const double cutoff_distance)
1260 bool pass_distance_check;
1262 const Point<dim> &p_0 = triangle_data.p_0;
1263 const Tensor<1, dim> &e_0 = triangle_data.e_0;
1264 const Tensor<1, dim> &e_1 = triangle_data.e_1;
1266 Tensor<1, dim> unit_normal = triangle_data.unit_normal;
1267 Tensor<1, 3> unit_normal_3d;
1269 const double a = triangle_data.a;
1270 const double b = triangle_data.b;
1271 const double c = triangle_data.c;
1272 const double det = triangle_data.det;
1275 const Tensor<1, dim> vector_to_plane = p_0 - particle_position;
1279 bool region_zero =
false;
1283 if (vector_to_plane * unit_normal > 0)
1284 unit_normal *= -1.0;
1289 const double distance_to_plane =
1290 -scalar_product(vector_to_plane, unit_normal);
1294 if (distance_to_plane > cutoff_distance)
1298 pass_distance_check =
false;
1299 contact_indicator = ParticleTriangleContactIndicator::no_contact;
1300 return std::make_tuple(pass_distance_check,
1307 const double d = scalar_product(e_0, vector_to_plane);
1308 const double e = scalar_product(e_1, vector_to_plane);
1311 double s = b * e - c * d;
1312 double t = b * d - a * e;
1322 ParticleTriangleContactIndicator::vertex_contact;
1346 ParticleTriangleContactIndicator::edge_contact;
1360 contact_indicator = ParticleTriangleContactIndicator::edge_contact;
1373 const double inv_det = 1. / det;
1382 contact_indicator = ParticleTriangleContactIndicator::face_contact;
1390 contact_indicator = ParticleTriangleContactIndicator::vertex_contact;
1392 const double tmp0 = b + d;
1393 const double tmp1 = c + e;
1396 const double numer = tmp1 - tmp0;
1397 const double denom = a - 2 * b + c;
1419 contact_indicator = ParticleTriangleContactIndicator::vertex_contact;
1421 const double tmp0 = b + e;
1422 const double tmp1 = a + d;
1425 const double numer = tmp1 - tmp0;
1426 const double denom = a - 2 * b + c;
1447 contact_indicator = ParticleTriangleContactIndicator::edge_contact;
1449 const double numer = (c + e) - (b + d);
1454 const double denom = a - 2 * b + c;
1464 const Point<dim> pt_in_triangle = p_0 + s * e_0 + t * e_1;
1469 const Tensor<1, dim> point_to_particle_normal =
1470 particle_position - pt_in_triangle;
1472 point_to_particle_normal.norm());
1477 pass_distance_check =
true;
1479 return std::make_tuple(pass_distance_check,
1487 const std::vector<Point<2>> &triangle);
1491 const std::vector<Point<3>> &triangle);
1493template std::tuple<bool,
1499 const Point<2> &particle_position,
1500 const double cutoff_distance);
1502template std::tuple<bool,
1508 const Point<3> &particle_position,
1509 const double cutoff_distance);
1515 const std::vector<Point<dim>> &triangle,
1516 const Point<dim> &point)
1518 double distance = 0.0;
1520 const Point<dim> &point_0 = triangle[0];
1521 const Point<dim> &point_1 = triangle[1];
1523 if constexpr (dim == 3)
1525 const Point<dim> &point_2 = triangle[2];
1527 const Tensor<1, dim> e_0 = point_1 - point_0;
1528 const Tensor<1, dim> e_1 = point_2 - point_0;
1530 const double a = e_0.norm_square();
1531 const double b = scalar_product(e_0, e_1);
1532 const double c = e_1.norm_square();
1533 const double det = a * c - b * b;
1536 Tensor<1, dim> vector_to_plane;
1537 Point<dim> pt_in_triangle;
1539 vector_to_plane = point_0 - point;
1545 const double d = scalar_product(e_0, vector_to_plane);
1546 const double e = scalar_product(e_1, vector_to_plane);
1549 double s = b * e - c * d;
1550 double t = b * d - a * e;
1604 const double inv_det = 1. / det;
1614 const double tmp0 = b + d;
1615 const double tmp1 = c + e;
1618 const double numer = tmp1 - tmp0;
1619 const double denom = a - 2 * b + c;
1641 const double tmp0 = b + e;
1642 const double tmp1 = a + d;
1645 const double numer = tmp1 - tmp0;
1646 const double denom = a - 2 * b + c;
1667 const double numer = (c + e) - (b + d);
1672 const double denom = a - 2 * b + c;
1682 pt_in_triangle = point_0 + s * e_0 + t * e_1;
1684 distance = pt_in_triangle.distance(point);
1687 if constexpr (dim == 2)
1689 const Tensor<1, dim> d = point_1 - point_0;
1691 const double t_bar =
1692 d * (point - point_0) / (d.norm() * d.norm() + 1e-12);
1696 const Tensor<1, dim> point_minus_p0 = point - point_0;
1697 distance = point_minus_p0.norm();
1699 else if (t_bar >= 1.0)
1701 const Tensor<1, dim> point_minus_p1 = point - point_1;
1702 distance = point_minus_p1.norm();
1706 const Tensor<1, dim> projection = point - (point_0 + t_bar * d);
1707 distance = projection.norm();
1716 const std::vector<Point<2>> &triangle,
1717 const Point<2> &point);
1720 const std::vector<Point<3>> &triangle,
1721 const Point<3> &point);
1724std::vector<Point<dim>>
1726 const Point<dim> &line_start,
1727 const Tensor<1, dim> &line_direction,
1728 const Point<dim> &sphere_center,
1729 const double &sphere_diameter)
1732 const double sphere_radius = 0.5 * sphere_diameter;
1734 const double a = line_direction.norm_square();
1736 2 * scalar_product(line_direction, line_start - sphere_center);
1738 (line_start - sphere_center).norm_square() - sphere_radius * sphere_radius;
1742 std::vector<Point<dim>> intersection_points;
1745 const double discriminant = b * b - 4 * a * c;
1746 if (discriminant > 0.)
1749 const double sqrt_discriminant = std::sqrt(discriminant);
1750 const double t1 = (-b - sqrt_discriminant) / (2. * a);
1751 const double t2 = (-b + sqrt_discriminant) / (2. * a);
1753 intersection_points.push_back(line_start + t1 * line_direction);
1754 intersection_points.push_back(line_start + t2 * line_direction);
1756 return intersection_points;
1758 if (discriminant == 0.)
1761 const double t = -b / (2. * a);
1762 intersection_points.push_back(line_start + t * line_direction);
1764 return intersection_points;
1768 return intersection_points;
1771template std::vector<Point<2>>
1773 const Point<2> &line_start,
1774 const Tensor<1, 2> &line_direction,
1775 const Point<2> &sphere_center,
1776 const double &sphere_radius);
1777template std::vector<Point<3>>
1779 const Point<3> &line_start,
1780 const Tensor<1, 3> &line_direction,
1781 const Point<3> &sphere_center,
1782 const double &sphere_radius);
1788 MappingQCache<dim> &mapping_cache,
1789 const Mapping<dim> &mapping,
1790 const double rotation_angle,
1791 const Point<dim> ¢er_of_rotation,
1792 const unsigned int rotation_axis_direction)
1794 if constexpr (dim == 2)
1796 mapping_cache.initialize(
1798 dof_handler.get_triangulation(),
1799 [&](
const auto &cell,
const auto &point) {
1801 if (cell->material_id() == 0)
1805 const auto shift_point = point - center_of_rotation;
1807 const auto rotate_point =
1808 Physics::Transformations::Rotations::rotation_matrix_2d(
1812 return static_cast<Point<dim>>(rotate_point + center_of_rotation);
1816 else if constexpr (dim == 3)
1818 mapping_cache.initialize(
1820 dof_handler.get_triangulation(),
1821 [&](
const auto &cell,
const auto &point) {
1823 if (cell->material_id() == 0)
1827 const auto shift_point = point - center_of_rotation;
1829 Tensor<1, 3> rotation_axis;
1830 rotation_axis[rotation_axis_direction] = 1.0;
1832 const auto rotate_point =
1833 Physics::Transformations::Rotations::rotation_matrix_3d(
1834 rotation_axis, rotation_angle) *
1837 return static_cast<Point<dim>>(rotate_point + center_of_rotation);
1845 MappingQCache<2> &mapping_cache,
1846 const Mapping<2> &mapping,
1847 const double rotation_angle,
1848 const Point<2> ¢er_of_rotation,
1849 const unsigned int rotation_axis_direction);
1853 MappingQCache<3> &mapping_cache,
1854 const Mapping<3> &mapping,
1855 const double rotation_angle,
1856 const Point<3> ¢er_of_rotation,
1857 const unsigned int rotation_axis_direction);
1859template <
int dim,
int spacedim>
1862 const Triangulation<dim, spacedim> &tria,
1865 std::set<
typename Triangulation<dim, spacedim>::active_cell_iterator>>
1868 vertices_cell_map.clear();
1869 const auto &cell_iterator = tria.active_cell_iterators();
1873 for (
const auto &cell : cell_iterator)
1877 const unsigned int vertices_per_cell = cell->n_vertices();
1878 for (
unsigned int i = 0; i < vertices_per_cell; i++)
1881 unsigned int v_index = cell->vertex_index(i);
1884 vertices_cell_map[v_index].insert(cell);
1890 const Triangulation<1, 2> &tria,
1891 std::map<
unsigned int,
1892 std::set<
typename Triangulation<1, 2>::active_cell_iterator>>
1893 &vertices_cell_map);
1896 const Triangulation<2, 2> &tria,
1897 std::map<
unsigned int,
1898 std::set<
typename Triangulation<2, 2>::active_cell_iterator>>
1899 &vertices_cell_map);
1902 const Triangulation<2, 3> &tria,
1903 std::map<
unsigned int,
1904 std::set<
typename Triangulation<2, 3>::active_cell_iterator>>
1905 &vertices_cell_map);
1908 const Triangulation<3, 3> &tria,
1909 std::map<
unsigned int,
1910 std::set<
typename Triangulation<3, 3>::active_cell_iterator>>
1911 &vertices_cell_map);
1914template <
int dim,
int spacedim>
1915std::vector<typename Triangulation<dim, spacedim>::active_cell_iterator>
1919 std::set<
typename Triangulation<dim, spacedim>::active_cell_iterator>>
1921 const typename Triangulation<dim, spacedim>::active_cell_iterator &cell)
1925 std::set<typename Triangulation<dim, spacedim>::active_cell_iterator>
1930 unsigned int vertices_per_cell = cell->n_vertices();
1931 for (
unsigned int i = 0; i < vertices_per_cell; i++)
1933 unsigned int v_index = cell->vertex_index(i);
1934 neighbors_cells.insert(vertices_cell_map[v_index].begin(),
1935 vertices_cell_map[v_index].end());
1939 std::vector<typename Triangulation<dim, spacedim>::active_cell_iterator>
1940 cells_sharing_vertices(neighbors_cells.begin(), neighbors_cells.end());
1941 return cells_sharing_vertices;
1944template std::vector<typename Triangulation<1, 2>::active_cell_iterator>
1946 std::map<
unsigned int, std::set<Triangulation<1, 2>::active_cell_iterator>>
1948 const typename Triangulation<1, 2>::active_cell_iterator &cell);
1950template std::vector<typename Triangulation<2>::active_cell_iterator>
1952 std::map<
unsigned int,
1953 std::set<
typename Triangulation<2>::active_cell_iterator>>
1955 const typename Triangulation<2>::active_cell_iterator &cell);
1957template std::vector<typename Triangulation<2, 3>::active_cell_iterator>
1959 std::map<
unsigned int,
1960 std::set<
typename Triangulation<2, 3>::active_cell_iterator>>
1962 const typename Triangulation<2, 3>::active_cell_iterator &cell);
1964template std::vector<typename Triangulation<3>::active_cell_iterator>
1966 std::map<
unsigned int,
1967 std::set<
typename Triangulation<3>::active_cell_iterator>>
1969 const typename Triangulation<3>::active_cell_iterator &cell);
1974 const DoFHandler<dim> &dof_handler,
1975 const Triangulation<dim> &box_triangulation)
1980 const DoFHandler<dim> box_dof_handler(box_triangulation);
1984 for (
const auto &box_cell : box_dof_handler.active_cell_iterators())
1986 const std::vector<typename DoFHandler<dim>::active_cell_iterator>
1990 for (
const auto &cell_to_refine : cells_to_refine)
1992 if (cell_to_refine->is_locally_owned())
1993 cell_to_refine->set_refine_flag();
2000 const DoFHandler<2> &dof_handler,
2001 const Triangulation<2> &box_triangulation);
2004 const DoFHandler<3> &dof_handler,
2005 const Triangulation<3> &box_triangulation);
Tensor< 1, 3 > tensor_nd_to_3d(const Tensor< 1, dim > &tensor)
Point< 3 > point_nd_to_3d(const Point< dim > &point)