]> https://gitweb.dealii.org/ - dealii.git/commitdiff
Remove deprecated QProjector member functions 14043/head
authorDaniel Arndt <arndtd@ornl.gov>
Fri, 24 Jun 2022 14:58:51 +0000 (10:58 -0400)
committerDaniel Arndt <arndtd@ornl.gov>
Fri, 24 Jun 2022 15:28:59 +0000 (11:28 -0400)
doc/news/changes/incompatibilities/20220624Arndt [new file with mode: 0644]
include/deal.II/base/qprojector.h
include/deal.II/numerics/vector_tools_boundary.templates.h
source/base/qprojector.cc
source/grid/grid_out.cc
tests/base/qprojector.cc
tests/base/quadrature_sorted_test.cc
tests/base/quadrature_test.cc
tests/fe/fe_support_points_common.h
tests/fe/rt_normal_02.cc

diff --git a/doc/news/changes/incompatibilities/20220624Arndt b/doc/news/changes/incompatibilities/20220624Arndt
new file mode 100644 (file)
index 0000000..67b3302
--- /dev/null
@@ -0,0 +1,4 @@
+Removed: The deprecated member functions of QProjector not using a ReferenceCell
+object have been removed.
+<br>
+(Daniel Arndt, 2022/06/24)
index 7d69d3f5100e9b522887f1577553a6cf45c257d9..45c98f972ac2ec6442a6c2e2e1ee159ec99d313a 100644 (file)
@@ -86,20 +86,6 @@ public:
    */
   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
@@ -111,18 +97,6 @@ public:
                   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
@@ -133,27 +107,6 @@ public:
                   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>
@@ -172,26 +125,6 @@ public:
                      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
@@ -213,29 +146,6 @@ public:
                      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
@@ -264,26 +174,6 @@ public:
   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
@@ -301,24 +191,6 @@ public:
   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
@@ -334,22 +206,6 @@ public:
                    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
@@ -363,19 +219,6 @@ public:
   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>.
@@ -415,27 +258,6 @@ public:
     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
@@ -466,32 +288,6 @@ public:
          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
@@ -575,14 +371,6 @@ inline QProjector<dim>::DataSetDescriptor::operator unsigned int() const
 
 
 
-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,
@@ -598,11 +386,6 @@ Quadrature<dim> inline QProjector<dim>::project_to_all_faces(
 #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,
@@ -611,22 +394,12 @@ 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,
@@ -638,13 +411,6 @@ QProjector<1>::project_to_all_faces(const ReferenceCell       reference_cell,
                                     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,
@@ -655,13 +421,6 @@ 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,
@@ -670,13 +429,6 @@ QProjector<2>::project_to_subface(const ReferenceCell    reference_cell,
                                   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,
@@ -684,9 +436,6 @@ QProjector<3>::project_to_subface(const ReferenceCell      reference_cell,
                                   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,
index ad0a9b9700d0dfa86d90d4d35c706e8f5d6f3bed..938a8018bc50bceeeabaec0b51172f4b3ab044d3 100644 (file)
@@ -1968,8 +1968,11 @@ namespace VectorTools
                         {
                           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));
                         }
                     }
@@ -2401,8 +2404,8 @@ namespace VectorTools
     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,
@@ -2563,8 +2566,8 @@ namespace VectorTools
         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,
index 5dddf213aa0eb1feff9566d2bd721cdeca4bc44d..5b5e763010c52ef84384ecefa5e6b06140a96c67 100644 (file)
@@ -79,17 +79,6 @@ namespace internal
 
 
 
-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,
@@ -109,17 +98,6 @@ 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,
@@ -182,17 +160,6 @@ 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,
@@ -243,20 +210,6 @@ 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,
@@ -278,24 +231,6 @@ 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,
@@ -440,24 +375,6 @@ 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,
@@ -571,7 +488,8 @@ QProjector<1>::project_to_all_faces(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));
@@ -694,7 +612,8 @@ QProjector<2>::project_to_all_faces(const ReferenceCell       reference_cell,
   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));
@@ -1006,7 +925,7 @@ QProjector<3>::project_to_all_faces(const ReferenceCell       reference_cell,
             }
 
           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(),
@@ -1024,15 +943,6 @@ QProjector<3>::project_to_all_faces(const ReferenceCell       reference_cell,
 
 
 
-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,
@@ -1057,7 +967,7 @@ 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));
       }
 
@@ -1108,7 +1018,7 @@ QProjector<2>::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));
       }
 
@@ -1131,15 +1041,6 @@ QProjector<2>::project_to_all_subfaces(const ReferenceCell  reference_cell,
 
 
 
-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,
@@ -1191,7 +1092,8 @@ 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,
@@ -1223,28 +1125,6 @@ QProjector<3>::project_to_all_subfaces(const ReferenceCell  reference_cell,
 
 
 
-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,
@@ -1277,16 +1157,6 @@ 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,
@@ -1306,7 +1176,8 @@ 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);
@@ -1318,20 +1189,6 @@ QProjector<dim>::project_to_all_children(const ReferenceCell    reference_cell,
 
 
 
-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,
@@ -1360,24 +1217,6 @@ 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,
@@ -1629,29 +1468,6 @@ QProjector<1>::DataSetDescriptor::subface(
 
 
 
-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(
@@ -1677,28 +1493,6 @@ 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(
@@ -1956,40 +1750,6 @@ 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>
@@ -2002,28 +1762,12 @@ QProjector<dim>::project_to_face(const ReferenceCell  reference_cell,
   (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,
@@ -2037,7 +1781,8 @@ 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());
 }
 
index 1ff6b1f1fecc9d4a6e83fda8c86fd83b9a65cfe4..935701648923dc25fa6c9016fd80c6baaee62e92 100644 (file)
@@ -4233,7 +4233,7 @@ namespace internal
           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())
@@ -4347,7 +4347,8 @@ namespace internal
           // 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())
@@ -4770,7 +4771,8 @@ namespace internal
 
                   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
index 2037d4b586c1ae21ea1710cd31836866b4a47ce1..cf66df28f25188f73fe63183176f0b7267dcce45 100644 (file)
@@ -40,8 +40,9 @@ check_line(Quadrature<1> &quadrature)
       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)
     {
@@ -63,7 +64,9 @@ check_face(Quadrature<1> &q1)
       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;
     }
@@ -74,7 +77,9 @@ check_face(Quadrature<1> &q1)
         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;
       }
@@ -92,22 +97,24 @@ check_faces(Quadrature<1> &q1)
   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;
index 4bd201870645fef475cef3690123d7633620e79a..bef2afcbf9d164caf020756c4f0fd394064bad2c 100644 (file)
@@ -112,8 +112,10 @@ check_faces(const std::vector<Quadrature<dim - 1> *> &quadratures,
     {
       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();
 
index f7f69ac728dfc6f57b6292ccff5a5540704917f2..362d810ffd1b1ee8029934d1c7d09a8198de36dc 100644 (file)
@@ -127,8 +127,10 @@ check_faces(const std::vector<Quadrature<dim - 1> *> &quadratures,
     {
       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();
 
index 7c1979d538e7e3e1a3bdc38c09265ee7efb8992c..de39b504b7208a1b41e4ba66838610fa36a0751d 100644 (file)
@@ -72,7 +72,10 @@ check_support(const FiniteElement<dim> &finel, const char *name)
   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;
index 1b54664863b25314250d12cc0dba2b8280a00980..4c6e559d34d106a8968aeef200eb6c7b39ef901a 100644 (file)
@@ -65,7 +65,8 @@ EvaluateNormal2(DoFHandler<2> *dof_handler, Vector<double> &solution)
   // 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(),
@@ -107,12 +108,13 @@ EvaluateNormal2(DoFHandler<2> *dof_handler, Vector<double> &solution)
           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);
@@ -121,6 +123,7 @@ EvaluateNormal2(DoFHandler<2> *dof_handler, Vector<double> &solution)
 
               const QProjector<2>::DataSetDescriptor offset_n =
                 (QProjector<2>::DataSetDescriptor::face(
+                  ReferenceCells::Quadrilateral,
                   neighbor,
                   cell_n->face_orientation(neighbor),
                   cell_n->face_flip(neighbor),

In the beginning the Universe was created. This has made a lot of people very angry and has been widely regarded as a bad move.

Douglas Adams


Typeset in Trocchi and Trocchi Bold Sans Serif.