47#define BOOST_BIND_GLOBAL_PLACEHOLDERS
48#include <boost/config.hpp>
49#include <boost/graph/adjacency_list.hpp>
50#include <boost/graph/bandwidth.hpp>
51#include <boost/graph/cuthill_mckee_ordering.hpp>
52#include <boost/graph/king_ordering.hpp>
53#include <boost/graph/minimum_degree_ordering.hpp>
54#include <boost/graph/properties.hpp>
55#include <boost/random.hpp>
56#include <boost/random/uniform_int_distribution.hpp>
58#undef BOOST_BIND_GLOBAL_PLACEHOLDERS
75 using namespace ::
boost;
77 using Graph = adjacency_list<vecS,
80 property<vertex_color_t,
82 property<vertex_degree_t, int>>>;
83 using Vertex = graph_traits<Graph>::vertex_descriptor;
84 using size_type = graph_traits<Graph>::vertices_size_type;
86 using Pair = std::pair<size_type, size_type>;
73 namespace boosttypes {
…}
92 template <
int dim,
int spacedim>
95 const bool use_constraints,
98 boosttypes::vertex_degree_t>::type
113 for (
unsigned int row = 0; row < dsp.
n_rows(); ++row)
114 for (
unsigned int col = 0; col < dsp.
row_length(row); ++col)
118 boosttypes::graph_traits<boosttypes::Graph>::vertex_iterator ui, ui_end;
120 graph_degree = get(::boost::vertex_degree, graph);
121 for (::boost::tie(ui, ui_end) = vertices(graph); ui != ui_end; ++ui)
122 graph_degree[*ui] = degree(*ui, graph);
127 template <
int dim,
int spacedim>
130 const bool reversed_numbering,
131 const bool use_constraints)
133 std::vector<types::global_dof_index> renumbering(
147 template <
int dim,
int spacedim>
151 const bool reversed_numbering,
152 const bool use_constraints)
156 boosttypes::vertex_degree_t>::type graph_degree;
161 boosttypes::vertex_index_t>::type index_map =
162 get(::boost::vertex_index, graph);
165 std::vector<boosttypes::Vertex> inv_perm(num_vertices(graph));
167 if (reversed_numbering ==
false)
168 ::boost::cuthill_mckee_ordering(graph,
170 get(::boost::vertex_color, graph),
171 make_degree_map(graph));
173 ::boost::cuthill_mckee_ordering(graph,
175 get(::boost::vertex_color, graph),
176 make_degree_map(graph));
179 new_dof_indices[index_map[inv_perm[c]]] = c;
181 Assert(std::find(new_dof_indices.begin(),
182 new_dof_indices.end(),
189 template <
int dim,
int spacedim>
192 const bool reversed_numbering,
193 const bool use_constraints)
195 std::vector<types::global_dof_index> renumbering(
209 template <
int dim,
int spacedim>
213 const bool reversed_numbering,
214 const bool use_constraints)
218 boosttypes::vertex_degree_t>::type graph_degree;
223 boosttypes::vertex_index_t>::type index_map =
224 get(::boost::vertex_index, graph);
227 std::vector<boosttypes::Vertex> inv_perm(num_vertices(graph));
229 if (reversed_numbering ==
false)
232 ::boost::king_ordering(graph, inv_perm.begin());
235 new_dof_indices[index_map[inv_perm[c]]] = c;
237 Assert(std::find(new_dof_indices.begin(),
238 new_dof_indices.end(),
245 template <
int dim,
int spacedim>
248 const bool reversed_numbering,
249 const bool use_constraints)
251 std::vector<types::global_dof_index> renumbering(
265 template <
int dim,
int spacedim>
268 std::vector<types::global_dof_index> &new_dof_indices,
270 const bool reversed_numbering,
271 const bool use_constraints)
273 (void)use_constraints;
282 using namespace ::
boost;
287 using Graph = adjacency_list<vecS, vecS, directedS>;
289 int n = dof_handler.
n_dofs();
293 std::vector<::types::global_dof_index> dofs_on_this_cell;
297 const unsigned int dofs_per_cell = cell->get_fe().n_dofs_per_cell();
299 dofs_on_this_cell.resize(dofs_per_cell);
301 cell->get_active_or_mg_dof_indices(dofs_on_this_cell);
302 for (
unsigned int i = 0; i < dofs_per_cell; ++i)
303 for (
unsigned int j = 0; j < dofs_per_cell; ++j)
304 if (dofs_on_this_cell[i] > dofs_on_this_cell[j])
306 add_edge(dofs_on_this_cell[i], dofs_on_this_cell[j], G);
307 add_edge(dofs_on_this_cell[j], dofs_on_this_cell[i], G);
312 using Vector = std::vector<int>;
315 Vector inverse_perm(n, 0);
320 Vector supernode_sizes(n, 1);
323 ::boost::property_map<Graph, vertex_index_t>::type
id =
324 get(vertex_index, G);
330 minimum_degree_ordering(
332 make_iterator_property_map(degree.
begin(),
id, degree[0]),
335 make_iterator_property_map(supernode_sizes.
begin(),
342 for (
int i = 0; i < n; ++i)
352 if (reversed_numbering ==
true)
353 std::copy(perm.
begin(), perm.
end(), new_dof_indices.begin());
355 std::copy(inverse_perm.
begin(),
357 new_dof_indices.begin());
364 template <
int dim,
int spacedim>
367 const bool reversed_numbering,
368 const bool use_constraints,
369 const std::vector<types::global_dof_index> &starting_indices)
371 std::vector<types::global_dof_index> renumbering(
388 template <
int dim,
int spacedim>
391 std::vector<types::global_dof_index> &new_indices,
393 const bool reversed_numbering,
394 const bool use_constraints,
395 const std::vector<types::global_dof_index> &starting_indices,
396 const unsigned int level)
398 const bool reorder_level_dofs =
413 if (reorder_level_dofs ==
true)
417 const IndexSet locally_relevant_dofs =
418 (reorder_level_dofs ==
false ?
421 const IndexSet &locally_owned_dofs =
431 constraints.
reinit(locally_owned_dofs, locally_relevant_dofs);
442 locally_owned_dofs.
size());
443 if (reorder_level_dofs ==
false)
455 if (reversed_numbering)
468 const IndexSet locally_active_dofs =
469 (reorder_level_dofs ==
false ?
473 bool needs_locally_active =
false;
474 for (
const auto starting_index : starting_indices)
476 if ((needs_locally_active ==
478 (locally_owned_dofs.
is_element(starting_index) ==
false))
481 locally_active_dofs.
is_element(starting_index),
483 "You specified global degree of freedom " +
484 std::to_string(starting_index) +
485 " as a starting index, but this index is not among the "
486 "locally active ones on this processor, as required "
487 "for this function."));
488 needs_locally_active =
true;
493 (needs_locally_active ? locally_active_dofs : locally_owned_dofs);
504 index_set_to_use.
size(),
506 if (reorder_level_dofs ==
false)
517 std::vector<types::global_dof_index> row_entries;
518 for (
unsigned int i = 0; i < index_set_to_use.
n_elements(); ++i)
522 const unsigned int row_length = dsp.
row_length(row);
524 for (
unsigned int j = 0; j < row_length; ++j)
527 if (col != row && index_set_to_use.
is_element(col))
537 std::vector<types::global_dof_index> local_starting_indices(
538 starting_indices.size());
539 for (
unsigned int i = 0; i < starting_indices.size(); ++i)
540 local_starting_indices[i] =
545 std::vector<types::global_dof_index> my_new_indices(
549 local_starting_indices);
550 if (reversed_numbering)
559 if (needs_locally_active ==
true)
562 IndexSet active_but_not_owned_dofs = locally_active_dofs;
563 active_but_not_owned_dofs.
subtract_set(locally_owned_dofs);
565 std::set<types::global_dof_index> erase_these_indices;
566 for (
const auto p : active_but_not_owned_dofs)
571 erase_these_indices.insert(my_new_indices[index]);
574 Assert(erase_these_indices.size() ==
577 Assert(
static_cast<unsigned int>(
578 std::count(my_new_indices.begin(),
579 my_new_indices.end(),
585 std::vector<types::global_dof_index> translate_indices(
586 my_new_indices.size());
588 std::set<types::global_dof_index>::const_iterator
589 next_erased_index = erase_these_indices.begin();
591 for (
unsigned int i = 0; i < translate_indices.size(); ++i)
592 if ((next_erased_index != erase_these_indices.end()) &&
593 (*next_erased_index == i))
600 translate_indices[i] = next_new_index;
610 new_indices.reserve(locally_owned_dofs.
n_elements());
611 for (
const auto &p : my_new_indices)
616 new_indices.push_back(translate_indices[p]);
622 new_indices = std::move(my_new_indices);
635 template <
int dim,
int spacedim>
638 const unsigned int level,
639 const bool reversed_numbering,
640 const std::vector<types::global_dof_index> &starting_indices)
645 std::vector<types::global_dof_index> new_indices(
664 template <
int dim,
int spacedim>
667 const std::vector<unsigned int> &component_order_arg)
669 std::vector<types::global_dof_index> renumbering(
673 compute_component_wise<dim, spacedim>(renumbering,
695 (result <= dof_handler.
n_dofs())),
703 template <
int dim,
int spacedim>
706 const unsigned int level,
707 const std::vector<unsigned int> &component_order_arg)
712 std::vector<types::global_dof_index> renumbering(
722 compute_component_wise<dim, spacedim>(
723 renumbering, start, end, component_order_arg,
true);
750 template <
int dim,
int spacedim,
typename CellIterator>
753 const CellIterator &start,
755 const std::vector<unsigned int> &component_order_arg,
756 const bool is_level_operation)
759 start->get_dof_handler().get_fe_collection();
765 new_indices.resize(0);
772 const IndexSet &locally_owned_dofs =
774 start->get_dof_handler().locally_owned_mg_dofs(start->level()) :
775 start->get_dof_handler().locally_owned_dofs();
779 std::vector<unsigned int> component_order(component_order_arg);
784 if (component_order.empty())
785 for (
unsigned int i = 0; i < fe_collection.
n_components(); ++i)
786 component_order.push_back(i);
792 for (
const unsigned int component : component_order)
800 std::vector<types::global_dof_index> local_dof_indices;
812 std::vector<std::vector<unsigned int>> component_list(fe_collection.
size());
813 for (
unsigned int f = 0; f < fe_collection.
size(); ++f)
817 component_list[f].resize(dofs_per_cell);
818 for (
unsigned int i = 0; i < dofs_per_cell; ++i)
820 component_list[f][i] =
824 const unsigned int comp =
830 component_list[f][i] = component_order[comp];
845 std::vector<std::vector<types::global_dof_index>> component_to_dof_map(
847 for (CellIterator cell = start; cell != end; ++cell)
849 if (is_level_operation)
852 if (!cell->is_locally_owned_on_level())
859 if (!cell->is_locally_owned())
863 if (is_level_operation)
865 cell->level() == start->level(),
867 "Multigrid renumbering in compute_component_wise() needs to be applied to a single level!"));
873 const unsigned int dofs_per_cell =
874 fe_collection[fe_index].n_dofs_per_cell();
875 local_dof_indices.resize(dofs_per_cell);
876 cell->get_active_or_mg_dof_indices(local_dof_indices);
878 for (
unsigned int i = 0; i < dofs_per_cell; ++i)
879 if (locally_owned_dofs.
is_element(local_dof_indices[i]))
880 component_to_dof_map[component_list[fe_index][i]].
push_back(
881 local_dof_indices[i]);
907 for (
unsigned int component = 0; component < fe_collection.
n_components();
910 std::sort(component_to_dof_map[component].begin(),
911 component_to_dof_map[component].end());
912 component_to_dof_map[component].erase(
913 std::unique(component_to_dof_map[component].begin(),
914 component_to_dof_map[component].end()),
915 component_to_dof_map[component].end());
920 const unsigned int n_buckets = fe_collection.
n_components();
921 std::vector<types::global_dof_index> shifts(n_buckets);
925 &start->get_dof_handler().get_triangulation())))
927#ifdef DEAL_II_WITH_MPI
928 std::vector<types::global_dof_index> local_dof_count(n_buckets);
930 for (
unsigned int c = 0; c < n_buckets; ++c)
931 local_dof_count[c] = component_to_dof_map[c].
size();
933 std::vector<types::global_dof_index> prefix_dof_count(n_buckets);
934 const int ierr = MPI_Exscan(
935 local_dof_count.data(),
936 prefix_dof_count.data(),
938 Utilities::MPI::mpi_type_id_for_type<types::global_dof_index>,
940 tria->get_mpi_communicator());
943 std::vector<types::global_dof_index> global_dof_count(n_buckets);
945 tria->get_mpi_communicator(),
950 for (
unsigned int c = 0; c < n_buckets; ++c)
952 shifts[c] = prefix_dof_count[c] + cumulated;
953 cumulated += global_dof_count[c];
963 for (
unsigned int c = 1; c < fe_collection.
n_components(); ++c)
964 shifts[c] = shifts[c - 1] + component_to_dof_map[c - 1].
size();
973 for (
unsigned int component = 0; component < fe_collection.
n_components();
976 next_free_index = shifts[component];
979 component_to_dof_map[component])
991 return next_free_index;
996 template <
int dim,
int spacedim>
1000 std::vector<types::global_dof_index> renumbering(
1021 (result <= dof_handler.
n_dofs())),
1029 template <
int dim,
int spacedim>
1036 std::vector<types::global_dof_index> renumbering(
1065 template <
int dim,
int spacedim,
class IteratorType,
class EndIteratorType>
1068 const IteratorType &start,
1069 const EndIteratorType &end,
1070 const bool is_level_operation)
1073 start->get_dof_handler().get_fe_collection();
1079 new_indices.resize(0);
1086 const IndexSet &locally_owned_dofs =
1087 is_level_operation ?
1088 start->get_dof_handler().locally_owned_mg_dofs(start->level()) :
1089 start->get_dof_handler().locally_owned_dofs();
1093 std::vector<types::global_dof_index> local_dof_indices;
1098 std::vector<std::vector<types::global_dof_index>> block_list(
1099 fe_collection.
size());
1100 for (
unsigned int f = 0; f < fe_collection.
size(); ++f)
1119 std::vector<std::vector<types::global_dof_index>> block_to_dof_map(
1121 for (IteratorType cell = start; cell != end; ++cell)
1123 if (is_level_operation)
1126 if (!cell->is_locally_owned_on_level())
1133 if (!cell->is_locally_owned())
1137 if (is_level_operation)
1139 cell->level() == start->level(),
1141 "Multigrid renumbering in compute_block_wise() needs to be applied to a single level!"));
1147 const unsigned int dofs_per_cell =
1148 fe_collection[fe_index].n_dofs_per_cell();
1149 local_dof_indices.resize(dofs_per_cell);
1150 cell->get_active_or_mg_dof_indices(local_dof_indices);
1152 for (
unsigned int i = 0; i < dofs_per_cell; ++i)
1153 if (locally_owned_dofs.
is_element(local_dof_indices[i]))
1154 block_to_dof_map[block_list[fe_index][i]].
push_back(
1155 local_dof_indices[i]);
1170 for (
unsigned int block = 0; block < fe_collection.
n_blocks(); ++block)
1172 std::sort(block_to_dof_map[block].begin(),
1173 block_to_dof_map[block].end());
1174 block_to_dof_map[block].erase(
1175 std::unique(block_to_dof_map[block].begin(),
1176 block_to_dof_map[block].end()),
1177 block_to_dof_map[block].end());
1182 const unsigned int n_buckets = fe_collection.
n_blocks();
1183 std::vector<types::global_dof_index> shifts(n_buckets);
1187 &start->get_dof_handler().get_triangulation())))
1189#ifdef DEAL_II_WITH_MPI
1190 std::vector<types::global_dof_index> local_dof_count(n_buckets);
1192 for (
unsigned int c = 0; c < n_buckets; ++c)
1193 local_dof_count[c] = block_to_dof_map[c].
size();
1195 std::vector<types::global_dof_index> prefix_dof_count(n_buckets);
1196 const int ierr = MPI_Exscan(
1197 local_dof_count.data(),
1198 prefix_dof_count.data(),
1200 Utilities::MPI::mpi_type_id_for_type<types::global_dof_index>,
1202 tria->get_mpi_communicator());
1205 std::vector<types::global_dof_index> global_dof_count(n_buckets);
1207 tria->get_mpi_communicator(),
1212 for (
unsigned int c = 0; c < n_buckets; ++c)
1214 shifts[c] = prefix_dof_count[c] + cumulated;
1215 cumulated += global_dof_count[c];
1225 for (
unsigned int c = 1; c < fe_collection.
n_blocks(); ++c)
1226 shifts[c] = shifts[c - 1] + block_to_dof_map[c - 1].
size();
1235 for (
unsigned int block = 0; block < fe_collection.
n_blocks(); ++block)
1237 const typename std::vector<types::global_dof_index>::const_iterator
1238 begin_of_component = block_to_dof_map[block].begin(),
1239 end_of_component = block_to_dof_map[block].end();
1241 next_free_index = shifts[block];
1243 for (
typename std::vector<types::global_dof_index>::const_iterator
1244 dof_index = begin_of_component;
1245 dof_index != end_of_component;
1256 return next_free_index;
1268 template <
int dim,
typename CellIteratorType>
1270 compute_hierarchical_recursive(
1273 const CellIteratorType &cell,
1274 const IndexSet &locally_owned_dof_indices,
1275 std::vector<types::global_dof_index> &new_indices)
1278 next_free_dof_offset;
1280 if (cell->has_children())
1283 for (
unsigned int c = 0; c < GeometryInfo<dim>::max_children_per_cell;
1285 current_next_free_dof_offset =
1286 compute_hierarchical_recursive<dim>(current_next_free_dof_offset,
1289 locally_owned_dof_indices,
1309 if (cell->is_locally_owned())
1312 const unsigned int dofs_per_cell =
1313 cell->get_fe().n_dofs_per_cell();
1314 std::vector<types::global_dof_index> local_dof_indices(
1316 cell->get_dof_indices(local_dof_indices);
1335 for (
unsigned int i = 0; i < dofs_per_cell; ++i)
1336 if (locally_owned_dof_indices.
is_element(local_dof_indices[i]))
1340 const unsigned int idx =
1342 local_dof_indices[i]);
1346 my_starting_index + current_next_free_dof_offset;
1347 ++current_next_free_dof_offset;
1353 return current_next_free_dof_offset;
1359 template <
int dim,
int spacedim>
1363 std::vector<types::global_dof_index> renumbering(
1386#ifdef DEAL_II_WITH_MPI
1389 const int ierr = MPI_Exscan(
1393 Utilities::MPI::mpi_type_id_for_type<types::global_dof_index>,
1395 tria->get_mpi_communicator());
1404#ifdef DEAL_II_WITH_P4EST
1409 for (
unsigned int c = 0; c < tria->n_cells(0); ++c)
1411 const unsigned int coarse_cell_index =
1412 tria->get_p4est_tree_to_coarse_cell_permutation()[c];
1415 this_cell(tria, 0, coarse_cell_index, &dof_handler);
1417 next_free_dof_offset =
1418 compute_hierarchical_recursive<dim>(next_free_dof_offset,
1433 dof_handler.
begin(0);
1434 cell != dof_handler.
end(0);
1436 next_free_dof_offset =
1437 compute_hierarchical_recursive<dim>(next_free_dof_offset,
1450 (next_free_dof_offset <= dof_handler.
n_dofs())),
1454 Assert(std::find(renumbering.begin(),
1464 template <
int dim,
int spacedim>
1467 const std::vector<bool> &selected_dofs)
1469 std::vector<types::global_dof_index> renumbering(
1478 template <
int dim,
int spacedim>
1481 const std::vector<bool> &selected_dofs,
1482 const unsigned int level)
1487 std::vector<types::global_dof_index> renumbering(
1499 template <
int dim,
int spacedim>
1502 std::vector<types::global_dof_index> &new_indices,
1504 const std::vector<bool> &selected_dofs)
1507 Assert(selected_dofs.size() == n_dofs,
1512 Assert(new_indices.size() == n_dofs,
1516 std::count(selected_dofs.begin(), selected_dofs.end(),
false);
1521 if (selected_dofs[i] ==
false)
1523 new_indices[i] = next_unselected;
1528 new_indices[i] = next_selected;
1537 template <
int dim,
int spacedim>
1540 std::vector<types::global_dof_index> &new_indices,
1542 const std::vector<bool> &selected_dofs,
1543 const unsigned int level)
1548 const unsigned int n_dofs = dof_handler.
n_dofs(
level);
1549 Assert(selected_dofs.size() == n_dofs,
1554 Assert(new_indices.size() == n_dofs,
1557 const unsigned int n_selected_dofs =
1558 std::count(selected_dofs.begin(), selected_dofs.end(),
false);
1560 unsigned int next_unselected = 0;
1561 unsigned int next_selected = n_selected_dofs;
1562 for (
unsigned int i = 0; i < n_dofs; ++i)
1563 if (selected_dofs[i] ==
false)
1565 new_indices[i] = next_unselected;
1570 new_indices[i] = next_selected;
1579 template <
int dim,
int spacedim>
1586 std::vector<types::global_dof_index> renumbering(
1595 template <
int dim,
int spacedim>
1598 std::vector<types::global_dof_index> &new_indices,
1599 std::vector<types::global_dof_index> &reverse,
1601 const typename std::vector<
1626 std::vector<bool> already_sorted(n_owned_dofs,
false);
1627 std::vector<types::global_dof_index> cell_dofs;
1631 unsigned int index = 0;
1633 for (
const auto &cell : cells)
1637 const unsigned int n_cell_dofs = cell->get_fe().n_dofs_per_cell();
1638 cell_dofs.resize(n_cell_dofs);
1640 cell->get_active_or_mg_dof_indices(cell_dofs);
1644 std::sort(cell_dofs.begin(), cell_dofs.end());
1646 for (
const auto dof : cell_dofs)
1648 const auto local_dof = owned_dofs.index_within_set(dof);
1650 !already_sorted[local_dof])
1652 already_sorted[local_dof] =
true;
1653 reverse[index++] = local_dof;
1657 Assert(index == n_owned_dofs,
1659 "Traversing over the given set of cells did not cover all "
1660 "degrees of freedom in the DoFHandler. Does the set of cells "
1661 "not include all active cells?"));
1664 new_indices[reverse[i]] = owned_dofs.nth_index_in_set(i);
1669 template <
int dim,
int spacedim>
1672 const unsigned int level,
1673 const typename std::vector<
1679 std::vector<types::global_dof_index> renumbering(dof.
n_dofs(
level));
1680 std::vector<types::global_dof_index> reverse(dof.
n_dofs(
level));
1688 template <
int dim,
int spacedim>
1691 std::vector<types::global_dof_index> &new_order,
1692 std::vector<types::global_dof_index> &reverse,
1694 const unsigned int level,
1695 const typename std::vector<
1709 std::vector<bool> already_sorted(n_global_dofs,
false);
1710 std::vector<types::global_dof_index> cell_dofs(n_cell_dofs);
1712 unsigned int global_index = 0;
1714 for (
const auto &cell : cells)
1718 cell->get_active_or_mg_dof_indices(cell_dofs);
1719 std::sort(cell_dofs.begin(), cell_dofs.end());
1721 for (
unsigned int i = 0; i < n_cell_dofs; ++i)
1723 if (!already_sorted[cell_dofs[i]])
1725 already_sorted[cell_dofs[i]] =
true;
1726 reverse[global_index++] = cell_dofs[i];
1730 Assert(global_index == n_global_dofs,
1732 "Traversing over the given set of cells did not cover all "
1733 "degrees of freedom in the DoFHandler. Does the set of cells "
1734 "not include all cells of the specified level?"));
1737 new_order[reverse[i]] = i;
1742 template <
int dim,
int spacedim>
1746 const bool dof_wise_renumbering)
1748 std::vector<types::global_dof_index> renumbering(dof.
n_dofs());
1749 std::vector<types::global_dof_index> reverse(dof.
n_dofs());
1751 renumbering, reverse, dof, direction, dof_wise_renumbering);
1758 template <
int dim,
int spacedim>
1761 std::vector<types::global_dof_index> &reverse,
1764 const bool dof_wise_renumbering)
1770 if (dof_wise_renumbering ==
false)
1772 std::vector<typename DoFHandler<dim, spacedim>::active_cell_iterator>
1778 comparator(direction);
1781 ordered_cells.push_back(cell);
1783 std::sort(ordered_cells.begin(), ordered_cells.end(), comparator);
1795 const unsigned int n_dofs = dof.
n_dofs();
1796 std::vector<std::pair<Point<spacedim>,
unsigned int>>
1797 support_point_list(n_dofs);
1800 Assert(fe_collection[0].has_support_points(),
1803 for (
unsigned int comp = 0; comp < fe_collection.
size(); ++comp)
1805 Assert(fe_collection[comp].has_support_points(),
1811 quadrature_collection,
1814 std::vector<bool> already_touched(n_dofs,
false);
1816 std::vector<types::global_dof_index> local_dof_indices;
1820 const unsigned int dofs_per_cell = cell->get_fe().n_dofs_per_cell();
1821 local_dof_indices.resize(dofs_per_cell);
1822 hp_fe_values.
reinit(cell);
1825 cell->get_active_or_mg_dof_indices(local_dof_indices);
1826 const std::vector<Point<spacedim>> &points =
1828 for (
unsigned int i = 0; i < dofs_per_cell; ++i)
1829 if (!already_touched[local_dof_indices[i]])
1831 support_point_list[local_dof_indices[i]].first = points[i];
1832 support_point_list[local_dof_indices[i]].second =
1833 local_dof_indices[i];
1834 already_touched[local_dof_indices[i]] =
true;
1839 std::sort(support_point_list.begin(),
1840 support_point_list.end(),
1843 new_indices[support_point_list[i].
second] = i;
1849 template <
int dim,
int spacedim>
1852 const unsigned int level,
1854 const bool dof_wise_renumbering)
1856 std::vector<types::global_dof_index> renumbering(dof.
n_dofs(
level));
1857 std::vector<types::global_dof_index> reverse(dof.
n_dofs(
level));
1859 renumbering, reverse, dof,
level, direction, dof_wise_renumbering);
1866 template <
int dim,
int spacedim>
1869 std::vector<types::global_dof_index> &reverse,
1871 const unsigned int level,
1873 const bool dof_wise_renumbering)
1875 if (dof_wise_renumbering ==
false)
1877 std::vector<typename DoFHandler<dim, spacedim>::level_cell_iterator>
1883 comparator(direction);
1892 ordered_cells.push_back(p);
1895 std::sort(ordered_cells.begin(), ordered_cells.end(), comparator);
1904 std::vector<std::pair<Point<spacedim>,
unsigned int>>
1905 support_point_list(n_dofs);
1912 std::vector<bool> already_touched(dof.
n_dofs(),
false);
1915 std::vector<types::global_dof_index> local_dof_indices(dofs_per_cell);
1920 for (; begin != end; ++begin)
1923 &begin_tria = begin;
1924 begin->get_active_or_mg_dof_indices(local_dof_indices);
1925 fe_values.
reinit(begin_tria);
1926 const std::vector<Point<spacedim>> &points =
1928 for (
unsigned int i = 0; i < dofs_per_cell; ++i)
1929 if (!already_touched[local_dof_indices[i]])
1931 support_point_list[local_dof_indices[i]].first = points[i];
1932 support_point_list[local_dof_indices[i]].second =
1933 local_dof_indices[i];
1934 already_touched[local_dof_indices[i]] =
true;
1939 std::sort(support_point_list.begin(),
1940 support_point_list.end(),
1943 new_indices[support_point_list[i].
second] = i;
1977 template <
class DHCellIterator>
1979 operator()(
const DHCellIterator &c1,
const DHCellIterator &c2)
const
1983 return compare(c1, c2, std::integral_constant<int, dim>());
1979 operator()(
const DHCellIterator &c1,
const DHCellIterator &c2)
const {
…}
1990 template <
class DHCellIterator,
int xdim>
1993 const DHCellIterator &c2,
1994 std::integral_constant<int, xdim>)
const
1998 const double s1 = std::atan2(
v1[0],
v1[1]);
1999 const double s2 = std::atan2(v2[0], v2[1]);
2000 return (
counter ? (s1 > s2) : (s2 > s1));
2008 template <
class DHCellIterator>
2011 const DHCellIterator &,
2012 std::integral_constant<int, 1>)
const
2015 ExcMessage(
"This operation only makes sense for dim>=2."));
2023 template <
int dim,
int spacedim>
2029 std::vector<types::global_dof_index> renumbering(dof.
n_dofs());
2037 template <
int dim,
int spacedim>
2044 std::vector<typename DoFHandler<dim, spacedim>::active_cell_iterator>
2050 ordered_cells.push_back(cell);
2052 std::sort(ordered_cells.begin(), ordered_cells.end(), comparator);
2054 std::vector<types::global_dof_index> reverse(new_indices.size());
2060 template <
int dim,
int spacedim>
2063 const unsigned int level,
2067 std::vector<typename DoFHandler<dim, spacedim>::level_cell_iterator>
2079 ordered_cells.push_back(p);
2082 std::sort(ordered_cells.begin(), ordered_cells.end(), comparator);
2089 template <
int dim,
int spacedim>
2093 std::vector<types::global_dof_index> renumbering(
2102 template <
int dim,
int spacedim>
2109 std::vector<types::global_dof_index> renumbering(
2120 template <
int dim,
int spacedim>
2126 Assert(new_indices.size() == n_dofs,
2129 std::iota(new_indices.begin(),
2137 ::boost::mt19937 random_number_generator;
2138 for (
unsigned int i = 1; i < n_dofs; ++i)
2141 const unsigned int j =
2142 ::boost::random::uniform_int_distribution<>(0, i)(
2143 random_number_generator);
2147 std::swap(new_indices[i], new_indices[j]);
2153 template <
int dim,
int spacedim>
2157 const unsigned int level)
2160 Assert(new_indices.size() == n_dofs,
2163 std::iota(new_indices.begin(),
2171 ::boost::mt19937 random_number_generator;
2172 for (
unsigned int i = 1; i < n_dofs; ++i)
2175 const unsigned int j =
2176 ::boost::random::uniform_int_distribution<>(0, i)(
2177 random_number_generator);
2181 std::swap(new_indices[i], new_indices[j]);
2187 template <
int dim,
int spacedim>
2195 "Parallel triangulations are already enumerated according to their MPI process id."));
2197 std::vector<types::global_dof_index> renumbering(
2206 template <
int dim,
int spacedim>
2212 Assert(new_dof_indices.size() == n_dofs,
2218 std::vector<types::subdomain_id> subdomain_association(n_dofs);
2220 const unsigned int n_subdomains =
2221 *std::max_element(subdomain_association.begin(),
2222 subdomain_association.end()) +
2232 std::fill(new_dof_indices.begin(),
2233 new_dof_indices.end(),
2239 if (subdomain_association[i] == subdomain)
2243 new_dof_indices[i] = next_free_index;
2249 Assert(std::find(new_dof_indices.begin(),
2250 new_dof_indices.end(),
2257 template <
int dim,
int spacedim>
2261 std::vector<types::global_dof_index> renumbering(
2274 template <
int dim,
int spacedim>
2277 std::vector<types::global_dof_index> &new_dof_indices,
2281 Assert(new_dof_indices.size() == n_dofs,
2293 std::vector<types::global_dof_index> component_renumbering(
2295 compute_component_wise<dim, spacedim>(component_renumbering,
2298 std::vector<unsigned int>(),
2304 const std::vector<types::global_dof_index> dofs_per_component =
2306 for (
const auto &dpc : dofs_per_component)
2310 const unsigned int n_components =
2314 dof_handler.
n_dofs() / n_components;
2320 if (component_renumbering.empty())
2322 new_dof_indices.resize(0);
2325 std::fill(new_dof_indices.begin(),
2326 new_dof_indices.end(),
2334 std::vector<types::global_dof_index> component_dofs(
2335 local_dofs_per_component);
2336 for (
unsigned int component = 0; component < n_components; ++component)
2338 for (std::size_t i = 0; i < local_dofs_per_component; ++i)
2340 component_renumbering[n_components * i + component];
2341 component_renumbered_dofs.
add_indices(component_dofs.begin(),
2342 component_dofs.end());
2344 component_renumbered_dofs.
compress();
2349 component_renumbered_dofs2.
add_indices(component_renumbering.begin(),
2350 component_renumbering.end());
2351 Assert(component_renumbered_dofs2 == component_renumbered_dofs,
2358 AssertThrow(fe.dofs_per_cell == 0 || fe.has_support_points(),
2360 for (
unsigned int i = 0; i < fe.n_base_elements(); ++i)
2362 fe.base_element(0).get_unit_support_points() ==
2363 fe.base_element(i).get_unit_support_points(),
2365 "All base elements should have the same support points."));
2368 std::vector<types::global_dof_index> component_to_nodal(
2372 std::vector<types::global_dof_index> cell_dofs;
2373 std::vector<types::global_dof_index> component_renumbered_cell_dofs;
2377 auto next_dof_it = locally_owned_dofs.
begin();
2379 if (cell->is_locally_owned())
2384 cell->get_dof_indices(cell_dofs);
2391 if (locally_owned_dofs.
is_element(cell_dofs[i]))
2393 const auto local_index =
2395 component_renumbered_cell_dofs[i] =
2396 component_renumbering[local_index];
2400 component_renumbered_cell_dofs[i] =
2409 component_renumbered_cell_dofs[i]))
2411 for (
unsigned int component = 0;
2418 const auto local_index =
2420 component_renumbered_cell_dofs[i] +
2421 dofs_per_component * component);
2423 if (component_to_nodal[local_index] ==
2426 component_to_nodal[local_index] = *next_dof_it;
2437 const auto local_index =
2439 new_dof_indices[i] = component_to_nodal[local_index];
2448 typename VectorizedArrayType>
2454 const std::vector<types::global_dof_index> new_global_numbers =
2464 template <
int dim,
int spacedim,
typename Number,
typename AdditionalDataType>
2468 const AdditionalDataType &matrix_free_data)
2470 const std::vector<types::global_dof_index> new_global_numbers =
2477 dof_handler.
renumber_dofs(matrix_free_data.mg_level, new_global_numbers);
2482 template <
int dim,
int spacedim,
typename Number,
typename AdditionalDataType>
2483 std::vector<types::global_dof_index>
2487 const AdditionalDataType &matrix_free_data)
2489 AdditionalDataType my_mf_data = matrix_free_data;
2490 my_mf_data.initialize_mapping =
false;
2491 my_mf_data.tasks_parallel_scheme = AdditionalDataType::none;
2493 typename AdditionalDataType::MatrixFreeType separate_matrix_free;
2512 std::vector<std::vector<unsigned int>>
2513 group_dofs_by_rank_access(
2514 const ::Utilities::MPI::Partitioner &partitioner)
2518 std::vector<unsigned int> touch_count(partitioner.locally_owned_size());
2519 for (
const auto &p : partitioner.import_indices())
2520 for (unsigned
int i = p.
first; i < p.second; ++i)
2524 std::vector<std::vector<unsigned int>> result(1);
2525 for (
unsigned int i = 0; i < touch_count.size(); ++i)
2526 if (touch_count[i] == 0)
2527 result.back().push_back(i);
2532 std::map<unsigned int, std::vector<unsigned int>>
2533 multiple_ranks_access_dof;
2534 const std::vector<std::pair<unsigned int, unsigned int>> &import_targets =
2535 partitioner.import_targets();
2536 auto it = partitioner.import_indices().begin();
2537 for (
const std::pair<unsigned int, unsigned int> &proc : import_targets)
2539 result.emplace_back();
2540 unsigned int count_dofs = 0;
2541 while (count_dofs < proc.second)
2543 for (
unsigned int i = it->first; i < it->second;
2546 if (touch_count[i] == 1)
2547 result.back().push_back(i);
2549 multiple_ranks_access_dof[i].push_back(proc.first);
2559 std::map<std::vector<unsigned int>,
2560 std::vector<unsigned int>,
2561 std::function<
bool(
const std::vector<unsigned int> &,
2562 const std::vector<unsigned int> &)>>
2563 dofs_by_rank{[](
const std::vector<unsigned int> &a,
2564 const std::vector<unsigned int> &
b) {
2565 if (a.size() <
b.size())
2567 if (a.size() ==
b.size())
2569 for (
unsigned int i = 0; i < a.size(); ++i)
2572 else if (a[i] > b[i])
2577 for (
const auto &entry : multiple_ranks_access_dof)
2578 dofs_by_rank[entry.
second].push_back(entry.
first);
2580 for (
const auto &procs : dofs_by_rank)
2581 result.push_back(procs.
second);
2592 template <
int dim,
typename Number,
typename VectorizedArrayType>
2593 std::pair<std::vector<unsigned int>, std::vector<unsigned char>>
2594 compute_mf_numbering(
2596 const unsigned int component)
2600 const unsigned int n_comp =
2603 matrix_free.
get_dof_handler(component).get_fe().n_base_elements() == 1,
2608 const unsigned int fe_degree =
2610 const unsigned int nn = fe_degree - 1;
2619 std::array<std::pair<unsigned int, unsigned int>,
2624 dofs_on_objects[0] = std::make_pair(0U, 1U);
2625 dofs_on_objects[1] = std::make_pair(2 * n_comp, nn);
2626 dofs_on_objects[2] = std::make_pair(n_comp, 1U);
2630 dofs_on_objects[0] = std::make_pair(0U, 1U);
2631 dofs_on_objects[1] = std::make_pair(n_comp * (4 + 2 * nn), nn);
2632 dofs_on_objects[2] = std::make_pair(n_comp, 1U);
2633 dofs_on_objects[3] = std::make_pair(n_comp * 4, nn);
2634 dofs_on_objects[4] = std::make_pair(n_comp * (4 + 4 * nn), nn * nn);
2635 dofs_on_objects[5] = std::make_pair(n_comp * (4 + 1 * nn), nn);
2636 dofs_on_objects[6] = std::make_pair(2 * n_comp, 1U);
2637 dofs_on_objects[7] = std::make_pair(n_comp * (4 + 3 * nn), nn);
2638 dofs_on_objects[8] = std::make_pair(3 * n_comp, 1U);
2642 dofs_on_objects[0] = std::make_pair(0U, 1U);
2643 dofs_on_objects[1] = std::make_pair(n_comp * (8 + 2 * nn), nn);
2644 dofs_on_objects[2] = std::make_pair(n_comp, 1U);
2645 dofs_on_objects[3] = std::make_pair(n_comp * 8, nn);
2646 dofs_on_objects[4] =
2647 std::make_pair(n_comp * (8 + 12 * nn + 4 * nn * nn), nn * nn);
2648 dofs_on_objects[5] = std::make_pair(n_comp * (8 + 1 * nn), nn);
2649 dofs_on_objects[6] = std::make_pair(n_comp * 2, 1U);
2650 dofs_on_objects[7] = std::make_pair(n_comp * (8 + 3 * nn), nn);
2651 dofs_on_objects[8] = std::make_pair(n_comp * 3, 1U);
2652 dofs_on_objects[9] = std::make_pair(n_comp * (8 + 8 * nn), nn);
2653 dofs_on_objects[10] =
2654 std::make_pair(n_comp * (8 + 12 * nn + 2 * nn * nn), nn * nn);
2655 dofs_on_objects[11] = std::make_pair(n_comp * (8 + 9 * nn), nn);
2656 dofs_on_objects[12] = std::make_pair(n_comp * (8 + 12 * nn), nn * nn);
2657 dofs_on_objects[13] =
2658 std::make_pair(n_comp * (8 + 12 * nn + 6 * nn * nn), nn * nn * nn);
2659 dofs_on_objects[14] =
2660 std::make_pair(n_comp * (8 + 12 * nn + 1 * nn * nn), nn * nn);
2661 dofs_on_objects[15] = std::make_pair(n_comp * (8 + 10 * nn), nn);
2662 dofs_on_objects[16] =
2663 std::make_pair(n_comp * (8 + 12 * nn + 3 * nn * nn), nn * nn);
2664 dofs_on_objects[17] = std::make_pair(n_comp * (8 + 11 * nn), nn);
2665 dofs_on_objects[18] = std::make_pair(n_comp * 4, 1U);
2666 dofs_on_objects[19] = std::make_pair(n_comp * (8 + 6 * nn), nn);
2667 dofs_on_objects[20] = std::make_pair(n_comp * 5, 1U);
2668 dofs_on_objects[21] = std::make_pair(n_comp * (8 + 4 * nn), nn);
2669 dofs_on_objects[22] =
2670 std::make_pair(n_comp * (8 + 12 * nn + 5 * nn * nn), nn * nn);
2671 dofs_on_objects[23] = std::make_pair(n_comp * (8 + 5 * nn), nn);
2672 dofs_on_objects[24] = std::make_pair(n_comp * 6, 1U);
2673 dofs_on_objects[25] = std::make_pair(n_comp * (8 + 7 * nn), nn);
2674 dofs_on_objects[26] = std::make_pair(n_comp * 7, 1U);
2679 std::vector<unsigned int> &result,
2680 unsigned int &counter_dof_numbers) {
2682 owned_dofs.index_within_set(dof_index);
2687 result[local_dof_index] = counter_dof_numbers++;
2691 unsigned int counter_dof_numbers = 0;
2692 std::vector<unsigned int> dofs_extracted;
2693 std::vector<types::global_dof_index> dof_indices(
2710 const unsigned int n_owned_dofs = owned_dofs.n_elements();
2711 std::vector<unsigned int> dof_numbers_mf_order(
2713 std::vector<unsigned int> last_touch_by_cell_batch_range(
2715 std::vector<unsigned char> touch_count(n_owned_dofs);
2717 const auto operation_on_cell_range =
2720 const unsigned int &,
2721 const std::pair<unsigned int, unsigned int> &cell_range) {
2722 for (
unsigned int cell = cell_range.first; cell < cell_range.second;
2726 for (
unsigned int v = 0;
2727 v <
data.n_active_entries_per_cell_batch(cell);
2732 data.get_cell_iterator(cell, v, component)
2733 ->get_dof_indices(dof_indices);
2735 data.get_cell_iterator(cell, v, component)
2736 ->get_mg_dof_indices(dof_indices);
2739 for (
unsigned int a = 0; a < dofs_on_objects.size(); ++a)
2741 const auto &r = dofs_on_objects[a];
2742 if (a == 10 || a == 16)
2745 for (
unsigned int i1 = 0; i1 < nn; ++i1)
2746 for (
unsigned int i0 = 0; i0 < nn; ++i0)
2747 for (
unsigned int c = 0; c < n_comp; ++c)
2749 dof_indices[r.first + r.second * c + i1 +
2752 dof_numbers_mf_order,
2753 counter_dof_numbers);
2755 for (
unsigned int i = 0; i < r.second; ++i)
2756 for (
unsigned int c = 0; c < n_comp; ++c)
2758 dof_indices[r.first + r.second * c + i],
2760 dof_numbers_mf_order,
2761 counter_dof_numbers);
2767 dof_numbers_mf_order,
2768 counter_dof_numbers);
2775 data.get_dof_info(component).get_dof_indices_on_cell_batch(
2776 dofs_extracted, cell);
2777 for (
const unsigned int dof_index : dofs_extracted)
2778 if (dof_index < n_owned_dofs &&
2779 last_touch_by_cell_batch_range[dof_index] !=
2782 ++touch_count[dof_index];
2783 last_touch_by_cell_batch_range[dof_index] =
2793 "version of MatrixFree::cell_loop"));
2795 matrix_free.template cell_loop<unsigned int, unsigned int>(
2796 operation_on_cell_range, counter_dof_numbers, counter_dof_numbers);
2800 return std::make_pair(dof_numbers_mf_order, touch_count);
2810 typename VectorizedArrayType>
2811 std::vector<types::global_dof_index>
2817 ExcMessage(
"You need to set up indices in MatrixFree "
2818 "to be able to compute a renumbering!"));
2821 unsigned int component = 0;
2822 for (; component < matrix_free.
n_components(); ++component)
2827 ExcMessage(
"Could not locate the given DoFHandler in MatrixFree"));
2839 const std::vector<std::vector<unsigned int>> dofs_by_rank_access =
2840 group_dofs_by_rank_access(
2843 const auto &[local_numbering, touch_count] =
2844 compute_mf_numbering(matrix_free, component);
2854 enum class Category :
unsigned char
2863 switch (touch_count[i])
2866 categories[local_numbering[i]] = Category::constrained;
2869 categories[local_numbering[i]] = Category::single;
2872 categories[local_numbering[i]] = Category::multiple;
2875 for (
unsigned int chunk = 1; chunk < dofs_by_rank_access.size(); ++chunk)
2876 for (
const auto i : dofs_by_rank_access[chunk])
2877 categories[local_numbering[i]] = Category::mpi_dof;
2881 std::array<unsigned int, 4> n_entries_per_category{};
2882 for (
const Category i : categories)
2885 ++n_entries_per_category[
static_cast<int>(i)];
2887 std::array<unsigned int, 4> counters{};
2888 for (
unsigned int i = 1; i < 4; ++i)
2889 counters[i] = counters[i - 1] + n_entries_per_category[i - 1];
2890 std::vector<unsigned int> numbering_categories;
2892 for (
const Category category : categories)
2894 numbering_categories.push_back(counters[
static_cast<int>(category)]);
2895 ++counters[
static_cast<int>(category)];
2899 std::vector<::types::global_dof_index> new_global_numbers(
2902 new_global_numbers[i] =
2905 return new_global_numbers;
2913#include "dofs/dof_renumbering.inst"
unsigned int first_selected_component(const unsigned int overall_number_of_components=numbers::invalid_unsigned_int) const
cell_iterator end() const
const hp::FECollection< dim, spacedim > & get_fe_collection() const
void renumber_dofs(const std::vector< types::global_dof_index > &new_numbers)
const FiniteElement< dim, spacedim > & get_fe(const types::fe_index index=0) const
const IndexSet & locally_owned_mg_dofs(const unsigned int level) const
const Triangulation< dim, spacedim > & get_triangulation() const
const IndexSet & locally_owned_dofs() const
active_cell_iterator begin_active(const unsigned int level=0) const
types::global_dof_index n_dofs() const
typename LevelSelector::cell_iterator level_cell_iterator
cell_iterator begin(const unsigned int level=0) const
MPI_Comm get_mpi_communicator() const
types::global_dof_index n_locally_owned_dofs() const
void add_entries(const size_type row, ForwardIterator begin, ForwardIterator end, const bool indices_are_unique_and_sorted=false)
size_type row_length(const size_type row) const
size_type column_number(const size_type row, const size_type index) const
const std::vector< Point< spacedim > > & get_quadrature_points() const
void reinit(const TriaIterator< DoFCellAccessor< dim, spacedim, level_dof_access > > &cell)
unsigned int n_dofs_per_cell() const
unsigned int n_components() const
const unsigned int dofs_per_cell
std::pair< unsigned int, types::global_dof_index > system_to_block_index(const unsigned int component) const
const ComponentMask & get_nonzero_components(const unsigned int i) const
bool has_support_points() const
const std::vector< Point< dim > > & get_unit_support_points() const
bool is_primitive() const
std::pair< unsigned int, unsigned int > system_to_component_index(const unsigned int index) const
size_type index_within_set(const size_type global_index) const
size_type n_elements() const
bool is_element(const size_type index) const
ElementIterator begin() const
void subtract_set(const IndexSet &other)
size_type nth_index_in_set(const size_type local_index) const
void add_indices(const ForwardIterator &begin, const ForwardIterator &end)
const internal::MatrixFreeFunctions::TaskInfo & get_task_info() const
unsigned int get_mg_level() const
const internal::MatrixFreeFunctions::DoFInfo & get_dof_info(const unsigned int dof_handler_index_component=0) const
const DoFHandler< dim > & get_dof_handler(const unsigned int dof_handler_index=0) const
bool indices_initialized() const
unsigned int n_components() const
unsigned int n_active_cells() const
unsigned int n_cells() const
unsigned int size() const
void push_back(const FiniteElement< dim, spacedim > &new_fe)
unsigned int n_blocks() const
unsigned int n_components() const
const FEValuesType & get_present_fe_values() const
void reinit(const TriaIterator< DoFCellAccessor< dim, spacedim, lda > > &cell, const unsigned int q_index=numbers::invalid_unsigned_int, const unsigned int mapping_index=numbers::invalid_unsigned_int, const unsigned int fe_index=numbers::invalid_unsigned_int)
void push_back(const Quadrature< dim_in > &new_quadrature)
#define DEAL_II_NAMESPACE_OPEN
constexpr bool running_in_debug_mode()
#define DEAL_II_NAMESPACE_CLOSE
#define DEAL_II_ASSERT_UNREACHABLE()
#define DEAL_II_NOT_IMPLEMENTED()
IteratorRange< active_cell_iterator > active_cell_iterators() const
static ::ExceptionBase & ExcNotImplemented()
#define Assert(cond, exc)
#define AssertDimension(dim1, dim2)
#define AssertThrowMPI(error_code)
#define AssertIndexRange(index, range)
static ::ExceptionBase & ExcInternalError()
static ::ExceptionBase & ExcDoFHandlerNotInitialized()
static ::ExceptionBase & ExcDimensionMismatch(std::size_t arg1, std::size_t arg2)
static ::ExceptionBase & ExcMessage(std::string arg1)
#define AssertThrow(cond, exc)
typename ActiveSelector::cell_iterator cell_iterator
typename ActiveSelector::active_cell_iterator active_cell_iterator
void make_hanging_node_constraints(const DoFHandler< dim, spacedim > &dof_handler, AffineConstraints< number > &constraints)
void make_sparsity_pattern(const DoFHandler< dim, spacedim > &dof_handler, SparsityPatternBase &sparsity_pattern, const AffineConstraints< number > &constraints={}, const bool keep_constrained_dofs=true, const types::subdomain_id subdomain_id=numbers::invalid_subdomain_id)
@ update_quadrature_points
Transformed quadrature points.
std::vector< index_type > data
types::global_dof_index locally_owned_size
graph_traits< Graph >::vertices_size_type size_type
graph_traits< Graph >::vertex_descriptor Vertex
adjacency_list< vecS, vecS, undirectedS, property< vertex_color_t, default_color_type, property< vertex_degree_t, int > > > Graph
std::pair< size_type, size_type > Pair
void create_graph(const DoFHandler< dim, spacedim > &dof_handler, const bool use_constraints, boosttypes::Graph &graph, boosttypes::property_map< boosttypes::Graph, boosttypes::vertex_degree_t >::type &graph_degree)
void compute_Cuthill_McKee(std::vector< types::global_dof_index > &new_dof_indices, const DoFHandler< dim, spacedim > &, const bool reversed_numbering=false, const bool use_constraints=false)
void Cuthill_McKee(DoFHandler< dim, spacedim > &dof_handler, const bool reversed_numbering=false, const bool use_constraints=false)
void king_ordering(DoFHandler< dim, spacedim > &dof_handler, const bool reversed_numbering=false, const bool use_constraints=false)
void compute_king_ordering(std::vector< types::global_dof_index > &new_dof_indices, const DoFHandler< dim, spacedim > &, const bool reversed_numbering=false, const bool use_constraints=false)
void compute_minimum_degree(std::vector< types::global_dof_index > &new_dof_indices, const DoFHandler< dim, spacedim > &, const bool reversed_numbering=false, const bool use_constraints=false)
void minimum_degree(DoFHandler< dim, spacedim > &dof_handler, const bool reversed_numbering=false, const bool use_constraints=false)
void compute_support_point_wise(std::vector< types::global_dof_index > &new_dof_indices, const DoFHandler< dim, spacedim > &dof_handler)
void compute_subdomain_wise(std::vector< types::global_dof_index > &new_dof_indices, const DoFHandler< dim, spacedim > &dof_handler)
void matrix_free_data_locality(DoFHandler< dim, spacedim > &dof_handler, const MatrixFree< dim, Number, VectorizedArrayType > &matrix_free)
void subdomain_wise(DoFHandler< dim, spacedim > &dof_handler)
types::global_dof_index compute_block_wise(std::vector< types::global_dof_index > &new_dof_indices, const IteratorType &start, const EndIteratorType &end, const bool is_level_operation)
void hierarchical(DoFHandler< dim, spacedim > &dof_handler)
void compute_random(std::vector< types::global_dof_index > &new_dof_indices, const DoFHandler< dim, spacedim > &dof_handler)
void component_wise(DoFHandler< dim, spacedim > &dof_handler, const std::vector< unsigned int > &target_component=std::vector< unsigned int >())
void downstream(DoFHandler< dim, spacedim > &dof_handler, const Tensor< 1, spacedim > &direction, const bool dof_wise_renumbering=false)
void compute_Cuthill_McKee(std::vector< types::global_dof_index > &new_dof_indices, const DoFHandler< dim, spacedim > &, const bool reversed_numbering=false, const bool use_constraints=false, const std::vector< types::global_dof_index > &starting_indices=std::vector< types::global_dof_index >(), const unsigned int level=numbers::invalid_unsigned_int)
void block_wise(DoFHandler< dim, spacedim > &dof_handler)
void Cuthill_McKee(DoFHandler< dim, spacedim > &dof_handler, const bool reversed_numbering=false, const bool use_constraints=false, const std::vector< types::global_dof_index > &starting_indices=std::vector< types::global_dof_index >())
void compute_sort_selected_dofs_back(std::vector< types::global_dof_index > &new_dof_indices, const DoFHandler< dim, spacedim > &dof_handler, const std::vector< bool > &selected_dofs)
void sort_selected_dofs_back(DoFHandler< dim, spacedim > &dof_handler, const std::vector< bool > &selected_dofs)
void support_point_wise(DoFHandler< dim, spacedim > &dof_handler)
void compute_cell_wise(std::vector< types::global_dof_index > &renumbering, std::vector< types::global_dof_index > &inverse_renumbering, const DoFHandler< dim, spacedim > &dof_handler, const std::vector< typename DoFHandler< dim, spacedim >::active_cell_iterator > &cell_order)
std::vector< types::global_dof_index > compute_matrix_free_data_locality(const DoFHandler< dim, spacedim > &dof_handler, const MatrixFree< dim, Number, VectorizedArrayType > &matrix_free)
void clockwise_dg(DoFHandler< dim, spacedim > &dof_handler, const Point< spacedim > ¢er, const bool counter=false)
void random(DoFHandler< dim, spacedim > &dof_handler)
void compute_downstream(std::vector< types::global_dof_index > &new_dof_indices, std::vector< types::global_dof_index > &reverse, const DoFHandler< dim, spacedim > &dof_handler, const Tensor< 1, spacedim > &direction, const bool dof_wise_renumbering)
void cell_wise(DoFHandler< dim, spacedim > &dof_handler, const std::vector< typename DoFHandler< dim, spacedim >::active_cell_iterator > &cell_order)
types::global_dof_index compute_component_wise(std::vector< types::global_dof_index > &new_dof_indices, const CellIterator &start, const std_cxx20::type_identity_t< CellIterator > &end, const std::vector< unsigned int > &target_component, const bool is_level_operation)
void compute_clockwise_dg(std::vector< types::global_dof_index > &new_dof_indices, const DoFHandler< dim, spacedim > &dof_handler, const Point< spacedim > ¢er, const bool counter)
SymmetricTensor< 2, dim, Number > b(const Tensor< 2, dim, Number > &F)
T sum(const T &t, const MPI_Comm mpi_communicator)
T max(const T &t, const MPI_Comm mpi_communicator)
constexpr T pow(const T base, const int iexp)
std::vector< Integer > reverse_permutation(const std::vector< Integer > &permutation)
constexpr types::global_dof_index invalid_dof_index
constexpr unsigned int invalid_unsigned_int
typename type_identity< T >::type type_identity_t
unsigned short int fe_index
bool compare(const DHCellIterator &c1, const DHCellIterator &c2, std::integral_constant< int, xdim >) const
bool compare(const DHCellIterator &, const DHCellIterator &, std::integral_constant< int, 1 >) const
ClockCells(const Point< dim > ¢er, bool counter)
const Point< dim > & center
bool operator()(const DHCellIterator &c1, const DHCellIterator &c2) const
std::shared_ptr< const Utilities::MPI::Partitioner > vector_partitioner
TasksParallelScheme scheme