--- /dev/null
+Removed: The deprecated member functions of QProjector not using a ReferenceCell
+object have been removed.
+<br>
+(Daniel Arndt, 2022/06/24)
*/
using SubQuadrature = Quadrature<dim - 1>;
- /**
- * Compute the quadrature points on the cell if the given quadrature formula
- * is used on face <tt>face_no</tt>. For further details, see the general
- * doc for this class.
- *
- * @note This function is deprecated since it makes an implicit assumption
- * that the cell is a line (1D), a quad (2D), or a hex (3D). Use the other
- * version of this function that takes the reference cell type instead.
- */
- DEAL_II_DEPRECATED static void
- project_to_face(const SubQuadrature & quadrature,
- const unsigned int face_no,
- std::vector<Point<dim>> &q_points);
-
/**
* Compute the quadrature points on the cell if the given quadrature formula
* is used on face <tt>face_no</tt>. For further details, see the general
const unsigned int face_no,
std::vector<Point<dim>> &q_points);
- /**
- * Compute the cell quadrature formula corresponding to using
- * <tt>quadrature</tt> on face <tt>face_no</tt>. For further details, see
- * the general doc for this class.
- *
- * @note This function is deprecated since it makes an implicit assumption
- * that the cell is a line (1D), a quad (2D), or a hex (3D). Use the other
- * version of this function that takes the reference cell type instead.
- */
- DEAL_II_DEPRECATED static Quadrature<dim>
- project_to_face(const SubQuadrature &quadrature, const unsigned int face_no);
-
/**
* Compute the cell quadrature formula corresponding to using
* <tt>quadrature</tt> on face <tt>face_no</tt>. For further details, see
const SubQuadrature &quadrature,
const unsigned int face_no);
- /**
- * Compute the quadrature points on the cell if the given quadrature formula
- * is used on face <tt>face_no</tt>, subface number <tt>subface_no</tt>
- * corresponding to RefineCase::Type <tt>ref_case</tt>. The last argument is
- * only used in 3D.
- *
- * @note Only the points are transformed. The quadrature weights are the
- * same as those of the original rule.
- *
- * @note This function is deprecated since it makes an implicit assumption
- * that the cell is a line (1D), a quad (2D), or a hex (3D). Use the other
- * version of this function that takes the reference cell type instead.
- */
- DEAL_II_DEPRECATED static void
- project_to_subface(const SubQuadrature & quadrature,
- const unsigned int face_no,
- const unsigned int subface_no,
- std::vector<Point<dim>> & q_points,
- const RefinementCase<dim - 1> &ref_case =
- RefinementCase<dim - 1>::isotropic_refinement);
-
/**
* Compute the quadrature points on the cell if the given quadrature formula
* is used on face <tt>face_no</tt>, subface number <tt>subface_no</tt>
const RefinementCase<dim - 1> &ref_case =
RefinementCase<dim - 1>::isotropic_refinement);
- /**
- * Compute the cell quadrature formula corresponding to using
- * <tt>quadrature</tt> on subface <tt>subface_no</tt> of face
- * <tt>face_no</tt> with RefinementCase<dim-1> <tt>ref_case</tt>. The last
- * argument is only used in 3D.
- *
- * @note Only the points are transformed. The quadrature weights are the
- * same as those of the original rule.
- *
- * @note This function is deprecated since it makes an implicit assumption
- * that the cell is a line (1D), a quad (2D), or a hex (3D). Use the other
- * version of this function that takes the reference cell type instead.
- */
- DEAL_II_DEPRECATED static Quadrature<dim>
- project_to_subface(const SubQuadrature & quadrature,
- const unsigned int face_no,
- const unsigned int subface_no,
- const RefinementCase<dim - 1> &ref_case =
- RefinementCase<dim - 1>::isotropic_refinement);
-
/**
* Compute the cell quadrature formula corresponding to using
* <tt>quadrature</tt> on subface <tt>subface_no</tt> of face
const RefinementCase<dim - 1> &ref_case =
RefinementCase<dim - 1>::isotropic_refinement);
- /**
- * Take a face quadrature formula and generate a cell quadrature formula
- * from it where the quadrature points of the given argument are projected
- * on all faces.
- *
- * The weights of the new rule are replications of the original weights.
- * Thus, the sum of the weights is not one, but the number of faces, which
- * is the surface of the reference cell.
- *
- * This in particular allows us to extract a subset of points corresponding
- * to a single face and use it as a quadrature on this face, as is done in
- * FEFaceValues.
- *
- * @note In 3D, this function produces eight sets of quadrature points for
- * each face, in order to cope possibly different orientations of the mesh.
- *
- * @note This function is deprecated since it makes an implicit assumption
- * that the cell is a line (1D), a quad (2D), or a hex (3D). Use the other
- * version of this function that takes the reference cell type instead.
- */
- DEAL_II_DEPRECATED static Quadrature<dim>
- project_to_all_faces(const Quadrature<dim - 1> &quadrature);
-
/**
* Take a collection of face quadrature formulas and generate a cell
* quadrature formula from it where the quadrature points of the given
project_to_all_faces(const ReferenceCell reference_cell,
const Quadrature<dim - 1> &quadrature);
- /**
- * Take a face quadrature formula and generate a cell quadrature formula
- * from it where the quadrature points of the given argument are projected
- * on all subfaces.
- *
- * Like in project_to_all_faces(), the weights of the new rule sum up to the
- * number of faces (not subfaces), which is the surface of the reference
- * cell.
- *
- * This in particular allows us to extract a subset of points corresponding
- * to a single subface and use it as a quadrature on this face, as is done
- * in FESubfaceValues.
- *
- * @note This function is deprecated since it makes an implicit assumption
- * that the cell is a line (1D), a quad (2D), or a hex (3D). Use the other
- * version of this function that takes the reference cell type instead.
- */
- DEAL_II_DEPRECATED static Quadrature<dim>
- project_to_all_subfaces(const SubQuadrature &quadrature);
-
/**
* Take a face quadrature formula and generate a cell quadrature formula
* from it where the quadrature points of the given argument are projected
project_to_all_subfaces(const ReferenceCell reference_cell,
const SubQuadrature &quadrature);
- /**
- * Project a given quadrature formula to a child of a cell. You may want to
- * use this function in case you want to extend an integral only over the
- * area which a potential child would occupy. The child numbering is the
- * same as the children would be numbered upon refinement of the cell.
- *
- * As integration using this quadrature formula now only extends over a
- * fraction of the cell, the weights of the resulting object are divided by
- * GeometryInfo<dim>::children_per_cell.
- *
- * @note This function is deprecated since it makes an implicit assumption
- * that the cell is a line (1D), a quad (2D), or a hex (3D). Use the other
- * version of this function that takes the reference cell type instead.
- */
- DEAL_II_DEPRECATED static Quadrature<dim>
- project_to_child(const Quadrature<dim> &quadrature,
- const unsigned int child_no);
-
/**
* Project a given quadrature formula to a child of a cell. You may want to
* use this function in case you want to extend an integral only over the
const Quadrature<dim> &quadrature,
const unsigned int child_no);
- /**
- * Project a quadrature rule to all children of a cell. Similarly to
- * project_to_all_subfaces(), this function replicates the formula generated
- * by project_to_child() for all children, such that the weights sum up to
- * one, the volume of the total cell again.
- *
- * The child numbering is the same as the children would be numbered upon
- * refinement of the cell.
- *
- * @note This function is deprecated since it makes an implicit assumption
- * that the cell is a line (1D), a quad (2D), or a hex (3D). Use the other
- * version of this function that takes the reference cell type instead.
- */
- DEAL_II_DEPRECATED static Quadrature<dim>
- project_to_all_children(const Quadrature<dim> &quadrature);
-
/**
* Project a quadrature rule to all children of a cell. Similarly to
* project_to_all_subfaces(), this function replicates the formula generated
project_to_all_children(const ReferenceCell reference_cell,
const Quadrature<dim> &quadrature);
- /**
- * Project the one dimensional rule <tt>quadrature</tt> to the straight line
- * connecting the points <tt>p1</tt> and <tt>p2</tt>.
- *
- * @note This function is deprecated since it makes an implicit assumption
- * that the cell is a line (1D), a quad (2D), or a hex (3D). Use the other
- * version of this function that takes the reference cell type instead.
- */
- DEAL_II_DEPRECATED static Quadrature<dim>
- project_to_line(const Quadrature<1> &quadrature,
- const Point<dim> & p1,
- const Point<dim> & p2);
-
/**
* Project the one dimensional rule <tt>quadrature</tt> to the straight line
* connecting the points <tt>p1</tt> and <tt>p2</tt>.
static DataSetDescriptor
cell();
- /**
- * Static function to generate an offset object for a given face of a cell
- * with the given face orientation, flip and rotation. This function of
- * course is only allowed if <tt>dim>=2</tt>, and the face orientation,
- * flip and rotation are ignored if the space dimension equals 2.
- *
- * The last argument denotes the number of quadrature points the lower-
- * dimensional face quadrature formula (the one that has been projected
- * onto the faces) has.
- *
- * @note This function is deprecated since it makes an implicit assumption
- * that the cell is a line (1D), a quad (2D), or a hex (3D). Use the other
- * version of this function that takes the reference cell type instead.
- */
- DEAL_II_DEPRECATED static DataSetDescriptor
- face(const unsigned int face_no,
- const bool face_orientation,
- const bool face_flip,
- const bool face_rotation,
- const unsigned int n_quadrature_points);
-
/**
* Static function to generate an offset object for a given face of a cell
* with the given face orientation, flip and rotation. This function of
const bool face_rotation,
const hp::QCollection<dim - 1> &quadrature);
- /**
- * Static function to generate an offset object for a given subface of a
- * cell with the given face orientation, flip and rotation. This function
- * of course is only allowed if <tt>dim>=2</tt>, and the face orientation,
- * flip and rotation are ignored if the space dimension equals 2.
- *
- * The last but one argument denotes the number of quadrature points the
- * lower-dimensional face quadrature formula (the one that has been
- * projected onto the faces) has.
- *
- * Through the last argument anisotropic refinement can be respected.
- *
- * @note This function is deprecated since it makes an implicit assumption
- * that the cell is a line (1D), a quad (2D), or a hex (3D). Use the other
- * version of this function that takes the reference cell type instead.
- */
- DEAL_II_DEPRECATED static DataSetDescriptor
- subface(const unsigned int face_no,
- const unsigned int subface_no,
- const bool face_orientation,
- const bool face_flip,
- const bool face_rotation,
- const unsigned int n_quadrature_points,
- const internal::SubfaceCase<dim> ref_case =
- internal::SubfaceCase<dim>::case_isotropic);
-
/**
* Static function to generate an offset object for a given subface of a
* cell with the given face orientation, flip and rotation. This function
-template <int dim>
-Quadrature<dim> inline QProjector<dim>::project_to_all_faces(
- const Quadrature<dim - 1> &quadrature)
-{
- return project_to_all_faces(ReferenceCells::get_hypercube<dim>(), quadrature);
-}
-
-
template <int dim>
Quadrature<dim> inline QProjector<dim>::project_to_all_faces(
const ReferenceCell reference_cell,
#ifndef DOXYGEN
-template <>
-void
-QProjector<1>::project_to_face(const Quadrature<0> &,
- const unsigned int,
- std::vector<Point<1>> &);
template <>
void
QProjector<1>::project_to_face(const ReferenceCell reference_cell,
std::vector<Point<1>> &);
template <>
void
-QProjector<2>::project_to_face(const Quadrature<1> & quadrature,
- const unsigned int face_no,
- std::vector<Point<2>> &q_points);
-template <>
-void
QProjector<2>::project_to_face(const ReferenceCell reference_cell,
const Quadrature<1> & quadrature,
const unsigned int face_no,
std::vector<Point<2>> &q_points);
template <>
void
-QProjector<3>::project_to_face(const Quadrature<2> & quadrature,
- const unsigned int face_no,
- std::vector<Point<3>> &q_points);
-template <>
-void
QProjector<3>::project_to_face(const ReferenceCell reference_cell,
const Quadrature<2> & quadrature,
const unsigned int face_no,
const hp::QCollection<0> &quadrature);
-template <>
-void
-QProjector<1>::project_to_subface(const Quadrature<0> &,
- const unsigned int,
- const unsigned int,
- std::vector<Point<1>> &,
- const RefinementCase<0> &);
template <>
void
QProjector<1>::project_to_subface(const ReferenceCell reference_cell,
const RefinementCase<0> &);
template <>
void
-QProjector<2>::project_to_subface(const Quadrature<1> & quadrature,
- const unsigned int face_no,
- const unsigned int subface_no,
- std::vector<Point<2>> &q_points,
- const RefinementCase<1> &);
-template <>
-void
QProjector<2>::project_to_subface(const ReferenceCell reference_cell,
const Quadrature<1> & quadrature,
const unsigned int face_no,
const RefinementCase<1> &);
template <>
void
-QProjector<3>::project_to_subface(const Quadrature<2> & quadrature,
- const unsigned int face_no,
- const unsigned int subface_no,
- std::vector<Point<3>> & q_points,
- const RefinementCase<2> &face_ref_case);
-template <>
-void
QProjector<3>::project_to_subface(const ReferenceCell reference_cell,
const Quadrature<2> & quadrature,
const unsigned int face_no,
std::vector<Point<3>> & q_points,
const RefinementCase<2> &face_ref_case);
-template <>
-Quadrature<1>
-QProjector<1>::project_to_all_subfaces(const Quadrature<0> &quadrature);
template <>
Quadrature<1>
QProjector<1>::project_to_all_subfaces(const ReferenceCell reference_cell,
{
edge_quadrature_collection.push_back(
QProjector<dim>::project_to_face(
+ ReferenceCells::get_hypercube<dim>(),
QProjector<dim - 1>::project_to_face(
- reference_edge_quadrature, line),
+ ReferenceCells::get_hypercube<dim - 1>(),
+ reference_edge_quadrature,
+ line),
face));
}
}
hp::QCollection<dim> quadrature_collection;
for (unsigned int face : GeometryInfo<dim>::face_indices())
- quadrature_collection.push_back(
- QProjector<dim>::project_to_face(face_quadrature, face));
+ quadrature_collection.push_back(QProjector<dim>::project_to_face(
+ ReferenceCells::get_hypercube<dim>(), face_quadrature, face));
hp::FEValues<dim> fe_values(mapping_collection,
fe_collection,
face_quadrature_collection.push_back(quadrature);
for (unsigned int face : GeometryInfo<dim>::face_indices())
- quadrature_collection.push_back(
- QProjector<dim>::project_to_face(quadrature, face));
+ quadrature_collection.push_back(QProjector<dim>::project_to_face(
+ ReferenceCells::get_hypercube<dim>(), quadrature, face));
}
hp::FEFaceValues<dim> fe_face_values(mapping_collection,
-template <>
-void
-QProjector<1>::project_to_face(const Quadrature<0> & quadrature,
- const unsigned int face_no,
- std::vector<Point<1>> &q_points)
-{
- project_to_face(ReferenceCells::Line, quadrature, face_no, q_points);
-}
-
-
-
template <>
void
QProjector<1>::project_to_face(const ReferenceCell reference_cell,
-template <>
-void
-QProjector<2>::project_to_face(const Quadrature<1> & quadrature,
- const unsigned int face_no,
- std::vector<Point<2>> &q_points)
-{
- project_to_face(ReferenceCells::Quadrilateral, quadrature, face_no, q_points);
-}
-
-
-
template <>
void
QProjector<2>::project_to_face(const ReferenceCell reference_cell,
-template <>
-void
-QProjector<3>::project_to_face(const Quadrature<2> & quadrature,
- const unsigned int face_no,
- std::vector<Point<3>> &q_points)
-{
- project_to_face(ReferenceCells::Hexahedron, quadrature, face_no, q_points);
-}
-
-
-
template <>
void
QProjector<3>::project_to_face(const ReferenceCell reference_cell,
-template <>
-void
-QProjector<1>::project_to_subface(const Quadrature<0> & quadrature,
- const unsigned int face_no,
- const unsigned int subface_no,
- std::vector<Point<1>> & q_points,
- const RefinementCase<0> &ref_case)
-{
- project_to_subface(
- ReferenceCells::Line, quadrature, face_no, subface_no, q_points, ref_case);
-}
-
-
-
template <>
void
QProjector<1>::project_to_subface(const ReferenceCell reference_cell,
-template <>
-void
-QProjector<2>::project_to_subface(const Quadrature<1> & quadrature,
- const unsigned int face_no,
- const unsigned int subface_no,
- std::vector<Point<2>> & q_points,
- const RefinementCase<1> &ref_case)
-{
- project_to_subface(ReferenceCells::Quadrilateral,
- quadrature,
- face_no,
- subface_no,
- q_points,
- ref_case);
-}
-
-
-
template <>
void
QProjector<2>::project_to_subface(const ReferenceCell reference_cell,
-template <>
-void
-QProjector<3>::project_to_subface(const Quadrature<2> & quadrature,
- const unsigned int face_no,
- const unsigned int subface_no,
- std::vector<Point<3>> & q_points,
- const RefinementCase<2> &ref_case)
-{
- project_to_subface(ReferenceCells::Hexahedron,
- quadrature,
- face_no,
- subface_no,
- q_points,
- ref_case);
-}
-
-
-
template <>
void
QProjector<3>::project_to_subface(const ReferenceCell reference_cell,
// results
for (unsigned int face = 0; face < n_faces; ++face)
{
- project_to_face(quadrature[quadrature.size() == 1 ? 0 : face],
+ project_to_face(reference_cell,
+ quadrature[quadrature.size() == 1 ? 0 : face],
face,
help);
std::copy(help.begin(), help.end(), std::back_inserter(q_points));
for (unsigned int face = 0; face < n_faces; ++face)
{
help.resize(quadrature[quadrature.size() == 1 ? 0 : face].size());
- project_to_face(quadrature[quadrature.size() == 1 ? 0 : face],
+ project_to_face(reference_cell,
+ quadrature[quadrature.size() == 1 ? 0 : face],
face,
help);
std::copy(help.begin(), help.end(), std::back_inserter(q_points));
}
help.resize(quadrature[quadrature.size() == 1 ? 0 : face].size());
- project_to_face(mutation, face, help);
+ project_to_face(reference_cell, mutation, face, help);
std::copy(help.begin(), help.end(), std::back_inserter(q_points));
std::copy(mutation.get_weights().begin(),
-template <>
-Quadrature<1>
-QProjector<1>::project_to_all_subfaces(const Quadrature<0> &quadrature)
-{
- return project_to_all_subfaces(ReferenceCells::Line, quadrature);
-}
-
-
-
template <>
Quadrature<1>
QProjector<1>::project_to_all_subfaces(const ReferenceCell reference_cell,
for (unsigned int face = 0; face < n_faces; ++face)
for (unsigned int subface = 0; subface < subfaces_per_face; ++subface)
{
- project_to_subface(quadrature, face, subface, help);
+ project_to_subface(reference_cell, quadrature, face, subface, help);
std::copy(help.begin(), help.end(), std::back_inserter(q_points));
}
for (unsigned int face = 0; face < n_faces; ++face)
for (unsigned int subface = 0; subface < subfaces_per_face; ++subface)
{
- project_to_subface(quadrature, face, subface, help);
+ project_to_subface(reference_cell, quadrature, face, subface, help);
std::copy(help.begin(), help.end(), std::back_inserter(q_points));
}
-template <>
-Quadrature<2>
-QProjector<2>::project_to_all_subfaces(const SubQuadrature &quadrature)
-{
- return project_to_all_subfaces(ReferenceCells::Quadrilateral, quadrature);
-}
-
-
-
template <>
Quadrature<3>
QProjector<3>::project_to_all_subfaces(const ReferenceCell reference_cell,
RefinementCase<dim - 1>(ref_case));
++subface)
{
- project_to_subface(mutation,
+ project_to_subface(reference_cell,
+ mutation,
face,
subface,
help,
-template <>
-Quadrature<3>
-QProjector<3>::project_to_all_subfaces(const SubQuadrature &quadrature)
-{
- return project_to_all_subfaces(ReferenceCells::Hexahedron, quadrature);
-}
-
-
-
-// This function is not used in the library
-template <int dim>
-Quadrature<dim>
-QProjector<dim>::project_to_child(const Quadrature<dim> &quadrature,
- const unsigned int child_no)
-{
- return project_to_child(ReferenceCells::get_hypercube<dim>(),
- quadrature,
- child_no);
-}
-
-
-
template <int dim>
Quadrature<dim>
QProjector<dim>::project_to_child(const ReferenceCell reference_cell,
-template <int dim>
-Quadrature<dim>
-QProjector<dim>::project_to_all_children(const Quadrature<dim> &quadrature)
-{
- return project_to_all_children(ReferenceCells::get_hypercube<dim>(),
- quadrature);
-}
-
-
-
template <int dim>
Quadrature<dim>
QProjector<dim>::project_to_all_children(const ReferenceCell reference_cell,
// results
for (unsigned int child = 0; child < n_children; ++child)
{
- Quadrature<dim> help = project_to_child(quadrature, child);
+ Quadrature<dim> help =
+ project_to_child(reference_cell, quadrature, child);
for (unsigned int i = 0; i < n_points; ++i)
{
q_points[child * n_points + i] = help.point(i);
-template <int dim>
-Quadrature<dim>
-QProjector<dim>::project_to_line(const Quadrature<1> &quadrature,
- const Point<dim> & p1,
- const Point<dim> & p2)
-{
- return project_to_line(ReferenceCells::get_hypercube<dim>(),
- quadrature,
- p1,
- p2);
-}
-
-
-
template <int dim>
Quadrature<dim>
QProjector<dim>::project_to_line(const ReferenceCell reference_cell,
-template <int dim>
-typename QProjector<dim>::DataSetDescriptor
-QProjector<dim>::DataSetDescriptor::face(const unsigned int face_no,
- const bool face_orientation,
- const bool face_flip,
- const bool face_rotation,
- const unsigned int n_quadrature_points)
-{
- return face(ReferenceCells::get_hypercube<dim>(),
- face_no,
- face_orientation,
- face_flip,
- face_rotation,
- n_quadrature_points);
-}
-
-
-
template <int dim>
typename QProjector<dim>::DataSetDescriptor
QProjector<dim>::DataSetDescriptor::face(const ReferenceCell reference_cell,
-template <>
-QProjector<1>::DataSetDescriptor
-QProjector<1>::DataSetDescriptor::subface(
- const unsigned int face_no,
- const unsigned int subface_no,
- const bool face_orientation,
- const bool face_flip,
- const bool face_rotation,
- const unsigned int n_quadrature_points,
- const internal::SubfaceCase<1> ref_case)
-{
- return subface(ReferenceCells::Line,
- face_no,
- subface_no,
- face_orientation,
- face_flip,
- face_rotation,
- n_quadrature_points,
- ref_case);
-}
-
-
-
template <>
QProjector<2>::DataSetDescriptor
QProjector<2>::DataSetDescriptor::subface(
-template <>
-QProjector<2>::DataSetDescriptor
-QProjector<2>::DataSetDescriptor::subface(
- const unsigned int face_no,
- const unsigned int subface_no,
- const bool face_orientation,
- const bool face_flip,
- const bool face_rotation,
- const unsigned int n_quadrature_points,
- const internal::SubfaceCase<2> ref_case)
-{
- return subface(ReferenceCells::Quadrilateral,
- face_no,
- subface_no,
- face_orientation,
- face_flip,
- face_rotation,
- n_quadrature_points,
- ref_case);
-}
-
-
template <>
QProjector<3>::DataSetDescriptor
QProjector<3>::DataSetDescriptor::subface(
}
-template <>
-QProjector<3>::DataSetDescriptor
-QProjector<3>::DataSetDescriptor::subface(
- const unsigned int face_no,
- const unsigned int subface_no,
- const bool face_orientation,
- const bool face_flip,
- const bool face_rotation,
- const unsigned int n_quadrature_points,
- const internal::SubfaceCase<3> ref_case)
-{
- return subface(ReferenceCells::Hexahedron,
- face_no,
- subface_no,
- face_orientation,
- face_flip,
- face_rotation,
- n_quadrature_points,
- ref_case);
-}
-
-
-
-template <int dim>
-Quadrature<dim>
-QProjector<dim>::project_to_face(const SubQuadrature &quadrature,
- const unsigned int face_no)
-{
- return project_to_face(ReferenceCells::get_hypercube<dim>(),
- quadrature,
- face_no);
-}
-
-
template <int dim>
Quadrature<dim>
(void)reference_cell;
std::vector<Point<dim>> points(quadrature.size());
- project_to_face(quadrature, face_no, points);
+ project_to_face(reference_cell, quadrature, face_no, points);
return Quadrature<dim>(points, quadrature.get_weights());
}
-template <int dim>
-Quadrature<dim>
-QProjector<dim>::project_to_subface(const SubQuadrature & quadrature,
- const unsigned int face_no,
- const unsigned int subface_no,
- const RefinementCase<dim - 1> &ref_case)
-{
- return project_to_subface(ReferenceCells::get_hypercube<dim>(),
- quadrature,
- face_no,
- subface_no,
- ref_case);
-}
-
-
-
template <int dim>
Quadrature<dim>
QProjector<dim>::project_to_subface(const ReferenceCell reference_cell,
(void)reference_cell;
std::vector<Point<dim>> points(quadrature.size());
- project_to_subface(quadrature, face_no, subface_no, points, ref_case);
+ project_to_subface(
+ reference_cell, quadrature, face_no, subface_no, points, ref_case);
return Quadrature<dim>(points, quadrature.get_weights());
}
Quadrature<dim - 1> quadrature(boundary_points, dummy_weights);
q_projector = QProjector<dim>::project_to_all_faces(
- dealii::ReferenceCells::Quadrilateral, quadrature);
+ dealii::ReferenceCells::get_hypercube<dim>(), quadrature);
}
for (const auto &cell : tria.active_cell_iterators())
// tensor product of points, only one copy
QIterated<dim - 1> quadrature(quadrature1d, 1);
q_projector = std::make_unique<Quadrature<dim>>(
- QProjector<dim>::project_to_all_faces(quadrature));
+ QProjector<dim>::project_to_all_faces(
+ ReferenceCells::get_hypercube<dim>(), quadrature));
}
for (const auto &cell : tria.active_cell_iterators())
Quadrature<dim - 1> quadrature(boundary_points);
Quadrature<dim> q_projector(
- QProjector<dim>::project_to_all_faces(quadrature));
+ QProjector<dim>::project_to_all_faces(
+ ReferenceCells::get_hypercube<dim>(), quadrature));
// next loop over all
// boundary faces and
p1(2) = 0;
p2(2) = 10.;
}
- Quadrature<dim> q = QProjector<dim>::project_to_line(quadrature, p1, p2);
- double s = 0.;
+ Quadrature<dim> q = QProjector<dim>::project_to_line(
+ ReferenceCells::get_hypercube<dim>(), quadrature, p1, p2);
+ double s = 0.;
for (unsigned int k = 0; k < q.size(); ++k)
{
deallog << "Face " << f << std::endl;
Quadrature<dim> quadrature =
- QProjector<dim>::project_to_face(subquadrature, f);
+ QProjector<dim>::project_to_face(ReferenceCells::get_hypercube<dim>(),
+ subquadrature,
+ f);
for (unsigned int k = 0; k < quadrature.size(); ++k)
deallog << quadrature.point(k) << std::endl;
}
deallog << "Face " << f << " subface " << s << std::endl;
Quadrature<dim> quadrature =
- QProjector<dim>::project_to_face(subquadrature, f);
+ QProjector<dim>::project_to_face(ReferenceCells::get_hypercube<dim>(),
+ subquadrature,
+ f);
for (unsigned int k = 0; k < quadrature.size(); ++k)
deallog << quadrature.point(k) << std::endl;
}
Quadrature<dim - 1> subquadrature(q1);
const unsigned int nqs = subquadrature.size();
- Quadrature<dim> faces = QProjector<dim>::project_to_all_faces(subquadrature);
+ Quadrature<dim> faces =
+ QProjector<dim>::project_to_all_faces(ReferenceCells::get_hypercube<dim>(),
+ subquadrature);
for (const unsigned int f : GeometryInfo<dim>::face_indices())
{
deallog << "Face " << f << " orientation false" << std::endl;
- unsigned int offset =
- QProjector<dim>::DataSetDescriptor::face(f, false, false, false, nqs);
+ unsigned int offset = QProjector<dim>::DataSetDescriptor::face(
+ ReferenceCells::get_hypercube<dim>(), f, false, false, false, nqs);
for (unsigned int k = 0; k < nqs; ++k)
deallog << faces.point(offset + k) << std::endl;
deallog << "Face " << f << " orientation true" << std::endl;
- offset =
- QProjector<dim>::DataSetDescriptor::face(f, true, false, false, nqs);
+ offset = QProjector<dim>::DataSetDescriptor::face(
+ ReferenceCells::get_hypercube<dim>(), f, true, false, false, nqs);
for (unsigned int k = 0; k < nqs; ++k)
deallog << faces.point(offset + k) << std::endl;
{
Quadrature<dim> quadrature(
sub == false ?
- QProjector<dim>::project_to_all_faces(*quadratures[n]) :
- QProjector<dim>::project_to_all_subfaces(*quadratures[n]));
+ QProjector<dim>::project_to_all_faces(
+ ReferenceCells::get_hypercube<dim>(), *quadratures[n]) :
+ QProjector<dim>::project_to_all_subfaces(
+ ReferenceCells::get_hypercube<dim>(), *quadratures[n]));
const std::vector<Point<dim>> &points = quadrature.get_points();
const std::vector<double> & weights = quadrature.get_weights();
{
Quadrature<dim> quadrature(
sub == false ?
- QProjector<dim>::project_to_all_faces(*quadratures[n]) :
- QProjector<dim>::project_to_all_subfaces(*quadratures[n]));
+ QProjector<dim>::project_to_all_faces(
+ ReferenceCells::get_hypercube<dim>(), *quadratures[n]) :
+ QProjector<dim>::project_to_all_subfaces(
+ ReferenceCells::get_hypercube<dim>(), *quadratures[n]));
const std::vector<Point<dim>> &points = quadrature.get_points();
const std::vector<double> & weights = quadrature.get_weights();
for (const unsigned int i : GeometryInfo<dim>::face_indices())
{
std::vector<Point<dim>> q_points(q.get_points().size());
- QProjector<dim>::project_to_face(q, i, q_points);
+ QProjector<dim>::project_to_face(ReferenceCells::get_hypercube<dim>(),
+ q,
+ i,
+ q_points);
Quadrature<dim> qp(q_points);
deallog << name << '<' << dim << '>' << " face " << i << " support points"
<< std::endl;
// This quadrature rule determines the points, where the
// continuity will be tested.
QGauss<1> quad(6);
- Quadrature<2> qproject = QProjector<2>::project_to_all_faces(quad);
+ Quadrature<2> qproject =
+ QProjector<2>::project_to_all_faces(ReferenceCells::Quadrilateral, quad);
FEFaceValues<2> fe_v_face(
dof_handler->get_fe(),
if (!cell->face(f)->at_boundary())
{
const QProjector<2>::DataSetDescriptor offset =
- (QProjector<2>::DataSetDescriptor::face(f,
- cell->face_orientation(
- f),
- cell->face_flip(f),
- cell->face_rotation(f),
- quad.size()));
+ (QProjector<2>::DataSetDescriptor::face(
+ ReferenceCells::Quadrilateral,
+ f,
+ cell->face_orientation(f),
+ cell->face_flip(f),
+ cell->face_rotation(f),
+ quad.size()));
fe_v_face.reinit(cell, f);
DoFHandler<2>::active_cell_iterator cell_n = cell->neighbor(f);
const QProjector<2>::DataSetDescriptor offset_n =
(QProjector<2>::DataSetDescriptor::face(
+ ReferenceCells::Quadrilateral,
neighbor,
cell_n->face_orientation(neighbor),
cell_n->face_flip(neighbor),
projects / dealii.git / commitdiff