We're generally quite good at not using abbreviated words in deal.II function names,
with few exceptions that are mostly historic. Let's try to keep it that way.
(void)e;
if (d == 2)
- return dealii::ReferenceCell::Tri;
+ return dealii::ReferenceCell::Triangle;
if (d == 1)
return dealii::ReferenceCell::Line;
(void)e;
if (d == 2)
- return dealii::ReferenceCell::Quad;
+ return dealii::ReferenceCell::Quadrilateral;
if (d == 1)
return dealii::ReferenceCell::Line;
(void)e;
if (d == 3)
- return dealii::ReferenceCell::Tet;
+ return dealii::ReferenceCell::Tetrahedron;
if (d == 2)
- return dealii::ReferenceCell::Tri;
+ return dealii::ReferenceCell::Triangle;
if (d == 1)
return dealii::ReferenceCell::Line;
return dealii::ReferenceCell::Pyramid;
if (d == 2 && e == 0)
- return dealii::ReferenceCell::Quad;
+ return dealii::ReferenceCell::Quadrilateral;
else if (d == 2)
- return dealii::ReferenceCell::Tri;
+ return dealii::ReferenceCell::Triangle;
if (d == 1)
return dealii::ReferenceCell::Line;
return dealii::ReferenceCell::Wedge;
if (d == 2 && e > 1)
- return dealii::ReferenceCell::Quad;
+ return dealii::ReferenceCell::Quadrilateral;
else if (d == 2)
- return dealii::ReferenceCell::Tri;
+ return dealii::ReferenceCell::Triangle;
if (d == 1)
return dealii::ReferenceCell::Line;
(void)e;
if (d == 3)
- return dealii::ReferenceCell::Hex;
+ return dealii::ReferenceCell::Hexahedron;
if (d == 2)
- return dealii::ReferenceCell::Quad;
+ return dealii::ReferenceCell::Quadrilateral;
if (d == 1)
return dealii::ReferenceCell::Line;
dealii::ReferenceCell::Line)]
.reset(new CellTypeLine());
cell_types_impl[static_cast<types::geometric_entity_type>(
- dealii::ReferenceCell::Tri)]
+ dealii::ReferenceCell::Triangle)]
.reset(new CellTypeTri());
cell_types_impl[static_cast<types::geometric_entity_type>(
- dealii::ReferenceCell::Quad)]
+ dealii::ReferenceCell::Quadrilateral)]
.reset(new CellTypeQuad());
cell_types_impl[static_cast<types::geometric_entity_type>(
- dealii::ReferenceCell::Tet)]
+ dealii::ReferenceCell::Tetrahedron)]
.reset(new CellTypeTet());
cell_types_impl[static_cast<types::geometric_entity_type>(
dealii::ReferenceCell::Pyramid)]
dealii::ReferenceCell::Wedge)]
.reset(new CellTypeWedge());
cell_types_impl[static_cast<types::geometric_entity_type>(
- dealii::ReferenceCell::Hex)]
+ dealii::ReferenceCell::Hexahedron)]
.reset(new CellTypeHex());
// determine cell types and process vertices
public:
static const ReferenceCell Vertex;
static const ReferenceCell Line;
- static const ReferenceCell Tri;
- static const ReferenceCell Quad;
- static const ReferenceCell Tet;
+ static const ReferenceCell Triangle;
+ static const ReferenceCell Quadrilateral;
+ static const ReferenceCell Tetrahedron;
static const ReferenceCell Pyramid;
static const ReferenceCell Wedge;
- static const ReferenceCell Hex;
+ static const ReferenceCell Hexahedron;
static const ReferenceCell Invalid;
/**
* Return the correct simplex reference cell type for the given dimension
* `dim`. Depending on the template argument `dim`, this function returns a
- * reference to either Vertex, Tri, or Tet.
+ * reference to either Vertex, Triangle, or Tetrahedron.
*/
template <int dim>
static constexpr const ReferenceCell &
/**
* Return the correct hypercube reference cell type for the given dimension
* `dim`. Depending on the template argument `dim`, this function returns a
- * reference to either Vertex, Quad, or Hex.
+ * reference to either Vertex, Quadrilateral, or Hexahedron.
*/
template <int dim>
static constexpr const ReferenceCell &
/**
* Return the correct ReferenceCell for a given structural
* dimension and number of vertices. For example, if `dim==2` and
- * `n_vertices==4`, this function will return `Quad`. But if `dim==3` and
- * `n_vertices==4`, it will return `Tri`.
+ * `n_vertices==4`, this function will return `Quadrilateral`. But if `dim==3`
+ * and `n_vertices==4`, it will return `Tetrahedron`.
*/
static ReferenceCell
n_vertices_to_type(const int dim, const unsigned int n_vertices);
constexpr ReferenceCell();
/**
- * Return true if the object is a Vertex, Line, Quad, or Hex.
+ * Return true if the object is a Vertex, Line, Quadrilateral, or Hexahedron.
*/
bool
is_hyper_cube() const;
/**
- * Return true if the object is a Vertex, Line, Tri, or Tet.
+ * Return true if the object is a Vertex, Line, Triangle, or Tetrahedron.
*/
bool
is_simplex() const;
AssertIndexRange(vertex, GeometryInfo<1>::vertices_per_cell);
return {&GeometryInfo<2>::vertex_to_face[vertex][0], 1};
}
- else if (*this == ReferenceCell::Quad)
+ else if (*this == ReferenceCell::Quadrilateral)
{
AssertIndexRange(vertex, GeometryInfo<2>::vertices_per_cell);
return {&GeometryInfo<2>::vertex_to_face[vertex][0], 2};
}
- else if (*this == ReferenceCell::Hex)
+ else if (*this == ReferenceCell::Hexahedron)
{
AssertIndexRange(vertex, GeometryInfo<3>::vertices_per_cell);
return {&GeometryInfo<3>::vertex_to_face[vertex][0], 3};
}
- else if (*this == ReferenceCell::Tri)
+ else if (*this == ReferenceCell::Triangle)
{
AssertIndexRange(vertex, 3);
static const std::array<std::array<unsigned int, 2>, 3> table = {
return table[vertex];
}
- else if (*this == ReferenceCell::Tet)
+ else if (*this == ReferenceCell::Tetrahedron)
{
AssertIndexRange(vertex, 4);
static const std::array<std::array<unsigned int, 3>, 4> table = {
inline bool
ReferenceCell::is_hyper_cube() const
{
- return (*this == Vertex || *this == Line || *this == Quad || *this == Hex);
+ return (*this == Vertex || *this == Line || *this == Quadrilateral ||
+ *this == Hexahedron);
}
inline bool
ReferenceCell::is_simplex() const
{
- return (*this == Vertex || *this == Line || *this == Tri || *this == Tet);
+ return (*this == Vertex || *this == Line || *this == Triangle ||
+ *this == Tetrahedron);
}
return 0;
else if (*this == Line)
return 1;
- else if ((*this == Tri) || (*this == Quad))
+ else if ((*this == Triangle) || (*this == Quadrilateral))
return 2;
- else if ((*this == Tet) || (*this == Pyramid) || (*this == Wedge) ||
- (*this == Hex))
+ else if ((*this == Tetrahedron) || (*this == Pyramid) || (*this == Wedge) ||
+ (*this == Hexahedron))
return 3;
Assert(false, ExcNotImplemented());
case 1:
return ReferenceCell::Line;
case 2:
- return ReferenceCell::Tri;
+ return ReferenceCell::Triangle;
case 3:
- return ReferenceCell::Tet;
+ return ReferenceCell::Tetrahedron;
default:
Assert(false, ExcNotImplemented());
return ReferenceCell::Invalid;
case 1:
return ReferenceCell::Line;
case 2:
- return ReferenceCell::Quad;
+ return ReferenceCell::Quadrilateral;
case 3:
- return ReferenceCell::Hex;
+ return ReferenceCell::Hexahedron;
default:
Assert(false, ExcNotImplemented());
return ReferenceCell::Invalid;
// dim 1
{{X, X, ReferenceCell::Line, X, X, X, X, X, X}},
// dim 2
- {{X, X, X, ReferenceCell::Tri, ReferenceCell::Quad, X, X, X, X}},
+ {{X,
+ X,
+ X,
+ ReferenceCell::Triangle,
+ ReferenceCell::Quadrilateral,
+ X,
+ X,
+ X,
+ X}},
// dim 3
{{X,
X,
X,
X,
- ReferenceCell::Tet,
+ ReferenceCell::Tetrahedron,
ReferenceCell::Pyramid,
ReferenceCell::Wedge,
X,
- ReferenceCell::Hex}}}};
+ ReferenceCell::Hexahedron}}}};
Assert(table[dim][n_vertices] != ReferenceCell::Invalid,
ExcMessage("The combination of dim = " + std::to_string(dim) +
" and n_vertices = " + std::to_string(n_vertices) +
return GeometryInfo<dim>::d_linear_shape_function(xi, i);
if (*this ==
- ReferenceCell::Tri) // see also Simplex::ScalarPolynomial::compute_value
+ ReferenceCell::Triangle) // see also
+ // Simplex::ScalarPolynomial::compute_value
{
switch (i)
{
}
if (*this ==
- ReferenceCell::Tet) // see also Simplex::ScalarPolynomial::compute_value
+ ReferenceCell::Tetrahedron) // see also
+ // Simplex::ScalarPolynomial::compute_value
{
switch (i)
{
ReferenceCell::Wedge) // see also
// Simplex::ScalarWedgePolynomial::compute_value
{
- return ReferenceCell(ReferenceCell::Tri)
+ return ReferenceCell(ReferenceCell::Triangle)
.d_linear_shape_function<2>(Point<2>(xi[std::min(0, dim - 1)],
xi[std::min(1, dim - 1)]),
i % 3) *
return GeometryInfo<dim>::d_linear_shape_function_gradient(xi, i);
if (*this ==
- ReferenceCell::Tri) // see also Simplex::ScalarPolynomial::compute_grad
+ ReferenceCell::Triangle) // see also
+ // Simplex::ScalarPolynomial::compute_grad
{
switch (i)
{
AssertIndexRange(face_no, GeometryInfo<dim>::faces_per_cell);
return GeometryInfo<dim>::unit_tangential_vectors[face_no][i];
}
- else if (*this == ReferenceCell::Tri)
+ else if (*this == ReferenceCell::Triangle)
{
AssertIndexRange(face_no, 3);
static const std::array<Tensor<1, dim>, 3> table = {
return table[face_no];
}
- else if (*this == ReferenceCell::Tet)
+ else if (*this == ReferenceCell::Tetrahedron)
{
AssertIndexRange(face_no, 4);
static const std::array<std::array<Tensor<1, dim>, 2>, 4> table = {
}
else if (dim == 2)
{
- Assert(*this == Tri, ExcInternalError());
+ Assert(*this == Triangle, ExcInternalError());
// Return the rotated vector
return cross_product_2d(unit_tangential_vectors<dim>(face_no, 0));
/**
* Triangle.
*/
- struct Tri : public Base
+ struct Triangle : public Base
{
unsigned int
n_vertices() const override
/**
- * Quad.
+ * Quadrilateral
*/
- struct Quad : public TensorProductBase<2>
+ struct Quadrilateral : public TensorProductBase<2>
{
std::array<unsigned int, 2>
standard_vertex_to_face_and_vertex_index(
/**
- * Tet.
+ * Tetrahedron
*/
- struct Tet : public Base
+ struct Tetrahedron : public Base
{
unsigned int
n_vertices() const override
AssertIndexRange(face_no, n_faces());
- return dealii::ReferenceCell::Tri;
+ return dealii::ReferenceCell::Triangle;
}
unsigned int
AssertIndexRange(face_no, n_faces());
if (face_no == 0)
- return dealii::ReferenceCell::Quad;
+ return dealii::ReferenceCell::Quadrilateral;
else
- return dealii::ReferenceCell::Tri;
+ return dealii::ReferenceCell::Triangle;
}
unsigned int
AssertIndexRange(face_no, n_faces());
if (face_no > 1)
- return dealii::ReferenceCell::Quad;
+ return dealii::ReferenceCell::Quadrilateral;
else
- return dealii::ReferenceCell::Tri;
+ return dealii::ReferenceCell::Triangle;
}
unsigned int
/**
* Hex.
*/
- struct Hex : public TensorProductBase<3>
+ struct Hexahedron : public TensorProductBase<3>
{
std::array<unsigned int, 2>
standard_line_to_face_and_line_index(
face_reference_cell(const unsigned int face_no) const override
{
(void)face_no;
- return dealii::ReferenceCell::Quad;
+ return dealii::ReferenceCell::Quadrilateral;
}
virtual unsigned int
static const std::array<std::unique_ptr<internal::ReferenceCell::Base>, 8>
gei{{std::make_unique<internal::ReferenceCell::Vertex>(),
std::make_unique<internal::ReferenceCell::Line>(),
- std::make_unique<internal::ReferenceCell::Tri>(),
- std::make_unique<internal::ReferenceCell::Quad>(),
- std::make_unique<internal::ReferenceCell::Tet>(),
+ std::make_unique<internal::ReferenceCell::Triangle>(),
+ std::make_unique<internal::ReferenceCell::Quadrilateral>(),
+ std::make_unique<internal::ReferenceCell::Tetrahedron>(),
std::make_unique<internal::ReferenceCell::Pyramid>(),
std::make_unique<internal::ReferenceCell::Wedge>(),
- std::make_unique<internal::ReferenceCell::Hex>()}};
+ std::make_unique<internal::ReferenceCell::Hexahedron>()}};
AssertIndexRange(static_cast<std::uint8_t>(type), 8);
return *gei[static_cast<std::uint8_t>(type)];
}
if (i == std::array<T, 2>{{j[1], j[0]}})
return 0;
}
- else if (*this == ReferenceCell::Tri)
+ else if (*this == ReferenceCell::Triangle)
{
const std::array<T, 3> i{{vertices_0[0], vertices_0[1], vertices_0[2]}};
const std::array<T, 3> j{{vertices_1[0], vertices_1[1], vertices_1[2]}};
if (i == std::array<T, 3>{{j[1], j[0], j[2]}})
return 4;
}
- else if (*this == ReferenceCell::Quad)
+ else if (*this == ReferenceCell::Quadrilateral)
{
const std::array<T, 4> i{
{vertices_0[0], vertices_0[1], vertices_0[2], vertices_0[3]}};
Assert(false, ExcNotImplemented());
}
}
- else if (*this == ReferenceCell::Tri)
+ else if (*this == ReferenceCell::Triangle)
{
switch (orientation)
{
Assert(false, ExcNotImplemented());
}
}
- else if (*this == ReferenceCell::Quad)
+ else if (*this == ReferenceCell::Quadrilateral)
{
switch (orientation)
{
if (reference_cell == dealii::ReferenceCell::Line)
// Return the distance between the two vertices
return (vertices[1] - vertices[0]).norm();
- else if (reference_cell == dealii::ReferenceCell::Tri)
+ else if (reference_cell == dealii::ReferenceCell::Triangle)
// Return the longest of the three edges
return std::max({(vertices[1] - vertices[0]).norm(),
(vertices[2] - vertices[1]).norm(),
(vertices[2] - vertices[0]).norm()});
- else if (reference_cell == dealii::ReferenceCell::Quad)
+ else if (reference_cell == dealii::ReferenceCell::Quadrilateral)
// Return the longer one of the two diagonals of the quadrilateral
return std::max({(vertices[3] - vertices[0]).norm(),
(vertices[2] - vertices[1]).norm()});
- else if (reference_cell == dealii::ReferenceCell::Tet)
+ else if (reference_cell == dealii::ReferenceCell::Tetrahedron)
// Return the longest of the six edges of the tetrahedron
return std::max({(vertices[1] - vertices[0]).norm(),
(vertices[2] - vertices[0]).norm(),
(vertices[4] - vertices[3]).norm(),
(vertices[5] - vertices[4]).norm(),
(vertices[5] - vertices[3]).norm()});
- else if (reference_cell == dealii::ReferenceCell::Hex)
+ else if (reference_cell == dealii::ReferenceCell::Hexahedron)
// Return the longest of the four diagonals of the hexahedron
return std::max({(vertices[7] - vertices[0]).norm(),
(vertices[6] - vertices[1]).norm(),
if ((reference_cell == dealii::ReferenceCell::Vertex) ||
(reference_cell == dealii::ReferenceCell::Line) ||
- (reference_cell == dealii::ReferenceCell::Quad) ||
- (reference_cell == dealii::ReferenceCell::Hex))
+ (reference_cell == dealii::ReferenceCell::Quadrilateral) ||
+ (reference_cell == dealii::ReferenceCell::Hexahedron))
needs_hypercube_setup |= true;
- else if ((reference_cell == dealii::ReferenceCell::Tri) ||
- (reference_cell == dealii::ReferenceCell::Tet))
+ else if ((reference_cell == dealii::ReferenceCell::Triangle) ||
+ (reference_cell == dealii::ReferenceCell::Tetrahedron))
needs_simplex_setup |= true;
else if (reference_cell == dealii::ReferenceCell::Wedge)
needs_wedge_setup |= true;
if ((reference_cell == dealii::ReferenceCell::Vertex) ||
(reference_cell == dealii::ReferenceCell::Line) ||
- (reference_cell == dealii::ReferenceCell::Quad) ||
- (reference_cell == dealii::ReferenceCell::Hex))
+ (reference_cell ==
+ dealii::ReferenceCell::Quadrilateral) ||
+ (reference_cell == dealii::ReferenceCell::Hexahedron))
quadrature.push_back(*quadrature_hypercube);
- else if ((reference_cell == dealii::ReferenceCell::Tri) ||
- (reference_cell == dealii::ReferenceCell::Tet))
+ else if ((reference_cell ==
+ dealii::ReferenceCell::Triangle) ||
+ (reference_cell ==
+ dealii::ReferenceCell::Tetrahedron))
quadrature.push_back(*quadrature_simplex);
else if (reference_cell == dealii::ReferenceCell::Wedge)
quadrature.push_back(*quadrature_wedge);
vtk_cell_id[0] = cell_type_by_dim[dim];
vtk_cell_id[1] = 1;
}
- else if (patch.reference_cell == ReferenceCell::Tri)
+ else if (patch.reference_cell == ReferenceCell::Triangle)
{
vtk_cell_id[0] = VTK_LAGRANGE_TRIANGLE;
vtk_cell_id[1] = 1;
Assert(false, ExcNotImplemented());
}
}
- else if (patch.reference_cell == ReferenceCell::Tri &&
+ else if (patch.reference_cell == ReferenceCell::Triangle &&
patch.data.n_cols() == 3)
{
vtk_cell_id[0] = VTK_TRIANGLE;
vtk_cell_id[1] = 1;
}
- else if (patch.reference_cell == ReferenceCell::Tri &&
+ else if (patch.reference_cell == ReferenceCell::Triangle &&
patch.data.n_cols() == 6)
{
vtk_cell_id[0] = VTK_QUADRATIC_TRIANGLE;
vtk_cell_id[1] = 1;
}
- else if (patch.reference_cell == ReferenceCell::Tet &&
+ else if (patch.reference_cell == ReferenceCell::Tetrahedron &&
patch.data.n_cols() == 4)
{
vtk_cell_id[0] = VTK_TETRA;
vtk_cell_id[1] = 1;
}
- else if (patch.reference_cell == ReferenceCell::Tet &&
+ else if (patch.reference_cell == ReferenceCell::Tetrahedron &&
patch.data.n_cols() == 10)
{
vtk_cell_id[0] = VTK_QUADRATIC_TETRA;
<< "\" NodesPerElement=\"2\">\n";
else if (dimension == 2)
{
- Assert(reference_cell == ReferenceCell::Quad ||
- reference_cell == ReferenceCell::Tri,
+ Assert(reference_cell == ReferenceCell::Quadrilateral ||
+ reference_cell == ReferenceCell::Triangle,
ExcNotImplemented());
ss << indent(indent_level + 1) << "<Topology TopologyType=\"";
- if (reference_cell == ReferenceCell::Quad)
+ if (reference_cell == ReferenceCell::Quadrilateral)
{
ss << "Quadrilateral"
<< "\" NumberOfElements=\"" << num_cells << "\">\n"
<< indent(indent_level + 2) << "<DataItem Dimensions=\""
<< num_cells << " " << (1 << dimension);
}
- else // if (reference_cell == ReferenceCell::Tri)
+ else // if (reference_cell == ReferenceCell::Triangle)
{
ss << "Triangle"
<< "\" NumberOfElements=\"" << num_cells << "\">\n"
}
else if (dimension == 3)
{
- Assert(reference_cell == ReferenceCell::Hex ||
- reference_cell == ReferenceCell::Tet,
+ Assert(reference_cell == ReferenceCell::Hexahedron ||
+ reference_cell == ReferenceCell::Tetrahedron,
ExcNotImplemented());
ss << indent(indent_level + 1) << "<Topology TopologyType=\"";
- if (reference_cell == ReferenceCell::Hex)
+ if (reference_cell == ReferenceCell::Hexahedron)
{
ss << "Hexahedron"
<< "\" NumberOfElements=\"" << num_cells << "\">\n"
<< indent(indent_level + 2) << "<DataItem Dimensions=\""
<< num_cells << " " << (1 << dimension);
}
- else // if (reference_cell == ReferenceCell::Tet)
+ else // if (reference_cell == ReferenceCell::Tetrahedron)
{
ss << "Tetrahedron"
<< "\" NumberOfElements=\"" << num_cells << "\">\n"
const unsigned int face_no,
std::vector<Point<2>> &q_points)
{
- project_to_face(ReferenceCell::Quad, quadrature, face_no, q_points);
+ project_to_face(ReferenceCell::Quadrilateral, quadrature, face_no, q_points);
}
Assert(q_points.size() == quadrature.size(),
ExcDimensionMismatch(q_points.size(), quadrature.size()));
- if (reference_cell == ReferenceCell::Tri)
+ if (reference_cell == ReferenceCell::Triangle)
{
// use linear polynomial to map the reference quadrature points correctly
// on faces, i.e., Simplex::ScalarPolynomial<1>(1)
Assert(false, ExcInternalError());
}
}
- else if (reference_cell == ReferenceCell::Quad)
+ else if (reference_cell == ReferenceCell::Quadrilateral)
{
for (unsigned int p = 0; p < quadrature.size(); ++p)
switch (face_no)
const unsigned int face_no,
std::vector<Point<3>> &q_points)
{
- project_to_face(ReferenceCell::Hex, quadrature, face_no, q_points);
+ project_to_face(ReferenceCell::Hexahedron, quadrature, face_no, q_points);
}
const unsigned int face_no,
std::vector<Point<3>> &q_points)
{
- Assert(reference_cell == ReferenceCell::Hex, ExcNotImplemented());
+ Assert(reference_cell == ReferenceCell::Hexahedron, ExcNotImplemented());
(void)reference_cell;
const unsigned int dim = 3;
std::vector<Point<2>> & q_points,
const RefinementCase<1> &ref_case)
{
- project_to_subface(
- ReferenceCell::Quad, quadrature, face_no, subface_no, q_points, ref_case);
+ project_to_subface(ReferenceCell::Quadrilateral,
+ quadrature,
+ face_no,
+ subface_no,
+ q_points,
+ ref_case);
}
Assert(q_points.size() == quadrature.size(),
ExcDimensionMismatch(q_points.size(), quadrature.size()));
- if (reference_cell == ReferenceCell::Tri)
+ if (reference_cell == ReferenceCell::Triangle)
{
// use linear polynomial to map the reference quadrature points correctly
// on faces, i.e., Simplex::ScalarPolynomial<1>(1)
Assert(false, ExcInternalError());
}
}
- else if (reference_cell == ReferenceCell::Quad)
+ else if (reference_cell == ReferenceCell::Quadrilateral)
{
for (unsigned int p = 0; p < quadrature.size(); ++p)
switch (face_no)
std::vector<Point<3>> & q_points,
const RefinementCase<2> &ref_case)
{
- project_to_subface(
- ReferenceCell::Hex, quadrature, face_no, subface_no, q_points, ref_case);
+ project_to_subface(ReferenceCell::Hexahedron,
+ quadrature,
+ face_no,
+ subface_no,
+ q_points,
+ ref_case);
}
std::vector<Point<3>> & q_points,
const RefinementCase<2> &ref_case)
{
- Assert(reference_cell == ReferenceCell::Hex, ExcNotImplemented());
+ Assert(reference_cell == ReferenceCell::Hexahedron, ExcNotImplemented());
(void)reference_cell;
const unsigned int dim = 3;
QProjector<2>::project_to_all_faces(const ReferenceCell reference_cell,
const hp::QCollection<1> &quadrature)
{
- if (reference_cell == ReferenceCell::Tri)
+ if (reference_cell == ReferenceCell::Triangle)
{
const auto support_points_line =
[](const auto &face, const auto &orientation) -> std::vector<Point<2>> {
return {points, weights};
}
- Assert(reference_cell == ReferenceCell::Quad, ExcNotImplemented());
+ Assert(reference_cell == ReferenceCell::Quadrilateral, ExcNotImplemented());
const unsigned int dim = 2;
std::array<Point<3>, 3> vertices;
std::copy_n(face.first.begin(), face.first.size(), vertices.begin());
const auto temp =
- ReferenceCell::Tri.permute_according_orientation(vertices, orientation);
+ ReferenceCell::Triangle.permute_according_orientation(vertices,
+ orientation);
return std::vector<Point<3>>(temp.begin(),
temp.begin() + face.first.size());
};
std::array<Point<3>, 4> vertices;
std::copy_n(face.first.begin(), face.first.size(), vertices.begin());
const auto temp =
- ReferenceCell::Quad.permute_according_orientation(vertices, orientation);
+ ReferenceCell::Quadrilateral.permute_according_orientation(vertices,
+ orientation);
return std::vector<Point<3>>(temp.begin(),
temp.begin() + face.first.size());
};
return Quadrature<3>(points, weights);
};
- if (reference_cell == ReferenceCell::Tet)
+ if (reference_cell == ReferenceCell::Tetrahedron)
{
// reference faces (defined by its support points and its area)
// note: the area is later not used as a scaling factor but recomputed
}
- Assert(reference_cell == ReferenceCell::Hex, ExcNotImplemented());
+ Assert(reference_cell == ReferenceCell::Hexahedron, ExcNotImplemented());
const unsigned int dim = 3;
QProjector<2>::project_to_all_subfaces(const ReferenceCell reference_cell,
const SubQuadrature &quadrature)
{
- if (reference_cell == ReferenceCell::Tri ||
- reference_cell == ReferenceCell::Tet)
+ if (reference_cell == ReferenceCell::Triangle ||
+ reference_cell == ReferenceCell::Tetrahedron)
return Quadrature<2>(); // nothing to do
- Assert(reference_cell == ReferenceCell::Quad, ExcNotImplemented());
+ Assert(reference_cell == ReferenceCell::Quadrilateral, ExcNotImplemented());
const unsigned int dim = 2;
Quadrature<2>
QProjector<2>::project_to_all_subfaces(const SubQuadrature &quadrature)
{
- return project_to_all_subfaces(ReferenceCell::Quad, quadrature);
+ return project_to_all_subfaces(ReferenceCell::Quadrilateral, quadrature);
}
QProjector<3>::project_to_all_subfaces(const ReferenceCell reference_cell,
const SubQuadrature &quadrature)
{
- if (reference_cell == ReferenceCell::Tri ||
- reference_cell == ReferenceCell::Tet)
+ if (reference_cell == ReferenceCell::Triangle ||
+ reference_cell == ReferenceCell::Tetrahedron)
return Quadrature<3>(); // nothing to do
- Assert(reference_cell == ReferenceCell::Hex, ExcNotImplemented());
+ Assert(reference_cell == ReferenceCell::Hexahedron, ExcNotImplemented());
const unsigned int dim = 3;
SubQuadrature q_reflected = internal::QProjector::reflect(quadrature);
Quadrature<3>
QProjector<3>::project_to_all_subfaces(const SubQuadrature &quadrature)
{
- return project_to_all_subfaces(ReferenceCell::Hex, quadrature);
+ return project_to_all_subfaces(ReferenceCell::Hexahedron, quadrature);
}
const bool face_rotation,
const unsigned int n_quadrature_points)
{
- if (reference_cell == ReferenceCell::Tri ||
- reference_cell == ReferenceCell::Tet)
+ if (reference_cell == ReferenceCell::Triangle ||
+ reference_cell == ReferenceCell::Tetrahedron)
{
if (dim == 2)
return {(2 * face_no + face_orientation) * n_quadrature_points};
const bool face_rotation,
const hp::QCollection<dim - 1> &quadrature)
{
- if (reference_cell == ReferenceCell::Tri ||
- reference_cell == ReferenceCell::Tet ||
+ if (reference_cell == ReferenceCell::Triangle ||
+ reference_cell == ReferenceCell::Tetrahedron ||
reference_cell == ReferenceCell::Wedge ||
reference_cell == ReferenceCell::Pyramid)
{
{8, 6, 6, 6, 6}};
const auto &scale =
- (reference_cell == ReferenceCell::Tri) ?
+ (reference_cell == ReferenceCell::Triangle) ?
scale_tri :
- ((reference_cell == ReferenceCell::Tet) ?
+ ((reference_cell == ReferenceCell::Tetrahedron) ?
scale_tet :
((reference_cell == ReferenceCell::Wedge) ? scale_wedge :
scale_pyramid));
const unsigned int n_quadrature_points,
const internal::SubfaceCase<2>)
{
- Assert(reference_cell == ReferenceCell::Quad, ExcNotImplemented());
+ Assert(reference_cell == ReferenceCell::Quadrilateral, ExcNotImplemented());
(void)reference_cell;
Assert(face_no < GeometryInfo<2>::faces_per_cell, ExcInternalError());
const unsigned int n_quadrature_points,
const internal::SubfaceCase<2> ref_case)
{
- return subface(ReferenceCell::Quad,
+ return subface(ReferenceCell::Quadrilateral,
face_no,
subface_no,
face_orientation,
{
const unsigned int dim = 3;
- Assert(reference_cell == ReferenceCell::Hex, ExcNotImplemented());
+ Assert(reference_cell == ReferenceCell::Hexahedron, ExcNotImplemented());
(void)reference_cell;
Assert(face_no < GeometryInfo<dim>::faces_per_cell, ExcInternalError());
const unsigned int n_quadrature_points,
const internal::SubfaceCase<3> ref_case)
{
- return subface(ReferenceCell::Hex,
+ return subface(ReferenceCell::Hexahedron,
face_no,
subface_no,
face_orientation,
quad_dof_identities
[most_dominating_fe_index][other_fe_index]
[cell->quad(q)->reference_cell() ==
- dealii::ReferenceCell::Quad],
+ dealii::ReferenceCell::Quadrilateral],
most_dominating_fe_index_face_no);
for (const auto &identity : identities)
quad_dof_identities
[most_dominating_fe_index][other_fe_index]
[cell->quad(q)->reference_cell() ==
- dealii::ReferenceCell::Quad],
+ dealii::ReferenceCell::Quadrilateral],
most_dominating_fe_index_face_no);
for (const auto &identity : identities)
for (unsigned int f = 0; f < this->n_unique_quads(); ++f)
{
- adjust_quad_dof_index_for_face_orientation_table[f] =
- Table<2, int>(this->n_dofs_per_quad(f),
- internal::ReferenceCell::get_cell(
- this->reference_cell())
- .face_reference_cell(f) == ReferenceCell::Quad ?
- 8 :
- 6);
+ adjust_quad_dof_index_for_face_orientation_table[f] = Table<2, int>(
+ this->n_dofs_per_quad(f),
+ internal::ReferenceCell::get_cell(this->reference_cell())
+ .face_reference_cell(f) == ReferenceCell::Quadrilateral ?
+ 8 :
+ 6);
adjust_quad_dof_index_for_face_orientation_table[f].fill(0);
}
}
[this->n_unique_quads() == 1 ? 0 : face]
.n_elements() ==
(internal::ReferenceCell::get_cell(this->reference_cell())
- .face_reference_cell(face) == ReferenceCell::Quad ?
+ .face_reference_cell(face) == ReferenceCell::Quadrilateral ?
8 :
6) *
this->n_dofs_per_quad(face),
const Conformity conformity,
const BlockIndices & block_indices)
: FiniteElementData(dofs_per_object,
- dim == 0 ? ReferenceCell::Vertex :
- (dim == 1 ? ReferenceCell::Line :
- (dim == 2 ? ReferenceCell::Quad :
- ReferenceCell::Hex)),
+ dim == 0 ?
+ ReferenceCell::Vertex :
+ (dim == 1 ? ReferenceCell::Line :
+ (dim == 2 ? ReferenceCell::Quadrilateral :
+ ReferenceCell::Hexahedron)),
n_components,
degree,
conformity,
{
GridGenerator::hyper_cube(tria, 0, 1);
}
- else if ((dim == 2) && (reference_cell == ReferenceCell::Tri))
+ else if ((dim == 2) && (reference_cell == ReferenceCell::Triangle))
{
const std::vector<Point<spacedim>> vertices = {
Point<spacedim>(), // the origin
tria.create_triangulation(vertices, cells, {});
}
- else if ((dim == 3) && (reference_cell == ReferenceCell::Tet))
+ else if ((dim == 3) && (reference_cell == ReferenceCell::Tetrahedron))
{
AssertDimension(spacedim, 3);
type_name_2.end());
if (type_name_2 == "TRI" || type_name_2 == "TRIANGLE")
- return ReferenceCell::Tri;
+ return ReferenceCell::Triangle;
else if (type_name_2 == "QUAD" || type_name_2 == "QUADRILATERAL")
- return ReferenceCell::Quad;
+ return ReferenceCell::Quadrilateral;
else if (type_name_2 == "SHELL")
{
if (n_nodes_per_element == 3)
- return ReferenceCell::Tri;
+ return ReferenceCell::Triangle;
else
- return ReferenceCell::Quad;
+ return ReferenceCell::Quadrilateral;
}
else if (type_name_2 == "TET" || type_name_2 == "TETRA" ||
type_name_2 == "TETRAHEDRON")
- return ReferenceCell::Tet;
+ return ReferenceCell::Tetrahedron;
else if (type_name_2 == "PYRA" || type_name_2 == "PYRAMID")
return ReferenceCell::Pyramid;
else if (type_name_2 == "WEDGE")
return ReferenceCell::Wedge;
else if (type_name_2 == "HEX" || type_name_2 == "HEXAHEDRON")
- return ReferenceCell::Hex;
+ return ReferenceCell::Hexahedron;
Assert(false, ExcNotImplemented());
return ReferenceCell::Invalid;
if ((reference_cell == ReferenceCell::Vertex) ||
(reference_cell == ReferenceCell::Line) ||
- (reference_cell == ReferenceCell::Quad) ||
- (reference_cell == ReferenceCell::Hex))
+ (reference_cell == ReferenceCell::Quadrilateral) ||
+ (reference_cell == ReferenceCell::Hexahedron))
out << cell->vertex_index(GeometryInfo<dim>::ucd_to_deal[i]);
- else if ((reference_cell == ReferenceCell::Tri) ||
- (reference_cell == ReferenceCell::Tet) ||
+ else if ((reference_cell == ReferenceCell::Triangle) ||
+ (reference_cell == ReferenceCell::Tetrahedron) ||
(reference_cell == ReferenceCell::Wedge))
out << cell->vertex_index(i);
else if (reference_cell == ReferenceCell::Pyramid)
std::vector<double> dummy_weights(n_points, 1. / n_points);
Quadrature<dim - 1> quadrature(boundary_points, dummy_weights);
- q_projector =
- QProjector<dim>::project_to_all_faces(dealii::ReferenceCell::Quad,
- quadrature);
+ q_projector = QProjector<dim>::project_to_all_faces(
+ dealii::ReferenceCell::Quadrilateral, quadrature);
}
for (const auto &cell : tria.active_cell_iterators())
#include <deal.II/fe/mapping_fe.h>
#include <deal.II/fe/mapping_q1.h>
+#include <deal.II/fe/mapping_q_generic.h>
#include <deal.II/grid/grid_generator.h>
#include <deal.II/grid/reference_cell.h>
#include <deal.II/simplex/polynomials.h>
#include <deal.II/simplex/quadrature_lib.h>
+#include <memory>
+
DEAL_II_NAMESPACE_OPEN
internal::ReferenceCell::make_reference_cell_from_int(0);
const ReferenceCell ReferenceCell::Line =
internal::ReferenceCell::make_reference_cell_from_int(1);
-const ReferenceCell ReferenceCell::Tri =
+const ReferenceCell ReferenceCell::Triangle =
internal::ReferenceCell::make_reference_cell_from_int(2);
-const ReferenceCell ReferenceCell::Quad =
+const ReferenceCell ReferenceCell::Quadrilateral =
internal::ReferenceCell::make_reference_cell_from_int(3);
-const ReferenceCell ReferenceCell::Tet =
+const ReferenceCell ReferenceCell::Tetrahedron =
internal::ReferenceCell::make_reference_cell_from_int(4);
const ReferenceCell ReferenceCell::Pyramid =
internal::ReferenceCell::make_reference_cell_from_int(5);
const ReferenceCell ReferenceCell::Wedge =
internal::ReferenceCell::make_reference_cell_from_int(6);
-const ReferenceCell ReferenceCell::Hex =
+const ReferenceCell ReferenceCell::Hexahedron =
internal::ReferenceCell::make_reference_cell_from_int(7);
const ReferenceCell ReferenceCell::Invalid =
internal::ReferenceCell::make_reference_cell_from_int(
return "Vertex";
else if (*this == Line)
return "Line";
- else if (*this == Tri)
+ else if (*this == Triangle)
return "Tri";
- else if (*this == Quad)
+ else if (*this == Quadrilateral)
return "Quad";
- else if (*this == Tet)
+ else if (*this == Tetrahedron)
return "Tet";
else if (*this == Pyramid)
return "Pyramid";
else if (*this == Wedge)
return "Wedge";
- else if (*this == Hex)
+ else if (*this == Hexahedron)
return "Hex";
else if (*this == Invalid)
return "Invalid";
tria_faces.quad_reference_cell.insert(
tria_faces.quad_reference_cell.end(),
new_size - tria_faces.quad_reference_cell.size(),
- dealii::ReferenceCell::Quad);
+ dealii::ReferenceCell::Quadrilateral);
}
}
tria_level.reference_cell.insert(
tria_level.reference_cell.end(),
total_cells - tria_level.reference_cell.size(),
- tria_level.dim == 2 ? dealii::ReferenceCell::Quad :
- dealii::ReferenceCell::Hex);
+ tria_level.dim == 2 ? dealii::ReferenceCell::Quadrilateral :
+ dealii::ReferenceCell::Hexahedron);
}
}
}
triangulation.active_cell_iterators_on_level(level))
if (cell->refine_flag_set())
{
- if (cell->reference_cell() == dealii::ReferenceCell::Tri)
+ if (cell->reference_cell() == dealii::ReferenceCell::Triangle)
{
needed_cells += 4;
needed_vertices += 0;
n_single_lines += 3;
}
else if (cell->reference_cell() ==
- dealii::ReferenceCell::Quad)
+ dealii::ReferenceCell::Quadrilateral)
{
needed_cells += 4;
needed_vertices += 1;
unsigned int n_new_vertices = 0;
- if (cell->reference_cell() == dealii::ReferenceCell::Tri)
+ if (cell->reference_cell() == dealii::ReferenceCell::Triangle)
n_new_vertices = 6;
- else if (cell->reference_cell() == dealii::ReferenceCell::Quad)
+ else if (cell->reference_cell() ==
+ dealii::ReferenceCell::Quadrilateral)
n_new_vertices = 9;
else
AssertThrow(false, ExcNotImplemented());
new_vertices[cell->n_vertices() + line_no] =
cell->line(line_no)->child(0)->vertex_index(1);
- if (cell->reference_cell() == dealii::ReferenceCell::Quad)
+ if (cell->reference_cell() == dealii::ReferenceCell::Quadrilateral)
{
while (triangulation.vertices_used[next_unused_vertex] == true)
++next_unused_vertex;
unsigned int lmin = 0;
unsigned int lmax = 0;
- if (cell->reference_cell() == dealii::ReferenceCell::Tri)
+ if (cell->reference_cell() == dealii::ReferenceCell::Triangle)
{
lmin = 6;
lmax = 9;
}
- else if (cell->reference_cell() == dealii::ReferenceCell::Quad)
+ else if (cell->reference_cell() ==
+ dealii::ReferenceCell::Quadrilateral)
{
lmin = 8;
lmax = 12;
if (true)
{
- if (cell->reference_cell() == dealii::ReferenceCell::Tri)
+ if (cell->reference_cell() == dealii::ReferenceCell::Triangle)
{
// add lines in the right order [TODO: clean up]
const auto ref = [&](const unsigned int face_no,
new_lines[8]->set_bounding_object_indices(
{new_vertices[5], new_vertices[3]});
}
- else if (cell->reference_cell() == dealii::ReferenceCell::Quad)
+ else if (cell->reference_cell() ==
+ dealii::ReferenceCell::Quadrilateral)
{
unsigned int l = 0;
for (const unsigned int face_no : cell->face_indices())
unsigned int n_children = 0;
- if (cell->reference_cell() == dealii::ReferenceCell::Tri)
+ if (cell->reference_cell() == dealii::ReferenceCell::Triangle)
n_children = 4;
- else if (cell->reference_cell() == dealii::ReferenceCell::Quad)
+ else if (cell->reference_cell() ==
+ dealii::ReferenceCell::Quadrilateral)
n_children = 4;
else
AssertThrow(false, ExcNotImplemented());
}
if ((dim == 2) &&
- (cell->reference_cell() == dealii::ReferenceCell::Tri))
+ (cell->reference_cell() == dealii::ReferenceCell::Triangle))
{
subcells[0]->set_bounding_object_indices({new_lines[0]->index(),
new_lines[8]->index(),
// triangulation.levels[subcells[2]->level()]->face_orientations[subcells[2]->index()
// * GeometryInfo<2>::faces_per_cell + 0] = 0;
}
- else if ((dim == 2) &&
- (cell->reference_cell() == dealii::ReferenceCell::Quad))
+ else if ((dim == 2) && (cell->reference_cell() ==
+ dealii::ReferenceCell::Quadrilateral))
{
subcells[0]->set_bounding_object_indices(
{new_lines[0]->index(),
next_unused_cell,
cell);
- if (cell->reference_cell() == dealii::ReferenceCell::Quad &&
+ if (cell->reference_cell() ==
+ dealii::ReferenceCell::Quadrilateral &&
check_for_distorted_cells &&
has_distorted_children<dim, spacedim>(cell))
cells_with_distorted_children.distorted_cells.push_back(
{
case 2:
{
- if (this->reference_cell() == ReferenceCell::Tri)
+ if (this->reference_cell() == ReferenceCell::Triangle)
{
const auto neighbor_cell = this->neighbor(face);
subface;
const auto &info =
- internal::ReferenceCell::get_cell(ReferenceCell::Tri);
+ internal::ReferenceCell::get_cell(ReferenceCell::Triangle);
const unsigned int neighbor_child_index =
info.child_cell_on_face(neighbor_face, neighbor_subface);
TriaIterator<CellAccessor<dim, spacedim>> sub_neighbor =
return sub_neighbor;
}
- else if (this->reference_cell() == ReferenceCell::Quad)
+ else if (this->reference_cell() == ReferenceCell::Quadrilateral)
{
const unsigned int neighbor_neighbor =
this->neighbor_of_neighbor(face);
case 3:
{
- if (this->reference_cell() == ReferenceCell::Hex)
+ if (this->reference_cell() == ReferenceCell::Hexahedron)
{
// this function returns the neighbor's
// child on a given face and
return {};
const auto &info = internal::ReferenceCell::get_cell(
- dim == 2 ? ReferenceCell::Tri : ReferenceCell::Tet);
+ dim == 2 ? ReferenceCell::Triangle : ReferenceCell::Tetrahedron);
std::vector<std::vector<Point<dim - 1>>> unit_face_points;
// all faces have the same support points
: dealii::FE_Poly<dim, spacedim>(
BarycentricPolynomials<dim>::get_fe_p_basis(degree),
FiniteElementData<dim>(dpo_vector,
- dim == 2 ? ReferenceCell::Tri :
- ReferenceCell::Tet,
+ dim == 2 ? ReferenceCell::Triangle :
+ ReferenceCell::Tetrahedron,
1,
degree,
conformity),
std::vector<bool>(FiniteElementData<dim>(dpo_vector,
- dim == 2 ? ReferenceCell::Tri :
- ReferenceCell::Tet,
+ dim == 2 ?
+ ReferenceCell::Triangle :
+ ReferenceCell::Tetrahedron,
1,
degree)
.dofs_per_cell,
true),
- std::vector<ComponentMask>(FiniteElementData<dim>(dpo_vector,
- dim == 2 ?
- ReferenceCell::Tri :
- ReferenceCell::Tet,
- 1,
- degree)
- .dofs_per_cell,
- std::vector<bool>(1, true)))
+ std::vector<ComponentMask>(
+ FiniteElementData<dim>(dpo_vector,
+ dim == 2 ? ReferenceCell::Triangle :
+ ReferenceCell::Tetrahedron,
+ 1,
+ degree)
+ .dofs_per_cell,
+ std::vector<bool>(1, true)))
{
this->unit_support_points = unit_support_points_fe_poly<dim>(degree);
// Discontinuous elements don't have face support points
<< std::endl;
if (dim == 2)
{
- deallog << (FE_Nothing<dim>(ReferenceCell::Quad, 2, true) ==
+ deallog << (FE_Nothing<dim>(ReferenceCell::Quadrilateral, 2, true) ==
FE_Nothing<dim>(2, true))
<< std::endl;
- deallog << (FE_Nothing<dim>(ReferenceCell::Tri, 2, true) ==
+ deallog << (FE_Nothing<dim>(ReferenceCell::Triangle, 2, true) ==
FE_Nothing<dim>(2, true))
<< std::endl;
}
if (dim == 3)
{
- deallog << (FE_Nothing<dim>(ReferenceCell::Hex, 2, true) ==
+ deallog << (FE_Nothing<dim>(ReferenceCell::Hexahedron, 2, true) ==
FE_Nothing<dim>(2, true))
<< std::endl;
- deallog << (FE_Nothing<dim>(ReferenceCell::Tet, 2, true) ==
+ deallog << (FE_Nothing<dim>(ReferenceCell::Tetrahedron, 2, true) ==
FE_Nothing<dim>(2, true))
<< std::endl;
deallog << (FE_Nothing<dim>(ReferenceCell::Wedge, 1, false) ==
if (cell->is_locally_owned() == false)
continue;
- if (cell->reference_cell() == ReferenceCell::Tri)
+ if (cell->reference_cell() == ReferenceCell::Triangle)
cell->set_active_fe_index(0);
- else if (cell->reference_cell() == ReferenceCell::Quad)
+ else if (cell->reference_cell() == ReferenceCell::Quadrilateral)
cell->set_active_fe_index(1);
else
Assert(false, ExcNotImplemented());
DoFHandler<dim> dof_handler(tria);
for (const auto &cell : dof_handler.active_cell_iterators())
- if (cell->reference_cell() == ReferenceCell::Tri ||
- cell->reference_cell() == ReferenceCell::Tet)
+ if (cell->reference_cell() == ReferenceCell::Triangle ||
+ cell->reference_cell() == ReferenceCell::Tetrahedron)
cell->set_active_fe_index(0);
else
cell->set_active_fe_index(1);
DoFHandler<dim> dof_handler(tria);
for (const auto &cell : dof_handler.active_cell_iterators())
- if (cell->reference_cell() == ReferenceCell::Tri ||
- cell->reference_cell() == ReferenceCell::Tet)
+ if (cell->reference_cell() == ReferenceCell::Triangle ||
+ cell->reference_cell() == ReferenceCell::Tetrahedron)
cell->set_active_fe_index(0);
else
cell->set_active_fe_index(1);
initlog();
test<2>(ReferenceCell::Line, 2);
- test<3>(ReferenceCell::Tri, 3);
- test<4>(ReferenceCell::Quad, 4);
+ test<3>(ReferenceCell::Triangle, 3);
+ test<4>(ReferenceCell::Quadrilateral, 4);
deallog << "OK!" << std::endl;
}
Triangulation<3> dummy, tria;
- GridGenerator::reference_cell(ReferenceCell::Tet, dummy);
+ GridGenerator::reference_cell(ReferenceCell::Tetrahedron, dummy);
auto vertices = dummy.get_vertices();
{
const auto &face = dummy.begin()->face(face_no);
const auto permuted =
- ReferenceCell(ReferenceCell::Tri)
+ ReferenceCell(ReferenceCell::Triangle)
.permute_according_orientation(
std::array<unsigned int, 3>{{face->vertex_index(0),
face->vertex_index(1),
for (const auto l : face->line_indices())
{
const unsigned int l_ =
- internal::ReferenceCell::Tet().standard_to_real_face_line(l,
- face_no,
- orientation);
+ internal::ReferenceCell::Tetrahedron().standard_to_real_face_line(
+ l, face_no, orientation);
std::array<unsigned int, 2> a = {
{face->line(l_)->vertex_index(0), face->line(l_)->vertex_index(1)}};
Simplex::QGauss<dim - 1> quad_ref(n_points);
const auto quad =
- QProjector<dim>::project_to_all_faces(ReferenceCell::Tri, quad_ref);
+ QProjector<dim>::project_to_all_faces(ReferenceCell::Triangle, quad_ref);
const auto print = [&](const unsigned int face_no,
const bool face_orientation) {
<< ":" << std::endl;
for (unsigned int
q = 0,
- i = QProjector<dim>::DataSetDescriptor::face(ReferenceCell::Tri,
+ i = QProjector<dim>::DataSetDescriptor::face(ReferenceCell::Triangle,
face_no,
face_orientation,
false,
Simplex::QGauss<dim - 1> quad_ref(n_points);
const auto quad =
- QProjector<dim>::project_to_all_faces(ReferenceCell::Tet, quad_ref);
+ QProjector<dim>::project_to_all_faces(ReferenceCell::Tetrahedron, quad_ref);
const auto print = [&](const unsigned int face_no,
const bool face_orientation,
<< " face_flip=" << (face_flip ? "true" : "false")
<< " face_rotation=" << (face_rotation ? "true" : "false") << ":"
<< std::endl;
- for (unsigned int
- q = 0,
- i = QProjector<dim>::DataSetDescriptor::face(ReferenceCell::Tet,
- face_no,
- face_orientation,
- face_flip,
- face_rotation,
- quad_ref.size());
+ for (unsigned int q = 0,
+ i = QProjector<dim>::DataSetDescriptor::face(
+ ReferenceCell::Tetrahedron,
+ face_no,
+ face_orientation,
+ face_flip,
+ face_rotation,
+ quad_ref.size());
q < quad_ref.size();
++q, ++i)
{
initlog();
test<2>(ReferenceCell::Line);
- test<2>(ReferenceCell::Tri);
- test<2>(ReferenceCell::Quad);
- test<3>(ReferenceCell::Tet);
+ test<2>(ReferenceCell::Triangle);
+ test<2>(ReferenceCell::Quadrilateral);
+ test<3>(ReferenceCell::Tetrahedron);
test<3>(ReferenceCell::Pyramid);
test<3>(ReferenceCell::Wedge);
- test<3>(ReferenceCell::Hex);
+ test<3>(ReferenceCell::Hexahedron);
}
{
initlog();
- test<2>(ReferenceCell::Tri);
- test<2>(ReferenceCell::Quad);
- test<3>(ReferenceCell::Tet);
+ test<2>(ReferenceCell::Triangle);
+ test<2>(ReferenceCell::Quadrilateral);
+ test<3>(ReferenceCell::Tetrahedron);
test<3>(ReferenceCell::Pyramid);
test<3>(ReferenceCell::Wedge);
- test<3>(ReferenceCell::Hex);
+ test<3>(ReferenceCell::Hexahedron);
}
QGauss<dim - 1>(4));
const auto quad =
- QProjector<dim>::project_to_all_faces(ReferenceCell::Quad, quad_ref);
+ QProjector<dim>::project_to_all_faces(ReferenceCell::Quadrilateral,
+ quad_ref);
const auto print = [&](const unsigned int face_no) {
deallog << "face_no=" << face_no << ":" << std::endl;
- for (unsigned int
- q = 0,
- i = QProjector<dim>::DataSetDescriptor::face(
- ReferenceCell::Quad, face_no, false, false, false, quad_ref);
+ for (unsigned int q = 0,
+ i = QProjector<dim>::DataSetDescriptor::face(
+ ReferenceCell::Quadrilateral,
+ face_no,
+ false,
+ false,
+ false,
+ quad_ref);
q < quad_ref[face_no].size();
++q, ++i)
{
projects / dealii.git / commitdiff