23#include <boost/container/small_vector.hpp>
56 template <
int structdim>
64 if (std::lexicographical_compare(std::begin(a.
vertices),
66 std::begin(b.vertices),
67 std::end(b.vertices)))
74 if (std::equal(std::begin(a.
vertices),
76 std::begin(b.vertices)))
81 "Two CellData objects with equal vertices must "
82 "have the same material/boundary ids and manifold "
107 template <
typename FaceIteratorType>
111 CellData<dim - 1> face_cell_data(face->n_vertices());
112 for (
unsigned int vertex_n = 0; vertex_n < face->n_vertices();
114 face_cell_data.vertices[vertex_n] = face->vertex_index(vertex_n);
115 face_cell_data.boundary_id = face->boundary_id();
116 face_cell_data.manifold_id = face->manifold_id();
118 face_data.insert(std::move(face_cell_data));
146 template <
typename FaceIteratorType>
161 template <
int dim,
int spacedim>
163 tuple<std::vector<Point<spacedim>>, std::vector<CellData<dim>>,
SubCellData>
167 ExcMessage(
"The input triangulation must be non-empty."));
169 std::vector<Point<spacedim>> vertices = tria.
get_vertices();
170 std::vector<CellData<dim>> cells;
180 for (
const unsigned int cell_vertex_n : cell->vertex_indices())
182 Assert(cell->vertex_index(cell_vertex_n) < vertices.size(),
185 cell->vertex_index(cell_vertex_n);
189 cells.emplace_back(std::move(cell_data));
194 for (
const unsigned int face_n : cell->face_indices())
197 const auto face = cell->face(face_n);
206 for (
unsigned int line_n = 0; line_n < cell->n_lines(); ++line_n)
208 const auto line = cell->line(line_n);
214 for (
const unsigned int vertex_n : line->vertex_indices())
216 line->vertex_index(vertex_n);
219 line_data.insert(std::move(line_cell_data));
228 for (
const CellData<1> &face_line_data : line_data)
236 return std::tuple<std::vector<Point<spacedim>>,
237 std::vector<CellData<dim>>,
240 std::move(subcell_data));
245 template <
int dim,
int spacedim>
254 "Invalid SubCellData supplied according to ::check_consistency(). "
255 "This is caused by data containing objects for the wrong dimension."));
258 std::vector<bool> vertex_used(vertices.size(),
false);
259 for (
unsigned int c = 0; c < cells.size(); ++c)
260 for (
unsigned int v = 0; v < cells[c].vertices.size(); ++v)
262 Assert(cells[c].vertices[v] < vertices.size(),
263 ExcMessage(
"Invalid vertex index encountered! cells[" +
267 " is invalid, because only " +
269 " vertices were supplied."));
270 vertex_used[cells[c].vertices[v]] =
true;
277 std::vector<unsigned int> new_vertex_numbers(vertices.size(),
279 unsigned int next_free_number = 0;
280 for (
unsigned int i = 0; i < vertices.size(); ++i)
281 if (vertex_used[i] ==
true)
283 new_vertex_numbers[i] = next_free_number;
288 for (
unsigned int c = 0; c < cells.size(); ++c)
289 for (
auto &v : cells[c].vertices)
290 v = new_vertex_numbers[v];
295 for (
unsigned int v = 0;
300 new_vertex_numbers.size(),
302 "Invalid vertex index in subcelldata.boundary_lines. "
303 "subcelldata.boundary_lines[" +
308 " is invalid, because only " +
310 " vertices were supplied."));
317 for (
unsigned int v = 0;
322 new_vertex_numbers.size(),
324 "Invalid vertex index in subcelldata.boundary_quads. "
325 "subcelldata.boundary_quads[" +
330 " is invalid, because only " +
332 " vertices were supplied."));
340 std::vector<Point<spacedim>> tmp;
341 tmp.reserve(std::count(vertex_used.begin(), vertex_used.end(),
true));
342 for (
unsigned int v = 0; v < vertices.size(); ++v)
343 if (vertex_used[v] ==
true)
344 tmp.push_back(vertices[v]);
350 template <
int dim,
int spacedim>
355 std::vector<unsigned int> &considered_vertices,
362 std::vector<unsigned int> new_vertex_numbers(vertices.size());
363 std::iota(new_vertex_numbers.begin(), new_vertex_numbers.end(), 0);
366 if (considered_vertices.empty())
367 considered_vertices = new_vertex_numbers;
382 unsigned int longest_coordinate_direction = 0;
383 double longest_coordinate_length = bbox.
side_length(0);
384 for (
unsigned int d = 1; d < spacedim; ++d)
386 const double coordinate_length = bbox.
side_length(d);
387 if (longest_coordinate_length < coordinate_length)
389 longest_coordinate_length = coordinate_length;
390 longest_coordinate_direction = d;
396 std::vector<std::pair<unsigned int, Point<spacedim>>> sorted_vertices;
397 sorted_vertices.reserve(vertices.size());
398 for (
const unsigned int vertex_n : considered_vertices)
401 sorted_vertices.emplace_back(vertex_n, vertices[vertex_n]);
403 std::sort(sorted_vertices.begin(),
404 sorted_vertices.end(),
407 return a.second[longest_coordinate_direction] <
408 b.second[longest_coordinate_direction];
413 for (
unsigned int d = 0; d < spacedim; ++d)
421 auto range_start = sorted_vertices.begin();
422 while (range_start != sorted_vertices.end())
424 auto range_end = range_start + 1;
425 while (range_end != sorted_vertices.end() &&
426 std::abs(range_end->second[longest_coordinate_direction] -
427 range_start->second[longest_coordinate_direction]) <
433 std::sort(range_start,
437 return a.first < b.first;
446 for (
auto reference = range_start; reference != range_end; ++reference)
449 for (
auto it = reference + 1; it != range_end; ++it)
451 if (within_tolerance(reference->second, it->second))
453 new_vertex_numbers[it->first] = reference->first;
459 range_start = range_end;
466 for (
auto &cell : cells)
467 for (
auto &vertex_index : cell.vertices)
468 vertex_index = new_vertex_numbers[vertex_index];
470 for (
auto &vertex_index : quad.vertices)
471 vertex_index = new_vertex_numbers[vertex_index];
473 for (
auto &vertex_index : line.vertices)
474 vertex_index = new_vertex_numbers[vertex_index];
486 if (vertices.empty())
494 for (
unsigned int i = 0; i < vertices.size(); ++i)
495 map_point_to_local_vertex_index[vertices[i]] = i;
498 if (map_point_to_local_vertex_index.size() == vertices.size())
502 vertices.resize(map_point_to_local_vertex_index.size());
505 for (
const auto &p : map_point_to_local_vertex_index)
506 vertices[j++] = p.first;
512 template <
int dim,
int spacedim>
523 if (dim == 2 && spacedim == 3)
526 std::size_t n_negative_cells = 0;
527 std::size_t cell_no = 0;
528 for (
auto &cell : cells)
536 const auto reference_cell =
539 if (reference_cell.is_hyper_cube())
544 std::swap(cell.vertices[1], cell.vertices[2]);
549 std::swap(cell.vertices[0], cell.vertices[2]);
550 std::swap(cell.vertices[1], cell.vertices[3]);
551 std::swap(cell.vertices[4], cell.vertices[6]);
552 std::swap(cell.vertices[5], cell.vertices[7]);
555 else if (reference_cell.is_simplex())
560 std::swap(cell.vertices[cell.vertices.size() - 2],
561 cell.vertices[cell.vertices.size() - 1]);
566 std::swap(cell.vertices[0], cell.vertices[3]);
567 std::swap(cell.vertices[1], cell.vertices[4]);
568 std::swap(cell.vertices[2], cell.vertices[5]);
574 std::swap(cell.vertices[2], cell.vertices[3]);
588 return n_negative_cells;
592 template <
int dim,
int spacedim>
598 const std::size_t n_negative_cells =
607 AssertThrow(n_negative_cells == 0 || n_negative_cells == cells.size(),
610 "This function assumes that either all cells have positive "
611 "volume, or that all cells have been specified in an "
612 "inverted vertex order so that their volume is negative. "
613 "(In the latter case, this class automatically inverts "
614 "every cell.) However, the mesh you have specified "
615 "appears to have both cells with positive and cells with "
616 "negative volume. You need to check your mesh which "
617 "cells these are and how they got there.\n"
618 "As a hint, of the total ") +
619 std::to_string(cells.size()) +
" cells in the mesh, " +
620 std::to_string(n_negative_cells) +
621 " appear to have a negative volume."));
639 CheapEdge(
const unsigned int v0,
const unsigned int v1)
651 return ((v0 <
e.v0) || ((v0 ==
e.v0) && (v1 <
e.v1)));
674 std::set<CheapEdge> edges;
686 for (
unsigned int l = 0; l < GeometryInfo<dim>::lines_per_cell; ++
l)
688 const CheapEdge reverse_edge(
691 if (edges.find(reverse_edge) != edges.end())
696 const CheapEdge correct_edge(
699 edges.insert(correct_edge);
729 static const unsigned int
735 const unsigned int ParallelEdges<2>::starter_edges[2] = {0, 2};
738 const unsigned int ParallelEdges<2>::parallel_edges[4][1] = {{1},
744 const unsigned int ParallelEdges<3>::starter_edges[3] = {0, 2, 8};
747 const unsigned int ParallelEdges<3>::parallel_edges[12][3] = {
780 AdjacentCell(
const unsigned int cell_index,
781 const unsigned int edge_within_cell)
802 class AdjacentCells<2>
809 using const_iterator =
const AdjacentCell *;
820 push_back(
const AdjacentCell &adjacent_cell)
884 class AdjacentCells<3> :
public std::vector<AdjacentCell>
906 Edge(
const CellData<dim> &cell,
const unsigned int edge_number)
921 if (vertex_indices[0] > vertex_indices[1])
922 std::swap(vertex_indices[0], vertex_indices[1]);
932 return ((vertex_indices[0] <
e.vertex_indices[0]) ||
933 ((vertex_indices[0] ==
e.vertex_indices[0]) &&
934 (vertex_indices[1] <
e.vertex_indices[1])));
943 return ((vertex_indices[0] ==
e.vertex_indices[0]) &&
944 (vertex_indices[1] ==
e.vertex_indices[1]));
957 enum OrientationStatus
987 Cell(
const CellData<dim> &c,
const std::vector<Edge<dim>> &edge_list)
994 for (
unsigned int l = 0; l < GeometryInfo<dim>::lines_per_cell; ++
l)
996 const Edge<dim>
e(c,
l);
998 (std::lower_bound(edge_list.begin(), edge_list.end(),
e) -
1032 class EdgeDeltaSet<2>
1038 using const_iterator =
const unsigned int *;
1064 insert(
const unsigned int edge_index)
1125 class EdgeDeltaSet<3> :
public std::set<unsigned int>
1135 std::vector<Edge<dim>>
1142 std::vector<Edge<dim>> edge_list;
1144 for (
unsigned int i = 0; i < cells.size(); ++i)
1145 for (
unsigned int l = 0; l < GeometryInfo<dim>::lines_per_cell; ++
l)
1146 edge_list.emplace_back(cells[i], l);
1149 std::sort(edge_list.begin(), edge_list.end());
1150 edge_list.erase(std::unique(edge_list.begin(), edge_list.end()),
1163 std::vector<Cell<dim>>
1164 build_cells_and_connect_edges(
const std::vector<
CellData<dim>> &cells,
1165 std::vector<Edge<dim>> &edges)
1167 std::vector<Cell<dim>> cell_list;
1168 cell_list.reserve(cells.size());
1169 for (
unsigned int i = 0; i < cells.size(); ++i)
1173 cell_list.emplace_back(cells[i], edges);
1177 for (
unsigned int l = 0; l < GeometryInfo<dim>::lines_per_cell; ++
l)
1178 edges[cell_list.back().edge_indices[
l]].adjacent_cells.push_back(
1179 AdjacentCell(i, l));
1194 get_next_unoriented_cell(
const std::vector<Cell<dim>> &cells,
1195 const std::vector<Edge<dim>> &edges,
1196 const unsigned int current_cell)
1198 for (
unsigned int c = current_cell; c < cells.size(); ++c)
1199 for (
unsigned int l = 0; l < GeometryInfo<dim>::lines_per_cell; ++
l)
1201 Edge<dim>::not_oriented)
1216 orient_one_set_of_parallel_edges(
const std::vector<Cell<dim>> &cells,
1217 std::vector<Edge<dim>> &edges,
1218 const unsigned int cell,
1219 const unsigned int local_edge)
1246 edges[cells[cell].edge_indices[local_edge]].orientation_status =
1247 (dim == 2 ? Edge<dim>::backward : Edge<dim>::forward);
1263 edges[cells[cell].edge_indices[local_edge]].orientation_status =
1264 (dim == 2 ? Edge<dim>::forward : Edge<dim>::backward);
1273 EdgeDeltaSet<dim> Delta_k;
1274 EdgeDeltaSet<dim> Delta_k_minus_1;
1275 Delta_k_minus_1.insert(cells[cell].
edge_indices[local_edge]);
1277 while (Delta_k_minus_1.begin() !=
1278 Delta_k_minus_1.end())
1282 for (
typename EdgeDeltaSet<dim>::const_iterator delta =
1283 Delta_k_minus_1.begin();
1284 delta != Delta_k_minus_1.end();
1288 Edge<dim>::not_oriented,
1292 for (
typename AdjacentCells<dim>::const_iterator adjacent_cell =
1294 adjacent_cell != edges[*delta].adjacent_cells.end();
1297 const unsigned int K = adjacent_cell->cell_index;
1298 const unsigned int delta_is_edge_in_K =
1299 adjacent_cell->edge_within_cell;
1303 const unsigned int first_edge_vertex =
1304 (edges[*delta].orientation_status == Edge<dim>::forward ?
1305 edges[*delta].vertex_indices[0] :
1306 edges[*delta].vertex_indices[1]);
1307 const unsigned int first_edge_vertex_in_K =
1310 delta_is_edge_in_K, 0)];
1312 first_edge_vertex == first_edge_vertex_in_K ||
1313 first_edge_vertex ==
1315 dim>::line_to_cell_vertices(delta_is_edge_in_K, 1)],
1320 for (
unsigned int o_e = 0;
1321 o_e < ParallelEdges<dim>::n_other_parallel_edges;
1327 const unsigned int opposite_edge =
1328 cells[
K].edge_indices[ParallelEdges<
1330 const unsigned int first_opposite_edge_vertex =
1331 cells[
K].vertex_indices
1335 (first_edge_vertex == first_edge_vertex_in_K ? 0 :
1342 const typename Edge<dim>::OrientationStatus
1343 opposite_edge_orientation =
1344 (edges[opposite_edge].vertex_indices[0] ==
1345 first_opposite_edge_vertex ?
1346 Edge<dim>::forward :
1347 Edge<dim>::backward);
1352 Edge<dim>::not_oriented)
1356 edges[opposite_edge].orientation_status =
1357 opposite_edge_orientation;
1358 Delta_k.insert(opposite_edge);
1374 opposite_edge_orientation,
1380 opposite_edge_orientation)
1393 Delta_k_minus_1 = Delta_k;
1407 rotate_cell(
const std::vector<Cell<dim>> &cell_list,
1408 const std::vector<Edge<dim>> &edge_list,
1415 for (
unsigned int e = 0; e < GeometryInfo<dim>::lines_per_cell; ++
e)
1422 starting_vertex_of_edge[
e] =
1426 starting_vertex_of_edge[
e] =
1442 if ((starting_vertex_of_edge[0] == starting_vertex_of_edge[2]) ||
1443 (starting_vertex_of_edge[0] == starting_vertex_of_edge[3]))
1444 origin_vertex_of_cell = starting_vertex_of_edge[0];
1445 else if ((starting_vertex_of_edge[1] ==
1446 starting_vertex_of_edge[2]) ||
1447 (starting_vertex_of_edge[1] ==
1448 starting_vertex_of_edge[3]))
1449 origin_vertex_of_cell = starting_vertex_of_edge[1];
1461 for (origin_vertex_of_cell = 0;
1462 origin_vertex_of_cell < GeometryInfo<dim>::vertices_per_cell;
1463 ++origin_vertex_of_cell)
1464 if (std::count(starting_vertex_of_edge,
1465 starting_vertex_of_edge +
1470 Assert(origin_vertex_of_cell <
1493 while (raw_cells[
cell_index].vertices[0] != origin_vertex_of_cell)
1495 const unsigned int tmp = raw_cells[
cell_index].vertices[0];
1518 static const unsigned int cube_permutations[8][8] = {
1519 {0, 1, 2, 3, 4, 5, 6, 7},
1520 {1, 5, 3, 7, 0, 4, 2, 6},
1521 {2, 6, 0, 4, 3, 7, 1, 5},
1522 {3, 2, 1, 0, 7, 6, 5, 4},
1523 {4, 0, 6, 2, 5, 1, 7, 3},
1524 {5, 4, 7, 6, 1, 0, 3, 2},
1525 {6, 7, 4, 5, 2, 3, 0, 1},
1526 {7, 3, 5, 1, 6, 2, 4, 0}};
1531 temp_vertex_indices[v] =
1533 .vertices[cube_permutations[origin_vertex_of_cell][v]];
1535 raw_cells[
cell_index].vertices[v] = temp_vertex_indices[v];
1559 std::vector<Edge<dim>> edge_list = build_edges(cells);
1560 std::vector<Cell<dim>> cell_list =
1561 build_cells_and_connect_edges(cells, edge_list);
1565 unsigned int next_cell_with_unoriented_edge = 0;
1566 while ((next_cell_with_unoriented_edge = get_next_unoriented_cell(
1567 cell_list, edge_list, next_cell_with_unoriented_edge)) !=
1581 for (
unsigned int l = 0;
l < dim; ++
l)
1582 if (edge_list[cell_list[next_cell_with_unoriented_edge]
1585 orient_one_set_of_parallel_edges(
1588 next_cell_with_unoriented_edge,
1589 ParallelEdges<dim>::starter_edges[l]);
1593 for (
unsigned int l = 0; l < GeometryInfo<dim>::lines_per_cell; ++
l)
1594 Assert(edge_list[cell_list[next_cell_with_unoriented_edge]
1603 for (
unsigned int c = 0; c < cells.size(); ++c)
1604 rotate_cell(cell_list, edge_list, c, cells);
1621 Assert(cells.size() != 0,
1623 "List of elements to orient must have at least one cell"));
1631 if (!is_consistent(cells))
1648 template <
int dim,
int spacedim>
1649 std::map<unsigned int, Point<spacedim>>
1652 std::map<unsigned int, Point<spacedim>> vertex_map;
1656 for (; cell != endc; ++cell)
1658 for (
const unsigned int i : cell->face_indices())
1662 if (face->at_boundary())
1664 for (
unsigned j = 0; j < face->n_vertices(); ++j)
1667 const unsigned int vertex_index = face->vertex_index(j);
1668 vertex_map[vertex_index] = vertex;
1678 template <
int dim,
int spacedim>
1681 const bool isotropic,
1682 const unsigned int max_iterations)
1684 unsigned int iter = 0;
1685 bool continue_refinement =
true;
1687 while (continue_refinement && (iter < max_iterations))
1691 continue_refinement =
false;
1694 for (
const unsigned int j : cell->face_indices())
1695 if (cell->at_boundary(j) ==
false &&
1696 cell->neighbor(j)->has_children())
1700 cell->set_refine_flag();
1701 continue_refinement =
true;
1704 continue_refinement |= cell->flag_for_face_refinement(j);
1713 template <
int dim,
int spacedim>
1716 const double max_ratio,
1717 const unsigned int max_iterations)
1719 unsigned int iter = 0;
1720 bool continue_refinement =
true;
1722 while (continue_refinement && (iter < max_iterations))
1725 continue_refinement =
false;
1728 std::pair<unsigned int, double> info =
1729 GridTools::get_longest_direction<dim, spacedim>(cell);
1730 if (info.second > max_ratio)
1732 cell->set_refine_flag(
1734 continue_refinement =
true;
1743 template <
int dim,
int spacedim>
1744 std::map<unsigned int, Point<spacedim>>
1748 std::map<unsigned int, Point<spacedim>> result;
1751 if (!cell->is_artificial())
1754 for (
unsigned int i = 0; i < vs.size(); ++i)
1755 result[cell->vertex_index(i)] = vs[i];
1763 template <
int dim,
int spacedim>
1765 std::set<typename Triangulation<dim, spacedim>::active_cell_iterator>>
1769 std::set<typename Triangulation<dim, spacedim>::active_cell_iterator>>
1774 for (; cell != endc; ++cell)
1775 for (
const unsigned int i : cell->vertex_indices())
1780 if (
triangulation.Triangulation<dim, spacedim>::has_hanging_nodes())
1787 for (; cell != endc; ++cell)
1789 for (
const unsigned int i : cell->face_indices())
1791 if ((cell->at_boundary(i) ==
false) &&
1792 (cell->neighbor(i)->is_active()))
1795 adjacent_cell = cell->neighbor(i);
1796 for (
unsigned int j = 0; j < cell->face(i)->n_vertices();
1806 for (
unsigned int i = 0; i < cell->n_lines(); ++i)
1807 if (cell->line(i)->has_children())
1822 template <
int dim,
int spacedim>
1838 for (
const auto &cell :
triangulation.active_cell_iterators())
1840 const unsigned int index = cell->active_cell_index();
1841 cell_connectivity.
add(index, index);
1842 for (
auto f : cell->face_indices())
1843 if ((cell->at_boundary(f) ==
false) &&
1844 (cell->neighbor(f)->has_children() ==
false))
1846 const unsigned int other_index =
1847 cell->neighbor(f)->active_cell_index();
1848 cell_connectivity.
add(index, other_index);
1849 cell_connectivity.
add(other_index, index);
1856 template <
int dim,
int spacedim>
1896 std::vector<boost::container::small_vector<unsigned int, 16>>
1898 for (
const auto &cell :
triangulation.active_cell_iterators())
1900 for (
const unsigned int v : cell->vertex_indices())
1901 vertex_to_cell[cell->vertex_index(v)].push_back(
1902 cell->active_cell_index());
1907 std::vector<types::global_dof_index> neighbors;
1908 for (
const auto &cell :
triangulation.active_cell_iterators())
1911 for (
const unsigned int v : cell->vertex_indices())
1912 neighbors.insert(neighbors.end(),
1913 vertex_to_cell[cell->vertex_index(v)].begin(),
1914 vertex_to_cell[cell->vertex_index(v)].end());
1915 std::sort(neighbors.begin(), neighbors.end());
1916 cell_connectivity.
add_entries(cell->active_cell_index(),
1918 std::unique(neighbors.begin(),
1925 template <
int dim,
int spacedim>
1929 const unsigned int level,
1932 std::vector<boost::container::small_vector<unsigned int, 16>>
1939 for (
const unsigned int v : cell->vertex_indices())
1940 vertex_to_cell[cell->vertex_index(v)].push_back(cell->index());
1945 std::vector<types::global_dof_index> neighbors;
1949 for (
const unsigned int v : cell->vertex_indices())
1950 neighbors.insert(neighbors.end(),
1951 vertex_to_cell[cell->vertex_index(v)].begin(),
1952 vertex_to_cell[cell->vertex_index(v)].end());
1953 std::sort(neighbors.begin(), neighbors.end());
1956 std::unique(neighbors.begin(),
1964#include "grid/grid_tools_topology.inst"
bool operator==(const AlignedVector< T > &lhs, const AlignedVector< T > &rhs)
Number side_length(const unsigned int direction) const
void add_entries(const size_type row, ForwardIterator begin, ForwardIterator end, const bool indices_are_unique_and_sorted=false)
void reinit(const size_type m, const size_type n, const IndexSet &rowset=IndexSet())
void add(const size_type i, const size_type j)
Abstract base class for mapping classes.
virtual boost::container::small_vector< Point< spacedim >, ReferenceCells::max_n_vertices< dim >() > get_vertices(const typename Triangulation< dim, spacedim >::cell_iterator &cell) const
static ReferenceCell n_vertices_to_type(const int dim, const unsigned int n_vertices)
const std::vector< Point< spacedim > > & get_vertices() const
unsigned int n_levels() const
cell_iterator end() const
virtual void execute_coarsening_and_refinement()
active_cell_iterator begin_active(const unsigned int level=0) const
#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
IteratorRange< cell_iterator > cell_iterators_on_level(const unsigned int level) const
static ::ExceptionBase & ExcMeshNotOrientable()
static ::ExceptionBase & ExcNotImplemented()
#define Assert(cond, exc)
static ::ExceptionBase & ExcGridHasInvalidCell(int arg1)
#define AssertIndexRange(index, range)
static ::ExceptionBase & ExcInternalError()
static ::ExceptionBase & ExcMessage(std::string arg1)
#define AssertThrow(cond, exc)
void consistently_order_cells(std::vector< CellData< dim > > &cells)
CGAL::Exact_predicates_exact_constructions_kernel_with_sqrt K
SymmetricTensor< 2, dim, Number > e(const Tensor< 2, dim, Number > &F)
Tensor< 2, dim, Number > l(const Tensor< 2, dim, Number > &F, const Tensor< 2, dim, Number > &dF_dt)
constexpr const ReferenceCell Wedge
constexpr const ReferenceCell Pyramid
VectorType::value_type * end(VectorType &V)
VectorType::value_type * begin(VectorType &V)
std::string int_to_string(const unsigned int value, const unsigned int digits=numbers::invalid_unsigned_int)
constexpr unsigned int invalid_unsigned_int
constexpr types::boundary_id internal_face_boundary_id
constexpr types::manifold_id flat_manifold_id
::VectorizedArray< Number, width > abs(const ::VectorizedArray< Number, width > &)
void swap(ObserverPointer< T, P > &t1, ObserverPointer< T, Q > &t2)
const ::parallel::distributed::Triangulation< dim, spacedim > * triangulation
std::vector< unsigned int > vertices
types::manifold_id manifold_id
types::material_id material_id
types::boundary_id boundary_id
static unsigned int line_to_cell_vertices(const unsigned int line, const unsigned int vertex)
static std_cxx20::ranges::iota_view< unsigned int, unsigned int > vertex_indices()
std::vector< CellData< 2 > > boundary_quads
bool check_consistency(const unsigned int dim) const
std::vector< CellData< 1 > > boundary_lines
bool operator<(const SynchronousIterators< Iterators > &a, const SynchronousIterators< Iterators > &b)