const types::manifold_id flat_manifold_id =
static_cast<types::manifold_id>(-1);
+ /**
+ * Value indicating that a face or line is in its default orientation.
+ *
+ * See the
+ * @ref GlossFaceOrientation "glossary"
+ * for more information.
+ */
+ const types::geometric_orientation default_geometric_orientation =
+ static_cast<types::geometric_orientation>(0b001);
+
/**
* A special id for an invalid subdomain id. This value may not be used as a
* valid id but is used, for example, for default arguments to indicate a
for (const auto line : accessor.line_indices())
{
const auto line_orientation = line_orientations[line];
- if (line_orientation ==
- ReferenceCell::default_combined_face_orientation())
+ if (line_orientation == numbers::default_geometric_orientation)
dof_operation.process_dofs(
accessor.get_dof_handler(),
0,
accessor.combined_face_orientation(face_no);
const unsigned int quad_index = accessor.quad_index(face_no);
if (combined_orientation ==
- ReferenceCell::default_combined_face_orientation())
+ numbers::default_geometric_orientation)
dof_operation.process_dofs(
accessor.get_dof_handler(),
0,
AffineConstraints<number> &constraints,
const ComponentMask &component_mask = {},
const types::geometric_orientation combined_orientation =
- ReferenceCell::default_combined_face_orientation(),
+ numbers::default_geometric_orientation,
const FullMatrix<double> &matrix = FullMatrix<double>(),
const std::vector<unsigned int> &first_vector_components =
std::vector<unsigned int>(),
* freedom actually represent.
*/
virtual unsigned int
- face_to_cell_index(
- const unsigned int face_dof_index,
- const unsigned int face,
- const types::geometric_orientation combined_orientation =
- ReferenceCell::default_combined_face_orientation()) const;
+ face_to_cell_index(const unsigned int face_dof_index,
+ const unsigned int face,
+ const types::geometric_orientation combined_orientation =
+ numbers::default_geometric_orientation) const;
/**
* Given a local dof @p index on a line and the orientation @p
* dofs_per_cell.
*/
virtual unsigned int
- face_to_cell_index(
- const unsigned int face_dof_index,
- const unsigned int face,
- const types::geometric_orientation combined_orientation =
- ReferenceCell::default_combined_face_orientation()) const override;
+ face_to_cell_index(const unsigned int face_dof_index,
+ const unsigned int face,
+ const types::geometric_orientation combined_orientation =
+ numbers::default_geometric_orientation) const override;
/**
* Return a list of constant modes of the element. For this element, the
* dofs_per_cell.
*/
virtual unsigned int
- face_to_cell_index(
- const unsigned int face_dof_index,
- const unsigned int face,
- const types::geometric_orientation combined_orientation =
- ReferenceCell::default_combined_face_orientation()) const override;
+ face_to_cell_index(const unsigned int face_dof_index,
+ const unsigned int face,
+ const types::geometric_orientation combined_orientation =
+ numbers::default_geometric_orientation) const override;
/**
* Implementation of the respective function in the base class.
// only faces with default orientation have to do something
if (ori_cq.get_combined_orientation(f_) !=
- ReferenceCell::default_combined_face_orientation())
+ numbers::default_geometric_orientation)
continue;
// determine entity type of face
// ... comparison gives orientation
ori_ql.set_combined_orientation(
con_ql.ptr[f] + l,
- same ? ReferenceCell::default_combined_face_orientation() :
+ same ? numbers::default_geometric_orientation :
ReferenceCell::reversed_combined_line_orientation());
}
}
#include <deal.II/base/ndarray.h>
#include <deal.II/base/point.h>
#include <deal.II/base/tensor.h>
+#include <deal.II/base/types.h>
#include <deal.II/base/utilities.h>
#include <deal.II/grid/tria_orientation.h>
/**
* Return the default combined face orientation flag (i.e., the default set of
* orientations, defined by orientation, rotate, and flip for a face in 3d).
+ *
+ * @deprecated Use numbers::default_geometric_orientation instead.
*/
+ DEAL_II_DEPRECATED_EARLY_WITH_COMMENT(
+ "Use numbers::default_geometric_orientation instead.")
static constexpr types::geometric_orientation
default_combined_face_orientation();
child_cell_on_face(const unsigned int face,
const unsigned int subface,
const types::geometric_orientation face_orientation =
- default_combined_face_orientation()) const;
+ numbers::default_geometric_orientation) const;
/**
* For a given vertex in a cell, return a pair of a face index and a
* is identical to calling
* `reference_cell.vertex<dim>(
* reference_cell.face_to_cell_vertices(
- f, v, ReferenceCell::default_combined_face_orientation()))`.
+ f, v, numbers::default_geometric_orientation))`.
*/
template <int dim>
Point<dim>
inline constexpr types::geometric_orientation
ReferenceCell::default_combined_face_orientation()
{
- // Our convention is that 'orientation' has a default value of true and
- // occupies the least-significant bit while rotate and flip have default
- // values of 'false' and occupy the second and third bits.
- return 0b001;
+ return numbers::default_geometric_orientation;
}
// TODO: once the default orientation is switched to 0 then we can remove this
// special case for 1D.
if (get_dimension() == 1)
- Assert(combined_face_orientation ==
- ReferenceCell::default_combined_face_orientation(),
+ Assert(combined_face_orientation == numbers::default_geometric_orientation,
ExcMessage("In 1D, all faces must have the default orientation."));
else
AssertIndexRange(combined_face_orientation, n_face_orientations(face));
{{{0, 1}}, {{1, 2}}, {{2, 0}}}};
return table[face][combined_face_orientation ==
- default_combined_face_orientation() ?
+ numbers::default_geometric_orientation ?
vertex :
(1 - vertex)];
}
"the current reference cell lives. You have dim=" +
std::to_string(dim) + " but the reference cell is " +
std::to_string(get_dimension()) + " dimensional."));
- return this->template vertex<dim>(
- face_to_cell_vertices(face, vertex, default_combined_face_orientation()));
+ return this->template vertex<dim>(face_to_cell_vertices(
+ face, vertex, numbers::default_geometric_orientation));
}
DEAL_II_NOT_IMPLEMENTED();
break;
case ReferenceCells::Line:
- Assert(face_orientation == default_combined_face_orientation(),
+ Assert(face_orientation == numbers::default_geometric_orientation,
ExcMessage(
"In 1D, all faces must have the default orientation."));
return vertex;
const types::geometric_orientation combined_face_orientation,
const types::geometric_orientation line_orientation) const
{
- constexpr auto D = ReferenceCell::default_combined_face_orientation();
+ constexpr auto D = numbers::default_geometric_orientation;
constexpr auto R = ReferenceCell::reversed_combined_line_orientation();
if (*this == ReferenceCells::Hexahedron)
{
const bool match =
line_orientation == table[face_line_no / 2][combined_face_orientation];
- return match ? ReferenceCell::default_combined_face_orientation() :
+ return match ? numbers::default_geometric_orientation :
ReferenceCell::reversed_combined_line_orientation();
}
else if (*this == ReferenceCells::Tetrahedron)
const bool match =
line_orientation == table[combined_line][combined_face_orientation];
- return match ? ReferenceCell::default_combined_face_orientation() :
+ return match ? numbers::default_geometric_orientation :
ReferenceCell::reversed_combined_line_orientation();
}
else
// TODO: This might actually be wrong for some of the other
// kinds of objects. We should check this
- return ReferenceCell::default_combined_face_orientation();
+ return numbers::default_geometric_orientation;
}
// vertex_vertex_permutations once we make 0 the default orientation.
(void)vertex_vertex_permutations;
if (vertices_0[0] == vertices_1[0])
- return default_combined_face_orientation();
+ return numbers::default_geometric_orientation;
break;
case ReferenceCells::Line:
return compute_orientation(line_vertex_permutations);
AssertIndexRange(face, accessor.n_faces());
if (dim == 1)
- Assert(combined_orientation ==
- ReferenceCell::default_combined_face_orientation(),
+ Assert(combined_orientation == numbers::default_geometric_orientation,
ExcMessage("In 1d, faces do not have an orientation, so the "
"only valid value is the default."));
else if (dim == 2)
Assert(combined_orientation ==
- ReferenceCell::default_combined_face_orientation() ||
+ numbers::default_geometric_orientation ||
combined_orientation ==
ReferenceCell::reversed_combined_line_orientation(),
ExcMessage(
(void)face;
if constexpr (structdim == 1)
- return ReferenceCell::default_combined_face_orientation();
+ return numbers::default_geometric_orientation;
else if constexpr (structdim == 2)
{
// if all elements are quads (or if we have a very special consistently
// oriented triangular mesh) then we do not store this array
if (this->tria->levels[this->present_level]
->face_orientations.n_objects() == 0)
- return ReferenceCell::default_combined_face_orientation();
+ return numbers::default_geometric_orientation;
else
return this->tria->levels[this->present_level]
->face_orientations.get_orientation(
return true;
else if constexpr (structdim == 2)
return this->line_orientation(face) ==
- ReferenceCell::default_combined_face_orientation();
+ numbers::default_geometric_orientation;
else
return this->tria->levels[this->present_level]
->face_orientations.get_orientation(
(void)line;
if constexpr (structdim == 1)
- return ReferenceCell::default_combined_face_orientation();
+ return numbers::default_geometric_orientation;
else if constexpr (structdim == 2 && dim == 2)
// lines in 2d are faces
{
const auto combined_orientation = combined_face_orientation(line);
- Assert(combined_orientation ==
- ReferenceCell::default_combined_face_orientation() ||
+ Assert(combined_orientation == numbers::default_geometric_orientation ||
combined_orientation ==
ReferenceCell::reversed_combined_line_orientation(),
ExcInternalError());
Assert(index < this->tria->faces->quads_line_orientations.size(),
ExcInternalError());
return this->tria->faces->quads_line_orientations[index] ?
- ReferenceCell::default_combined_face_orientation() :
+ numbers::default_geometric_orientation :
ReferenceCell::reversed_combined_line_orientation();
}
else if constexpr (structdim == 3 && dim == 3)
Assert(index < this->tria->faces->quads_line_orientations.size(),
ExcInternalError());
this->tria->faces->quads_line_orientations[index] =
- value == ReferenceCell::default_combined_face_orientation();
+ value == numbers::default_geometric_orientation;
}
}
TriaAccessor<0, dim, spacedim>::combined_face_orientation(
const unsigned int /*face*/)
{
- return ReferenceCell::default_combined_face_orientation();
+ return numbers::default_geometric_orientation;
}
TriaObjectsOrientations::reinit(const unsigned int n_objects)
{
n_stored_objects = n_objects;
- object_orientations.assign(
- n_objects, ReferenceCell::default_combined_face_orientation());
+ object_orientations.assign(n_objects,
+ numbers::default_geometric_orientation);
}
inline void
TriaObjectsOrientations::resize(const unsigned int n_objects)
{
- object_orientations.resize(
- n_objects, ReferenceCell::default_combined_face_orientation());
+ object_orientations.resize(n_objects,
+ numbers::default_geometric_orientation);
n_stored_objects = n_objects;
}
Assert(
cell_m->combined_face_orientation(f_m) ==
- ReferenceCell::default_combined_face_orientation() &&
+ numbers::default_geometric_orientation &&
cell_p->combined_face_orientation(f_p) ==
- ReferenceCell::default_combined_face_orientation(),
+ numbers::default_geometric_orientation,
ExcMessage(
"Non standard face orientation is currently not implemented."));
// Note, assuming that the edge orientations are "standard", i.e.,
// cell->line_orientation(line) =
- // ReferenceCell::default_combined_face_orientation()
+ // numbers::default_geometric_orientation
Assert(cell->line_orientation(line) ==
- ReferenceCell::default_combined_face_orientation(),
+ numbers::default_geometric_orientation,
ExcMessage("Edge orientation does not meet expectation."));
// Next, translate from face to cell. Note, this might be assuming
// that the edge orientations are "standard"
reference_cell == ReferenceCells::Tetrahedron)
{
if (dim == 2)
- return {(2 * face_no +
- (combined_orientation ==
- ReferenceCell::default_combined_face_orientation() ?
- 1 :
- 0)) *
+ return {(2 * face_no + (combined_orientation ==
+ numbers::default_geometric_orientation ?
+ 1 :
+ 0)) *
n_quadrature_points};
else if (dim == 3)
{
offset += scale[i] * quadrature[i].size();
if (dim == 2)
- return {offset +
- (combined_orientation ==
- ReferenceCell::default_combined_face_orientation()) *
- quadrature[quadrature.size() == 1 ? 0 : face_no].size()};
+ return {
+ offset +
+ (combined_orientation == numbers::default_geometric_orientation) *
+ quadrature[quadrature.size() == 1 ? 0 : face_no].size()};
else if (dim == 3)
{
return {offset +
if (dim == 2)
{
AssertIndexRange(face_pair.orientation, 2);
- p4est_orientation =
- face_pair.orientation ==
- ReferenceCell::default_combined_face_orientation() ?
- 0u :
- 1u;
+ p4est_orientation = face_pair.orientation ==
+ numbers::default_geometric_orientation ?
+ 0u :
+ 1u;
}
else
{
// assertion -- in essence, derived classes have to implement
// an overloaded version of this function if we are to use any
// other than default (standard) orientation
- if (combined_orientation !=
- ReferenceCell::default_combined_face_orientation())
+ if (combined_orientation != numbers::default_geometric_orientation)
Assert((this->n_dofs_per_line() <= 1) && (this->n_dofs_per_quad(face) <= 1),
ExcMessage(
"The function in this base class can not handle this case. "
const unsigned int index,
const types::geometric_orientation combined_orientation) const
{
- Assert(combined_orientation ==
- ReferenceCell::default_combined_face_orientation() ||
+ Assert(combined_orientation == numbers::default_geometric_orientation ||
combined_orientation ==
ReferenceCell::reversed_combined_line_orientation(),
ExcInternalError());
Assert(adjust_line_dof_index_for_line_orientation_table.size() ==
this->n_dofs_per_line(),
ExcInternalError());
- if (combined_orientation ==
- ReferenceCell::default_combined_face_orientation())
+ if (combined_orientation == numbers::default_geometric_orientation)
return index;
else
return index + adjust_line_dof_index_for_line_orientation_table[index];
unsigned int k = QProjector<dim>::DataSetDescriptor::face(
this->reference_cell(),
face,
- ReferenceCell::default_combined_face_orientation(),
+ numbers::default_geometric_orientation,
n_face_points);
for (unsigned int i = 0; i < boundary_weights_abf.size(1); ++i)
nodal_values[start_abf_dofs + i] +=
const auto offset = QProjector<dim>::DataSetDescriptor::face(
this->reference_cell(),
f,
- ReferenceCell::default_combined_face_orientation(),
+ numbers::default_geometric_orientation,
face_points.size());
for (unsigned int k = 0; k < face_points.size(); ++k)
this->generalized_support_points[face_points.size() * f + k] =
for (unsigned int line = 0; line < GeometryInfo<dim>::lines_per_cell;
++line)
this->generalized_support_points[line * n_edge_points + q_point] =
- edge_quadrature.point(
- QProjector<dim>::DataSetDescriptor::face(
- this->reference_cell(),
- line,
- ReferenceCell::default_combined_face_orientation(),
- n_edge_points) +
- q_point);
+ edge_quadrature.point(QProjector<dim>::DataSetDescriptor::face(
+ this->reference_cell(),
+ line,
+ numbers::default_geometric_orientation,
+ n_edge_points) +
+ q_point);
for (unsigned int i = 0; i < order; ++i)
boundary_weights(q_point, i) =
++line)
for (unsigned int q_point = 0; q_point < n_edge_points; ++q_point)
this->generalized_support_points[line * n_edge_points + q_point] =
- edge_quadrature.point(
- QProjector<dim>::DataSetDescriptor::face(
- this->reference_cell(),
- line,
- ReferenceCell::default_combined_face_orientation(),
- n_edge_points) +
- q_point);
+ edge_quadrature.point(QProjector<dim>::DataSetDescriptor::face(
+ this->reference_cell(),
+ line,
+ numbers::default_geometric_orientation,
+ n_edge_points) +
+ q_point);
}
}
QProjector<dim - 1>::DataSetDescriptor::face(
ReferenceCells::get_hypercube<dim - 1>(),
line,
- ReferenceCell::default_combined_face_orientation(),
+ numbers::default_geometric_orientation,
n_edge_points) +
q_point);
this->generalized_support_points[face * n_face_points + q_point +
GeometryInfo<dim>::lines_per_cell *
n_edge_points] =
- face_quadrature.point(
- QProjector<dim>::DataSetDescriptor::face(
- this->reference_cell(),
- face,
- ReferenceCell::default_combined_face_orientation(),
- n_face_points) +
- q_point);
+ face_quadrature.point(QProjector<dim>::DataSetDescriptor::face(
+ this->reference_cell(),
+ face,
+ numbers::default_geometric_orientation,
+ n_face_points) +
+ q_point);
}
// Create support points in the interior.
QProjector<dim - 1>::DataSetDescriptor::face(
ReferenceCells::get_hypercube<dim - 1>(),
line,
- ReferenceCell::default_combined_face_orientation(),
+ numbers::default_geometric_orientation,
n_edge_points) +
q_point);
break;
case 2:
- if (combined_orientation ==
- ReferenceCell::default_combined_face_orientation())
+ if (combined_orientation == numbers::default_geometric_orientation)
adjusted_dof_index_on_line = dof_index_on_line;
else
adjusted_dof_index_on_line =
// case where everything is in standard orientation
Assert((this->n_dofs_per_line() <= 1) ||
combined_orientation ==
- ReferenceCell::default_combined_face_orientation(),
+ numbers::default_geometric_orientation,
ExcNotImplemented());
adjusted_dof_index_on_line = dof_index_on_line;
break;
// just have to draw a bunch of pictures. in the meantime,
// we can implement the Q2 case in which it is simple
Assert((this->n_dofs_per_quad(face) <= 1) ||
- combined_orientation ==
- ReferenceCell::default_combined_face_orientation(),
+ combined_orientation == numbers::default_geometric_orientation,
ExcNotImplemented());
return (this->get_first_quad_index(face) + index);
}
++current)
{
// Enter the support point into the vector
- this->generalized_support_points[current] = faces.point(
- current + QProjector<dim>::DataSetDescriptor::face(
- this->reference_cell(),
- 0,
- ReferenceCell::default_combined_face_orientation(),
- n_face_points));
+ this->generalized_support_points[current] =
+ faces.point(current + QProjector<dim>::DataSetDescriptor::face(
+ this->reference_cell(),
+ 0,
+ numbers::default_geometric_orientation,
+ n_face_points));
}
}
faces.point(k + QProjector<dim>::DataSetDescriptor::face(
this->reference_cell(),
0,
- ReferenceCell::default_combined_face_orientation(),
+ numbers::default_geometric_orientation,
this->n_dofs_per_face(face_no)));
current =
for (const auto face_vertex_no : face_reference_cell.vertex_indices())
{
const auto vertex_no = reference_cell.face_to_cell_vertices(
- face_no,
- face_vertex_no,
- ReferenceCell::default_combined_face_orientation());
+ face_no, face_vertex_no, numbers::default_geometric_orientation);
midpoint += reference_cell.template vertex<dim>(vertex_no);
}
reference_cell.face_to_cell_vertices(
face_no,
face_vertex_no,
- ReferenceCell::default_combined_face_orientation());
+ numbers::default_geometric_orientation);
midpoint +=
reference_cell.template vertex<dim>(vertex_no);
vertices.push_back(reference_cell.face_to_cell_vertices(
face_no,
face_vertex_no,
- ReferenceCell::default_combined_face_orientation()));
+ numbers::default_geometric_orientation));
Assert(vertices.size() == 3, ExcInternalError());
auto b =
for (unsigned int i = size_old; i < size_new; ++i)
{
Assert(matched_pairs[i].orientation ==
- ReferenceCell::default_combined_face_orientation(),
+ numbers::default_geometric_orientation,
ExcMessage(
"Found a face match with non standard orientation. "
"This function is only suitable for meshes with cells "
std::array<Point<dim>, 3> vertices;
for (unsigned int vertex_no = 0; vertex_no < 3; ++vertex_no)
vertices[vertex_no] = vertex<dim>(face_to_cell_vertices(
- face_no, vertex_no, default_combined_face_orientation()));
+ face_no, vertex_no, numbers::default_geometric_orientation));
auto pair = project_to_quad(vertices, p, face_cell);
if (pair.second < min_distance_square)
const auto cell_line_no =
face_to_cell_lines(face_no,
face_line_no,
- default_combined_face_orientation());
+ numbers::default_geometric_orientation);
const auto v0 =
vertex<dim>(line_to_cell_vertices(cell_line_no, 0));
const auto v1 =
const types::geometric_orientation line_orientation)
{
AssertIndexRange(child_no, ReferenceCells::Line.template n_children<1>());
- Assert(line_orientation ==
- ReferenceCell::default_combined_face_orientation() ||
+ Assert(line_orientation == numbers::default_geometric_orientation ||
line_orientation ==
ReferenceCell::reversed_combined_line_orientation(),
ExcInternalError());
- constexpr auto D = ReferenceCell::default_combined_face_orientation();
+ constexpr auto D = numbers::default_geometric_orientation;
if (child_no == 0)
return line_orientation == D ? 0 : 1;
else
// orientation for a line
Assert(
combined_orientation ==
- ReferenceCell::default_combined_face_orientation() ||
+ numbers::default_geometric_orientation ||
combined_orientation ==
ReferenceCell::reversed_combined_line_orientation(),
ExcInternalError());
faces.quads_line_orientations
[q * ReferenceCells::max_n_lines<2>() + j] =
combined_orientation ==
- ReferenceCell::default_combined_face_orientation();
+ numbers::default_geometric_orientation;
}
}
}
const auto &orientations = connectivity.entity_orientations(1);
for (unsigned int i = 0; i < orientations.n_objects(); ++i)
if (orientations.get_combined_orientation(i) !=
- ReferenceCell::default_combined_face_orientation())
+ numbers::default_geometric_orientation)
{
orientation_needed = true;
break;
// set flags denoting deviations from standard orientation of
// faces back to initialization values
cell->child(child)->set_combined_face_orientation(
- f, ReferenceCell::default_combined_face_orientation());
+ f, numbers::default_geometric_orientation);
cell->child(child)->clear_used_flag();
}
12>
new_lines;
std::array<types::geometric_orientation, 12> inherited_orientations;
- inherited_orientations.fill(
- ReferenceCell::default_combined_face_orientation());
+ inherited_orientations.fill(numbers::default_geometric_orientation);
unsigned int lmin = 0;
unsigned int lmax = 0;
const auto combined_orientation =
cell->combined_face_orientation(face_no);
Assert(combined_orientation ==
- ReferenceCell::default_combined_face_orientation() ||
+ numbers::default_geometric_orientation ||
combined_orientation ==
ReferenceCell::reversed_combined_line_orientation(),
ExcInternalError());
if (cell->reference_cell() == ReferenceCells::Triangle)
for (unsigned int face_no : cell->face_indices())
subcells[3]->set_combined_face_orientation(
- face_no, ReferenceCell::default_combined_face_orientation());
+ face_no, numbers::default_geometric_orientation);
for (unsigned int i = 0; i < n_children / 2; ++i)
cell->set_children(2 * i, subcells[2 * i]->index());
new_quad->set_manifold_id(hex->manifold_id());
for (const auto j : new_quads[i]->line_indices())
new_quad->set_line_orientation(
- j, ReferenceCell::default_combined_face_orientation());
+ j, numbers::default_geometric_orientation);
}
// we always get 8 children per refined cell
// reset faces that are at the boundary of the mother cube
for (const auto f : new_hex->face_indices())
new_hex->set_combined_face_orientation(
- f,
- ReferenceCell::default_combined_face_orientation());
+ f, numbers::default_geometric_orientation);
}
for (unsigned int i = 0; i < n_new_hexes / 2; ++i)
hex->set_children(2 * i, new_hexes[2 * i]->index());
j < GeometryInfo<dim>::lines_per_face;
++j)
new_quad->set_line_orientation(
- j,
- ReferenceCell::default_combined_face_orientation());
+ j, numbers::default_geometric_orientation);
}
// now set the line orientation of children of
// outer lines correctly, the lines in the
j < GeometryInfo<dim>::lines_per_face;
++j)
new_quad->set_line_orientation(
- j,
- ReferenceCell::default_combined_face_orientation());
+ j, numbers::default_geometric_orientation);
}
// now set the line orientation of children of
// outer lines correctly, the lines in the
j < GeometryInfo<dim>::lines_per_face;
++j)
new_quads[i]->set_line_orientation(
- j,
- ReferenceCell::default_combined_face_orientation());
+ j, numbers::default_geometric_orientation);
}
types::subdomain_id subdomainid = hex->subdomain_id();
for (const unsigned int f :
GeometryInfo<dim>::face_indices())
new_hexes[i]->set_combined_face_orientation(
- f,
- ReferenceCell::default_combined_face_orientation());
+ f, numbers::default_geometric_orientation);
}
// note these hexes as children to the present cell
for (unsigned int i = 0; i < n_new_hexes / 2; ++i)
for (unsigned int i = 0; i < 4; ++i)
if (lines[i]->vertex_index(i % 2) ==
middle_vertices[i % 2])
- line_orientation[i] = ReferenceCell::
- default_combined_face_orientation();
+ line_orientation[i] =
+ numbers::default_geometric_orientation;
else
{
// it must be the other way round then
for (unsigned int i = 0; i < 4; ++i)
if (lines[i]->vertex_index(i % 2) ==
middle_vertices[i % 2])
- line_orientation[i] = ReferenceCell::
- default_combined_face_orientation();
+ line_orientation[i] =
+ numbers::default_geometric_orientation;
else
{
// it must be the other way round then
for (unsigned int i = 0; i < 4; ++i)
if (lines[i]->vertex_index(i % 2) ==
middle_vertices[i % 2])
- line_orientation[i] = ReferenceCell::
- default_combined_face_orientation();
+ line_orientation[i] =
+ numbers::default_geometric_orientation;
else
{
// it must be the other way round then
// face
for (unsigned int i = 0; i < 4; ++i)
if (lines[i]->vertex_index(0) == middle_vertices[i])
- line_orientation[i] = ReferenceCell::
- default_combined_face_orientation();
+ line_orientation[i] =
+ numbers::default_geometric_orientation;
else
{
// it must be the other way round then
if (lines[i]->vertex_index((i + 1) % 2) ==
middle_vertex_index<dim, spacedim>(
hex->face(3 + i / 4)))
- line_orientation[i] = ReferenceCell::
- default_combined_face_orientation();
+ line_orientation[i] =
+ numbers::default_geometric_orientation;
else
{
// it must be the other way round then
// always true, since it was just constructed
// that way
line_orientation[12] =
- ReferenceCell::default_combined_face_orientation();
+ numbers::default_geometric_orientation;
// set up the 4 quads, numbered as follows (left
// quad numbering, right line numbering
// line is 'true', if vertex 0 is on the front
for (unsigned int i = 0; i < 4; ++i)
if (lines[i]->vertex_index(0) == middle_vertices[i])
- line_orientation[i] = ReferenceCell::
- default_combined_face_orientation();
+ line_orientation[i] =
+ numbers::default_geometric_orientation;
else
{
// it must be the other way round then
if (lines[i]->vertex_index((i + 1) % 2) ==
middle_vertex_index<dim, spacedim>(
hex->face(1 + i / 4)))
- line_orientation[i] = ReferenceCell::
- default_combined_face_orientation();
+ line_orientation[i] =
+ numbers::default_geometric_orientation;
else
{
// it must be the other way
// always true, since it was just constructed
// that way
line_orientation[12] =
- ReferenceCell::default_combined_face_orientation();
+ numbers::default_geometric_orientation;
// set up the 4 quads, numbered as follows (left
// quad numbering, right line numbering
// line is 'true', if vertex 0 is on the front
for (unsigned int i = 0; i < 4; ++i)
if (lines[i]->vertex_index(0) == middle_vertices[i])
- line_orientation[i] = ReferenceCell::
- default_combined_face_orientation();
+ line_orientation[i] =
+ numbers::default_geometric_orientation;
else
{
// it must be the other way round then
if (lines[i]->vertex_index((i + 1) % 2) ==
middle_vertex_index<dim, spacedim>(
hex->face(i / 4 - 1)))
- line_orientation[i] = ReferenceCell::
- default_combined_face_orientation();
+ line_orientation[i] =
+ numbers::default_geometric_orientation;
else
{
// it must be the other way round then
// for the last line the line orientation is always
// the default, since it was just constructed that way
line_orientation[12] =
- ReferenceCell::default_combined_face_orientation();
+ numbers::default_geometric_orientation;
// set up the 4 quads, numbered as follows (left
// quad numbering, right line numbering
for (unsigned int i = 0; i < 24; ++i)
if (lines[i]->vertex_index((i + 1) % 2) ==
vertex_indices[i / 4])
- line_orientation[i] = ReferenceCell::
- default_combined_face_orientation();
+ line_orientation[i] =
+ numbers::default_geometric_orientation;
else
{
// it must be the other way
// always true, since they were just constructed
// that way
for (unsigned int i = 24; i < 30; ++i)
- line_orientation[i] = ReferenceCell::
- default_combined_face_orientation();
+ line_orientation[i] =
+ numbers::default_geometric_orientation;
// set up the 12 quads, numbered as follows
// (left quad numbering, right line numbering
(std::next(dof_handler.begin(0)))->face(1),
cm,
ComponentMask(),
- ReferenceCell::default_combined_face_orientation(),
+ numbers::default_geometric_orientation,
FullMatrix<double>(),
std::vector<unsigned int>(),
periodicity_factor);
{
deallog << " {" << line_index << " -> "
<< (cell->line_orientation(line_index) ==
- ReferenceCell::default_combined_face_orientation())
+ numbers::default_geometric_orientation)
<< "}" << std::endl;
} // line_index
} // cell
{
deallog << " {" << line_index << " -> "
<< (cell->line_orientation(line_index) ==
- ReferenceCell::default_combined_face_orientation())
+ numbers::default_geometric_orientation)
<< "}" << std::endl;
} // line_index
} // cell
for (unsigned int e = 0; e < GeometryInfo<3>::lines_per_cell; ++e)
deallog << " edge=" << e
<< (c->line_orientation(e) ==
- ReferenceCell::default_combined_face_orientation() ?
+ numbers::default_geometric_orientation ?
" -> true" :
" -> false")
<< std::endl;
for (unsigned int e = 0; e < GeometryInfo<3>::lines_per_cell; ++e)
deallog << " edge=" << e
<< (c->line_orientation(e) ==
- ReferenceCell::default_combined_face_orientation() ?
+ numbers::default_geometric_orientation ?
" -> true" :
" -> false")
<< std::endl;
for (unsigned int e = 0; e < GeometryInfo<3>::lines_per_cell; ++e)
deallog << " edge=" << e
<< (c->line_orientation(e) ==
- ReferenceCell::default_combined_face_orientation() ?
+ numbers::default_geometric_orientation ?
" -> true" :
" -> false")
<< std::endl;
{
deallog << line << ": "
<< (cell->line_orientation(line) ==
- ReferenceCell::default_combined_face_orientation() ?
+ numbers::default_geometric_orientation ?
"true" :
"false")
<< std::endl;
Assert(cell->line_orientation(line) ==
- ReferenceCell::default_combined_face_orientation(),
+ numbers::default_geometric_orientation,
ExcInternalError());
}
}
++line_index)
{
deallog << (cell->line_orientation(line_index) ==
- ReferenceCell::default_combined_face_orientation())
+ numbers::default_geometric_orientation)
<< " ";
} // line_index
deallog << '}' << std::endl << std::endl;
++line_index)
{
deallog << (cell->line_orientation(line_index) ==
- ReferenceCell::default_combined_face_orientation())
+ numbers::default_geometric_orientation)
<< " ";
} // line_index
deallog << '}' << std::endl << std::endl;
Assert(reference_cell.face_vertex_location<dim>(f, v) ==
reference_cell.vertex<dim>(
reference_cell.face_to_cell_vertices(
- f, v, ReferenceCell::default_combined_face_orientation())),
+ f, v, numbers::default_geometric_orientation)),
ExcInternalError());
}
}
Point<3> extra_vertex;
for (unsigned int i = 0; i < 3; ++i)
extra_vertex += ref_cell.template vertex<3>(ref_cell.face_to_cell_vertices(
- face_n, i, ReferenceCell::default_combined_face_orientation()));
+ face_n, i, numbers::default_geometric_orientation));
extra_vertex /= 3.0;
extra_vertex += ref_cell.template unit_normal_vectors<3>(face_n);
cell_data.back().vertices.resize(0);
for (unsigned int i = 0; i < 3; ++i)
cell_data.back().vertices.push_back(ref_cell.face_to_cell_vertices(
- face_n, i, ref_cell.default_combined_face_orientation()));
+ face_n, i, numbers::default_geometric_orientation));
cell_data.back().vertices.push_back(ref_cell.n_vertices());
std::sort(cell_data.back().vertices.begin(), cell_data.back().vertices.end());
Point<3> extra_vertex;
for (unsigned int i = 0; i < 3; ++i)
extra_vertex += ref_cell.template vertex<3>(ref_cell.face_to_cell_vertices(
- face_n, i, ReferenceCell::default_combined_face_orientation()));
+ face_n, i, numbers::default_geometric_orientation));
extra_vertex /= 3.0;
extra_vertex += ref_cell.template unit_normal_vectors<3>(face_n);
cell_data.back().vertices.resize(0);
for (unsigned int i = 0; i < 3; ++i)
cell_data.back().vertices.push_back(ref_cell.face_to_cell_vertices(
- face_n, i, ref_cell.default_combined_face_orientation()));
+ face_n, i, numbers::default_geometric_orientation));
cell_data.back().vertices.push_back(ref_cell.n_vertices());
std::sort(cell_data.back().vertices.begin(), cell_data.back().vertices.end());