Quadrature<dim> inline QProjector<dim>::project_to_all_faces(
const Quadrature<dim - 1> &quadrature)
{
- return project_to_all_faces(ReferenceCell::get_hypercube<dim>(), quadrature);
+ return project_to_all_faces(ReferenceCells::get_hypercube<dim>(), quadrature);
}
update_flags,
mapping,
hp::QCollection<dim - 1>(QProjector<dim - 1>::project_to_all_children(
- ReferenceCell::get_hypercube<dim - 1>(), quadrature)),
+ ReferenceCells::get_hypercube<dim - 1>(), quadrature)),
output_data);
}
* @note The use of this object should be avoided since it is only applicable
* in cases where a mesh consists exclusively of quadrilaterals or hexahedra.
* Use
- * `ReferenceCell::get_hypercube<dim>().get_default_linear_mapping()`
+ * `ReferenceCells::get_hypercube<dim>().get_default_linear_mapping()`
* instead.
*/
template <int dim, int spacedim = dim>
double
volume(const Triangulation<dim, spacedim> &tria,
const Mapping<dim, spacedim> & mapping =
- (ReferenceCell::get_hypercube<dim>()
+ (ReferenceCells::get_hypercube<dim>()
.template get_default_linear_mapping<dim, spacedim>()));
/**
minimal_cell_diameter(
const Triangulation<dim, spacedim> &triangulation,
const Mapping<dim, spacedim> & mapping =
- (ReferenceCell::get_hypercube<dim>()
+ (ReferenceCells::get_hypercube<dim>()
.template get_default_linear_mapping<dim, spacedim>()));
/**
maximal_cell_diameter(
const Triangulation<dim, spacedim> &triangulation,
const Mapping<dim, spacedim> & mapping =
- (ReferenceCell::get_hypercube<dim>()
+ (ReferenceCells::get_hypercube<dim>()
.template get_default_linear_mapping<dim, spacedim>()));
/**
extract_used_vertices(
const Triangulation<dim, spacedim> &container,
const Mapping<dim, spacedim> & mapping =
- (ReferenceCell::get_hypercube<dim>()
+ (ReferenceCells::get_hypercube<dim>()
.template get_default_linear_mapping<dim, spacedim>()));
/**
const typename Triangulation<dim, spacedim>::active_cell_iterator &cell,
const Point<spacedim> & position,
const Mapping<dim, spacedim> & mapping =
- (ReferenceCell::get_hypercube<dim>()
+ (ReferenceCells::get_hypercube<dim>()
.template get_default_linear_mapping<dim, spacedim>()));
/**
!cell->face(face)->at_boundary())
{
Assert(cell->reference_cell() ==
- ReferenceCell::get_hypercube<dim>(),
+ ReferenceCells::get_hypercube<dim>(),
ExcNotImplemented());
// this line has children
!cell->face(face)->at_boundary())
{
Assert(cell->reference_cell() ==
- ReferenceCell::get_hypercube<dim>(),
+ ReferenceCells::get_hypercube<dim>(),
ExcNotImplemented());
// this face has hanging nodes
*/
Cache(const Triangulation<dim, spacedim> &tria,
const Mapping<dim, spacedim> & mapping =
- (ReferenceCell::get_hypercube<dim>()
+ (ReferenceCells::get_hypercube<dim>()
.template get_default_linear_mapping<dim, spacedim>()));
/**
class ReferenceCell
{
public:
- /**
- * 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, Triangle, or Tetrahedron.
- */
- template <int dim>
- static constexpr const ReferenceCell &
- get_simplex();
-
- /**
- * 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, Quadrilateral, or Hexahedron.
- */
- template <int dim>
- static constexpr const ReferenceCell &
- get_hypercube();
-
/**
* Return the correct ReferenceCell for a given structural
* dimension and number of vertices. For example, if `dim==2` and
-inline constexpr ReferenceCell::ReferenceCell()
- : ReferenceCell(static_cast<std::uint8_t>(-1))
-{}
-
-
-
inline constexpr ReferenceCell::ReferenceCell(const std::uint8_t kind)
: kind(kind)
{}
DEAL_II_CONSTEXPR const ReferenceCell Invalid =
internal::ReferenceCell::make_reference_cell_from_int(
static_cast<std::uint8_t>(-1));
+
+ /**
+ * 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, Triangle, or Tetrahedron.
+ */
+ template <int dim>
+ constexpr const ReferenceCell &
+ get_simplex();
+
+ /**
+ * 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, Quadrilateral, or Hexahedron.
+ */
+ template <int dim>
+ constexpr const ReferenceCell &
+ get_hypercube();
} // namespace ReferenceCells
+inline constexpr ReferenceCell::ReferenceCell()
+ : ReferenceCell(ReferenceCells::Invalid)
+{}
+
+
+
template <class Archive>
inline void
ReferenceCell::serialize(Archive &archive, const unsigned int /*version*/)
-template <int dim>
-inline constexpr const ReferenceCell &
-ReferenceCell::get_simplex()
+namespace ReferenceCells
{
- switch (dim)
- {
- case 0:
- return ReferenceCells::Vertex;
- case 1:
- return ReferenceCells::Line;
- case 2:
- return ReferenceCells::Triangle;
- case 3:
- return ReferenceCells::Tetrahedron;
- default:
- Assert(false, ExcNotImplemented());
- return ReferenceCells::Invalid;
- }
-}
-
+ template <int dim>
+ inline constexpr const ReferenceCell &
+ get_simplex()
+ {
+ switch (dim)
+ {
+ case 0:
+ return ReferenceCells::Vertex;
+ case 1:
+ return ReferenceCells::Line;
+ case 2:
+ return ReferenceCells::Triangle;
+ case 3:
+ return ReferenceCells::Tetrahedron;
+ default:
+ Assert(false, ExcNotImplemented());
+ return ReferenceCells::Invalid;
+ }
+ }
-template <int dim>
-inline constexpr const ReferenceCell &
-ReferenceCell::get_hypercube()
-{
- switch (dim)
- {
- case 0:
- return ReferenceCells::Vertex;
- case 1:
- return ReferenceCells::Line;
- case 2:
- return ReferenceCells::Quadrilateral;
- case 3:
- return ReferenceCells::Hexahedron;
- default:
- Assert(false, ExcNotImplemented());
- return ReferenceCells::Invalid;
- }
-}
+ template <int dim>
+ inline constexpr const ReferenceCell &
+ get_hypercube()
+ {
+ switch (dim)
+ {
+ case 0:
+ return ReferenceCells::Vertex;
+ case 1:
+ return ReferenceCells::Line;
+ case 2:
+ return ReferenceCells::Quadrilateral;
+ case 3:
+ return ReferenceCells::Hexahedron;
+ default:
+ Assert(false, ExcNotImplemented());
+ return ReferenceCells::Invalid;
+ }
+ }
+} // namespace ReferenceCells
inline ReferenceCell
const unsigned int i) const
{
AssertDimension(dim, get_dimension());
- if (*this == get_hypercube<dim>())
+ if (*this == ReferenceCells::get_hypercube<dim>())
return GeometryInfo<dim>::d_linear_shape_function(xi, i);
if (*this ==
const unsigned int i) const
{
AssertDimension(dim, get_dimension());
- if (*this == get_hypercube<dim>())
+ if (*this == ReferenceCells::get_hypercube<dim>())
return GeometryInfo<dim>::d_linear_shape_function_gradient(xi, i);
if (*this ==
AssertDimension(dim, get_dimension());
AssertIndexRange(i, dim - 1);
- if (*this == get_hypercube<dim>())
+ if (*this == ReferenceCells::get_hypercube<dim>())
{
AssertIndexRange(face_no, GeometryInfo<dim>::faces_per_cell);
return GeometryInfo<dim>::unit_tangential_vectors[face_no][i];
Assert(index < dim, ExcInternalError());
if ((reference_cell == dealii::ReferenceCells::Invalid ||
- reference_cell == dealii::ReferenceCell::get_hypercube<dim>()) ==
+ reference_cell == dealii::ReferenceCells::get_hypercube<dim>()) ==
false)
{
#ifdef DEAL_II_WITH_SIMPLEX_SUPPORT
++fe_no)
shape_info_dummy(c, fe_no).reinit(
dof_handlers[no]->get_fe(fe_no).reference_cell() ==
- ReferenceCell::get_hypercube<dim>() ?
+ ReferenceCells::get_hypercube<dim>() ?
quad :
quad_simplex,
dof_handlers[no]->get_fe(fe_no),
try
{
const dealii::ReferenceCell reference_cell =
- dealii::ReferenceCell::get_simplex<dim>();
+ dealii::ReferenceCells::get_simplex<dim>();
const auto quad_face = get_face_quadrature(quad);
this->n_q_points_face = quad_face.size();
& function_map,
AffineConstraints<double> & constraints,
const Mapping<dim, spacedim> &mapping =
- (ReferenceCell::get_hypercube<dim>()
+ (ReferenceCells::get_hypercube<dim>()
.template get_default_linear_mapping<dim, spacedim>()));
/**
const std::set<types::boundary_id> &boundary_ids,
AffineConstraints<double> & constraints,
const Mapping<dim, spacedim> & mapping =
- (ReferenceCell::get_hypercube<dim>()
+ (ReferenceCells::get_hypercube<dim>()
.template get_default_linear_mapping<dim, spacedim>()));
/**
& function_map,
AffineConstraints<double> & constraints,
const Mapping<dim, spacedim> &mapping =
- (ReferenceCell::get_hypercube<dim>()
+ (ReferenceCells::get_hypercube<dim>()
.template get_default_linear_mapping<dim, spacedim>()));
/**
const std::set<types::boundary_id> &boundary_ids,
AffineConstraints<double> & constraints,
const Mapping<dim, spacedim> & mapping =
- (ReferenceCell::get_hypercube<dim>()
+ (ReferenceCells::get_hypercube<dim>()
.template get_default_linear_mapping<dim, spacedim>()));
//@}
Quadrature<dim> quadrature_mf;
- if (dof.get_fe(0).reference_cell() == ReferenceCell::get_hypercube<dim>())
+ if (dof.get_fe(0).reference_cell() ==
+ ReferenceCells::get_hypercube<dim>())
quadrature_mf = QGauss<dim>(dof.get_fe().degree + 2);
else
// TODO: since we have currently only implemented a handful quadrature
const std::vector<Point<dim>> & particle_reference_locations,
ParticleHandler<dim, spacedim> & particle_handler,
const Mapping<dim, spacedim> & mapping =
- (ReferenceCell::get_hypercube<dim>()
+ (ReferenceCells::get_hypercube<dim>()
.template get_default_linear_mapping<dim, spacedim>()));
/**
const types::particle_index id,
std::mt19937 & random_number_generator,
const Mapping<dim, spacedim> &mapping =
- (ReferenceCell::get_hypercube<dim>()
+ (ReferenceCells::get_hypercube<dim>()
.template get_default_linear_mapping<dim, spacedim>()));
/**
const types::particle_index n_particles_to_create,
ParticleHandler<dim, spacedim> & particle_handler,
const Mapping<dim, spacedim> & mapping =
- (ReferenceCell::get_hypercube<dim>()
+ (ReferenceCells::get_hypercube<dim>()
.template get_default_linear_mapping<dim, spacedim>()),
const unsigned int random_number_seed = 5432);
& global_bounding_boxes,
ParticleHandler<dim, spacedim> &particle_handler,
const Mapping<dim, spacedim> & mapping =
- (ReferenceCell::get_hypercube<dim>()
+ (ReferenceCells::get_hypercube<dim>()
.template get_default_linear_mapping<dim, spacedim>()),
const ComponentMask & components = ComponentMask(),
const std::vector<std::vector<double>> &properties = {});
& global_bounding_boxes,
ParticleHandler<dim, spacedim> &particle_handler,
const Mapping<dim, spacedim> & mapping =
- (ReferenceCell::get_hypercube<dim>()
+ (ReferenceCells::get_hypercube<dim>()
.template get_default_linear_mapping<dim, spacedim>()),
const std::vector<std::vector<double>> &properties = {});
} // namespace Generators
(n_data_sets + spacedim) :
n_data_sets,
patch.data.n_rows()));
- Assert(patch.reference_cell != ReferenceCell::get_hypercube<dim>() ||
+ Assert(patch.reference_cell != ReferenceCells::get_hypercube<dim>() ||
(n_data_sets == 0) ||
(patch.data.n_cols() ==
Utilities::fixed_power<dim>(n_subdivisions + 1)),
if (write_higher_order_cells)
{
- if (patch.reference_cell == ReferenceCell::get_hypercube<dim>())
+ if (patch.reference_cell == ReferenceCells::get_hypercube<dim>())
{
const std::array<unsigned int, 4> cell_type_by_dim{
{VTK_VERTEX,
vtk_cell_id[0] = VTK_PYRAMID;
vtk_cell_id[1] = 1;
}
- else if (patch.reference_cell == ReferenceCell::get_hypercube<dim>())
+ else if (patch.reference_cell == ReferenceCells::get_hypercube<dim>())
{
const std::array<unsigned int, 4> cell_type_by_dim{
{VTK_VERTEX, VTK_LINE, VTK_QUAD, VTK_HEXAHEDRON}};
Assert(false, ExcNotImplemented());
}
- if (patch.reference_cell != ReferenceCell::get_hypercube<dim>() ||
+ if (patch.reference_cell != ReferenceCells::get_hypercube<dim>() ||
write_higher_order_cells)
vtk_cell_id[2] = patch.data.n_cols();
else
for (const auto &patch : patches)
{
// The following formula doesn't hold for non-tensor products.
- if (patch.reference_cell == ReferenceCell::get_hypercube<dim>())
+ if (patch.reference_cell == ReferenceCells::get_hypercube<dim>())
{
n_nodes += Utilities::fixed_power<dim>(patch.n_subdivisions + 1);
n_cells += Utilities::fixed_power<dim>(patch.n_subdivisions);
for (const auto &patch : patches)
{
// The following formulas don't hold for non-tensor products.
- if (patch.reference_cell == ReferenceCell::get_hypercube<dim>())
+ if (patch.reference_cell == ReferenceCells::get_hypercube<dim>())
{
n_nodes += Utilities::fixed_power<dim>(patch.n_subdivisions + 1);
: patch_index(no_neighbor)
, n_subdivisions(1)
, points_are_available(false)
- , reference_cell(ReferenceCell::get_hypercube<dim>())
+ , reference_cell(ReferenceCells::get_hypercube<dim>())
// all the other data has a constructor of its own, except for the "neighbors"
// field, which we set to invalid values.
{
Patch<0, spacedim>::Patch()
: patch_index(no_neighbor)
, points_are_available(false)
- , reference_cell(ReferenceCell::get_hypercube<0>())
+ , reference_cell(ReferenceCells::get_hypercube<0>())
{
Assert(spacedim <= 3, ExcNotImplemented());
}
// special treatment of simplices since they are not subdivided, such
// that no new nodes have to be created, but the precomputed ones can be
// used
- if (patch.reference_cell != ReferenceCell::get_hypercube<dim>())
+ if (patch.reference_cell != ReferenceCells::get_hypercube<dim>())
{
Point<spacedim> node;
for (const auto &patch : patches)
{
// special treatment of simplices since they are not subdivided
- if (patch.reference_cell != ReferenceCell::get_hypercube<dim>())
+ if (patch.reference_cell != ReferenceCells::get_hypercube<dim>())
{
out.write_cell_single(count++,
first_vertex_of_patch,
for (const auto &patch : patches)
{
- if (patch.reference_cell != ReferenceCell::get_hypercube<dim>())
+ if (patch.reference_cell != ReferenceCells::get_hypercube<dim>())
{
connectivity.resize(patch.data.n_cols());
{
case 0:
return get_xdmf_content(indent_level,
- ReferenceCell::get_hypercube<0>());
+ ReferenceCells::get_hypercube<0>());
case 1:
return get_xdmf_content(indent_level,
- ReferenceCell::get_hypercube<1>());
+ ReferenceCells::get_hypercube<1>());
case 2:
return get_xdmf_content(indent_level,
- ReferenceCell::get_hypercube<2>());
+ ReferenceCells::get_hypercube<2>());
case 3:
return get_xdmf_content(indent_level,
- ReferenceCell::get_hypercube<3>());
+ ReferenceCells::get_hypercube<3>());
default:
Assert(false, ExcNotImplemented());
}
QProjector<dim>::project_to_child(const Quadrature<dim> &quadrature,
const unsigned int child_no)
{
- return project_to_child(ReferenceCell::get_hypercube<dim>(),
+ return project_to_child(ReferenceCells::get_hypercube<dim>(),
quadrature,
child_no);
}
const Quadrature<dim> &quadrature,
const unsigned int child_no)
{
- Assert(reference_cell == ReferenceCell::get_hypercube<dim>(),
+ Assert(reference_cell == ReferenceCells::get_hypercube<dim>(),
ExcNotImplemented());
(void)reference_cell;
Quadrature<dim>
QProjector<dim>::project_to_all_children(const Quadrature<dim> &quadrature)
{
- return project_to_all_children(ReferenceCell::get_hypercube<dim>(),
+ return project_to_all_children(ReferenceCells::get_hypercube<dim>(),
quadrature);
}
QProjector<dim>::project_to_all_children(const ReferenceCell reference_cell,
const Quadrature<dim> &quadrature)
{
- Assert(reference_cell == ReferenceCell::get_hypercube<dim>(),
+ Assert(reference_cell == ReferenceCells::get_hypercube<dim>(),
ExcNotImplemented());
(void)reference_cell;
const Point<dim> & p1,
const Point<dim> & p2)
{
- return project_to_line(ReferenceCell::get_hypercube<dim>(),
+ return project_to_line(ReferenceCells::get_hypercube<dim>(),
quadrature,
p1,
p2);
const Point<dim> & p1,
const Point<dim> & p2)
{
- Assert(reference_cell == ReferenceCell::get_hypercube<dim>(),
+ Assert(reference_cell == ReferenceCells::get_hypercube<dim>(),
ExcNotImplemented());
(void)reference_cell;
const bool face_rotation,
const unsigned int n_quadrature_points)
{
- return face(ReferenceCell::get_hypercube<dim>(),
+ return face(ReferenceCells::get_hypercube<dim>(),
face_no,
face_orientation,
face_flip,
}
}
- Assert(reference_cell == ReferenceCell::get_hypercube<dim>(),
+ Assert(reference_cell == ReferenceCells::get_hypercube<dim>(),
ExcNotImplemented());
Assert(face_no < GeometryInfo<dim>::faces_per_cell, ExcInternalError());
}
}
- Assert(reference_cell == ReferenceCell::get_hypercube<dim>(),
+ Assert(reference_cell == ReferenceCells::get_hypercube<dim>(),
ExcNotImplemented());
Assert(face_no < GeometryInfo<dim>::faces_per_cell, ExcInternalError());
QProjector<dim>::project_to_face(const SubQuadrature &quadrature,
const unsigned int face_no)
{
- return project_to_face(ReferenceCell::get_hypercube<dim>(),
+ return project_to_face(ReferenceCells::get_hypercube<dim>(),
quadrature,
face_no);
}
const SubQuadrature &quadrature,
const unsigned int face_no)
{
- Assert(reference_cell == ReferenceCell::get_hypercube<dim>(),
+ Assert(reference_cell == ReferenceCells::get_hypercube<dim>(),
ExcNotImplemented());
(void)reference_cell;
const unsigned int subface_no,
const RefinementCase<dim - 1> &ref_case)
{
- return project_to_subface(ReferenceCell::get_hypercube<dim>(),
+ return project_to_subface(ReferenceCells::get_hypercube<dim>(),
quadrature,
face_no,
subface_no,
const unsigned int subface_no,
const RefinementCase<dim - 1> &ref_case)
{
- Assert(reference_cell == ReferenceCell::get_hypercube<dim>(),
+ Assert(reference_cell == ReferenceCells::get_hypercube<dim>(),
ExcNotImplemented());
(void)reference_cell;
else
for (indices[0] = 0; indices[0] < n_polynomials; ++indices[0], ++ind)
{
- unsigned int i = index_map_inverse[ind];
+ const unsigned int i = index_map_inverse[ind];
if (update_values)
{
const unsigned int n_edge_points = reference_edge_quadrature.size();
const Quadrature<dim - 1> &edge_quadrature =
QProjector<dim - 1>::project_to_all_faces(
- ReferenceCell::get_hypercube<dim - 1>(), reference_edge_quadrature);
+ ReferenceCells::get_hypercube<dim - 1>(), reference_edge_quadrature);
if (order > 0)
{
q_point] =
edge_quadrature.point(
QProjector<dim - 1>::DataSetDescriptor::face(
- ReferenceCell::get_hypercube<dim - 1>(),
+ ReferenceCells::get_hypercube<dim - 1>(),
line,
true,
false,
q_point] =
edge_quadrature.point(
QProjector<dim - 1>::DataSetDescriptor::face(
- ReferenceCell::get_hypercube<dim - 1>(),
+ ReferenceCells::get_hypercube<dim - 1>(),
line,
true,
false,
template <int dim, int spacedim>
FE_Nothing<dim, spacedim>::FE_Nothing(const unsigned int n_components,
const bool dominate)
- : FE_Nothing<dim, spacedim>(ReferenceCell::get_hypercube<dim>(),
+ : FE_Nothing<dim, spacedim>(ReferenceCells::get_hypercube<dim>(),
n_components,
dominate)
{}
namebuf << "FE_Nothing<" << Utilities::dim_string(dim, spacedim) << ">(";
std::vector<std::string> name_components;
- if (this->reference_cell() != ReferenceCell::get_hypercube<dim>())
+ if (this->reference_cell() != ReferenceCells::get_hypercube<dim>())
name_components.push_back(this->reference_cell().to_string());
if (this->n_components() > 1)
name_components.push_back(std::to_string(this->n_components()));
// line 5: use line 9
QProjector<dim - 1>::project_to_subface(
- ReferenceCell::get_hypercube<dim - 1>(), qline, 0, 0, p_line);
+ ReferenceCells::get_hypercube<dim - 1>(), qline, 0, 0, p_line);
for (unsigned int i = 0; i < n; ++i)
constraint_points.push_back(p_line[i] + Point<dim - 1>(0.5, 0));
// line 6: use line 10
QProjector<dim - 1>::project_to_subface(
- ReferenceCell::get_hypercube<dim - 1>(), qline, 0, 1, p_line);
+ ReferenceCells::get_hypercube<dim - 1>(), qline, 0, 1, p_line);
for (unsigned int i = 0; i < n; ++i)
constraint_points.push_back(p_line[i] + Point<dim - 1>(0.5, 0));
// line 7: use line 13
QProjector<dim - 1>::project_to_subface(
- ReferenceCell::get_hypercube<dim - 1>(), qline, 2, 0, p_line);
+ ReferenceCells::get_hypercube<dim - 1>(), qline, 2, 0, p_line);
for (unsigned int i = 0; i < n; ++i)
constraint_points.push_back(p_line[i] + Point<dim - 1>(0, 0.5));
// line 8: use line 14
QProjector<dim - 1>::project_to_subface(
- ReferenceCell::get_hypercube<dim - 1>(), qline, 2, 1, p_line);
+ ReferenceCells::get_hypercube<dim - 1>(), qline, 2, 1, p_line);
for (unsigned int i = 0; i < n; ++i)
constraint_points.push_back(p_line[i] + Point<dim - 1>(0, 0.5));
++subface)
{
QProjector<dim - 1>::project_to_subface(
- ReferenceCell::get_hypercube<dim - 1>(),
+ ReferenceCells::get_hypercube<dim - 1>(),
qline,
face,
subface,
AssertDimension(quadrature.size(), 1);
std::unique_ptr<typename Mapping<dim, spacedim>::InternalDataBase> data_ptr =
- std::make_unique<InternalData>(
- QProjector<dim>::project_to_all_faces(ReferenceCell::get_hypercube<dim>(),
- quadrature[0]));
+ std::make_unique<InternalData>(QProjector<dim>::project_to_all_faces(
+ ReferenceCells::get_hypercube<dim>(), quadrature[0]));
auto &data = dynamic_cast<InternalData &>(*data_ptr);
// verify that we have computed the transitive hull of the required
{
std::unique_ptr<typename Mapping<dim, spacedim>::InternalDataBase> data_ptr =
std::make_unique<InternalData>(QProjector<dim>::project_to_all_subfaces(
- ReferenceCell::get_hypercube<dim>(), quadrature));
+ ReferenceCells::get_hypercube<dim>(), quadrature));
auto &data = dynamic_cast<InternalData &>(*data_ptr);
// verify that we have computed the transitive hull of the required
if (data.update_each & update_quadrature_points)
{
const auto offset = QProjector<dim>::DataSetDescriptor::face(
- ReferenceCell::get_hypercube<dim>(),
+ ReferenceCells::get_hypercube<dim>(),
face_no,
cell->face_orientation(face_no),
cell->face_flip(face_no),
if (data.update_each & update_quadrature_points)
{
const auto offset = QProjector<dim>::DataSetDescriptor::subface(
- ReferenceCell::get_hypercube<dim>(),
+ ReferenceCells::get_hypercube<dim>(),
face_no,
sub_no,
cell->face_orientation(face_no),
std::make_unique<InternalData>(euler_dof_handler->get_fe(), fe_mask);
auto & data = dynamic_cast<InternalData &>(*data_ptr);
const Quadrature<dim> q(
- QProjector<dim>::project_to_all_faces(ReferenceCell::get_hypercube<dim>(),
+ QProjector<dim>::project_to_all_faces(ReferenceCells::get_hypercube<dim>(),
quadrature[0]));
this->compute_face_data(update_flags, q, quadrature[0].size(), data);
std::make_unique<InternalData>(euler_dof_handler->get_fe(), fe_mask);
auto & data = dynamic_cast<InternalData &>(*data_ptr);
const Quadrature<dim> q(QProjector<dim>::project_to_all_subfaces(
- ReferenceCell::get_hypercube<dim>(), quadrature));
+ ReferenceCells::get_hypercube<dim>(), quadrature));
this->compute_face_data(update_flags, q, quadrature.size(), data);
return data_ptr;
face_no,
numbers::invalid_unsigned_int,
QProjector<dim>::DataSetDescriptor::face(
- ReferenceCell::get_hypercube<dim>(),
+ ReferenceCells::get_hypercube<dim>(),
face_no,
cell->face_orientation(face_no),
cell->face_flip(face_no),
face_no,
numbers::invalid_unsigned_int,
QProjector<dim>::DataSetDescriptor::subface(
- ReferenceCell::get_hypercube<dim>(),
+ ReferenceCells::get_hypercube<dim>(),
face_no,
subface_no,
cell->face_orientation(face_no),
auto &data = dynamic_cast<InternalData &>(*data_ptr);
data.initialize_face(this->requires_update_flags(update_flags),
QProjector<dim>::project_to_all_faces(
- ReferenceCell::get_hypercube<dim>(), quadrature[0]),
+ ReferenceCells::get_hypercube<dim>(), quadrature[0]),
quadrature[0].size());
return data_ptr;
auto &data = dynamic_cast<InternalData &>(*data_ptr);
data.initialize_face(this->requires_update_flags(update_flags),
QProjector<dim>::project_to_all_subfaces(
- ReferenceCell::get_hypercube<dim>(), quadrature),
+ ReferenceCells::get_hypercube<dim>(), quadrature),
quadrature.size());
return data_ptr;
face_no,
numbers::invalid_unsigned_int,
QProjector<dim>::DataSetDescriptor::face(
- ReferenceCell::get_hypercube<dim>(),
+ ReferenceCells::get_hypercube<dim>(),
face_no,
cell->face_orientation(face_no),
cell->face_flip(face_no),
face_no,
subface_no,
QProjector<dim>::DataSetDescriptor::subface(
- ReferenceCell::get_hypercube<dim>(),
+ ReferenceCells::get_hypercube<dim>(),
face_no,
subface_no,
cell->face_orientation(face_no),
auto &data = dynamic_cast<InternalData &>(*data_ptr);
data.initialize_face(this->requires_update_flags(update_flags),
QProjector<dim>::project_to_all_faces(
- ReferenceCell::get_hypercube<dim>(), quadrature[0]),
+ ReferenceCells::get_hypercube<dim>(), quadrature[0]),
quadrature[0].size());
return data_ptr;
auto &data = dynamic_cast<InternalData &>(*data_ptr);
data.initialize_face(this->requires_update_flags(update_flags),
QProjector<dim>::project_to_all_subfaces(
- ReferenceCell::get_hypercube<dim>(), quadrature),
+ ReferenceCells::get_hypercube<dim>(), quadrature),
quadrature.size());
return data_ptr;
face_no,
numbers::invalid_unsigned_int,
QProjector<dim>::DataSetDescriptor::face(
- ReferenceCell::get_hypercube<dim>(),
+ ReferenceCells::get_hypercube<dim>(),
face_no,
cell->face_orientation(face_no),
cell->face_flip(face_no),
face_no,
subface_no,
QProjector<dim>::DataSetDescriptor::subface(
- ReferenceCell::get_hypercube<dim>(),
+ ReferenceCells::get_hypercube<dim>(),
face_no,
subface_no,
cell->face_orientation(face_no),
{
AssertDimension(dim, reference_cell.get_dimension());
- if (reference_cell == ReferenceCell::get_hypercube<dim>())
+ if (reference_cell == ReferenceCells::get_hypercube<dim>())
{
GridGenerator::hyper_cube(tria, 0, 1);
}
const auto face_reference_cell = face->reference_cell();
- if (face_reference_cell == ReferenceCell::get_hypercube<facedim>())
+ if (face_reference_cell == ReferenceCells::get_hypercube<facedim>())
{
for (unsigned int i = 0; i < facedim; ++i)
xi[i] = 1. / 2;
"cells used by this triangulation if the "
"triangulation doesn't yet have any cells in it."));
return (this->reference_cells.size() == 1 &&
- this->reference_cells[0] == ReferenceCell::get_hypercube<dim>());
+ this->reference_cells[0] == ReferenceCells::get_hypercube<dim>());
}
// TODO: This assumes that the dofs per face on all faces coincide!
const unsigned int face_no = 0;
- Assert(fe.reference_cell() == ReferenceCell::get_hypercube<dim>(),
+ Assert(fe.reference_cell() == ReferenceCells::get_hypercube<dim>(),
ExcNotImplemented());
unsigned int increment =
// TODO: This assumes that the dofs per face on all faces coincide!
const unsigned int face_no = 0;
- Assert(fe.reference_cell() == ReferenceCell::get_hypercube<dim>(),
+ Assert(fe.reference_cell() == ReferenceCells::get_hypercube<dim>(),
ExcNotImplemented());
Assert(couplings.n_rows() == fe.n_components(),
(cell_and_index->first->at_boundary() ||
(DoFHandlerType::dimension != DoFHandlerType::space_dimension))) ||
(cell_and_index->first->reference_cell() !=
- ReferenceCell::get_hypercube<dim>()))
+ ReferenceCells::get_hypercube<dim>()))
{
Assert(patch.space_dim == DoFHandlerType::space_dimension,
ExcInternalError());
// basis.
const auto polys = get_basis<dim>(degree);
return FiniteElementData<dim>(get_dpo_vector<dim>(degree),
- ReferenceCell::get_simplex<dim>(),
+ ReferenceCells::get_simplex<dim>(),
1, // n_components
polys.degree(),
FiniteElementData<dim>::H1);
AssertDimension(reference_cells.size(), 1);
- if (reference_cells[0] == ReferenceCell::get_simplex<dim>())
+ if (reference_cells[0] == ReferenceCells::get_simplex<dim>())
mapping = std::make_shared<MappingFE<dim>>(Simplex::FE_P<dim>(1));
else if (reference_cells[0] == ReferenceCells::Wedge)
mapping = std::make_shared<MappingFE<dim>>(Simplex::FE_WedgeP<dim>(1));