Reference documentation for deal.II version GIT d77e5ebb0a 2023-01-27 22:35:02+00:00
\(\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\}}\)
reference_cell.cc
Go to the documentation of this file.
1 // ---------------------------------------------------------------------
2 //
3 // Copyright (C) 2020 - 2022 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 
20 
24 #include <deal.II/fe/fe_wedge_p.h>
25 #include <deal.II/fe/mapping_fe.h>
26 #include <deal.II/fe/mapping_q.h>
27 #include <deal.II/fe/mapping_q1.h>
28 
31 #include <deal.II/grid/tria.h>
32 
33 #include <iostream>
34 #include <memory>
35 
37 
38 namespace
39 {
40  namespace VTKCellType
41  {
42  // Define VTK constants for linear, quadratic and
43  // high-order Lagrange geometrices
44  enum : unsigned int
45  {
46  VTK_VERTEX = 1,
47  // Linear cells
48  VTK_LINE = 3,
49  VTK_TRIANGLE = 5,
50  VTK_QUAD = 9,
51  VTK_TETRA = 10,
52  VTK_HEXAHEDRON = 12,
53  VTK_WEDGE = 13,
54  VTK_PYRAMID = 14,
55  // Quadratic cells
56  VTK_QUADRATIC_EDGE = 21,
57  VTK_QUADRATIC_TRIANGLE = 22,
58  VTK_QUADRATIC_QUAD = 23,
59  VTK_QUADRATIC_TETRA = 24,
60  VTK_QUADRATIC_HEXAHEDRON = 25,
61  VTK_QUADRATIC_WEDGE = 26,
62  VTK_QUADRATIC_PYRAMID = 27,
63  // Lagrange cells
64  VTK_LAGRANGE_CURVE = 68,
65  VTK_LAGRANGE_TRIANGLE = 69,
66  VTK_LAGRANGE_QUADRILATERAL = 70,
67  VTK_LAGRANGE_TETRAHEDRON = 71,
68  VTK_LAGRANGE_HEXAHEDRON = 72,
69  VTK_LAGRANGE_WEDGE = 73,
70  VTK_LAGRANGE_PYRAMID = 74,
71  // Invalid code
72  VTK_INVALID = numbers::invalid_unsigned_int
73  };
74 
75  } // namespace VTKCellType
76 
77 } // namespace
78 
80 
83 
86 
87 std::string
89 {
90  switch (this->kind)
91  {
93  return "Vertex";
95  return "Line";
97  return "Tri";
99  return "Quad";
101  return "Tet";
103  return "Pyramid";
105  return "Wedge";
107  return "Hex";
109  return "Invalid";
110  default:
111  Assert(false, ExcNotImplemented());
112  }
113 
114  return "Invalid";
115 }
116 
117 
118 
119 template <int dim, int spacedim>
120 std::unique_ptr<Mapping<dim, spacedim>>
121 ReferenceCell::get_default_mapping(const unsigned int degree) const
122 {
124 
125  if (is_hyper_cube())
126  return std::make_unique<MappingQ<dim, spacedim>>(degree);
127  else if (is_simplex())
128  return std::make_unique<MappingFE<dim, spacedim>>(
130  else if (*this == ReferenceCells::Pyramid)
131  return std::make_unique<MappingFE<dim, spacedim>>(
133  else if (*this == ReferenceCells::Wedge)
134  return std::make_unique<MappingFE<dim, spacedim>>(
135  FE_WedgeP<dim, spacedim>(degree));
136  else
137  {
138  Assert(false, ExcNotImplemented());
139  }
140 
141  return std::make_unique<MappingQ<dim, spacedim>>(degree);
142 }
143 
144 
145 
146 template <int dim, int spacedim>
149 {
151 
152  if (is_hyper_cube())
153  {
155  }
156  else if (is_simplex())
157  {
158  static const MappingFE<dim, spacedim> mapping(
160  return mapping;
161  }
162  else if (*this == ReferenceCells::Pyramid)
163  {
164  static const MappingFE<dim, spacedim> mapping(
166  return mapping;
167  }
168  else if (*this == ReferenceCells::Wedge)
169  {
170  static const MappingFE<dim, spacedim> mapping(
172  return mapping;
173  }
174  else
175  {
176  Assert(false, ExcNotImplemented());
177  }
178 
179  return StaticMappingQ1<dim, spacedim>::mapping; // never reached
180 }
181 
182 
183 
184 template <int dim>
186 ReferenceCell::get_gauss_type_quadrature(const unsigned n_points_1D) const
187 {
189 
190  if (is_hyper_cube())
191  return QGauss<dim>(n_points_1D);
192  else if (is_simplex())
193  return QGaussSimplex<dim>(n_points_1D);
194  else if (*this == ReferenceCells::Pyramid)
195  return QGaussPyramid<dim>(n_points_1D);
196  else if (*this == ReferenceCells::Wedge)
197  return QGaussWedge<dim>(n_points_1D);
198  else
199  Assert(false, ExcNotImplemented());
200 
201  return Quadrature<dim>(); // never reached
202 }
203 
204 
205 
206 template <int dim>
207 const Quadrature<dim> &
209 {
211 
212  // A function that is used to fill a quadrature object of the
213  // desired type the first time we encounter a particular
214  // reference cell
215  const auto create_quadrature = [](const ReferenceCell &reference_cell) {
216  std::vector<Point<dim>> vertices(reference_cell.n_vertices());
217  for (const unsigned int v : reference_cell.vertex_indices())
218  vertices[v] = reference_cell.vertex<dim>(v);
219 
220  return Quadrature<dim>(vertices);
221  };
222 
223  if (is_hyper_cube())
224  {
225  static const Quadrature<dim> quadrature = create_quadrature(*this);
226  return quadrature;
227  }
228  else if (is_simplex())
229  {
230  static const Quadrature<dim> quadrature = create_quadrature(*this);
231  return quadrature;
232  }
233  else if (*this == ReferenceCells::Pyramid)
234  {
235  static const Quadrature<dim> quadrature = create_quadrature(*this);
236  return quadrature;
237  }
238  else if (*this == ReferenceCells::Wedge)
239  {
240  static const Quadrature<dim> quadrature = create_quadrature(*this);
241  return quadrature;
242  }
243  else
244  Assert(false, ExcNotImplemented());
245 
246  static const Quadrature<dim> dummy;
247  return dummy; // never reached
248 }
249 
250 
251 
252 unsigned int
253 ReferenceCell::exodusii_vertex_to_deal_vertex(const unsigned int vertex_n) const
254 {
255  AssertIndexRange(vertex_n, n_vertices());
256 
257  switch (this->kind)
258  {
261  return vertex_n;
263  {
264  constexpr std::array<unsigned int, 4> exodus_to_deal{{0, 1, 3, 2}};
265  return exodus_to_deal[vertex_n];
266  }
268  return vertex_n;
270  {
271  constexpr std::array<unsigned int, 8> exodus_to_deal{
272  {0, 1, 3, 2, 4, 5, 7, 6}};
273  return exodus_to_deal[vertex_n];
274  }
276  {
277  constexpr std::array<unsigned int, 6> exodus_to_deal{
278  {2, 1, 0, 5, 4, 3}};
279  return exodus_to_deal[vertex_n];
280  }
282  {
283  constexpr std::array<unsigned int, 5> exodus_to_deal{{0, 1, 3, 2, 4}};
284  return exodus_to_deal[vertex_n];
285  }
286  default:
287  Assert(false, ExcNotImplemented());
288  }
289 
291 }
292 
293 
294 
295 unsigned int
296 ReferenceCell::exodusii_face_to_deal_face(const unsigned int face_n) const
297 {
298  AssertIndexRange(face_n, n_faces());
299 
300  switch (this->kind)
301  {
303  return 0;
306  return face_n;
308  {
309  constexpr std::array<unsigned int, 4> exodus_to_deal{{2, 1, 3, 0}};
310  return exodus_to_deal[face_n];
311  }
313  {
314  constexpr std::array<unsigned int, 4> exodus_to_deal{{1, 3, 2, 0}};
315  return exodus_to_deal[face_n];
316  }
318  {
319  constexpr std::array<unsigned int, 6> exodus_to_deal{
320  {2, 1, 3, 0, 4, 5}};
321  return exodus_to_deal[face_n];
322  }
324  {
325  constexpr std::array<unsigned int, 6> exodus_to_deal{{3, 4, 2, 0, 1}};
326  return exodus_to_deal[face_n];
327  }
329  {
330  constexpr std::array<unsigned int, 5> exodus_to_deal{{3, 2, 4, 1, 0}};
331  return exodus_to_deal[face_n];
332  }
333  default:
334  Assert(false, ExcNotImplemented());
335  }
336 
338 }
339 
340 
341 
342 unsigned int
343 ReferenceCell::unv_vertex_to_deal_vertex(const unsigned int vertex_n) const
344 {
345  AssertIndexRange(vertex_n, n_vertices());
346  // Information on this file format isn't easy to find - the documents here
347  //
348  // https://www.ceas3.uc.edu/sdrluff/
349  //
350  // Don't actually explain anything about the sections we care about (2412) in
351  // any detail. For node numbering I worked backwards from what is actually in
352  // our test files (since that's supposed to work), which all use some
353  // non-standard clockwise numbering scheme which starts at the bottom right
354  // vertex.
355  if (*this == ReferenceCells::Line)
356  {
357  return vertex_n;
358  }
359  else if (*this == ReferenceCells::Quadrilateral)
360  {
361  constexpr std::array<unsigned int, 4> unv_to_deal{{1, 0, 2, 3}};
362  return unv_to_deal[vertex_n];
363  }
364  else if (*this == ReferenceCells::Hexahedron)
365  {
366  constexpr std::array<unsigned int, 8> unv_to_deal{
367  {6, 7, 5, 4, 2, 3, 1, 0}};
368  return unv_to_deal[vertex_n];
369  }
370 
371  Assert(false, ExcNotImplemented());
372 
374 }
375 
376 
377 
378 unsigned int
380 {
381  switch (this->kind)
382  {
384  return VTKCellType::VTK_VERTEX;
386  return VTKCellType::VTK_LINE;
388  return VTKCellType::VTK_TRIANGLE;
390  return VTKCellType::VTK_QUAD;
392  return VTKCellType::VTK_TETRA;
394  return VTKCellType::VTK_PYRAMID;
396  return VTKCellType::VTK_WEDGE;
398  return VTKCellType::VTK_HEXAHEDRON;
400  return VTKCellType::VTK_INVALID;
401  default:
402  Assert(false, ExcNotImplemented());
403  }
404 
405  return VTKCellType::VTK_INVALID;
406 }
407 
408 
409 
410 unsigned int
412 {
413  switch (this->kind)
414  {
416  return VTKCellType::VTK_VERTEX;
418  return VTKCellType::VTK_QUADRATIC_EDGE;
420  return VTKCellType::VTK_QUADRATIC_TRIANGLE;
422  return VTKCellType::VTK_QUADRATIC_QUAD;
424  return VTKCellType::VTK_QUADRATIC_TETRA;
426  return VTKCellType::VTK_QUADRATIC_PYRAMID;
428  return VTKCellType::VTK_QUADRATIC_WEDGE;
430  return VTKCellType::VTK_QUADRATIC_HEXAHEDRON;
432  return VTKCellType::VTK_INVALID;
433  default:
434  Assert(false, ExcNotImplemented());
435  }
436 
437  return VTKCellType::VTK_INVALID;
438 }
439 
440 
441 
442 unsigned int
444 {
445  switch (this->kind)
446  {
448  return VTKCellType::VTK_VERTEX;
450  return VTKCellType::VTK_LAGRANGE_CURVE;
452  return VTKCellType::VTK_LAGRANGE_TRIANGLE;
454  return VTKCellType::VTK_LAGRANGE_QUADRILATERAL;
456  return VTKCellType::VTK_LAGRANGE_TETRAHEDRON;
458  return VTKCellType::VTK_LAGRANGE_PYRAMID;
460  return VTKCellType::VTK_LAGRANGE_WEDGE;
462  return VTKCellType::VTK_LAGRANGE_HEXAHEDRON;
464  return VTKCellType::VTK_INVALID;
465  default:
466  Assert(false, ExcNotImplemented());
467  }
468 
469  return VTKCellType::VTK_INVALID;
470 }
471 
472 
473 
474 template <>
475 unsigned int
476 ReferenceCell::vtk_lexicographic_to_node_index<0>(
477  const std::array<unsigned, 0> &,
478  const std::array<unsigned, 0> &,
479  const bool) const
480 {
481  Assert(false, ExcNotImplemented());
482  return 0;
483 }
484 
485 
486 
487 template <>
488 unsigned int
489 ReferenceCell::vtk_lexicographic_to_node_index<1>(
490  const std::array<unsigned, 1> &,
491  const std::array<unsigned, 1> &,
492  const bool) const
493 {
494  Assert(false, ExcNotImplemented());
495  return 0;
496 }
497 
498 
499 
504 template <>
505 unsigned int
506 ReferenceCell::vtk_lexicographic_to_node_index<2>(
507  const std::array<unsigned, 2> &node_indices,
508  const std::array<unsigned, 2> &nodes_per_direction,
509  const bool) const
510 {
512 
513  const unsigned int i = node_indices[0];
514  const unsigned int j = node_indices[1];
515 
516  const bool ibdy = (i == 0 || i == nodes_per_direction[0]);
517  const bool jbdy = (j == 0 || j == nodes_per_direction[1]);
518  // How many boundaries do we lie on at once?
519  const int nbdy = (ibdy ? 1 : 0) + (jbdy ? 1 : 0);
520 
521  if (nbdy == 2) // Vertex DOF
522  { // ijk is a corner node. Return the proper index (somewhere in [0,3]):
523  return (i != 0u ? (j != 0u ? 2 : 1) : (j != 0u ? 3 : 0));
524  }
525 
526  int offset = 4;
527  if (nbdy == 1) // Edge DOF
528  {
529  if (!ibdy)
530  { // On i axis
531  return (i - 1) +
532  (j != 0u ?
533  nodes_per_direction[0] - 1 + nodes_per_direction[1] - 1 :
534  0) +
535  offset;
536  }
537 
538  if (!jbdy)
539  { // On j axis
540  return (j - 1) +
541  (i != 0u ? nodes_per_direction[0] - 1 :
542  2 * (nodes_per_direction[0] - 1) +
543  nodes_per_direction[1] - 1) +
544  offset;
545  }
546  }
547 
548  offset += 2 * (nodes_per_direction[0] - 1 + nodes_per_direction[1] - 1);
549  // nbdy == 0: Face DOF
550  return offset + (i - 1) + (nodes_per_direction[0] - 1) * ((j - 1));
551 }
552 
553 
554 
565 template <>
566 unsigned int
567 ReferenceCell::vtk_lexicographic_to_node_index<3>(
568  const std::array<unsigned, 3> &node_indices,
569  const std::array<unsigned, 3> &nodes_per_direction,
570  const bool legacy_format) const
571 {
573 
574  const unsigned int i = node_indices[0];
575  const unsigned int j = node_indices[1];
576  const unsigned int k = node_indices[2];
577 
578  const bool ibdy = (i == 0 || i == nodes_per_direction[0]);
579  const bool jbdy = (j == 0 || j == nodes_per_direction[1]);
580  const bool kbdy = (k == 0 || k == nodes_per_direction[2]);
581  // How many boundaries do we lie on at once?
582  const int nbdy = (ibdy ? 1 : 0) + (jbdy ? 1 : 0) + (kbdy ? 1 : 0);
583 
584  if (nbdy == 3) // Vertex DOF
585  { // ijk is a corner node. Return the proper index (somewhere in [0,7]):
586  return (i != 0u ? (j != 0u ? 2 : 1) : (j != 0u ? 3 : 0)) +
587  (k != 0u ? 4 : 0);
588  }
589 
590  int offset = 8;
591  if (nbdy == 2) // Edge DOF
592  {
593  if (!ibdy)
594  { // On i axis
595  return (i - 1) +
596  (j != 0u ?
597  nodes_per_direction[0] - 1 + nodes_per_direction[1] - 1 :
598  0) +
599  (k != 0u ? 2 * (nodes_per_direction[0] - 1 +
600  nodes_per_direction[1] - 1) :
601  0) +
602  offset;
603  }
604  if (!jbdy)
605  { // On j axis
606  return (j - 1) +
607  (i != 0u ? nodes_per_direction[0] - 1 :
608  2 * (nodes_per_direction[0] - 1) +
609  nodes_per_direction[1] - 1) +
610  (k != 0u ? 2 * (nodes_per_direction[0] - 1 +
611  nodes_per_direction[1] - 1) :
612  0) +
613  offset;
614  }
615  // !kbdy, On k axis
616  offset +=
617  4 * (nodes_per_direction[0] - 1) + 4 * (nodes_per_direction[1] - 1);
618  if (legacy_format)
619  return (k - 1) +
620  (nodes_per_direction[2] - 1) *
621  (i != 0u ? (j != 0u ? 3 : 1) : (j != 0u ? 2 : 0)) +
622  offset;
623  else
624  return (k - 1) +
625  (nodes_per_direction[2] - 1) *
626  (i != 0u ? (j != 0u ? 2 : 1) : (j != 0u ? 3 : 0)) +
627  offset;
628  }
629 
630  offset += 4 * (nodes_per_direction[0] - 1 + nodes_per_direction[1] - 1 +
631  nodes_per_direction[2] - 1);
632  if (nbdy == 1) // Face DOF
633  {
634  if (ibdy) // On i-normal face
635  {
636  return (j - 1) + ((nodes_per_direction[1] - 1) * (k - 1)) +
637  (i != 0u ? (nodes_per_direction[1] - 1) *
638  (nodes_per_direction[2] - 1) :
639  0) +
640  offset;
641  }
642  offset += 2 * (nodes_per_direction[1] - 1) * (nodes_per_direction[2] - 1);
643  if (jbdy) // On j-normal face
644  {
645  return (i - 1) + ((nodes_per_direction[0] - 1) * (k - 1)) +
646  (j != 0u ? (nodes_per_direction[2] - 1) *
647  (nodes_per_direction[0] - 1) :
648  0) +
649  offset;
650  }
651  offset += 2 * (nodes_per_direction[2] - 1) * (nodes_per_direction[0] - 1);
652  // kbdy, On k-normal face
653  return (i - 1) + ((nodes_per_direction[0] - 1) * (j - 1)) +
654  (k != 0u ?
655  (nodes_per_direction[0] - 1) * (nodes_per_direction[1] - 1) :
656  0) +
657  offset;
658  }
659 
660  // nbdy == 0: Body DOF
661  offset += 2 * ((nodes_per_direction[1] - 1) * (nodes_per_direction[2] - 1) +
662  (nodes_per_direction[2] - 1) * (nodes_per_direction[0] - 1) +
663  (nodes_per_direction[0] - 1) * (nodes_per_direction[1] - 1));
664  return offset + (i - 1) +
665  (nodes_per_direction[0] - 1) *
666  ((j - 1) + (nodes_per_direction[1] - 1) * ((k - 1)));
667 }
668 
669 
670 
671 unsigned int
672 ReferenceCell::vtk_vertex_to_deal_vertex(const unsigned int vertex_index) const
673 {
674  AssertIndexRange(vertex_index, n_vertices());
675 
676  // For some of the following, deal.II uses the same ordering as VTK
677  // and in that case, we only need to return 'vertex_index' (i.e.,
678  // use the identity mapping). For some others, we need to translate.
679  //
680  // For the ordering, see the VTK manual (for example at
681  // http://www.princeton.edu/~efeibush/viscourse/vtk.pdf, page 9).
682  switch (this->kind)
683  {
685  return vertex_index;
687  return vertex_index;
689  return vertex_index;
691  {
692  static constexpr std::array<unsigned int, 4> index_translation_table =
693  {{0, 1, 3, 2}};
694  return index_translation_table[vertex_index];
695  }
697  return vertex_index;
699  {
700  static constexpr std::array<unsigned int, 5> index_translation_table =
701  {{0, 1, 3, 2, 4}};
702  return index_translation_table[vertex_index];
703  }
705  return vertex_index;
707  {
708  static constexpr std::array<unsigned int, 8> index_translation_table =
709  {{0, 1, 3, 2, 4, 5, 7, 6}};
710  return index_translation_table[vertex_index];
711  }
713  {
714  Assert(false, ExcNotImplemented());
716  }
717  default:
718  Assert(false, ExcNotImplemented());
719  }
720 
722 }
723 
724 
725 
726 unsigned int
728 {
729  /*
730  From the GMSH documentation:
731 
732  elm-type
733  defines the geometrical type of the n-th element:
734 
735  1
736  Line (2 nodes).
737 
738  2
739  Triangle (3 nodes).
740 
741  3
742  Quadrangle (4 nodes).
743 
744  4
745  Tetrahedron (4 nodes).
746 
747  5
748  Hexahedron (8 nodes).
749 
750  6
751  Prism (6 nodes).
752 
753  7
754  Pyramid (5 nodes).
755 
756  8
757  Second order line (3 nodes: 2 associated with the vertices and 1 with the
758  edge).
759 
760  9
761  Second order triangle (6 nodes: 3 associated with the vertices and 3 with
762  the edges).
763 
764  10 Second order quadrangle (9 nodes: 4 associated with the
765  vertices, 4 with the edges and 1 with the face).
766 
767  11 Second order tetrahedron (10 nodes: 4 associated with the vertices and 6
768  with the edges).
769 
770  12 Second order hexahedron (27 nodes: 8 associated with the vertices, 12
771  with the edges, 6 with the faces and 1 with the volume).
772 
773  13 Second order prism (18 nodes: 6 associated with the vertices, 9 with the
774  edges and 3 with the quadrangular faces).
775 
776  14 Second order pyramid (14 nodes: 5 associated with the vertices, 8 with
777  the edges and 1 with the quadrangular face).
778 
779  15 Point (1 node).
780  */
781 
782  switch (this->kind)
783  {
785  return 15;
787  return 1;
789  return 2;
791  return 3;
793  return 4;
795  return 7;
797  return 6;
799  return 5;
801  default:
802  Assert(false, ExcNotImplemented());
803  }
804 
806 }
807 
808 
809 
810 std::ostream &
811 operator<<(std::ostream &out, const ReferenceCell &reference_cell)
812 {
813  AssertThrow(out.fail() == false, ExcIO());
814 
815  // Output as an integer to avoid outputting it as a character with
816  // potentially non-printing value:
817  out << static_cast<unsigned int>(reference_cell.kind);
818  return out;
819 }
820 
821 
822 
823 std::istream &
825 {
826  AssertThrow(in.fail() == false, ExcIO());
827 
828  // Read the information as an integer and convert it to the correct type
829  unsigned int value;
830  in >> value;
831  reference_cell.kind = static_cast<decltype(reference_cell.kind)>(value);
832 
833  // Ensure that the object we read is valid
834  Assert(
844  ExcMessage(
845  "The reference cell kind just read does not correspond to one of the "
846  "valid choices. There must be an error."));
847 
848  return in;
849 }
850 
851 
852 
853 #include "reference_cell.inst"
854 
OutputOperator< VectorType > & operator<<(OutputOperator< VectorType > &out, unsigned int step)
Definition: operator.h:165
std::istream & operator>>(std::istream &in, Point< dim, Number > &p)
Definition: point.h:685
unsigned int n_vertices() const
bool is_hyper_cube() const
unsigned int vtk_linear_type() const
Quadrature< dim > get_gauss_type_quadrature(const unsigned n_points_1D) const
static constexpr ndarray< unsigned int, 2, 2 > line_vertex_permutations
unsigned int gmsh_element_type() const
static constexpr ndarray< unsigned int, 8, 4 > quadrilateral_vertex_permutations
unsigned int n_faces() const
std::uint8_t kind
unsigned int exodusii_vertex_to_deal_vertex(const unsigned int vertex_n) const
unsigned int unv_vertex_to_deal_vertex(const unsigned int vertex_n) const
unsigned int vtk_vertex_to_deal_vertex(const unsigned int vertex_index) const
std::unique_ptr< Mapping< dim, spacedim > > get_default_mapping(const unsigned int degree) const
unsigned int vtk_quadratic_type() const
unsigned int vtk_lagrange_type() const
unsigned int get_dimension() const
unsigned int exodusii_face_to_deal_face(const unsigned int face_n) const
const Mapping< dim, spacedim > & get_default_linear_mapping() const
std::string to_string() const
bool is_simplex() const
const Quadrature< dim > & get_nodal_type_quadrature() const
static constexpr ndarray< unsigned int, 6, 3 > triangle_vertex_permutations
#define DEAL_II_NAMESPACE_OPEN
Definition: config.h:461
#define DEAL_II_NAMESPACE_CLOSE
Definition: config.h:462
Point< 3 > vertices[4]
#define Assert(cond, exc)
Definition: exceptions.h:1509
static ::ExceptionBase & ExcNotImplemented()
#define AssertDimension(dim1, dim2)
Definition: exceptions.h:1703
#define AssertIndexRange(index, range)
Definition: exceptions.h:1768
static ::ExceptionBase & ExcIO()
static ::ExceptionBase & ExcMessage(std::string arg1)
#define AssertThrow(cond, exc)
Definition: exceptions.h:1619
void reference_cell(Triangulation< dim, spacedim > &tria, const ReferenceCell &reference_cell)
constexpr const ReferenceCell Tetrahedron
constexpr const ReferenceCell Quadrilateral
constexpr const ReferenceCell Wedge
constexpr const ReferenceCell Pyramid
constexpr const ReferenceCell Invalid
constexpr const ReferenceCell Triangle
constexpr const ReferenceCell Hexahedron
constexpr const ReferenceCell Vertex
constexpr const ReferenceCell Line
static const unsigned int invalid_unsigned_int
Definition: types.h:206
typename internal::ndarray::HelperArray< T, Ns... >::type ndarray
Definition: ndarray.h:108