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(ReferenceCell::get_hypercube<dim>(), quadrature);
}
update_flags,
mapping,
hp::QCollection<dim - 1>(QProjector<dim - 1>::project_to_all_children(
- ReferenceCell::get_hypercube(dim - 1), quadrature)),
+ ReferenceCell::get_hypercube<dim - 1>(), quadrature)),
output_data);
}
volume(const Triangulation<dim, spacedim> &tria,
const Mapping<dim, spacedim> & mapping =
ReferenceCell::get_default_linear_mapping<dim, spacedim>(
- ReferenceCell::get_hypercube(dim)));
+ ReferenceCell::get_hypercube<dim>()));
/**
* Return an approximation of the diameter of the smallest active cell of a
const Triangulation<dim, spacedim> &triangulation,
const Mapping<dim, spacedim> & mapping =
ReferenceCell::get_default_linear_mapping<dim, spacedim>(
- ReferenceCell::get_hypercube(dim)));
+ ReferenceCell::get_hypercube<dim>()));
/**
* Return an approximation of the diameter of the largest active cell of a
const Triangulation<dim, spacedim> &triangulation,
const Mapping<dim, spacedim> & mapping =
ReferenceCell::get_default_linear_mapping<dim, spacedim>(
- ReferenceCell::get_hypercube(dim)));
+ ReferenceCell::get_hypercube<dim>()));
/**
* Given a list of vertices (typically obtained using
const Triangulation<dim, spacedim> &container,
const Mapping<dim, spacedim> & mapping =
ReferenceCell::get_default_linear_mapping<dim, spacedim>(
- ReferenceCell::get_hypercube(dim)));
+ ReferenceCell::get_hypercube<dim>()));
/**
* Find and return the index of the closest vertex to a given point in the
const Point<spacedim> & position,
const Mapping<dim, spacedim> & mapping =
ReferenceCell::get_default_linear_mapping<dim, spacedim>(
- ReferenceCell::get_hypercube(dim)));
+ ReferenceCell::get_hypercube<dim>()));
/**
* Compute a globally unique index for each vertex and hanging node
!cell->face(face)->at_boundary())
{
Assert(cell->reference_cell_type() ==
- ReferenceCell::get_hypercube(dim),
+ ReferenceCell::get_hypercube<dim>(),
ExcNotImplemented());
// this line has children
!cell->face(face)->at_boundary())
{
Assert(cell->reference_cell_type() ==
- ReferenceCell::get_hypercube(dim),
+ ReferenceCell::get_hypercube<dim>(),
ExcNotImplemented());
// this face has hanging nodes
Cache(const Triangulation<dim, spacedim> &tria,
const Mapping<dim, spacedim> & mapping =
ReferenceCell::get_default_linear_mapping<dim, spacedim>(
- ReferenceCell::get_hypercube(dim)));
+ ReferenceCell::get_hypercube<dim>()));
/**
* Destructor.
* Return the correct simplex reference cell type for the given dimension
* @p dim.
*/
- inline Type
- get_simplex(const unsigned int dim)
+ template <int dim>
+ inline const Type &
+ get_simplex()
{
switch (dim)
{
* Return the correct hypercube reference cell type for the given dimension
* @p dim.
*/
- inline Type
- get_hypercube(const unsigned int dim)
+ template <int dim>
+ inline const Type &
+ get_hypercube()
{
switch (dim)
{
const unsigned int i) const
{
AssertDimension(dim, get_dimension());
- if (*this == get_hypercube(dim))
+ if (*this == get_hypercube<dim>())
return GeometryInfo<dim>::d_linear_shape_function(xi, i);
if (*this == Type::Tri) // see also Simplex::ScalarPolynomial::compute_value
const unsigned int i) const
{
AssertDimension(dim, get_dimension());
- if (*this == get_hypercube(dim))
+ if (*this == get_hypercube<dim>())
return GeometryInfo<dim>::d_linear_shape_function_gradient(xi, i);
if (*this == Type::Tri) // see also Simplex::ScalarPolynomial::compute_grad
AssertDimension(dim, get_dimension());
AssertIndexRange(i, dim - 1);
- if (*this == get_hypercube(dim))
+ if (*this == get_hypercube<dim>())
{
AssertIndexRange(face_no, GeometryInfo<dim>::faces_per_cell);
return GeometryInfo<dim>::unit_tangential_vectors[face_no][i];
{
AssertDimension(dim, reference_cell.get_dimension());
- if (reference_cell == get_hypercube(dim))
+ if (reference_cell == get_hypercube<dim>())
{
AssertIndexRange(face_no, GeometryInfo<dim>::faces_per_cell);
return GeometryInfo<dim>::unit_normal_vector[face_no];
Assert(index < dim, ExcInternalError());
if ((reference_cell_type == ReferenceCell::Type::Invalid ||
- reference_cell_type == ReferenceCell::get_hypercube(dim)) == false)
+ reference_cell_type == ReferenceCell::get_hypercube<dim>()) ==
+ false)
{
#ifdef DEAL_II_WITH_SIMPLEX_SUPPORT
return index;
++fe_no)
shape_info_dummy(c, fe_no).reinit(
dof_handlers[no]->get_fe(fe_no).reference_cell_type() ==
- ReferenceCell::get_hypercube(dim) ?
+ ReferenceCell::get_hypercube<dim>() ?
quad :
quad_simplex,
dof_handlers[no]->get_fe(fe_no),
try
{
- const auto reference_cell_type = ReferenceCell::get_simplex(dim);
+ const auto reference_cell_type =
+ ReferenceCell::get_simplex<dim>();
const auto quad_face = get_face_quadrature(quad);
this->n_q_points_face = quad_face.size();
AffineConstraints<double> & constraints,
const Mapping<dim, spacedim> &mapping =
ReferenceCell::get_default_linear_mapping<dim, spacedim>(
- ReferenceCell::get_hypercube(dim)));
+ ReferenceCell::get_hypercube<dim>()));
/**
* This function does the same as the
AffineConstraints<double> & constraints,
const Mapping<dim, spacedim> & mapping =
ReferenceCell::get_default_linear_mapping<dim, spacedim>(
- ReferenceCell::get_hypercube(dim)));
+ ReferenceCell::get_hypercube<dim>()));
/**
* Compute the constraints that correspond to boundary conditions of the
AffineConstraints<double> & constraints,
const Mapping<dim, spacedim> &mapping =
ReferenceCell::get_default_linear_mapping<dim, spacedim>(
- ReferenceCell::get_hypercube(dim)));
+ ReferenceCell::get_hypercube<dim>()));
/**
* Same as above for homogeneous tangential-flux constraints.
AffineConstraints<double> & constraints,
const Mapping<dim, spacedim> & mapping =
ReferenceCell::get_default_linear_mapping<dim, spacedim>(
- ReferenceCell::get_hypercube(dim)));
+ ReferenceCell::get_hypercube<dim>()));
//@}
} // namespace VectorTools
Quadrature<dim> quadrature_mf;
if (dof.get_fe(0).reference_cell_type() ==
- ReferenceCell::get_hypercube(dim))
+ ReferenceCell::get_hypercube<dim>())
quadrature_mf = QGauss<dim>(dof.get_fe().degree + 2);
else
// TODO: since we have currently only implemented a handful quadrature
ParticleHandler<dim, spacedim> & particle_handler,
const Mapping<dim, spacedim> & mapping =
ReferenceCell::get_default_linear_mapping<dim, spacedim>(
- ReferenceCell::get_hypercube(dim)));
+ ReferenceCell::get_hypercube<dim>()));
/**
* A function that generates one particle at a random location in cell @p cell and with
std::mt19937 & random_number_generator,
const Mapping<dim, spacedim> &mapping =
ReferenceCell::get_default_linear_mapping<dim, spacedim>(
- ReferenceCell::get_hypercube(dim)));
+ ReferenceCell::get_hypercube<dim>()));
/**
* A function that generates particles randomly in the domain with a
ParticleHandler<dim, spacedim> & particle_handler,
const Mapping<dim, spacedim> & mapping =
ReferenceCell::get_default_linear_mapping<dim, spacedim>(
- ReferenceCell::get_hypercube(dim)),
+ ReferenceCell::get_hypercube<dim>()),
const unsigned int random_number_seed = 5432);
ParticleHandler<dim, spacedim> &particle_handler,
const Mapping<dim, spacedim> & mapping =
ReferenceCell::get_default_linear_mapping<dim, spacedim>(
- ReferenceCell::get_hypercube(dim)),
+ ReferenceCell::get_hypercube<dim>()),
const ComponentMask & components = ComponentMask(),
const std::vector<std::vector<double>> &properties = {});
ParticleHandler<dim, spacedim> &particle_handler,
const Mapping<dim, spacedim> & mapping =
ReferenceCell::get_default_linear_mapping<dim, spacedim>(
- ReferenceCell::get_hypercube(dim)),
+ ReferenceCell::get_hypercube<dim>()),
const std::vector<std::vector<double>> &properties = {});
} // namespace Generators
} // namespace Particles
n_data_sets,
patch.data.n_rows()));
Assert(patch.reference_cell_type !=
- ReferenceCell::get_hypercube(dim) ||
+ ReferenceCell::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_type == ReferenceCell::get_hypercube(dim))
+ if (patch.reference_cell_type == ReferenceCell::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_type == ReferenceCell::get_hypercube(dim))
+ else if (patch.reference_cell_type == ReferenceCell::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_type != ReferenceCell::get_hypercube(dim) ||
+ if (patch.reference_cell_type != ReferenceCell::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_type == ReferenceCell::get_hypercube(dim))
+ if (patch.reference_cell_type == ReferenceCell::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_type == ReferenceCell::get_hypercube(dim))
+ if (patch.reference_cell_type == ReferenceCell::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_type(ReferenceCell::get_hypercube(dim))
+ , reference_cell_type(ReferenceCell::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_type(ReferenceCell::get_hypercube(0))
+ , reference_cell_type(ReferenceCell::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_type != ReferenceCell::get_hypercube(dim))
+ if (patch.reference_cell_type != ReferenceCell::get_hypercube<dim>())
{
Point<spacedim> node;
for (const auto &patch : patches)
{
// special treatment of simplices since they are not subdivided
- if (patch.reference_cell_type != ReferenceCell::get_hypercube(dim))
+ if (patch.reference_cell_type != ReferenceCell::get_hypercube<dim>())
{
out.write_cell_single(count++,
first_vertex_of_patch,
std::string
XDMFEntry::get_xdmf_content(const unsigned int indent_level) const
{
- return get_xdmf_content(indent_level,
- ReferenceCell::get_hypercube(dimension));
+ switch (dimension)
+ {
+ case 0:
+ return get_xdmf_content(indent_level,
+ ReferenceCell::get_hypercube<0>());
+ case 1:
+ return get_xdmf_content(indent_level,
+ ReferenceCell::get_hypercube<1>());
+ case 2:
+ return get_xdmf_content(indent_level,
+ ReferenceCell::get_hypercube<2>());
+ case 3:
+ return get_xdmf_content(indent_level,
+ ReferenceCell::get_hypercube<3>());
+ default:
+ Assert(false, ExcNotImplemented());
+ }
+
+ return "";
}
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(ReferenceCell::get_hypercube<dim>(),
quadrature,
child_no);
}
const Quadrature<dim> & quadrature,
const unsigned int child_no)
{
- Assert(reference_cell_type == ReferenceCell::get_hypercube(dim),
+ Assert(reference_cell_type == ReferenceCell::get_hypercube<dim>(),
ExcNotImplemented());
(void)reference_cell_type;
Quadrature<dim>
QProjector<dim>::project_to_all_children(const Quadrature<dim> &quadrature)
{
- return project_to_all_children(ReferenceCell::get_hypercube(dim), quadrature);
+ return project_to_all_children(ReferenceCell::get_hypercube<dim>(),
+ quadrature);
}
const ReferenceCell::Type reference_cell_type,
const Quadrature<dim> & quadrature)
{
- Assert(reference_cell_type == ReferenceCell::get_hypercube(dim),
+ Assert(reference_cell_type == ReferenceCell::get_hypercube<dim>(),
ExcNotImplemented());
(void)reference_cell_type;
const Point<dim> & p1,
const Point<dim> & p2)
{
- return project_to_line(ReferenceCell::get_hypercube(dim), quadrature, p1, p2);
+ return project_to_line(ReferenceCell::get_hypercube<dim>(),
+ quadrature,
+ p1,
+ p2);
}
const Point<dim> & p1,
const Point<dim> & p2)
{
- Assert(reference_cell_type == ReferenceCell::get_hypercube(dim),
+ Assert(reference_cell_type == ReferenceCell::get_hypercube<dim>(),
ExcNotImplemented());
(void)reference_cell_type;
const bool face_rotation,
const unsigned int n_quadrature_points)
{
- return face(ReferenceCell::get_hypercube(dim),
+ return face(ReferenceCell::get_hypercube<dim>(),
face_no,
face_orientation,
face_flip,
}
}
- Assert(reference_cell_type == ReferenceCell::get_hypercube(dim),
+ Assert(reference_cell_type == ReferenceCell::get_hypercube<dim>(),
ExcNotImplemented());
Assert(face_no < GeometryInfo<dim>::faces_per_cell, ExcInternalError());
}
}
- Assert(reference_cell_type == ReferenceCell::get_hypercube(dim),
+ Assert(reference_cell_type == ReferenceCell::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(ReferenceCell::get_hypercube<dim>(),
quadrature,
face_no);
}
const SubQuadrature & quadrature,
const unsigned int face_no)
{
- Assert(reference_cell_type == ReferenceCell::get_hypercube(dim),
+ Assert(reference_cell_type == ReferenceCell::get_hypercube<dim>(),
ExcNotImplemented());
(void)reference_cell_type;
const unsigned int subface_no,
const RefinementCase<dim - 1> &ref_case)
{
- return project_to_subface(ReferenceCell::get_hypercube(dim),
+ return project_to_subface(ReferenceCell::get_hypercube<dim>(),
quadrature,
face_no,
subface_no,
const unsigned int subface_no,
const RefinementCase<dim - 1> &ref_case)
{
- Assert(reference_cell_type == ReferenceCell::get_hypercube(dim),
+ Assert(reference_cell_type == ReferenceCell::get_hypercube<dim>(),
ExcNotImplemented());
(void)reference_cell_type;
const QGauss<1> reference_edge_quadrature(order + 1);
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);
+ QProjector<dim - 1>::project_to_all_faces(
+ ReferenceCell::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),
+ ReferenceCell::get_hypercube<dim - 1>(),
line,
true,
false,
q_point] =
edge_quadrature.point(
QProjector<dim - 1>::DataSetDescriptor::face(
- ReferenceCell::get_hypercube(dim - 1),
+ ReferenceCell::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>(ReferenceCell::get_hypercube<dim>(),
n_components,
dominate)
{}
namebuf << "FE_Nothing<" << Utilities::dim_string(dim, spacedim) << ">(";
std::vector<std::string> name_components;
- if (this->reference_cell_type() != ReferenceCell::get_hypercube(dim))
+ if (this->reference_cell_type() != ReferenceCell::get_hypercube<dim>())
name_components.push_back(this->reference_cell_type().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);
+ ReferenceCell::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);
+ ReferenceCell::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);
+ ReferenceCell::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);
+ ReferenceCell::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),
+ ReferenceCell::get_hypercube<dim - 1>(),
qline,
face,
subface,
std::unique_ptr<typename Mapping<dim, spacedim>::InternalDataBase> data_ptr =
std::make_unique<InternalData>(
- QProjector<dim>::project_to_all_faces(ReferenceCell::get_hypercube(dim),
+ QProjector<dim>::project_to_all_faces(ReferenceCell::get_hypercube<dim>(),
quadrature[0]));
auto &data = dynamic_cast<InternalData &>(*data_ptr);
{
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));
+ ReferenceCell::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),
+ ReferenceCell::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),
+ ReferenceCell::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(ReferenceCell::get_hypercube<dim>(),
quadrature[0]));
this->compute_face_data(update_flags, q, quadrature[0].size(), data);
std::unique_ptr<typename Mapping<dim, spacedim>::InternalDataBase> data_ptr =
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));
+ const Quadrature<dim> q(QProjector<dim>::project_to_all_subfaces(
+ ReferenceCell::get_hypercube<dim>(), quadrature));
this->compute_face_data(update_flags, q, quadrature.size(), data);
return data_ptr;
update_internal_dofs(cell, data);
- internal::MappingFEFieldImplementation::do_fill_fe_face_values<dim,
- spacedim,
- VectorType>(
- *this,
- cell,
- face_no,
- numbers::invalid_unsigned_int,
- QProjector<dim>::DataSetDescriptor::face(ReferenceCell::get_hypercube(dim),
- face_no,
- cell->face_orientation(face_no),
- cell->face_flip(face_no),
- cell->face_rotation(face_no),
- quadrature[0].size()),
- quadrature[0],
- data,
- euler_dof_handler->get_fe(),
- fe_mask,
- fe_to_real,
- output_data);
+ internal::MappingFEFieldImplementation::
+ do_fill_fe_face_values<dim, spacedim, VectorType>(
+ *this,
+ cell,
+ face_no,
+ numbers::invalid_unsigned_int,
+ QProjector<dim>::DataSetDescriptor::face(
+ ReferenceCell::get_hypercube<dim>(),
+ face_no,
+ cell->face_orientation(face_no),
+ cell->face_flip(face_no),
+ cell->face_rotation(face_no),
+ quadrature[0].size()),
+ quadrature[0],
+ data,
+ euler_dof_handler->get_fe(),
+ fe_mask,
+ fe_to_real,
+ output_data);
}
update_internal_dofs(cell, data);
- internal::MappingFEFieldImplementation::do_fill_fe_face_values<dim,
- spacedim,
- VectorType>(
- *this,
- cell,
- face_no,
- numbers::invalid_unsigned_int,
- QProjector<dim>::DataSetDescriptor::subface(ReferenceCell::get_hypercube(
- dim),
- face_no,
- subface_no,
- cell->face_orientation(face_no),
- cell->face_flip(face_no),
- cell->face_rotation(face_no),
- quadrature.size(),
- cell->subface_case(face_no)),
- quadrature,
- data,
- euler_dof_handler->get_fe(),
- fe_mask,
- fe_to_real,
- output_data);
+ internal::MappingFEFieldImplementation::
+ do_fill_fe_face_values<dim, spacedim, VectorType>(
+ *this,
+ cell,
+ face_no,
+ numbers::invalid_unsigned_int,
+ QProjector<dim>::DataSetDescriptor::subface(
+ ReferenceCell::get_hypercube<dim>(),
+ face_no,
+ subface_no,
+ cell->face_orientation(face_no),
+ cell->face_flip(face_no),
+ cell->face_rotation(face_no),
+ quadrature.size(),
+ cell->subface_case(face_no)),
+ quadrature,
+ data,
+ euler_dof_handler->get_fe(),
+ fe_mask,
+ fe_to_real,
+ output_data);
}
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]),
+ ReferenceCell::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),
+ ReferenceCell::get_hypercube<dim>(), quadrature),
quadrature.size());
return data_ptr;
cell,
face_no,
numbers::invalid_unsigned_int,
- QProjector<dim>::DataSetDescriptor::face(ReferenceCell::get_hypercube(dim),
- face_no,
- cell->face_orientation(face_no),
- cell->face_flip(face_no),
- cell->face_rotation(face_no),
- quadrature[0].size()),
+ QProjector<dim>::DataSetDescriptor::face(
+ ReferenceCell::get_hypercube<dim>(),
+ face_no,
+ cell->face_orientation(face_no),
+ cell->face_flip(face_no),
+ cell->face_rotation(face_no),
+ quadrature[0].size()),
quadrature[0],
data,
output_data);
cell,
face_no,
subface_no,
- QProjector<dim>::DataSetDescriptor::subface(ReferenceCell::get_hypercube(
- dim),
- face_no,
- subface_no,
- cell->face_orientation(face_no),
- cell->face_flip(face_no),
- cell->face_rotation(face_no),
- quadrature.size(),
- cell->subface_case(face_no)),
+ QProjector<dim>::DataSetDescriptor::subface(
+ ReferenceCell::get_hypercube<dim>(),
+ face_no,
+ subface_no,
+ cell->face_orientation(face_no),
+ cell->face_flip(face_no),
+ cell->face_rotation(face_no),
+ quadrature.size(),
+ cell->subface_case(face_no)),
quadrature,
data,
output_data);
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]),
+ ReferenceCell::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),
+ ReferenceCell::get_hypercube<dim>(), quadrature),
quadrature.size());
return data_ptr;
cell,
face_no,
numbers::invalid_unsigned_int,
- QProjector<dim>::DataSetDescriptor::face(ReferenceCell::get_hypercube(dim),
- face_no,
- cell->face_orientation(face_no),
- cell->face_flip(face_no),
- cell->face_rotation(face_no),
- quadrature[0].size()),
+ QProjector<dim>::DataSetDescriptor::face(
+ ReferenceCell::get_hypercube<dim>(),
+ face_no,
+ cell->face_orientation(face_no),
+ cell->face_flip(face_no),
+ cell->face_rotation(face_no),
+ quadrature[0].size()),
quadrature[0],
data,
output_data);
cell,
face_no,
subface_no,
- QProjector<dim>::DataSetDescriptor::subface(ReferenceCell::get_hypercube(
- dim),
- face_no,
- subface_no,
- cell->face_orientation(face_no),
- cell->face_flip(face_no),
- cell->face_rotation(face_no),
- quadrature.size(),
- cell->subface_case(face_no)),
+ QProjector<dim>::DataSetDescriptor::subface(
+ ReferenceCell::get_hypercube<dim>(),
+ face_no,
+ subface_no,
+ cell->face_orientation(face_no),
+ cell->face_flip(face_no),
+ cell->face_rotation(face_no),
+ quadrature.size(),
+ cell->subface_case(face_no)),
quadrature,
data,
output_data);
const auto face_reference_cell_type = face->reference_cell_type();
- if (face_reference_cell_type == ReferenceCell::get_hypercube(facedim))
+ if (face_reference_cell_type == ReferenceCell::get_hypercube<facedim>())
{
for (unsigned int i = 0; i < facedim; ++i)
xi[i] = 1. / 2;
{
AssertDimension(dim, reference_cell.get_dimension());
- if (reference_cell == get_hypercube(dim))
+ if (reference_cell == get_hypercube<dim>())
{
GridGenerator::hyper_cube(tria, 0, 1);
}
{
AssertDimension(dim, reference_cell.get_dimension());
- if (reference_cell == get_hypercube(dim))
+ if (reference_cell == get_hypercube<dim>())
return std::make_unique<MappingQGeneric<dim, spacedim>>(degree);
else if (reference_cell == Type::Tri || reference_cell == Type::Tet)
return std::make_unique<MappingFE<dim, spacedim>>(
{
AssertDimension(dim, reference_cell.get_dimension());
- if (reference_cell == get_hypercube(dim))
+ if (reference_cell == get_hypercube<dim>())
{
return StaticMappingQ1<dim, spacedim>::mapping;
}
{
AssertDimension(dim, reference_cell.get_dimension());
- if (reference_cell == get_hypercube(dim))
+ if (reference_cell == get_hypercube<dim>())
return QGauss<dim>(n_points_1D);
else if (reference_cell == Type::Tri || reference_cell == Type::Tet)
return Simplex::QGauss<dim>(n_points_1D);
return Quadrature<dim>(tria.get_vertices());
};
- if (reference_cell == get_hypercube(dim))
+ if (reference_cell == get_hypercube<dim>())
{
static Quadrature<dim> quadrature = create_quadrature(reference_cell);
return quadrature;
{
return (this->reference_cell_types.size() == 0) ||
(this->reference_cell_types.size() == 1 &&
- this->reference_cell_types[0] == ReferenceCell::get_hypercube(dim));
+ this->reference_cell_types[0] == ReferenceCell::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_type() == ReferenceCell::get_hypercube(dim),
+ Assert(fe.reference_cell_type() == ReferenceCell::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_type() == ReferenceCell::get_hypercube(dim),
+ Assert(fe.reference_cell_type() == ReferenceCell::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_type() !=
- ReferenceCell::get_hypercube(dim)))
+ ReferenceCell::get_hypercube<dim>()))
{
Assert(patch.space_dim == DoFHandlerType::space_dimension,
ExcInternalError());
AssertDimension(reference_cell_types.size(), 1);
- if (reference_cell_types[0] == ReferenceCell::get_simplex(dim))
+ if (reference_cell_types[0] == ReferenceCell::get_simplex<dim>())
mapping = std::make_shared<MappingFE<dim>>(Simplex::FE_P<dim>(1));
else if (reference_cell_types[0] == ReferenceCell::Type::Wedge)
mapping = std::make_shared<MappingFE<dim>>(Simplex::FE_WedgeP<dim>(1));