Reference documentation for deal.II version 9.3.3
\(\newcommand{\dealvcentcolon}{\mathrel{\mathop{:}}}\) \(\newcommand{\dealcoloneq}{\dealvcentcolon\mathrel{\mkern-1.2mu}=}\) \(\newcommand{\jump}[1]{\left[\!\left[ #1 \right]\!\right]}\) \(\newcommand{\average}[1]{\left\{\!\left\{ #1 \right\}\!\right\}}\)
face_setup_internal.h
Go to the documentation of this file.
1// ---------------------------------------------------------------------
2//
3// Copyright (C) 2018 - 2021 by the deal.II authors
4//
5// This file is part of the deal.II library.
6//
7// The deal.II library is free software; you can use it, redistribute
8// it, and/or modify it under the terms of the GNU Lesser General
9// Public License as published by the Free Software Foundation; either
10// version 2.1 of the License, or (at your option) any later version.
11// The full text of the license can be found in the file LICENSE.md at
12// the top level directory of deal.II.
13//
14// ---------------------------------------------------------------------
15
16
17#ifndef dealii_face_setup_internal_h
18#define dealii_face_setup_internal_h
19
20#include <deal.II/base/config.h>
21
22#include <deal.II/base/memory_consumption.h>
23#include <deal.II/base/utilities.h>
24
25#include <deal.II/distributed/tria_base.h>
26
27#include <deal.II/grid/tria.h>
28#include <deal.II/grid/tria_accessor.h>
29
30#include <deal.II/matrix_free/face_info.h>
31#include <deal.II/matrix_free/task_info.h>
32
33#include <fstream>
34
35
36DEAL_II_NAMESPACE_OPEN
37
38
39namespace internal
40{
41 namespace MatrixFreeFunctions
42 {
47 struct FaceIdentifier
48 {
49 FaceIdentifier()
50 : n_hanging_faces_smaller_subdomain(0)
51 , n_hanging_faces_larger_subdomain(0)
52 {}
53
54 std::vector<std::pair<CellId, CellId>> shared_faces;
55 unsigned int n_hanging_faces_smaller_subdomain;
56 unsigned int n_hanging_faces_larger_subdomain;
57 };
58
59
60
69 template <int dim>
70 struct FaceSetup
71 {
72 FaceSetup();
73
80 void
81 initialize(
82 const ::Triangulation<dim> &triangulation,
83 const unsigned int mg_level,
84 const bool hold_all_faces_to_owned_cells,
85 std::vector<std::pair<unsigned int, unsigned int>> &cell_levels);
86
93 void
94 generate_faces(
95 const ::Triangulation<dim> & triangulation,
96 const std::vector<std::pair<unsigned int, unsigned int>> &cell_levels,
97 TaskInfo & task_info);
98
105 FaceToCellTopology<1>
106 create_face(
107 const unsigned int face_no,
108 const typename ::Triangulation<dim>::cell_iterator &cell,
109 const unsigned int number_cell_interior,
110 const typename ::Triangulation<dim>::cell_iterator &neighbor,
111 const unsigned int number_cell_exterior);
112
113 bool use_active_cells;
114
119 enum class FaceCategory : char
120 {
121 locally_active_at_boundary,
122 locally_active_done_here,
123 locally_active_done_elsewhere,
124 ghosted,
125 multigrid_refinement_edge
126 };
127
128 std::vector<FaceCategory> face_is_owned;
129 std::vector<bool> at_processor_boundary;
130 std::vector<FaceToCellTopology<1>> inner_faces;
131 std::vector<FaceToCellTopology<1>> boundary_faces;
132 std::vector<FaceToCellTopology<1>> inner_ghost_faces;
133 std::vector<FaceToCellTopology<1>> refinement_edge_faces;
134 };
135
136
137
141 template <int vectorization_width>
142 void
143 collect_faces_vectorization(
144 const std::vector<FaceToCellTopology<1>> &faces_in,
145 const std::vector<bool> & hard_vectorization_boundary,
146 std::vector<unsigned int> & face_partition_data,
147 std::vector<FaceToCellTopology<vectorization_width>> &faces_out);
148
149
150
151 /* -------------------------------------------------------------------- */
152
153#ifndef DOXYGEN
154
155 template <int dim>
156 FaceSetup<dim>::FaceSetup()
157 : use_active_cells(true)
158 {}
159
160
161
162 template <int dim>
163 void
164 FaceSetup<dim>::initialize(
165 const ::Triangulation<dim> &triangulation,
166 const unsigned int mg_level,
167 const bool hold_all_faces_to_owned_cells,
168 std::vector<std::pair<unsigned int, unsigned int>> &cell_levels)
169 {
170 use_active_cells = mg_level == numbers::invalid_unsigned_int;
171
172# ifdef DEBUG
173 // safety check
174 if (use_active_cells)
175 for (const auto &cell_level : cell_levels)
176 {
177 typename ::Triangulation<dim>::cell_iterator dcell(
178 &triangulation, cell_level.first, cell_level.second);
179 Assert(dcell->is_active(), ExcInternalError());
180 }
181# endif
182
183 // step 1: add ghost cells for those cells that we identify as
184 // interesting
185
186 at_processor_boundary.resize(cell_levels.size(), false);
187 face_is_owned.resize(dim > 1 ? triangulation.n_raw_faces() :
188 triangulation.n_vertices(),
189 FaceCategory::locally_active_done_elsewhere);
190
191 // go through the mesh and divide the faces on the processor
192 // boundaries as evenly as possible between the processors
193 std::map<types::subdomain_id, FaceIdentifier>
194 inner_faces_at_proc_boundary;
195 if (triangulation.locally_owned_subdomain() !=
196 numbers::invalid_subdomain_id)
197 {
198 const types::subdomain_id my_domain =
199 triangulation.locally_owned_subdomain();
200 for (unsigned int i = 0; i < cell_levels.size(); ++i)
201 {
202 if (i > 0 && cell_levels[i] == cell_levels[i - 1])
203 continue;
204 typename ::Triangulation<dim>::cell_iterator dcell(
205 &triangulation, cell_levels[i].first, cell_levels[i].second);
206 for (const unsigned int f : dcell->face_indices())
207 {
208 if (dcell->at_boundary(f) && !dcell->has_periodic_neighbor(f))
209 continue;
210 typename ::Triangulation<dim>::cell_iterator neighbor =
211 dcell->neighbor_or_periodic_neighbor(f);
212
213 // faces at hanging nodes are always treated by the processor
214 // who owns the element on the fine side. but we need to count
215 // the number of inner faces in order to balance the remaining
216 // faces properly
217 const CellId id_mine = dcell->id();
218 if (use_active_cells && neighbor->has_children())
219 for (unsigned int c = 0;
220 c < (dcell->has_periodic_neighbor(f) ?
221 dcell->periodic_neighbor(f)
222 ->face(dcell->periodic_neighbor_face_no(f))
223 ->n_children() :
224 dcell->face(f)->n_children());
225 ++c)
226 {
227 typename ::Triangulation<dim>::cell_iterator
228 neighbor_c =
229 dcell->at_boundary(f) ?
230 dcell->periodic_neighbor_child_on_subface(f, c) :
231 dcell->neighbor_child_on_subface(f, c);
232 const types::subdomain_id neigh_domain =
233 neighbor_c->subdomain_id();
234 if (my_domain < neigh_domain)
235 inner_faces_at_proc_boundary[neigh_domain]
236 .n_hanging_faces_larger_subdomain++;
237 else if (my_domain > neigh_domain)
238 inner_faces_at_proc_boundary[neigh_domain]
239 .n_hanging_faces_smaller_subdomain++;
240 }
241 else
242 {
243 const types::subdomain_id neigh_domain =
244 use_active_cells ? neighbor->subdomain_id() :
245 neighbor->level_subdomain_id();
246 if (neighbor->level() < dcell->level() &&
247 use_active_cells)
248 {
249 if (my_domain < neigh_domain)
250 inner_faces_at_proc_boundary[neigh_domain]
251 .n_hanging_faces_smaller_subdomain++;
252 else if (my_domain > neigh_domain)
253 inner_faces_at_proc_boundary[neigh_domain]
254 .n_hanging_faces_larger_subdomain++;
255 }
256 else if (neighbor->level() == dcell->level() &&
257 my_domain != neigh_domain)
258 {
259 // always list the cell whose owner has the lower
260 // subdomain id first. this applies to both processors
261 // involved, so both processors will generate the same
262 // list that we will later order
263 const CellId id_neigh = neighbor->id();
264 if (my_domain < neigh_domain)
265 inner_faces_at_proc_boundary[neigh_domain]
266 .shared_faces.emplace_back(id_mine, id_neigh);
267 else
268 inner_faces_at_proc_boundary[neigh_domain]
269 .shared_faces.emplace_back(id_neigh, id_mine);
270 }
271 }
272 }
273 }
274
275 // sort the cell ids related to each neighboring processor. This
276 // algorithm is symmetric so every processor combination should
277 // arrive here and no deadlock should be possible
278 for (auto &inner_face : inner_faces_at_proc_boundary)
279 {
280 Assert(inner_face.first != my_domain,
281 ExcInternalError("Should not send info to myself"));
282 std::sort(inner_face.second.shared_faces.begin(),
283 inner_face.second.shared_faces.end());
284 inner_face.second.shared_faces.erase(
285 std::unique(inner_face.second.shared_faces.begin(),
286 inner_face.second.shared_faces.end()),
287 inner_face.second.shared_faces.end());
288
289 // safety check: both involved processors should see the same list
290 // because the pattern of ghosting is symmetric. We test this by
291 // looking at the length of the lists of faces
292# if defined(DEAL_II_WITH_MPI) && defined(DEBUG)
293 MPI_Comm comm = MPI_COMM_SELF;
294 if (const ::parallel::TriangulationBase<dim> *ptria =
295 dynamic_cast<const ::parallel::TriangulationBase<dim>
296 *>(&triangulation))
297 comm = ptria->get_communicator();
298
299 MPI_Status status;
300 unsigned int mysize = inner_face.second.shared_faces.size();
301 unsigned int othersize = numbers::invalid_unsigned_int;
302 MPI_Sendrecv(&mysize,
303 1,
304 MPI_UNSIGNED,
305 inner_face.first,
306 600 + my_domain,
307 &othersize,
308 1,
309 MPI_UNSIGNED,
310 inner_face.first,
311 600 + inner_face.first,
312 comm,
313 &status);
314 AssertDimension(mysize, othersize);
315 mysize = inner_face.second.n_hanging_faces_smaller_subdomain;
316 MPI_Sendrecv(&mysize,
317 1,
318 MPI_UNSIGNED,
319 inner_face.first,
320 700 + my_domain,
321 &othersize,
322 1,
323 MPI_UNSIGNED,
324 inner_face.first,
325 700 + inner_face.first,
326 comm,
327 &status);
328 AssertDimension(mysize, othersize);
329 mysize = inner_face.second.n_hanging_faces_larger_subdomain;
330 MPI_Sendrecv(&mysize,
331 1,
332 MPI_UNSIGNED,
333 inner_face.first,
334 800 + my_domain,
335 &othersize,
336 1,
337 MPI_UNSIGNED,
338 inner_face.first,
339 800 + inner_face.first,
340 comm,
341 &status);
342 AssertDimension(mysize, othersize);
343# endif
344
345 // Arrange the face "ownership" such that cells that are access
346 // by more than one face (think of a cell in a corner) get
347 // ghosted. This arrangement has the advantage that we need to
348 // send less data because the same data is used twice. The
349 // strategy applied here is to ensure the same order of face
350 // pairs on both processors that share some faces, and make the
351 // same decision on both sides.
352
353 // Create a vector with cell ids sorted over the processor with
354 // the larger rank. In the code below we need to be able to
355 // identify the same cell once for the processor with higher
356 // rank and once for the processor with the lower rank. The
357 // format for the processor with the higher rank is already
358 // contained in `shared_faces`, whereas we need a copy that we
359 // sort differently for the other way around.
360 std::vector<std::tuple<CellId, CellId, unsigned int>> other_range(
361 inner_face.second.shared_faces.size());
362 for (unsigned int i = 0; i < other_range.size(); ++i)
363 other_range[i] =
364 std::make_tuple(inner_face.second.shared_faces[i].second,
365 inner_face.second.shared_faces[i].first,
366 i);
367 std::sort(other_range.begin(), other_range.end());
368
369 // the vector 'assignment' sets whether a particular cell
370 // appears more often and acts as a pre-selection of the rank. A
371 // value of 1 means that the process with the higher rank gets
372 // those faces, a value -1 means that the process with the lower
373 // rank gets it, whereas a value 0 means that the decision can
374 // be made in an arbitrary way.
375 unsigned int n_faces_lower_proc = 0, n_faces_higher_proc = 0;
376 std::vector<char> assignment(other_range.size(), 0);
377 if (inner_face.second.shared_faces.size() > 0)
378 {
379 // identify faces that go to the processor with the higher
380 // rank
381 unsigned int count = 0;
382 for (unsigned int i = 1;
383 i < inner_face.second.shared_faces.size();
384 ++i)
385 if (inner_face.second.shared_faces[i].first ==
386 inner_face.second.shared_faces[i - 1 - count].first)
387 ++count;
388 else
389 {
390 AssertThrow(count < 2 * dim, ExcInternalError());
391 if (count > 0)
392 {
393 for (unsigned int k = 0; k <= count; ++k)
394 assignment[i - 1 - k] = 1;
395 n_faces_higher_proc += count + 1;
396 }
397 count = 0;
398 }
399
400 // identify faces that definitely go to the processor with
401 // the lower rank - this must use the sorting of CellId
402 // variables from the processor with the higher rank, i.e.,
403 // other_range rather than `shared_faces`.
404 count = 0;
405 for (unsigned int i = 1; i < other_range.size(); ++i)
406 if (std::get<0>(other_range[i]) ==
407 std::get<0>(other_range[i - 1 - count]))
408 ++count;
409 else
410 {
411 AssertThrow(count < 2 * dim, ExcInternalError());
412 if (count > 0)
413 {
414 for (unsigned int k = 0; k <= count; ++k)
415 {
416 Assert(inner_face.second
417 .shared_faces[std::get<2>(
418 other_range[i - 1])]
419 .second ==
420 inner_face.second
421 .shared_faces[std::get<2>(
422 other_range[i - 1 - k])]
423 .second,
424 ExcInternalError());
425 // only assign to -1 if higher rank was not
426 // yet set
427 if (assignment[std::get<2>(
428 other_range[i - 1 - k])] == 0)
429 {
430 assignment[std::get<2>(
431 other_range[i - 1 - k])] = -1;
432 ++n_faces_lower_proc;
433 }
434 }
435 }
436 count = 0;
437 }
438 }
439
440
441 // divide the faces evenly between the two processors. the
442 // processor with small rank takes the first half, the processor
443 // with larger rank the second half. Adjust for the hanging
444 // faces that always get assigned to one side, and the faces we
445 // have already assigned due to the criterion above
446 n_faces_lower_proc +=
447 inner_face.second.n_hanging_faces_smaller_subdomain;
448 n_faces_higher_proc +=
449 inner_face.second.n_hanging_faces_larger_subdomain;
450 const unsigned int n_total_faces_at_proc_boundary =
451 (inner_face.second.shared_faces.size() +
452 inner_face.second.n_hanging_faces_smaller_subdomain +
453 inner_face.second.n_hanging_faces_larger_subdomain);
454 unsigned int split_index = n_total_faces_at_proc_boundary / 2;
455 if (split_index < n_faces_lower_proc)
456 split_index = 0;
457 else if (split_index <
458 n_total_faces_at_proc_boundary - n_faces_higher_proc)
459 split_index -= n_faces_lower_proc;
460 else
461 split_index = n_total_faces_at_proc_boundary -
462 n_faces_higher_proc - n_faces_lower_proc;
463
464 // make sure the splitting is consistent between both sides
465# if defined(DEAL_II_WITH_MPI) && defined(DEBUG)
466 MPI_Sendrecv(&split_index,
467 1,
468 MPI_UNSIGNED,
469 inner_face.first,
470 900 + my_domain,
471 &othersize,
472 1,
473 MPI_UNSIGNED,
474 inner_face.first,
475 900 + inner_face.first,
476 comm,
477 &status);
478 AssertDimension(split_index, othersize);
479 MPI_Sendrecv(&n_faces_lower_proc,
480 1,
481 MPI_UNSIGNED,
482 inner_face.first,
483 1000 + my_domain,
484 &othersize,
485 1,
486 MPI_UNSIGNED,
487 inner_face.first,
488 1000 + inner_face.first,
489 comm,
490 &status);
491 AssertDimension(n_faces_lower_proc, othersize);
492 MPI_Sendrecv(&n_faces_higher_proc,
493 1,
494 MPI_UNSIGNED,
495 inner_face.first,
496 1100 + my_domain,
497 &othersize,
498 1,
499 MPI_UNSIGNED,
500 inner_face.first,
501 1100 + inner_face.first,
502 comm,
503 &status);
504 AssertDimension(n_faces_higher_proc, othersize);
505# endif
506
507 // collect the faces on both sides
508 std::vector<std::pair<CellId, CellId>> owned_faces_lower,
509 owned_faces_higher;
510 for (unsigned int i = 0; i < assignment.size(); ++i)
511 if (assignment[i] < 0)
512 owned_faces_lower.push_back(
513 inner_face.second.shared_faces[i]);
514 else if (assignment[i] > 0)
515 owned_faces_higher.push_back(
516 inner_face.second.shared_faces[i]);
517 AssertIndexRange(split_index,
518 inner_face.second.shared_faces.size() + 1 -
519 owned_faces_lower.size() -
520 owned_faces_higher.size());
521
522 unsigned int i = 0, c = 0;
523 for (; i < assignment.size() && c < split_index; ++i)
524 if (assignment[i] == 0)
525 {
526 owned_faces_lower.push_back(
527 inner_face.second.shared_faces[i]);
528 ++c;
529 }
530 for (; i < assignment.size(); ++i)
531 if (assignment[i] == 0)
532 {
533 owned_faces_higher.push_back(
534 inner_face.second.shared_faces[i]);
535 }
536
537# ifdef DEBUG
538 // check consistency of faces on both sides
539 std::vector<std::pair<CellId, CellId>> check_faces;
540 check_faces.insert(check_faces.end(),
541 owned_faces_lower.begin(),
542 owned_faces_lower.end());
543 check_faces.insert(check_faces.end(),
544 owned_faces_higher.begin(),
545 owned_faces_higher.end());
546 std::sort(check_faces.begin(), check_faces.end());
547 AssertDimension(check_faces.size(),
548 inner_face.second.shared_faces.size());
549 for (unsigned int i = 0; i < check_faces.size(); ++i)
550 Assert(check_faces[i] == inner_face.second.shared_faces[i],
551 ExcInternalError());
552# endif
553
554 // now only set half of the faces as the ones to keep
555 if (my_domain < inner_face.first)
556 inner_face.second.shared_faces.swap(owned_faces_lower);
557 else
558 inner_face.second.shared_faces.swap(owned_faces_higher);
559
560 std::sort(inner_face.second.shared_faces.begin(),
561 inner_face.second.shared_faces.end());
562 }
563 }
564
565 // fill in the additional cells that we need access to via ghosting to
566 // cell_levels
567 std::set<std::pair<unsigned int, unsigned int>> ghost_cells;
568 for (unsigned int i = 0; i < cell_levels.size(); ++i)
569 {
570 typename ::Triangulation<dim>::cell_iterator dcell(
571 &triangulation, cell_levels[i].first, cell_levels[i].second);
572 if (use_active_cells)
573 Assert(dcell->is_active(), ExcNotImplemented());
574 for (const auto f : dcell->face_indices())
575 {
576 if (dcell->at_boundary(f) && !dcell->has_periodic_neighbor(f))
577 face_is_owned[dcell->face(f)->index()] =
578 FaceCategory::locally_active_at_boundary;
579
580 // treat boundaries of cells of different refinement level
581 // inside the domain in case of multigrid separately
582 else if ((dcell->at_boundary(f) == false ||
583 dcell->has_periodic_neighbor(f)) &&
584 mg_level != numbers::invalid_unsigned_int &&
585 dcell->neighbor_or_periodic_neighbor(f)->level() <
586 dcell->level())
587 {
588 face_is_owned[dcell->face(f)->index()] =
589 FaceCategory::multigrid_refinement_edge;
590 }
591 else
592 {
593 typename ::Triangulation<dim>::cell_iterator neighbor =
594 dcell->neighbor_or_periodic_neighbor(f);
595
596 // neighbor is refined -> face will be treated by neighbor
597 if (use_active_cells && neighbor->has_children() &&
598 hold_all_faces_to_owned_cells == false)
599 continue;
600
601 bool add_to_ghost = false;
602 const types::subdomain_id
603 id1 = use_active_cells ? dcell->subdomain_id() :
604 dcell->level_subdomain_id(),
605 id2 = use_active_cells ?
606 (neighbor->has_children() ?
607 dcell->neighbor_child_on_subface(f, 0)
608 ->subdomain_id() :
609 neighbor->subdomain_id()) :
610 neighbor->level_subdomain_id();
611
612 // Check whether the current face should be processed
613 // locally (instead of being processed from the other
614 // side). We process a face locally when we are more refined
615 // (in the active cell case) or when the face is listed in
616 // the `shared_faces` data structure that we built above.
617 if ((id1 == id2 &&
618 (use_active_cells == false || neighbor->is_active())) ||
619 dcell->level() > neighbor->level() ||
620 std::binary_search(
621 inner_faces_at_proc_boundary[id2].shared_faces.begin(),
622 inner_faces_at_proc_boundary[id2].shared_faces.end(),
623 std::make_pair(id1 < id2 ? dcell->id() : neighbor->id(),
624 id1 < id2 ? neighbor->id() :
625 dcell->id())))
626 {
627 face_is_owned[dcell->face(f)->index()] =
628 FaceCategory::locally_active_done_here;
629 if (dcell->level() == neighbor->level())
630 face_is_owned
631 [neighbor
632 ->face(dcell->has_periodic_neighbor(f) ?
633 dcell->periodic_neighbor_face_no(f) :
634 dcell->neighbor_face_no(f))
635 ->index()] =
636 FaceCategory::locally_active_done_here;
637
638 // If neighbor is a ghost element (i.e.
639 // dcell->subdomain_id !
640 // dcell->neighbor(f)->subdomain_id()), we need to add its
641 // index into cell level list.
642 if (use_active_cells)
643 add_to_ghost =
644 (dcell->subdomain_id() != neighbor->subdomain_id());
645 else
646 add_to_ghost = (dcell->level_subdomain_id() !=
647 neighbor->level_subdomain_id());
648 }
649 else if (hold_all_faces_to_owned_cells == true)
650 {
651 // add all cells to ghost layer...
652 face_is_owned[dcell->face(f)->index()] =
653 FaceCategory::ghosted;
654 if (use_active_cells)
655 {
656 if (neighbor->has_children())
657 for (unsigned int s = 0;
658 s < dcell->face(f)->n_children();
659 ++s)
660 if (dcell->at_boundary(f))
661 {
662 if (dcell
663 ->periodic_neighbor_child_on_subface(f,
664 s)
665 ->subdomain_id() !=
666 dcell->subdomain_id())
667 add_to_ghost = true;
668 }
669 else
670 {
671 if (dcell->neighbor_child_on_subface(f, s)
672 ->subdomain_id() !=
673 dcell->subdomain_id())
674 add_to_ghost = true;
675 }
676 else
677 add_to_ghost = (dcell->subdomain_id() !=
678 neighbor->subdomain_id());
679 }
680 else
681 add_to_ghost = (dcell->level_subdomain_id() !=
682 neighbor->level_subdomain_id());
683 }
684
685 if (add_to_ghost)
686 {
687 if (use_active_cells && neighbor->has_children())
688 for (unsigned int s = 0;
689 s < dcell->face(f)->n_children();
690 ++s)
691 {
692 typename ::Triangulation<dim>::cell_iterator
693 neighbor_child =
694 dcell->at_boundary(f) ?
695 dcell->periodic_neighbor_child_on_subface(f,
696 s) :
697 dcell->neighbor_child_on_subface(f, s);
698 if (neighbor_child->subdomain_id() !=
699 dcell->subdomain_id())
700 ghost_cells.insert(
701 std::pair<unsigned int, unsigned int>(
702 neighbor_child->level(),
703 neighbor_child->index()));
704 }
705 else
706 ghost_cells.insert(
707 std::pair<unsigned int, unsigned int>(
708 neighbor->level(), neighbor->index()));
709 at_processor_boundary[i] = true;
710 }
711 }
712 }
713 }
714
715 // step 2: append the ghost cells at the end of the locally owned
716 // cells
717 for (const auto &ghost_cell : ghost_cells)
718 cell_levels.push_back(ghost_cell);
719 }
720
721
722
723 template <int dim>
724 void
725 FaceSetup<dim>::generate_faces(
726 const ::Triangulation<dim> & triangulation,
727 const std::vector<std::pair<unsigned int, unsigned int>> &cell_levels,
728 TaskInfo & task_info)
729 {
730 // step 1: create the inverse map between cell iterators and the
731 // cell_level_index field
732 std::map<std::pair<unsigned int, unsigned int>, unsigned int>
733 map_to_vectorized;
734 for (unsigned int cell = 0; cell < cell_levels.size(); ++cell)
735 if (cell == 0 || cell_levels[cell] != cell_levels[cell - 1])
736 {
737 typename ::Triangulation<dim>::cell_iterator dcell(
738 &triangulation,
739 cell_levels[cell].first,
740 cell_levels[cell].second);
741 std::pair<unsigned int, unsigned int> level_index(dcell->level(),
742 dcell->index());
743 map_to_vectorized[level_index] = cell;
744 }
745
746 // step 2: fill the information about inner faces and boundary faces
747 const unsigned int vectorization_length = task_info.vectorization_length;
748 task_info.face_partition_data.resize(
749 task_info.cell_partition_data.size() - 1, 0);
750 task_info.boundary_partition_data.resize(
751 task_info.cell_partition_data.size() - 1, 0);
752 std::vector<unsigned char> face_visited(face_is_owned.size(), 0);
753 for (unsigned int partition = 0;
754 partition < task_info.cell_partition_data.size() - 2;
755 ++partition)
756 {
757 unsigned int boundary_counter = 0;
758 unsigned int inner_counter = 0;
759 for (unsigned int cell = task_info.cell_partition_data[partition] *
760 vectorization_length;
761 cell < task_info.cell_partition_data[partition + 1] *
762 vectorization_length;
763 ++cell)
764 if (cell == 0 || cell_levels[cell] != cell_levels[cell - 1])
765 {
766 typename ::Triangulation<dim>::cell_iterator dcell(
767 &triangulation,
768 cell_levels[cell].first,
769 cell_levels[cell].second);
770 for (const auto f : dcell->face_indices())
771 {
772 // boundary face
773 if (face_is_owned[dcell->face(f)->index()] ==
774 FaceCategory::locally_active_at_boundary)
775 {
776 Assert(dcell->at_boundary(f), ExcInternalError());
777 ++boundary_counter;
778 FaceToCellTopology<1> info;
779 info.cells_interior[0] = cell;
780 info.cells_exterior[0] = numbers::invalid_unsigned_int;
781 info.interior_face_no = f;
782 info.exterior_face_no = dcell->face(f)->boundary_id();
783 info.face_type =
784 dcell->face(f)->reference_cell() !=
785 ::ReferenceCells::get_hypercube<dim - 1>();
786 info.subface_index =
787 GeometryInfo<dim>::max_children_per_cell;
788 info.face_orientation = 0;
789 boundary_faces.push_back(info);
790
791 face_visited[dcell->face(f)->index()]++;
792 }
793 // interior face, including faces over periodic boundaries
794 else
795 {
796 typename ::Triangulation<dim>::cell_iterator
797 neighbor = dcell->neighbor_or_periodic_neighbor(f);
798 if (use_active_cells && neighbor->has_children())
799 {
800 for (unsigned int c = 0;
801 c < dcell->face(f)->n_children();
802 ++c)
803 {
804 typename ::Triangulation<
805 dim>::cell_iterator neighbor_c =
806 dcell->at_boundary(f) ?
807 dcell->periodic_neighbor_child_on_subface(
808 f, c) :
809 dcell->neighbor_child_on_subface(f, c);
810 const types::subdomain_id neigh_domain =
811 neighbor_c->subdomain_id();
812 const unsigned int neighbor_face_no =
813 dcell->has_periodic_neighbor(f) ?
814 dcell->periodic_neighbor_face_no(f) :
815 dcell->neighbor_face_no(f);
816 if (neigh_domain != dcell->subdomain_id() ||
817 face_visited
818 [dcell->face(f)->child(c)->index()] ==
819 1)
820 {
821 std::pair<unsigned int, unsigned int>
822 level_index(neighbor_c->level(),
823 neighbor_c->index());
824 if (face_is_owned
825 [dcell->face(f)->child(c)->index()] ==
826 FaceCategory::locally_active_done_here)
827 {
828 ++inner_counter;
829 inner_faces.push_back(create_face(
830 neighbor_face_no,
831 neighbor_c,
832 map_to_vectorized[level_index],
833 dcell,
834 cell));
835 }
836 else if (face_is_owned[dcell->face(f)
837 ->child(c)
838 ->index()] ==
839 FaceCategory::ghosted)
840 {
841 inner_ghost_faces.push_back(create_face(
842 neighbor_face_no,
843 neighbor_c,
844 map_to_vectorized[level_index],
845 dcell,
846 cell));
847 }
848 else
849 Assert(
850 face_is_owned[dcell->face(f)
851 ->index()] ==
852 FaceCategory::
853 locally_active_done_elsewhere ||
854 face_is_owned[dcell->face(f)
855 ->index()] ==
856 FaceCategory::ghosted,
857 ExcInternalError());
858 }
859 else
860 {
861 face_visited
862 [dcell->face(f)->child(c)->index()] = 1;
863 }
864 }
865 }
866 else
867 {
868 const types::subdomain_id my_domain =
869 use_active_cells ? dcell->subdomain_id() :
870 dcell->level_subdomain_id();
871 const types::subdomain_id neigh_domain =
872 use_active_cells ? neighbor->subdomain_id() :
873 neighbor->level_subdomain_id();
874 if (neigh_domain != my_domain ||
875 face_visited[dcell->face(f)->index()] == 1)
876 {
877 std::pair<unsigned int, unsigned int>
878 level_index(neighbor->level(),
879 neighbor->index());
880 if (face_is_owned[dcell->face(f)->index()] ==
881 FaceCategory::locally_active_done_here)
882 {
883 Assert(use_active_cells ||
884 dcell->level() ==
885 neighbor->level(),
886 ExcInternalError());
887 ++inner_counter;
888 inner_faces.push_back(create_face(
889 f,
890 dcell,
891 cell,
892 neighbor,
893 map_to_vectorized[level_index]));
894 }
895 else if (face_is_owned[dcell->face(f)
896 ->index()] ==
897 FaceCategory::ghosted)
898 {
899 inner_ghost_faces.push_back(create_face(
900 f,
901 dcell,
902 cell,
903 neighbor,
904 map_to_vectorized[level_index]));
905 }
906 }
907 else
908 {
909 face_visited[dcell->face(f)->index()] = 1;
910 if (dcell->has_periodic_neighbor(f))
911 face_visited
912 [neighbor
913 ->face(
914 dcell->periodic_neighbor_face_no(f))
915 ->index()] = 1;
916 }
917 if (face_is_owned[dcell->face(f)->index()] ==
918 FaceCategory::multigrid_refinement_edge)
919 {
920 refinement_edge_faces.push_back(
921 create_face(f,
922 dcell,
923 cell,
924 neighbor,
925 refinement_edge_faces.size()));
926 }
927 }
928 }
929 }
930 }
931 task_info.face_partition_data[partition + 1] =
932 task_info.face_partition_data[partition] + inner_counter;
933 task_info.boundary_partition_data[partition + 1] =
934 task_info.boundary_partition_data[partition] + boundary_counter;
935 }
936 task_info.ghost_face_partition_data.resize(2);
937 task_info.ghost_face_partition_data[0] = 0;
938 task_info.ghost_face_partition_data[1] = inner_ghost_faces.size();
939 task_info.refinement_edge_face_partition_data.resize(2);
940 task_info.refinement_edge_face_partition_data[0] = 0;
941 task_info.refinement_edge_face_partition_data[1] =
942 refinement_edge_faces.size();
943 }
944
945
946
947 template <int dim>
948 FaceToCellTopology<1>
949 FaceSetup<dim>::create_face(
950 const unsigned int face_no,
951 const typename ::Triangulation<dim>::cell_iterator &cell,
952 const unsigned int number_cell_interior,
953 const typename ::Triangulation<dim>::cell_iterator &neighbor,
954 const unsigned int number_cell_exterior)
955 {
956 FaceToCellTopology<1> info;
957 info.cells_interior[0] = number_cell_interior;
958 info.cells_exterior[0] = number_cell_exterior;
959 info.interior_face_no = face_no;
960 if (cell->has_periodic_neighbor(face_no))
961 info.exterior_face_no = cell->periodic_neighbor_face_no(face_no);
962 else
963 info.exterior_face_no = cell->neighbor_face_no(face_no);
964
965 info.face_type = cell->face(face_no)->reference_cell() !=
966 ::ReferenceCells::get_hypercube<dim - 1>();
967
968 info.subface_index = GeometryInfo<dim>::max_children_per_cell;
969 Assert(neighbor->level() <= cell->level(), ExcInternalError());
970 if (cell->level() > neighbor->level())
971 {
972 if (cell->has_periodic_neighbor(face_no))
973 info.subface_index =
974 cell->periodic_neighbor_of_coarser_periodic_neighbor(face_no)
975 .second;
976 else
977 info.subface_index =
978 cell->neighbor_of_coarser_neighbor(face_no).second;
979 }
980
981 // special treatment of periodic boundaries
982 if (dim == 3 && cell->has_periodic_neighbor(face_no))
983 {
984 const unsigned int exterior_face_orientation =
985 !cell->get_triangulation()
986 .get_periodic_face_map()
987 .at({cell, face_no})
988 .second[0] +
989 2 * cell->get_triangulation()
990 .get_periodic_face_map()
991 .at({cell, face_no})
992 .second[1] +
993 4 * cell->get_triangulation()
994 .get_periodic_face_map()
995 .at({cell, face_no})
996 .second[2];
997
998 info.face_orientation = exterior_face_orientation;
999
1000 return info;
1001 }
1002
1003 info.face_orientation = 0;
1004 const unsigned int interior_face_orientation =
1005 !cell->face_orientation(face_no) + 2 * cell->face_flip(face_no) +
1006 4 * cell->face_rotation(face_no);
1007 const unsigned int exterior_face_orientation =
1008 !neighbor->face_orientation(info.exterior_face_no) +
1009 2 * neighbor->face_flip(info.exterior_face_no) +
1010 4 * neighbor->face_rotation(info.exterior_face_no);
1011 if (interior_face_orientation != 0)
1012 {
1013 info.face_orientation = 8 + interior_face_orientation;
1014 Assert(exterior_face_orientation == 0,
1015 ExcMessage(
1016 "Face seems to be wrongly oriented from both sides"));
1017 }
1018 else
1019 info.face_orientation = exterior_face_orientation;
1020 return info;
1021 }
1022
1023
1024
1031 inline bool
1032 compare_faces_for_vectorization(
1033 const FaceToCellTopology<1> & face1,
1034 const FaceToCellTopology<1> & face2,
1035 const std::vector<unsigned int> &active_fe_indices,
1036 const unsigned int length)
1037 {
1038 if (face1.interior_face_no != face2.interior_face_no)
1039 return false;
1040 if (face1.exterior_face_no != face2.exterior_face_no)
1041 return false;
1042 if (face1.subface_index != face2.subface_index)
1043 return false;
1044 if (face1.face_orientation != face2.face_orientation)
1045 return false;
1046 if (face1.face_type != face2.face_type)
1047 return false;
1048
1049 if (active_fe_indices.size() > 0)
1050 {
1051 if (active_fe_indices[face1.cells_interior[0] / length] !=
1052 active_fe_indices[face2.cells_interior[0] / length])
1053 return false;
1054
1055 if (face2.cells_exterior[0] != numbers::invalid_unsigned_int)
1056 if (active_fe_indices[face1.cells_exterior[0] / length] !=
1057 active_fe_indices[face2.cells_exterior[0] / length])
1058 return false;
1059 }
1060
1061 return true;
1062 }
1063
1064
1065
1072 template <int length>
1073 struct FaceComparator
1074 {
1075 FaceComparator(const std::vector<unsigned int> &active_fe_indices)
1076 : active_fe_indices(active_fe_indices)
1077 {}
1078
1079 bool
1080 operator()(const FaceToCellTopology<length> &face1,
1081 const FaceToCellTopology<length> &face2) const
1082 {
1083 // check if active FE indices match
1084 if (face1.face_type < face2.face_type)
1085 return true;
1086 else if (face1.face_type > face2.face_type)
1087 return false;
1088
1089 // check if active FE indices match
1090 if (active_fe_indices.size() > 0)
1091 {
1092 // ... for interior faces
1093 if (active_fe_indices[face1.cells_interior[0] / length] <
1094 active_fe_indices[face2.cells_interior[0] / length])
1095 return true;
1096 else if (active_fe_indices[face1.cells_interior[0] / length] >
1097 active_fe_indices[face2.cells_interior[0] / length])
1098 return false;
1099
1100 // ... for exterior faces
1101 if (face2.cells_exterior[0] != numbers::invalid_unsigned_int)
1102 {
1103 if (active_fe_indices[face1.cells_exterior[0] / length] <
1104 active_fe_indices[face2.cells_exterior[0] / length])
1105 return true;
1106 else if (active_fe_indices[face1.cells_exterior[0] / length] >
1107 active_fe_indices[face2.cells_exterior[0] / length])
1108 return false;
1109 }
1110 }
1111
1112 for (unsigned int i = 0; i < length; ++i)
1113 if (face1.cells_interior[i] < face2.cells_interior[i])
1114 return true;
1115 else if (face1.cells_interior[i] > face2.cells_interior[i])
1116 return false;
1117 for (unsigned int i = 0; i < length; ++i)
1118 if (face1.cells_exterior[i] < face2.cells_exterior[i])
1119 return true;
1120 else if (face1.cells_exterior[i] > face2.cells_exterior[i])
1121 return false;
1122 if (face1.interior_face_no < face2.interior_face_no)
1123 return true;
1124 else if (face1.interior_face_no > face2.interior_face_no)
1125 return false;
1126 if (face1.exterior_face_no < face2.exterior_face_no)
1127 return true;
1128 else if (face1.exterior_face_no > face2.exterior_face_no)
1129 return false;
1130
1131 // we do not need to check for subface_index and orientation because
1132 // those cannot be different if when all the other values are the
1133 // same.
1134 AssertDimension(face1.subface_index, face2.subface_index);
1135 AssertDimension(face1.face_orientation, face2.face_orientation);
1136
1137 return false;
1138 }
1139
1140 private:
1141 const std::vector<unsigned int> &active_fe_indices;
1142 };
1143
1144
1145
1146 template <int vectorization_width>
1147 void
1148 collect_faces_vectorization(
1149 const std::vector<FaceToCellTopology<1>> &faces_in,
1150 const std::vector<bool> & hard_vectorization_boundary,
1151 std::vector<unsigned int> & face_partition_data,
1152 std::vector<FaceToCellTopology<vectorization_width>> &faces_out,
1153 const std::vector<unsigned int> & active_fe_indices)
1154 {
1155 FaceToCellTopology<vectorization_width> macro_face;
1156 std::vector<std::vector<unsigned int>> faces_type;
1157
1158 unsigned int face_start = face_partition_data[0],
1159 face_end = face_partition_data[0];
1160
1161 face_partition_data[0] = faces_out.size();
1162 for (unsigned int partition = 0;
1163 partition < face_partition_data.size() - 1;
1164 ++partition)
1165 {
1166 std::vector<std::vector<unsigned int>> new_faces_type;
1167
1168 // start with the end point for the last partition
1169 face_start = face_end;
1170 face_end = face_partition_data[partition + 1];
1171
1172 // set the partitioner to the new vectorized lengths
1173 face_partition_data[partition + 1] = face_partition_data[partition];
1174
1175 // loop over the faces in the current partition and reorder according
1176 // to the face type
1177 for (unsigned int face = face_start; face < face_end; ++face)
1178 {
1179 for (auto &face_type : faces_type)
1180 {
1181 // Compare current face with first face of type type
1182 if (compare_faces_for_vectorization(faces_in[face],
1183 faces_in[face_type[0]],
1184 active_fe_indices,
1185 vectorization_width))
1186 {
1187 face_type.push_back(face);
1188 goto face_found;
1189 }
1190 }
1191 faces_type.emplace_back(1, face);
1192 face_found:
1193 {}
1194 }
1195
1196 // insert new faces in sorted list to get good data locality
1197 FaceComparator<vectorization_width> face_comparator(
1198 active_fe_indices);
1199 std::set<FaceToCellTopology<vectorization_width>,
1200 FaceComparator<vectorization_width>>
1201 new_faces(face_comparator);
1202 for (const auto &face_type : faces_type)
1203 {
1204 macro_face.face_type = faces_in[face_type[0]].face_type;
1205 macro_face.interior_face_no =
1206 faces_in[face_type[0]].interior_face_no;
1207 macro_face.exterior_face_no =
1208 faces_in[face_type[0]].exterior_face_no;
1209 macro_face.subface_index = faces_in[face_type[0]].subface_index;
1210 macro_face.face_orientation =
1211 faces_in[face_type[0]].face_orientation;
1212 unsigned int no_faces = face_type.size();
1213 std::vector<unsigned char> touched(no_faces, 0);
1214
1215 // do two passes through the data. The first is to identify
1216 // similar faces within the same index range as the cells which
1217 // will allow for vectorized read operations, the second picks up
1218 // all the rest
1219 unsigned int n_vectorized = 0;
1220 for (unsigned int f = 0; f < no_faces; ++f)
1221 if (faces_in[face_type[f]].cells_interior[0] %
1222 vectorization_width ==
1223 0)
1224 {
1225 bool is_contiguous = true;
1226 if (f + vectorization_width > no_faces)
1227 is_contiguous = false;
1228 else
1229 for (unsigned int v = 1; v < vectorization_width; ++v)
1230 if (faces_in[face_type[f + v]].cells_interior[0] !=
1231 faces_in[face_type[f]].cells_interior[0] + v)
1232 is_contiguous = false;
1233 if (is_contiguous)
1234 {
1235 AssertIndexRange(f,
1236 face_type.size() -
1237 vectorization_width + 1);
1238 for (unsigned int v = 0; v < vectorization_width; ++v)
1239 {
1240 macro_face.cells_interior[v] =
1241 faces_in[face_type[f + v]].cells_interior[0];
1242 macro_face.cells_exterior[v] =
1243 faces_in[face_type[f + v]].cells_exterior[0];
1244 touched[f + v] = 1;
1245 }
1246 new_faces.insert(macro_face);
1247 f += vectorization_width - 1;
1248 n_vectorized += vectorization_width;
1249 }
1250 }
1251
1252 std::vector<unsigned int> untouched;
1253 untouched.reserve(no_faces - n_vectorized);
1254 for (unsigned int f = 0; f < no_faces; ++f)
1255 if (touched[f] == 0)
1256 untouched.push_back(f);
1257 unsigned int v = 0;
1258 for (const auto f : untouched)
1259 {
1260 macro_face.cells_interior[v] =
1261 faces_in[face_type[f]].cells_interior[0];
1262 macro_face.cells_exterior[v] =
1263 faces_in[face_type[f]].cells_exterior[0];
1264 ++v;
1265 if (v == vectorization_width)
1266 {
1267 new_faces.insert(macro_face);
1268 v = 0;
1269 }
1270 }
1271 if (v > 0 && v < vectorization_width)
1272 {
1273 // must add non-filled face
1274 if (hard_vectorization_boundary[partition + 1] ||
1275 partition == face_partition_data.size() - 2)
1276 {
1277 for (; v < vectorization_width; ++v)
1278 {
1279 // Dummy cell, not used
1280 macro_face.cells_interior[v] =
1281 numbers::invalid_unsigned_int;
1282 macro_face.cells_exterior[v] =
1283 numbers::invalid_unsigned_int;
1284 }
1285 new_faces.insert(macro_face);
1286 }
1287 else
1288 {
1289 // postpone to the next partition
1290 std::vector<unsigned int> untreated(v);
1291 for (unsigned int f = 0; f < v; ++f)
1292 untreated[f] = face_type[*(untouched.end() - 1 - f)];
1293 new_faces_type.push_back(untreated);
1294 }
1295 }
1296 }
1297
1298 // insert sorted list to vector of faces
1299 for (auto it = new_faces.begin(); it != new_faces.end(); ++it)
1300 faces_out.push_back(*it);
1301 face_partition_data[partition + 1] += new_faces.size();
1302
1303 // set the faces that were left over to faces_type for the next round
1304 faces_type = std::move(new_faces_type);
1305 }
1306
1307# ifdef DEBUG
1308 // final safety checks
1309 for (const auto &face_type : faces_type)
1310 AssertDimension(face_type.size(), 0U);
1311
1312 AssertDimension(faces_out.size(), face_partition_data.back());
1313 unsigned int nfaces = 0;
1314 for (unsigned int i = face_partition_data[0];
1315 i < face_partition_data.back();
1316 ++i)
1317 for (unsigned int v = 0; v < vectorization_width; ++v)
1318 nfaces +=
1319 (faces_out[i].cells_interior[v] != numbers::invalid_unsigned_int);
1320 AssertDimension(nfaces, faces_in.size());
1321
1322 std::vector<std::pair<unsigned int, unsigned int>> in_faces, out_faces;
1323 for (const auto &face_in : faces_in)
1324 in_faces.emplace_back(face_in.cells_interior[0],
1325 face_in.cells_exterior[0]);
1326 for (unsigned int i = face_partition_data[0];
1327 i < face_partition_data.back();
1328 ++i)
1329 for (unsigned int v = 0;
1330 v < vectorization_width &&
1331 faces_out[i].cells_interior[v] != numbers::invalid_unsigned_int;
1332 ++v)
1333 out_faces.emplace_back(faces_out[i].cells_interior[v],
1334 faces_out[i].cells_exterior[v]);
1335 std::sort(in_faces.begin(), in_faces.end());
1336 std::sort(out_faces.begin(), out_faces.end());
1337 AssertDimension(in_faces.size(), out_faces.size());
1338 for (unsigned int i = 0; i < in_faces.size(); ++i)
1339 {
1340 AssertDimension(in_faces[i].first, out_faces[i].first);
1341 AssertDimension(in_faces[i].second, out_faces[i].second);
1342 }
1343# endif
1344 }
1345
1346#endif // ifndef DOXYGEN
1347
1348 } // namespace MatrixFreeFunctions
1349} // namespace internal
1350
1351
1352DEAL_II_NAMESPACE_CLOSE
1353
1354#endif
CellId
Definition: cell_id.h:71
MPI_Comm
DEAL_II_NAMESPACE_OPEN
#define DEAL_II_NAMESPACE_OPEN
Definition: config.h:402
DEAL_II_NAMESPACE_CLOSE
#define DEAL_II_NAMESPACE_CLOSE
Definition: config.h:403
face_info.h
second
Point< 2 > second
Definition: grid_out.cc:4588
first
Point< 2 > first
Definition: grid_out.cc:4587
StandardExceptions::ExcNotImplemented
static ::ExceptionBase & ExcNotImplemented()
Assert
#define Assert(cond, exc)
Definition: exceptions.h:1465
AssertDimension
#define AssertDimension(dim1, dim2)
Definition: exceptions.h:1622
AssertIndexRange
#define AssertIndexRange(index, range)
Definition: exceptions.h:1690
StandardExceptions::ExcInternalError
static ::ExceptionBase & ExcInternalError()
StandardExceptions::ExcMessage
static ::ExceptionBase & ExcMessage(std::string arg1)
AssertThrow
#define AssertThrow(cond, exc)
Definition: exceptions.h:1575
memory_consumption.h
LAPACKSupport::U
static const char U
Definition: lapack_support.h:169
ReferenceCells::get_hypercube
constexpr const ReferenceCell & get_hypercube()
Definition: reference_cell.h:1505
SparsityTools::partition
void partition(const SparsityPattern &sparsity_pattern, const unsigned int n_partitions, std::vector< unsigned int > &partition_indices, const Partitioner partitioner=Partitioner::metis)
Definition: sparsity_tools.cc:399
internal::MatrixFreeFunctions::collect_faces_vectorization
void collect_faces_vectorization(const std::vector< FaceToCellTopology< 1 > > &faces_in, const std::vector< bool > &hard_vectorization_boundary, std::vector< unsigned int > &face_partition_data, std::vector< FaceToCellTopology< vectorization_width > > &faces_out)
numbers::invalid_subdomain_id
const types::subdomain_id invalid_subdomain_id
Definition: types.h:276
numbers::invalid_unsigned_int
static const unsigned int invalid_unsigned_int
Definition: types.h:196
parallel::Triangulation
TriangulationBase< dim, spacedim > Triangulation
Definition: tria_base.h:396
triangulation
const ::parallel::distributed::Triangulation< dim, spacedim > * triangulation
Definition: p4est_wrappers.cc:69
comm
*braid_SplitCommworld & comm
Definition: parallel_in_time.h:1946
internal::MatrixFreeFunctions::FaceIdentifier::shared_faces
std::vector< std::pair< CellId, CellId > > shared_faces
Definition: face_setup_internal.h:54
internal::MatrixFreeFunctions::FaceSetup::inner_faces
std::vector< FaceToCellTopology< 1 > > inner_faces
Definition: face_setup_internal.h:130
internal::MatrixFreeFunctions::FaceSetup::boundary_faces
std::vector< FaceToCellTopology< 1 > > boundary_faces
Definition: face_setup_internal.h:131
internal::MatrixFreeFunctions::FaceSetup::refinement_edge_faces
std::vector< FaceToCellTopology< 1 > > refinement_edge_faces
Definition: face_setup_internal.h:133
internal::MatrixFreeFunctions::FaceSetup::initialize
void initialize(const ::Triangulation< dim > &triangulation, const unsigned int mg_level, const bool hold_all_faces_to_owned_cells, std::vector< std::pair< unsigned int, unsigned int > > &cell_levels)
internal::MatrixFreeFunctions::FaceSetup::create_face
FaceToCellTopology< 1 > create_face(const unsigned int face_no, const typename ::Triangulation< dim >::cell_iterator &cell, const unsigned int number_cell_interior, const typename ::Triangulation< dim >::cell_iterator &neighbor, const unsigned int number_cell_exterior)
internal::MatrixFreeFunctions::FaceSetup::inner_ghost_faces
std::vector< FaceToCellTopology< 1 > > inner_ghost_faces
Definition: face_setup_internal.h:132
internal::MatrixFreeFunctions::FaceSetup::generate_faces
void generate_faces(const ::Triangulation< dim > &triangulation, const std::vector< std::pair< unsigned int, unsigned int > > &cell_levels, TaskInfo &task_info)
task_info.h
tria_accessor.h
tria_base.h
Generated by doxygen 1.9.4