From: Peter Munch <peterrmuench@gmail.com>
Date: Thu, 25 Feb 2021 08:40:25 +0000 (+0100)
Subject: Remove Simplex namespace
X-Git-Tag: v9.3.0-rc1~412^2
X-Git-Url: https://gitweb.dealii.org/cgi-bin/gitweb.cgi?a=commitdiff_plain;h=6297dbe1aff8914c0bfbf38ba3d4d22c89ae02d9;p=dealii.git

Remove Simplex namespace
---

diff --git a/doc/news/changes/incompatibilities/20201212Munch b/doc/news/changes/incompatibilities/20201212Munch
index 4ecd10bb7d..4c5dfd21c5 100644
--- a/doc/news/changes/incompatibilities/20201212Munch
+++ b/doc/news/changes/incompatibilities/20201212Munch
@@ -1,6 +1,6 @@
 Changed: The interface of FE::fill_fe_face_values() now accepts instead
 of a Quadrature instance a hp::QCollection instance, enabling the evaluation of
 shape functions for different quadrature formulas on different faces for
-FiniteElement classes with supports for this feature (e.g. FE_Q, Simplex::FE_P). 
+FiniteElement classes with supports for this feature (e.g. FE_Q, FE_SimplexP). 
 <br>
 (Peter Munch, 2020/12/12)
diff --git a/doc/news/changes/major/20210126DavidWells b/doc/news/changes/major/20210126DavidWells
index 52af3ceaf3..bc1b33844a 100644
--- a/doc/news/changes/major/20210126DavidWells
+++ b/doc/news/changes/major/20210126DavidWells
@@ -1,4 +1,4 @@
-New: Added a new finite element Simplex::FE_P_Bubbles suitable for using mass
+New: Added a new finite element FE_SimplexP_Bubbles suitable for using mass
 lumping on simplex meshes.
 <br>
 (David Wells, 2021/01/26)
diff --git a/doc/news/changes/major/20210126DavidWells-2 b/doc/news/changes/major/20210126DavidWells-2
index 0011dbe6fe..9c9322fc09 100644
--- a/doc/news/changes/major/20210126DavidWells-2
+++ b/doc/news/changes/major/20210126DavidWells-2
@@ -1,4 +1,4 @@
-New: Added a new class Simplex::BarycentricPolynomial that makes defining
+New: Added a new class BarycentricPolynomial that makes defining
 polynomials on simplices much easier.
 <br>
 (David Wells, 2021/01/26)
diff --git a/doc/news/changes/major/20210208DavidWells b/doc/news/changes/major/20210208DavidWells
index c6b3fb39ef..4ed24ddb94 100644
--- a/doc/news/changes/major/20210208DavidWells
+++ b/doc/news/changes/major/20210208DavidWells
@@ -1,3 +1,3 @@
-New: Added a new quadrature rule Simplex::QWitherdenVincent for simplices.
+New: Added a new quadrature rule QWitherdenVincent for simplices.
 <br>
 (David Wells, 2021/02/08)
diff --git a/doc/news/changes/minor/20200704Munch b/doc/news/changes/minor/20200704Munch
deleted file mode 100644
index 858dbcb751..0000000000
--- a/doc/news/changes/minor/20200704Munch
+++ /dev/null
@@ -1,4 +0,0 @@
-New: The new class Simplex::ScalarPolynomial provides polynomials defined on 
-simplices.
-<br>
-(Peter Munch, 2020/07/02)
diff --git a/include/deal.II/base/polynomials_barycentric.h b/include/deal.II/base/polynomials_barycentric.h
index 8596ef0744..14c8349537 100644
--- a/include/deal.II/base/polynomials_barycentric.h
+++ b/include/deal.II/base/polynomials_barycentric.h
@@ -25,691 +25,684 @@
 
 DEAL_II_NAMESPACE_OPEN
 
-namespace Simplex
+/**
+ * Polynomial implemented in barycentric coordinates.
+ *
+ * Barycentric coordinates are a coordinate system defined on simplices that
+ * are particularly easy to work with since they express coordinates in the
+ * simplex as convex combinations of the vertices. For example, any point in a
+ * triangle can be written as
+ *
+ * @f[
+ *   (x, y) = c_0 (x_0, y_0) + c_1 (x_1, y_1) + c_2 (x_2, y_2).
+ * @f]
+ *
+ * where each value $c_i$ is the relative weight of each vertex (so the
+ * centroid is, in 2D, where each $c_i = 1/3$). Since we only consider convex
+ * combinations we can rewrite this equation as
+ *
+ * @f[
+ *   (x, y) = (1 - c_1 - c_2) (x_0, y_0) + c_1 (x_1, y_1) + c_2 (x_2, y_2).
+ * @f]
+ *
+ * This results in three polynomials that are equivalent to $P^1$ in 2D. More
+ * exactly, this class implements a polynomial space defined with the basis,
+ * in 2D, of
+ * @f{align*}{
+ * t_0(x, y) &= 1 - x - y \\
+ * t_1(x, y) &= x \\
+ * t_2(x, y) &= y
+ * @f}
+ * and, in 3D,
+ * @f{align*}{
+ * t_0(x, y) &= 1 - x - y - z \\
+ * t_1(x, y) &= x             \\
+ * t_2(x, y) &= y             \\
+ * t_2(x, y) &= z
+ * @f}
+ *
+ * which is, in practice, a very convenient basis for defining simplex
+ * polynomials: for example, the fourth basis function of a TRI6 element is
+ *
+ * @f[
+ * 4 * t_1(x, y) * t_2(x, y).
+ * @f]
+ *
+ * Barycentric polynomials in <code>dim</code>-dimensional space have
+ * <code>dim + 1</code> variables in since <code>t_0</code> can be written in
+ * terms of the other monomials.
+ *
+ * Monomials can be conveniently constructed with
+ * BarycentricPolynomial::monomial().
+ *
+ * @ingroup Polynomials
+ */
+template <int dim, typename Number = double>
+class BarycentricPolynomial
 {
+public:
   /**
-   * Polynomial implemented in barycentric coordinates.
-   *
-   * Barycentric coordinates are a coordinate system defined on simplices that
-   * are particularly easy to work with since they express coordinates in the
-   * simplex as convex combinations of the vertices. For example, any point in a
-   * triangle can be written as
-   *
-   * @f[
-   *   (x, y) = c_0 (x_0, y_0) + c_1 (x_1, y_1) + c_2 (x_2, y_2).
-   * @f]
-   *
-   * where each value $c_i$ is the relative weight of each vertex (so the
-   * centroid is, in 2D, where each $c_i = 1/3$). Since we only consider convex
-   * combinations we can rewrite this equation as
-   *
-   * @f[
-   *   (x, y) = (1 - c_1 - c_2) (x_0, y_0) + c_1 (x_1, y_1) + c_2 (x_2, y_2).
-   * @f]
-   *
-   * This results in three polynomials that are equivalent to $P^1$ in 2D. More
-   * exactly, this class implements a polynomial space defined with the basis,
-   * in 2D, of
-   * @f{align*}{
-   * t_0(x, y) &= 1 - x - y \\
-   * t_1(x, y) &= x \\
-   * t_2(x, y) &= y
-   * @f}
-   * and, in 3D,
-   * @f{align*}{
-   * t_0(x, y) &= 1 - x - y - z \\
-   * t_1(x, y) &= x             \\
-   * t_2(x, y) &= y             \\
-   * t_2(x, y) &= z
-   * @f}
-   *
-   * which is, in practice, a very convenient basis for defining simplex
-   * polynomials: for example, the fourth basis function of a TRI6 element is
-   *
-   * @f[
-   * 4 * t_1(x, y) * t_2(x, y).
-   * @f]
-   *
-   * Barycentric polynomials in <code>dim</code>-dimensional space have
-   * <code>dim + 1</code> variables in since <code>t_0</code> can be written in
-   * terms of the other monomials.
-   *
-   * Monomials can be conveniently constructed with
-   * BarycentricPolynomial::monomial().
-   *
-   * @ingroup Polynomials
-   */
-  template <int dim, typename Number = double>
-  class BarycentricPolynomial
-  {
-  public:
-    /**
-     * Constructor for the zero polynomial.
-     */
-    BarycentricPolynomial();
-
-    /**
-     * Constructor for a monomial.
-     */
-    BarycentricPolynomial(const TableIndices<dim + 1> &powers,
-                          const Number                 coefficient);
-
-    /**
-     * Return the specified monomial.
-     */
-    static BarycentricPolynomial<dim, Number>
-    monomial(const unsigned int d);
-
-    /**
-     * Print the polynomial to the output stream with lowest-order terms first.
-     * For example, the first P6 basis function is printed as
-     * <code>-1 * t0^1 + 2 * t0^2</code>, where <code>t0</code> is the first
-     * barycentric variable, <code>t1</code> is the second, etc.
-     */
-    void
-    print(std::ostream &out) const;
-
-    /**
-     * Degree of each barycentric polynomial.
-     */
-    TableIndices<dim + 1>
-    degrees() const;
-
-    /**
-     * Unary minus.
-     */
-    BarycentricPolynomial<dim, Number>
-    operator-() const;
-
-    /**
-     * Add a scalar.
-     */
-    template <typename Number2>
-    BarycentricPolynomial<dim, Number>
-    operator+(const Number2 &a) const;
-
-    /**
-     * Subtract a scalar.
-     */
-    template <typename Number2>
-    BarycentricPolynomial<dim, Number>
-    operator-(const Number2 &a) const;
-
-    /**
-     * Multiply by a scalar.
-     */
-    template <typename Number2>
-    BarycentricPolynomial<dim, Number> operator*(const Number2 &a) const;
-
-    /**
-     * Divide by a scalar.
-     */
-    template <typename Number2>
-    BarycentricPolynomial<dim, Number>
-    operator/(const Number2 &a) const;
-
-    /**
-     * Add another barycentric polynomial.
-     */
-    BarycentricPolynomial<dim, Number>
-    operator+(const BarycentricPolynomial<dim, Number> &augend) const;
-
-    /**
-     * Subtract another barycentric polynomial.
-     */
-    BarycentricPolynomial<dim, Number>
-    operator-(const BarycentricPolynomial<dim, Number> &augend) const;
-
-    /**
-     * Multiply by another barycentric polynomial.
-     */
-    BarycentricPolynomial<dim, Number>
-    operator*(const BarycentricPolynomial<dim, Number> &multiplicand) const;
-
-    /**
-     * Differentiate in barycentric coordinates.
-     */
-    BarycentricPolynomial<dim, Number>
-    barycentric_derivative(const unsigned int coordinate) const;
-
-    /**
-     * Differentiate in Cartesian coordinates.
-     */
-    BarycentricPolynomial<dim, Number>
-    derivative(const unsigned int coordinate) const;
-
-    /**
-     * Evaluate the polynomial.
-     */
-    Number
-    value(const Point<dim> &point) const;
-
-    /**
-     * Return an estimate, in bytes, of the memory usage of the object.
-     */
-    std::size_t
-    memory_consumption() const;
-
-  protected:
-    /**
-     * Coefficients of the polynomial. The exponents are the integer indexes.
-     */
-    Table<dim + 1, Number> coefficients;
-
-    /**
-     * Utility function for barycentric polynomials - its convenient to loop
-     * over all the indices at once in a dimension-independent way, but we also
-     * need to access the actual indices of the underlying Table object. This
-     * utility function converts an integral index into the equivalent
-     * TableIndices array (which are also the implicitly stored polynomial
-     * exponents).
-     */
-    static TableIndices<dim + 1>
-    index_to_indices(const std::size_t &          index,
-                     const TableIndices<dim + 1> &extent);
-  };
+   * Constructor for the zero polynomial.
+   */
+  BarycentricPolynomial();
 
   /**
-   * Scalar polynomial space based on barycentric polynomials.
-   */
-  template <int dim>
-  class BarycentricPolynomials : public ScalarPolynomialsBase<dim>
-  {
-  public:
-    /**
-     * Make the dimension available to the outside.
-     */
-    static const unsigned int dimension = dim;
-
-    /**
-     * Get the standard Lagrange basis for a specified degree.
-     */
-    static BarycentricPolynomials<dim>
-    get_fe_p_basis(const unsigned int degree);
-
-    /**
-     * Constructor taking the polynomial @p degree as input.
-     */
-    BarycentricPolynomials(
-      const std::vector<BarycentricPolynomial<dim>> &polynomials);
-
-    /**
-     * Access operator.
-     */
-    const BarycentricPolynomial<dim> &operator[](const std::size_t i) const;
-
-    /**
-     * @copydoc ScalarPolynomialsBase::evaluate()
-     */
-    void
-    evaluate(const Point<dim> &           unit_point,
-             std::vector<double> &        values,
-             std::vector<Tensor<1, dim>> &grads,
-             std::vector<Tensor<2, dim>> &grad_grads,
-             std::vector<Tensor<3, dim>> &third_derivatives,
-             std::vector<Tensor<4, dim>> &fourth_derivatives) const override;
-
-    /**
-     * @copydoc ScalarPolynomialsBase::compute_value()
-     */
-    double
-    compute_value(const unsigned int i, const Point<dim> &p) const override;
-
-    /**
-     * @copydoc ScalarPolynomialsBase::compute_1st_derivative()
-     */
-    Tensor<1, dim>
-    compute_1st_derivative(const unsigned int i,
-                           const Point<dim> & p) const override;
-
-    /**
-     * @copydoc ScalarPolynomialsBase::compute_2nd_derivative()
-     */
-    Tensor<2, dim>
-    compute_2nd_derivative(const unsigned int i,
-                           const Point<dim> & p) const override;
-
-    /**
-     * @copydoc ScalarPolynomialsBase::compute_3rd_derivative()
-     */
-    Tensor<3, dim>
-    compute_3rd_derivative(const unsigned int i,
-                           const Point<dim> & p) const override;
-
-    /**
-     * @copydoc ScalarPolynomialsBase::compute_4th_derivative()
-     */
-    Tensor<4, dim>
-    compute_4th_derivative(const unsigned int i,
-                           const Point<dim> & p) const override;
-
-    /**
-     * @copydoc ScalarPolynomialsBase::compute_grad()
-     */
-    Tensor<1, dim>
-    compute_grad(const unsigned int i, const Point<dim> &p) const override;
-
-    /**
-     * @copydoc ScalarPolynomialsBase::compute_grad_grad()
-     */
-    Tensor<2, dim>
-    compute_grad_grad(const unsigned int i, const Point<dim> &p) const override;
-
-    /**
-     * @copydoc ScalarPolynomialsBase::memory_consumption()
-     */
-    virtual std::size_t
-    memory_consumption() const override;
-
-    /**
-     * @copydoc ScalarPolynomialsBase::name()
-     */
-    std::string
-    name() const override;
-
-    /**
-     * @copydoc ScalarPolynomialsBase::clone()
-     */
-    virtual std::unique_ptr<ScalarPolynomialsBase<dim>>
-    clone() const override;
-
-  protected:
-    std::vector<BarycentricPolynomial<dim>> polys;
-
-    Table<2, BarycentricPolynomial<dim>> poly_grads;
-
-    Table<3, BarycentricPolynomial<dim>> poly_hessians;
-
-    Table<4, BarycentricPolynomial<dim>> poly_third_derivatives;
-
-    Table<5, BarycentricPolynomial<dim>> poly_fourth_derivatives;
-  };
+   * Constructor for a monomial.
+   */
+  BarycentricPolynomial(const TableIndices<dim + 1> &powers,
+                        const Number                 coefficient);
 
-  // non-member template functions for algebra
+  /**
+   * Return the specified monomial.
+   */
+  static BarycentricPolynomial<dim, Number>
+  monomial(const unsigned int d);
 
   /**
-   * Multiply a Simplex::BarycentricPolynomial by a constant.
+   * Print the polynomial to the output stream with lowest-order terms first.
+   * For example, the first P6 basis function is printed as
+   * <code>-1 * t0^1 + 2 * t0^2</code>, where <code>t0</code> is the first
+   * barycentric variable, <code>t1</code> is the second, etc.
    */
-  template <int dim, typename Number1, typename Number2>
-  BarycentricPolynomial<dim, Number1>
-  operator*(const Number2 &a, const BarycentricPolynomial<dim, Number1> &bp)
-  {
-    return bp * Number1(a);
-  }
+  void
+  print(std::ostream &out) const;
 
   /**
-   * Add a constant to a Simplex::BarycentricPolynomial.
+   * Degree of each barycentric polynomial.
    */
-  template <int dim, typename Number1, typename Number2>
-  BarycentricPolynomial<dim, Number1>
-  operator+(const Number2 &a, const BarycentricPolynomial<dim, Number1> &bp)
-  {
-    return bp + Number1(a);
-  }
+  TableIndices<dim + 1>
+  degrees() const;
 
   /**
-   * Subtract a Simplex::BarycentricPolynomial from a constant.
+   * Unary minus.
    */
-  template <int dim, typename Number1, typename Number2>
-  BarycentricPolynomial<dim, Number1>
-  operator-(const Number2 &a, const BarycentricPolynomial<dim, Number1> &bp)
-  {
-    return bp - Number1(a);
-  }
+  BarycentricPolynomial<dim, Number>
+  operator-() const;
 
   /**
-   * Write a Simplex::BarycentricPolynomial to the provided output stream.
+   * Add a scalar.
    */
-  template <int dim, typename Number>
-  std::ostream &
-  operator<<(std::ostream &out, const BarycentricPolynomial<dim, Number> &bp)
-  {
-    bp.print(out);
-    return out;
-  }
-} // namespace Simplex
+  template <typename Number2>
+  BarycentricPolynomial<dim, Number>
+  operator+(const Number2 &a) const;
 
-// Template function definitions
+  /**
+   * Subtract a scalar.
+   */
+  template <typename Number2>
+  BarycentricPolynomial<dim, Number>
+  operator-(const Number2 &a) const;
 
-namespace Simplex
-{
-  // BarycentricPolynomial:
-  template <int dim, typename Number>
-  BarycentricPolynomial<dim, Number>::BarycentricPolynomial()
-  {
-    TableIndices<dim + 1> extents;
-    for (unsigned int d = 0; d < dim + 1; ++d)
-      extents[d] = 1;
-    coefficients.reinit(extents);
+  /**
+   * Multiply by a scalar.
+   */
+  template <typename Number2>
+  BarycentricPolynomial<dim, Number> operator*(const Number2 &a) const;
 
-    coefficients(TableIndices<dim + 1>{}) = Number();
-  }
+  /**
+   * Divide by a scalar.
+   */
+  template <typename Number2>
+  BarycentricPolynomial<dim, Number>
+  operator/(const Number2 &a) const;
 
+  /**
+   * Add another barycentric polynomial.
+   */
+  BarycentricPolynomial<dim, Number>
+  operator+(const BarycentricPolynomial<dim, Number> &augend) const;
 
+  /**
+   * Subtract another barycentric polynomial.
+   */
+  BarycentricPolynomial<dim, Number>
+  operator-(const BarycentricPolynomial<dim, Number> &augend) const;
 
-  template <int dim, typename Number>
-  BarycentricPolynomial<dim, Number>::BarycentricPolynomial(
-    const TableIndices<dim + 1> &powers,
-    const Number                 coefficient)
-  {
-    TableIndices<dim + 1> extents;
-    for (unsigned int d = 0; d < dim + 1; ++d)
-      extents[d] = powers[d] + 1;
-    coefficients.reinit(extents);
+  /**
+   * Multiply by another barycentric polynomial.
+   */
+  BarycentricPolynomial<dim, Number>
+  operator*(const BarycentricPolynomial<dim, Number> &multiplicand) const;
 
-    coefficients(powers) = coefficient;
-  }
+  /**
+   * Differentiate in barycentric coordinates.
+   */
+  BarycentricPolynomial<dim, Number>
+  barycentric_derivative(const unsigned int coordinate) const;
 
+  /**
+   * Differentiate in Cartesian coordinates.
+   */
+  BarycentricPolynomial<dim, Number>
+  derivative(const unsigned int coordinate) const;
 
+  /**
+   * Evaluate the polynomial.
+   */
+  Number
+  value(const Point<dim> &point) const;
 
-  template <int dim, typename Number>
-  BarycentricPolynomial<dim, Number>
-  BarycentricPolynomial<dim, Number>::monomial(const unsigned int d)
-  {
-    AssertIndexRange(d, dim + 1);
-    TableIndices<dim + 1> indices;
-    indices[d] = 1;
-    return BarycentricPolynomial<dim, Number>(indices, Number(1));
-  }
+  /**
+   * Return an estimate, in bytes, of the memory usage of the object.
+   */
+  std::size_t
+  memory_consumption() const;
+
+protected:
+  /**
+   * Coefficients of the polynomial. The exponents are the integer indexes.
+   */
+  Table<dim + 1, Number> coefficients;
+
+  /**
+   * Utility function for barycentric polynomials - its convenient to loop
+   * over all the indices at once in a dimension-independent way, but we also
+   * need to access the actual indices of the underlying Table object. This
+   * utility function converts an integral index into the equivalent
+   * TableIndices array (which are also the implicitly stored polynomial
+   * exponents).
+   */
+  static TableIndices<dim + 1>
+  index_to_indices(const std::size_t &          index,
+                   const TableIndices<dim + 1> &extent);
+};
+
+/**
+ * Scalar polynomial space based on barycentric polynomials.
+ */
+template <int dim>
+class BarycentricPolynomials : public ScalarPolynomialsBase<dim>
+{
+public:
+  /**
+   * Make the dimension available to the outside.
+   */
+  static const unsigned int dimension = dim;
 
+  /**
+   * Get the standard Lagrange basis for a specified degree.
+   */
+  static BarycentricPolynomials<dim>
+  get_fe_p_basis(const unsigned int degree);
 
+  /**
+   * Constructor taking the polynomial @p degree as input.
+   */
+  BarycentricPolynomials(
+    const std::vector<BarycentricPolynomial<dim>> &polynomials);
 
-  template <int dim, typename Number>
+  /**
+   * Access operator.
+   */
+  const BarycentricPolynomial<dim> &operator[](const std::size_t i) const;
+
+  /**
+   * @copydoc ScalarPolynomialsBase::evaluate()
+   */
   void
-  BarycentricPolynomial<dim, Number>::print(std::ostream &out) const
-  {
-    const auto &coeffs     = this->coefficients;
-    auto        first      = index_to_indices(0, coeffs.size());
-    bool        print_plus = false;
-    if (coeffs(first) != Number())
-      {
-        out << coeffs(first);
-        print_plus = true;
-      }
-    for (std::size_t i = 1; i < coeffs.n_elements(); ++i)
-      {
-        const auto indices = index_to_indices(i, coeffs.size());
-        if (coeffs(indices) == Number())
-          continue;
-        if (print_plus)
-          out << " + ";
-        out << coeffs(indices);
-        for (unsigned int d = 0; d < dim + 1; ++d)
-          {
-            if (indices[d] != 0)
-              out << " * t" << d << '^' << indices[d];
-          }
-        print_plus = true;
-      }
+  evaluate(const Point<dim> &           unit_point,
+           std::vector<double> &        values,
+           std::vector<Tensor<1, dim>> &grads,
+           std::vector<Tensor<2, dim>> &grad_grads,
+           std::vector<Tensor<3, dim>> &third_derivatives,
+           std::vector<Tensor<4, dim>> &fourth_derivatives) const override;
 
-    if (!print_plus)
-      out << Number();
-  }
+  /**
+   * @copydoc ScalarPolynomialsBase::compute_value()
+   */
+  double
+  compute_value(const unsigned int i, const Point<dim> &p) const override;
 
+  /**
+   * @copydoc ScalarPolynomialsBase::compute_1st_derivative()
+   */
+  Tensor<1, dim>
+  compute_1st_derivative(const unsigned int i,
+                         const Point<dim> & p) const override;
 
+  /**
+   * @copydoc ScalarPolynomialsBase::compute_2nd_derivative()
+   */
+  Tensor<2, dim>
+  compute_2nd_derivative(const unsigned int i,
+                         const Point<dim> & p) const override;
 
-  template <int dim, typename Number>
-  TableIndices<dim + 1>
-  BarycentricPolynomial<dim, Number>::degrees() const
-  {
-    auto deg = coefficients.size();
-    for (unsigned int d = 0; d < dim + 1; ++d)
-      deg[d] -= 1;
-    return deg;
-  }
+  /**
+   * @copydoc ScalarPolynomialsBase::compute_3rd_derivative()
+   */
+  Tensor<3, dim>
+  compute_3rd_derivative(const unsigned int i,
+                         const Point<dim> & p) const override;
 
+  /**
+   * @copydoc ScalarPolynomialsBase::compute_4th_derivative()
+   */
+  Tensor<4, dim>
+  compute_4th_derivative(const unsigned int i,
+                         const Point<dim> & p) const override;
 
+  /**
+   * @copydoc ScalarPolynomialsBase::compute_grad()
+   */
+  Tensor<1, dim>
+  compute_grad(const unsigned int i, const Point<dim> &p) const override;
 
-  template <int dim, typename Number>
-  BarycentricPolynomial<dim, Number>
-  BarycentricPolynomial<dim, Number>::operator-() const
-  {
-    return *this * Number(-1);
-  }
+  /**
+   * @copydoc ScalarPolynomialsBase::compute_grad_grad()
+   */
+  Tensor<2, dim>
+  compute_grad_grad(const unsigned int i, const Point<dim> &p) const override;
 
+  /**
+   * @copydoc ScalarPolynomialsBase::memory_consumption()
+   */
+  virtual std::size_t
+  memory_consumption() const override;
 
+  /**
+   * @copydoc ScalarPolynomialsBase::name()
+   */
+  std::string
+  name() const override;
 
-  template <int dim, typename Number>
-  template <typename Number2>
-  BarycentricPolynomial<dim, Number>
-  BarycentricPolynomial<dim, Number>::operator+(const Number2 &a) const
-  {
-    BarycentricPolynomial<dim, Number> result(*this);
-    result.coefficients(index_to_indices(0, result.coefficients.size())) += a;
+  /**
+   * @copydoc ScalarPolynomialsBase::clone()
+   */
+  virtual std::unique_ptr<ScalarPolynomialsBase<dim>>
+  clone() const override;
 
-    return result;
-  }
+protected:
+  std::vector<BarycentricPolynomial<dim>> polys;
 
+  Table<2, BarycentricPolynomial<dim>> poly_grads;
 
+  Table<3, BarycentricPolynomial<dim>> poly_hessians;
 
-  template <int dim, typename Number>
-  template <typename Number2>
-  BarycentricPolynomial<dim, Number>
-  BarycentricPolynomial<dim, Number>::operator-(const Number2 &a) const
-  {
-    return *this + (-a);
-  }
+  Table<4, BarycentricPolynomial<dim>> poly_third_derivatives;
 
+  Table<5, BarycentricPolynomial<dim>> poly_fourth_derivatives;
+};
 
+// non-member template functions for algebra
 
-  template <int dim, typename Number>
-  template <typename Number2>
-  BarycentricPolynomial<dim, Number> BarycentricPolynomial<dim, Number>::
-                                     operator*(const Number2 &a) const
-  {
-    if (a == Number2())
-      {
-        return BarycentricPolynomial<dim, Number>();
-      }
+/**
+ * Multiply a BarycentricPolynomial by a constant.
+ */
+template <int dim, typename Number1, typename Number2>
+BarycentricPolynomial<dim, Number1>
+operator*(const Number2 &a, const BarycentricPolynomial<dim, Number1> &bp)
+{
+  return bp * Number1(a);
+}
+
+/**
+ * Add a constant to a BarycentricPolynomial.
+ */
+template <int dim, typename Number1, typename Number2>
+BarycentricPolynomial<dim, Number1>
+operator+(const Number2 &a, const BarycentricPolynomial<dim, Number1> &bp)
+{
+  return bp + Number1(a);
+}
+
+/**
+ * Subtract a BarycentricPolynomial from a constant.
+ */
+template <int dim, typename Number1, typename Number2>
+BarycentricPolynomial<dim, Number1>
+operator-(const Number2 &a, const BarycentricPolynomial<dim, Number1> &bp)
+{
+  return bp - Number1(a);
+}
+
+/**
+ * Write a BarycentricPolynomial to the provided output stream.
+ */
+template <int dim, typename Number>
+std::ostream &
+operator<<(std::ostream &out, const BarycentricPolynomial<dim, Number> &bp)
+{
+  bp.print(out);
+  return out;
+}
 
-    BarycentricPolynomial<dim, Number> result(*this);
-    for (std::size_t i = 0; i < result.coefficients.n_elements(); ++i)
-      {
-        const auto index = index_to_indices(i, result.coefficients.size());
-        result.coefficients(index) *= a;
-      }
+// Template function definitions
 
-    return result;
-  }
+// BarycentricPolynomial:
+template <int dim, typename Number>
+BarycentricPolynomial<dim, Number>::BarycentricPolynomial()
+{
+  TableIndices<dim + 1> extents;
+  for (unsigned int d = 0; d < dim + 1; ++d)
+    extents[d] = 1;
+  coefficients.reinit(extents);
 
+  coefficients(TableIndices<dim + 1>{}) = Number();
+}
 
 
-  template <int dim, typename Number>
-  template <typename Number2>
-  BarycentricPolynomial<dim, Number>
-  BarycentricPolynomial<dim, Number>::operator/(const Number2 &a) const
-  {
-    Assert(a != Number2(), ExcDivideByZero());
-    return *this * (Number(1) / Number(a));
-  }
 
+template <int dim, typename Number>
+BarycentricPolynomial<dim, Number>::BarycentricPolynomial(
+  const TableIndices<dim + 1> &powers,
+  const Number                 coefficient)
+{
+  TableIndices<dim + 1> extents;
+  for (unsigned int d = 0; d < dim + 1; ++d)
+    extents[d] = powers[d] + 1;
+  coefficients.reinit(extents);
 
+  coefficients(powers) = coefficient;
+}
 
-  template <int dim, typename Number>
-  BarycentricPolynomial<dim, Number>
-  BarycentricPolynomial<dim, Number>::
-  operator+(const BarycentricPolynomial<dim, Number> &augend) const
-  {
-    TableIndices<dim + 1> deg;
-    for (unsigned int d = 0; d < dim + 1; ++d)
-      {
-        deg[d] = std::max(degrees()[d], augend.degrees()[d]);
-      }
 
-    BarycentricPolynomial<dim, Number> result(deg, Number());
 
-    auto add_coefficients = [&](const Table<dim + 1, Number> &in) {
-      for (std::size_t i = 0; i < in.n_elements(); ++i)
+template <int dim, typename Number>
+BarycentricPolynomial<dim, Number>
+BarycentricPolynomial<dim, Number>::monomial(const unsigned int d)
+{
+  AssertIndexRange(d, dim + 1);
+  TableIndices<dim + 1> indices;
+  indices[d] = 1;
+  return BarycentricPolynomial<dim, Number>(indices, Number(1));
+}
+
+
+
+template <int dim, typename Number>
+void
+BarycentricPolynomial<dim, Number>::print(std::ostream &out) const
+{
+  const auto &coeffs     = this->coefficients;
+  auto        first      = index_to_indices(0, coeffs.size());
+  bool        print_plus = false;
+  if (coeffs(first) != Number())
+    {
+      out << coeffs(first);
+      print_plus = true;
+    }
+  for (std::size_t i = 1; i < coeffs.n_elements(); ++i)
+    {
+      const auto indices = index_to_indices(i, coeffs.size());
+      if (coeffs(indices) == Number())
+        continue;
+      if (print_plus)
+        out << " + ";
+      out << coeffs(indices);
+      for (unsigned int d = 0; d < dim + 1; ++d)
         {
-          const auto index = index_to_indices(i, in.size());
-          result.coefficients(index) += in(index);
+          if (indices[d] != 0)
+            out << " * t" << d << '^' << indices[d];
         }
-    };
+      print_plus = true;
+    }
 
-    add_coefficients(this->coefficients);
-    add_coefficients(augend.coefficients);
-    return result;
-  }
+  if (!print_plus)
+    out << Number();
+}
 
 
 
-  template <int dim, typename Number>
-  BarycentricPolynomial<dim, Number>
-  BarycentricPolynomial<dim, Number>::
-  operator-(const BarycentricPolynomial<dim, Number> &augend) const
-  {
-    return *this + (-augend);
-  }
+template <int dim, typename Number>
+TableIndices<dim + 1>
+BarycentricPolynomial<dim, Number>::degrees() const
+{
+  auto deg = coefficients.size();
+  for (unsigned int d = 0; d < dim + 1; ++d)
+    deg[d] -= 1;
+  return deg;
+}
 
 
 
-  template <int dim, typename Number>
-  BarycentricPolynomial<dim, Number> BarycentricPolynomial<dim, Number>::
-                                     operator*(const BarycentricPolynomial<dim, Number> &multiplicand) const
-  {
-    TableIndices<dim + 1> deg;
-    for (unsigned int d = 0; d < dim + 1; ++d)
-      {
-        deg[d] = multiplicand.degrees()[d] + degrees()[d];
-      }
+template <int dim, typename Number>
+BarycentricPolynomial<dim, Number>
+BarycentricPolynomial<dim, Number>::operator-() const
+{
+  return *this * Number(-1);
+}
 
-    BarycentricPolynomial<dim, Number> result(deg, Number());
 
-    const auto &coef_1   = this->coefficients;
-    const auto &coef_2   = multiplicand.coefficients;
-    auto &      coef_out = result.coefficients;
 
-    for (std::size_t i1 = 0; i1 < coef_1.n_elements(); ++i1)
-      {
-        const auto index_1 = index_to_indices(i1, coef_1.size());
-        for (std::size_t i2 = 0; i2 < coef_2.n_elements(); ++i2)
-          {
-            const auto index_2 = index_to_indices(i2, coef_2.size());
-
-            TableIndices<dim + 1> index_out;
-            for (unsigned int d = 0; d < dim + 1; ++d)
-              index_out[d] = index_1[d] + index_2[d];
-            coef_out(index_out) += coef_1(index_1) * coef_2(index_2);
-          }
-      }
+template <int dim, typename Number>
+template <typename Number2>
+BarycentricPolynomial<dim, Number>
+BarycentricPolynomial<dim, Number>::operator+(const Number2 &a) const
+{
+  BarycentricPolynomial<dim, Number> result(*this);
+  result.coefficients(index_to_indices(0, result.coefficients.size())) += a;
 
-    return result;
-  }
+  return result;
+}
 
 
 
-  template <int dim, typename Number>
-  BarycentricPolynomial<dim, Number>
-  BarycentricPolynomial<dim, Number>::barycentric_derivative(
-    const unsigned int coordinate) const
-  {
-    AssertIndexRange(coordinate, dim + 1);
+template <int dim, typename Number>
+template <typename Number2>
+BarycentricPolynomial<dim, Number>
+BarycentricPolynomial<dim, Number>::operator-(const Number2 &a) const
+{
+  return *this + (-a);
+}
+
 
-    if (degrees()[coordinate] == 0)
+
+template <int dim, typename Number>
+template <typename Number2>
+BarycentricPolynomial<dim, Number> BarycentricPolynomial<dim, Number>::
+                                   operator*(const Number2 &a) const
+{
+  if (a == Number2())
+    {
       return BarycentricPolynomial<dim, Number>();
+    }
 
-    auto deg = degrees();
-    deg[coordinate] -= 1;
-    BarycentricPolynomial<dim, Number> result(
-      deg, std::numeric_limits<Number>::max());
-    const auto &coeffs_in  = coefficients;
-    auto &      coeffs_out = result.coefficients;
-    for (std::size_t i = 0; i < coeffs_out.n_elements(); ++i)
-      {
-        const auto out_index   = index_to_indices(i, coeffs_out.size());
-        auto       input_index = out_index;
-        input_index[coordinate] += 1;
+  BarycentricPolynomial<dim, Number> result(*this);
+  for (std::size_t i = 0; i < result.coefficients.n_elements(); ++i)
+    {
+      const auto index = index_to_indices(i, result.coefficients.size());
+      result.coefficients(index) *= a;
+    }
 
-        coeffs_out(out_index) =
-          coeffs_in(input_index) * input_index[coordinate];
-      }
+  return result;
+}
 
-    return result;
-  }
 
 
+template <int dim, typename Number>
+template <typename Number2>
+BarycentricPolynomial<dim, Number>
+BarycentricPolynomial<dim, Number>::operator/(const Number2 &a) const
+{
+  Assert(a != Number2(), ExcDivideByZero());
+  return *this * (Number(1) / Number(a));
+}
 
-  template <int dim, typename Number>
-  BarycentricPolynomial<dim, Number>
-  BarycentricPolynomial<dim, Number>::derivative(
-    const unsigned int coordinate) const
-  {
-    AssertIndexRange(coordinate, dim);
-    return -barycentric_derivative(0) + barycentric_derivative(coordinate + 1);
-  }
 
 
+template <int dim, typename Number>
+BarycentricPolynomial<dim, Number>
+BarycentricPolynomial<dim, Number>::
+operator+(const BarycentricPolynomial<dim, Number> &augend) const
+{
+  TableIndices<dim + 1> deg;
+  for (unsigned int d = 0; d < dim + 1; ++d)
+    {
+      deg[d] = std::max(degrees()[d], augend.degrees()[d]);
+    }
 
-  template <int dim, typename Number>
-  Number
-  BarycentricPolynomial<dim, Number>::value(const Point<dim> &point) const
-  {
-    // TODO: this is probably not numerically stable for higher order.
-    // We really need some version of Horner's method.
-    Number result = {};
-
-    // Begin by converting point (which is in Cartesian coordinates) to
-    // barycentric coordinates:
-    std::array<Number, dim + 1> b_point;
-    b_point[0] = 1.0;
-    for (unsigned int d = 0; d < dim; ++d)
-      {
-        b_point[0] -= point[d];
-        b_point[d + 1] = point[d];
-      }
+  BarycentricPolynomial<dim, Number> result(deg, Number());
 
-    // Now evaluate the polynomial at the computed barycentric point:
-    for (std::size_t i = 0; i < coefficients.n_elements(); ++i)
+  auto add_coefficients = [&](const Table<dim + 1, Number> &in) {
+    for (std::size_t i = 0; i < in.n_elements(); ++i)
       {
-        const auto indices = index_to_indices(i, coefficients.size());
-        const auto coef    = coefficients(indices);
-        if (coef == Number())
-          continue;
-
-        auto temp = Number(1);
-        for (unsigned int d = 0; d < dim + 1; ++d)
-          temp *= std::pow(b_point[d], indices[d]);
-        result += coef * temp;
+        const auto index = index_to_indices(i, in.size());
+        result.coefficients(index) += in(index);
       }
+  };
 
-    return result;
-  }
+  add_coefficients(this->coefficients);
+  add_coefficients(augend.coefficients);
+  return result;
+}
 
-  template <int dim, typename Number>
-  std::size_t
-  BarycentricPolynomial<dim, Number>::memory_consumption() const
-  {
-    return coefficients.memory_consumption();
-  }
 
-  template <int dim, typename Number>
-  TableIndices<dim + 1>
-  BarycentricPolynomial<dim, Number>::index_to_indices(
-    const std::size_t &          index,
-    const TableIndices<dim + 1> &extent)
-  {
-    TableIndices<dim + 1> result;
-    auto                  temp = index;
-
-    for (unsigned int n = 0; n < dim + 1; ++n)
-      {
-        std::size_t slice_size = 1;
-        for (unsigned int n2 = n + 1; n2 < dim + 1; ++n2)
-          slice_size *= extent[n2];
-        result[n] = temp / slice_size;
-        temp %= slice_size;
-      }
-    return result;
-  }
-
-  template <int dim>
-  const BarycentricPolynomial<dim> &BarycentricPolynomials<dim>::
-                                    operator[](const std::size_t i) const
-  {
-    AssertIndexRange(i, polys.size());
-    return polys[i];
-  }
-} // namespace Simplex
+
+template <int dim, typename Number>
+BarycentricPolynomial<dim, Number>
+BarycentricPolynomial<dim, Number>::
+operator-(const BarycentricPolynomial<dim, Number> &augend) const
+{
+  return *this + (-augend);
+}
+
+
+
+template <int dim, typename Number>
+BarycentricPolynomial<dim, Number> BarycentricPolynomial<dim, Number>::
+                                   operator*(const BarycentricPolynomial<dim, Number> &multiplicand) const
+{
+  TableIndices<dim + 1> deg;
+  for (unsigned int d = 0; d < dim + 1; ++d)
+    {
+      deg[d] = multiplicand.degrees()[d] + degrees()[d];
+    }
+
+  BarycentricPolynomial<dim, Number> result(deg, Number());
+
+  const auto &coef_1   = this->coefficients;
+  const auto &coef_2   = multiplicand.coefficients;
+  auto &      coef_out = result.coefficients;
+
+  for (std::size_t i1 = 0; i1 < coef_1.n_elements(); ++i1)
+    {
+      const auto index_1 = index_to_indices(i1, coef_1.size());
+      for (std::size_t i2 = 0; i2 < coef_2.n_elements(); ++i2)
+        {
+          const auto index_2 = index_to_indices(i2, coef_2.size());
+
+          TableIndices<dim + 1> index_out;
+          for (unsigned int d = 0; d < dim + 1; ++d)
+            index_out[d] = index_1[d] + index_2[d];
+          coef_out(index_out) += coef_1(index_1) * coef_2(index_2);
+        }
+    }
+
+  return result;
+}
+
+
+
+template <int dim, typename Number>
+BarycentricPolynomial<dim, Number>
+BarycentricPolynomial<dim, Number>::barycentric_derivative(
+  const unsigned int coordinate) const
+{
+  AssertIndexRange(coordinate, dim + 1);
+
+  if (degrees()[coordinate] == 0)
+    return BarycentricPolynomial<dim, Number>();
+
+  auto deg = degrees();
+  deg[coordinate] -= 1;
+  BarycentricPolynomial<dim, Number> result(deg,
+                                            std::numeric_limits<Number>::max());
+  const auto &                       coeffs_in  = coefficients;
+  auto &                             coeffs_out = result.coefficients;
+  for (std::size_t i = 0; i < coeffs_out.n_elements(); ++i)
+    {
+      const auto out_index   = index_to_indices(i, coeffs_out.size());
+      auto       input_index = out_index;
+      input_index[coordinate] += 1;
+
+      coeffs_out(out_index) = coeffs_in(input_index) * input_index[coordinate];
+    }
+
+  return result;
+}
+
+
+
+template <int dim, typename Number>
+BarycentricPolynomial<dim, Number>
+BarycentricPolynomial<dim, Number>::derivative(
+  const unsigned int coordinate) const
+{
+  AssertIndexRange(coordinate, dim);
+  return -barycentric_derivative(0) + barycentric_derivative(coordinate + 1);
+}
+
+
+
+template <int dim, typename Number>
+Number
+BarycentricPolynomial<dim, Number>::value(const Point<dim> &point) const
+{
+  // TODO: this is probably not numerically stable for higher order.
+  // We really need some version of Horner's method.
+  Number result = {};
+
+  // Begin by converting point (which is in Cartesian coordinates) to
+  // barycentric coordinates:
+  std::array<Number, dim + 1> b_point;
+  b_point[0] = 1.0;
+  for (unsigned int d = 0; d < dim; ++d)
+    {
+      b_point[0] -= point[d];
+      b_point[d + 1] = point[d];
+    }
+
+  // Now evaluate the polynomial at the computed barycentric point:
+  for (std::size_t i = 0; i < coefficients.n_elements(); ++i)
+    {
+      const auto indices = index_to_indices(i, coefficients.size());
+      const auto coef    = coefficients(indices);
+      if (coef == Number())
+        continue;
+
+      auto temp = Number(1);
+      for (unsigned int d = 0; d < dim + 1; ++d)
+        temp *= std::pow(b_point[d], indices[d]);
+      result += coef * temp;
+    }
+
+  return result;
+}
+
+template <int dim, typename Number>
+std::size_t
+BarycentricPolynomial<dim, Number>::memory_consumption() const
+{
+  return coefficients.memory_consumption();
+}
+
+template <int dim, typename Number>
+TableIndices<dim + 1>
+BarycentricPolynomial<dim, Number>::index_to_indices(
+  const std::size_t &          index,
+  const TableIndices<dim + 1> &extent)
+{
+  TableIndices<dim + 1> result;
+  auto                  temp = index;
+
+  for (unsigned int n = 0; n < dim + 1; ++n)
+    {
+      std::size_t slice_size = 1;
+      for (unsigned int n2 = n + 1; n2 < dim + 1; ++n2)
+        slice_size *= extent[n2];
+      result[n] = temp / slice_size;
+      temp %= slice_size;
+    }
+  return result;
+}
+
+template <int dim>
+const BarycentricPolynomial<dim> &BarycentricPolynomials<dim>::
+                                  operator[](const std::size_t i) const
+{
+  AssertIndexRange(i, polys.size());
+  return polys[i];
+}
 
 DEAL_II_NAMESPACE_CLOSE
 
diff --git a/include/deal.II/base/polynomials_pyramid.h b/include/deal.II/base/polynomials_pyramid.h
index 31421e95f7..b75d9ee082 100644
--- a/include/deal.II/base/polynomials_pyramid.h
+++ b/include/deal.II/base/polynomials_pyramid.h
@@ -29,122 +29,118 @@ DEAL_II_NAMESPACE_OPEN
  *
  *  @ingroup simplex
  */
-namespace Simplex
+/**
+ * Polynomials defined on pyramid entities. This class is basis of
+ * FE_PyramidP.
+ */
+template <int dim>
+class ScalarPyramidPolynomial : public ScalarPolynomialsBase<dim>
 {
+public:
+  /**
+   * Make the dimension available to the outside.
+   */
+  static const unsigned int dimension = dim;
+
+  /*
+   * Constructor taking the polynomial @p degree as input.
+   *
+   * @note Currently, only linear polynomials (degree=1) are implemented.
+   */
+  ScalarPyramidPolynomial(const unsigned int degree);
+
   /**
-   * Polynomials defined on pyramid entities. This class is basis of
-   * Simplex::FE_PyramidP.
+   * @copydoc ScalarPolynomialsBase::evaluate()
+   *
+   * @note Currently, only the vectors @p values and @p grads are filled.
+   */
+  void
+  evaluate(const Point<dim> &           unit_point,
+           std::vector<double> &        values,
+           std::vector<Tensor<1, dim>> &grads,
+           std::vector<Tensor<2, dim>> &grad_grads,
+           std::vector<Tensor<3, dim>> &third_derivatives,
+           std::vector<Tensor<4, dim>> &fourth_derivatives) const override;
+
+  double
+  compute_value(const unsigned int i, const Point<dim> &p) const override;
+
+  /**
+   * @copydoc ScalarPolynomialsBase::compute_derivative()
+   *
+   * @note Currently, only implemented for first derivative.
    */
-  template <int dim>
-  class ScalarPyramidPolynomial : public ScalarPolynomialsBase<dim>
-  {
-  public:
-    /**
-     * Make the dimension available to the outside.
-     */
-    static const unsigned int dimension = dim;
-
-    /*
-     * Constructor taking the polynomial @p degree as input.
-     *
-     * @note Currently, only linear polynomials (degree=1) are implemented.
-     */
-    ScalarPyramidPolynomial(const unsigned int degree);
-
-    /**
-     * @copydoc ScalarPolynomialsBase::evaluate()
-     *
-     * @note Currently, only the vectors @p values and @p grads are filled.
-     */
-    void
-    evaluate(const Point<dim> &           unit_point,
-             std::vector<double> &        values,
-             std::vector<Tensor<1, dim>> &grads,
-             std::vector<Tensor<2, dim>> &grad_grads,
-             std::vector<Tensor<3, dim>> &third_derivatives,
-             std::vector<Tensor<4, dim>> &fourth_derivatives) const override;
-
-    double
-    compute_value(const unsigned int i, const Point<dim> &p) const override;
-
-    /**
-     * @copydoc ScalarPolynomialsBase::compute_derivative()
-     *
-     * @note Currently, only implemented for first derivative.
-     */
-    template <int order>
-    Tensor<order, dim>
-    compute_derivative(const unsigned int i, const Point<dim> &p) const;
-
-    Tensor<1, dim>
-    compute_1st_derivative(const unsigned int i,
-                           const Point<dim> & p) const override;
-
-    Tensor<2, dim>
-    compute_2nd_derivative(const unsigned int i,
-                           const Point<dim> & p) const override;
-
-    /**
-     * @copydoc ScalarPolynomialsBase::compute_3rd_derivative()
-     *
-     * @note Not implemented yet.
-     */
-    Tensor<3, dim>
-    compute_3rd_derivative(const unsigned int i,
-                           const Point<dim> & p) const override;
-
-    /**
-     * @copydoc ScalarPolynomialsBase::compute_4th_derivative()
-     *
-     * @note Not implemented yet.
-     */
-    Tensor<4, dim>
-    compute_4th_derivative(const unsigned int i,
-                           const Point<dim> & p) const override;
-
-    /**
-     * @copydoc ScalarPolynomialsBase::compute_grad()
-     *
-     * @note Not implemented yet.
-     */
-    Tensor<1, dim>
-    compute_grad(const unsigned int i, const Point<dim> &p) const override;
-
-    /**
-     * @copydoc ScalarPolynomialsBase::compute_grad_grad()
-     *
-     * @note Not implemented yet.
-     */
-    Tensor<2, dim>
-    compute_grad_grad(const unsigned int i, const Point<dim> &p) const override;
-
-    std::string
-    name() const override;
-
-    virtual std::unique_ptr<ScalarPolynomialsBase<dim>>
-    clone() const override;
-  };
-
-
-
-  template <int dim>
   template <int order>
   Tensor<order, dim>
-  ScalarPyramidPolynomial<dim>::compute_derivative(const unsigned int i,
-                                                   const Point<dim> & p) const
-  {
-    Tensor<order, dim> der;
+  compute_derivative(const unsigned int i, const Point<dim> &p) const;
+
+  Tensor<1, dim>
+  compute_1st_derivative(const unsigned int i,
+                         const Point<dim> & p) const override;
+
+  Tensor<2, dim>
+  compute_2nd_derivative(const unsigned int i,
+                         const Point<dim> & p) const override;
+
+  /**
+   * @copydoc ScalarPolynomialsBase::compute_3rd_derivative()
+   *
+   * @note Not implemented yet.
+   */
+  Tensor<3, dim>
+  compute_3rd_derivative(const unsigned int i,
+                         const Point<dim> & p) const override;
+
+  /**
+   * @copydoc ScalarPolynomialsBase::compute_4th_derivative()
+   *
+   * @note Not implemented yet.
+   */
+  Tensor<4, dim>
+  compute_4th_derivative(const unsigned int i,
+                         const Point<dim> & p) const override;
 
-    Assert(order == 1, ExcNotImplemented());
-    const auto grad = compute_grad(i, p);
+  /**
+   * @copydoc ScalarPolynomialsBase::compute_grad()
+   *
+   * @note Not implemented yet.
+   */
+  Tensor<1, dim>
+  compute_grad(const unsigned int i, const Point<dim> &p) const override;
+
+  /**
+   * @copydoc ScalarPolynomialsBase::compute_grad_grad()
+   *
+   * @note Not implemented yet.
+   */
+  Tensor<2, dim>
+  compute_grad_grad(const unsigned int i, const Point<dim> &p) const override;
+
+  std::string
+  name() const override;
+
+  virtual std::unique_ptr<ScalarPolynomialsBase<dim>>
+  clone() const override;
+};
+
+
+
+template <int dim>
+template <int order>
+Tensor<order, dim>
+ScalarPyramidPolynomial<dim>::compute_derivative(const unsigned int i,
+                                                 const Point<dim> & p) const
+{
+  Tensor<order, dim> der;
 
-    for (unsigned int i = 0; i < dim; i++)
-      der[i] = grad[i];
+  Assert(order == 1, ExcNotImplemented());
+  const auto grad = compute_grad(i, p);
 
-    return der;
-  }
+  for (unsigned int i = 0; i < dim; i++)
+    der[i] = grad[i];
 
-} // namespace Simplex
+  return der;
+}
 
 DEAL_II_NAMESPACE_CLOSE
 
diff --git a/include/deal.II/base/polynomials_wedge.h b/include/deal.II/base/polynomials_wedge.h
index 880660f27d..296c806163 100644
--- a/include/deal.II/base/polynomials_wedge.h
+++ b/include/deal.II/base/polynomials_wedge.h
@@ -25,149 +25,139 @@
 DEAL_II_NAMESPACE_OPEN
 
 /**
- * A namespace for functions and classes that provide support for simplex
- * reference cell entities, i.e., triangles and tetrahedrons.
+ * Polynomials defined on wedge entities. This class is basis of
+ * FE_WedgeP.
  *
- *  @ingroup simplex
+ * The polynomials are created via a tensor product of a
+ * BarycentricPolynomials<2>::get_fe_p_basis(degree) and a
+ * BarycentricPolynomials<1>::get_fe_p_basis(degree), however, are
+ * re-numerated to better match the definition of FiniteElement.
  */
-namespace Simplex
+template <int dim>
+class ScalarWedgePolynomial : public ScalarPolynomialsBase<dim>
 {
+public:
   /**
-   * Polynomials defined on wedge entities. This class is basis of
-   * Simplex::FE_WedgeP.
+   * Make the dimension available to the outside.
+   */
+  static const unsigned int dimension = dim;
+
+  /*
+   * Constructor taking the polynomial @p degree as input.
+   *
+   * @note Currently, only linear (degree=1) and quadratic polynomials
+   *   (degree=2) are implemented.
+   */
+  ScalarWedgePolynomial(const unsigned int degree);
+
+  /**
+   * @copydoc ScalarPolynomialsBase::evaluate()
+   *
+   * @note Currently, only the vectors @p values and @p grads are filled.
+   */
+  void
+  evaluate(const Point<dim> &           unit_point,
+           std::vector<double> &        values,
+           std::vector<Tensor<1, dim>> &grads,
+           std::vector<Tensor<2, dim>> &grad_grads,
+           std::vector<Tensor<3, dim>> &third_derivatives,
+           std::vector<Tensor<4, dim>> &fourth_derivatives) const override;
+
+  double
+  compute_value(const unsigned int i, const Point<dim> &p) const override;
+
+  /**
+   * @copydoc ScalarPolynomialsBase::compute_derivative()
    *
-   * The polynomials are created via a tensor product of a
-   * Simplex::BarycentricPolynomials<2>::get_fe_p_basis(degree) and a
-   * Simplex::BarycentricPolynomials<1>::get_fe_p_basis(degree), however, are
-   * re-numerated to better match the definition of FiniteElement.
+   * @note Currently, only implemented for first derivative.
    */
-  template <int dim>
-  class ScalarWedgePolynomial : public ScalarPolynomialsBase<dim>
-  {
-  public:
-    /**
-     * Make the dimension available to the outside.
-     */
-    static const unsigned int dimension = dim;
-
-    /*
-     * Constructor taking the polynomial @p degree as input.
-     *
-     * @note Currently, only linear (degree=1) and quadratic polynomials
-     *   (degree=2) are implemented.
-     */
-    ScalarWedgePolynomial(const unsigned int degree);
-
-    /**
-     * @copydoc ScalarPolynomialsBase::evaluate()
-     *
-     * @note Currently, only the vectors @p values and @p grads are filled.
-     */
-    void
-    evaluate(const Point<dim> &           unit_point,
-             std::vector<double> &        values,
-             std::vector<Tensor<1, dim>> &grads,
-             std::vector<Tensor<2, dim>> &grad_grads,
-             std::vector<Tensor<3, dim>> &third_derivatives,
-             std::vector<Tensor<4, dim>> &fourth_derivatives) const override;
-
-    double
-    compute_value(const unsigned int i, const Point<dim> &p) const override;
-
-    /**
-     * @copydoc ScalarPolynomialsBase::compute_derivative()
-     *
-     * @note Currently, only implemented for first derivative.
-     */
-    template <int order>
-    Tensor<order, dim>
-    compute_derivative(const unsigned int i, const Point<dim> &p) const;
-
-    Tensor<1, dim>
-    compute_1st_derivative(const unsigned int i,
-                           const Point<dim> & p) const override;
-
-    /**
-     * @copydoc ScalarPolynomialsBase::compute_2nd_derivative()
-     *
-     * @note Not implemented yet.
-     */
-    Tensor<2, dim>
-    compute_2nd_derivative(const unsigned int i,
-                           const Point<dim> & p) const override;
-
-    /**
-     * @copydoc ScalarPolynomialsBase::compute_3rd_derivative()
-     *
-     * @note Not implemented yet.
-     */
-    Tensor<3, dim>
-    compute_3rd_derivative(const unsigned int i,
-                           const Point<dim> & p) const override;
-
-    /**
-     * @copydoc ScalarPolynomialsBase::compute_4th_derivative()
-     *
-     * @note Not implemented yet.
-     */
-    Tensor<4, dim>
-    compute_4th_derivative(const unsigned int i,
-                           const Point<dim> & p) const override;
-
-    /**
-     * @copydoc ScalarPolynomialsBase::compute_grad()
-     *
-     * @note Not implemented yet.
-     */
-    Tensor<1, dim>
-    compute_grad(const unsigned int i, const Point<dim> &p) const override;
-
-    /**
-     * @copydoc ScalarPolynomialsBase::compute_grad_grad()
-     *
-     * @note Not implemented yet.
-     */
-    Tensor<2, dim>
-    compute_grad_grad(const unsigned int i, const Point<dim> &p) const override;
-
-    std::string
-    name() const override;
-
-    virtual std::unique_ptr<ScalarPolynomialsBase<dim>>
-    clone() const override;
-
-  private:
-    /**
-     * Scalar polynomials defined on a triangle.
-     */
-    const BarycentricPolynomials<2> poly_tri;
-
-    /**
-     * Scalar polynomials defined on a line.
-     */
-    const BarycentricPolynomials<1> poly_line;
-  };
-
-
-
-  template <int dim>
   template <int order>
   Tensor<order, dim>
-  ScalarWedgePolynomial<dim>::compute_derivative(const unsigned int i,
-                                                 const Point<dim> & p) const
-  {
-    Tensor<order, dim> der;
+  compute_derivative(const unsigned int i, const Point<dim> &p) const;
 
-    AssertDimension(order, 1);
-    const auto grad = compute_grad(i, p);
+  Tensor<1, dim>
+  compute_1st_derivative(const unsigned int i,
+                         const Point<dim> & p) const override;
+
+  /**
+   * @copydoc ScalarPolynomialsBase::compute_2nd_derivative()
+   *
+   * @note Not implemented yet.
+   */
+  Tensor<2, dim>
+  compute_2nd_derivative(const unsigned int i,
+                         const Point<dim> & p) const override;
+
+  /**
+   * @copydoc ScalarPolynomialsBase::compute_3rd_derivative()
+   *
+   * @note Not implemented yet.
+   */
+  Tensor<3, dim>
+  compute_3rd_derivative(const unsigned int i,
+                         const Point<dim> & p) const override;
+
+  /**
+   * @copydoc ScalarPolynomialsBase::compute_4th_derivative()
+   *
+   * @note Not implemented yet.
+   */
+  Tensor<4, dim>
+  compute_4th_derivative(const unsigned int i,
+                         const Point<dim> & p) const override;
+
+  /**
+   * @copydoc ScalarPolynomialsBase::compute_grad()
+   *
+   * @note Not implemented yet.
+   */
+  Tensor<1, dim>
+  compute_grad(const unsigned int i, const Point<dim> &p) const override;
+
+  /**
+   * @copydoc ScalarPolynomialsBase::compute_grad_grad()
+   *
+   * @note Not implemented yet.
+   */
+  Tensor<2, dim>
+  compute_grad_grad(const unsigned int i, const Point<dim> &p) const override;
+
+  std::string
+  name() const override;
+
+  virtual std::unique_ptr<ScalarPolynomialsBase<dim>>
+  clone() const override;
+
+private:
+  /**
+   * Scalar polynomials defined on a triangle.
+   */
+  const BarycentricPolynomials<2> poly_tri;
+
+  /**
+   * Scalar polynomials defined on a line.
+   */
+  const BarycentricPolynomials<1> poly_line;
+};
+
+
+
+template <int dim>
+template <int order>
+Tensor<order, dim>
+ScalarWedgePolynomial<dim>::compute_derivative(const unsigned int i,
+                                               const Point<dim> & p) const
+{
+  Tensor<order, dim> der;
 
-    for (unsigned int i = 0; i < dim; i++)
-      der[i] = grad[i];
+  AssertDimension(order, 1);
+  const auto grad = compute_grad(i, p);
 
-    return der;
-  }
+  for (unsigned int i = 0; i < dim; i++)
+    der[i] = grad[i];
 
-} // namespace Simplex
+  return der;
+}
 
 DEAL_II_NAMESPACE_CLOSE
 
diff --git a/include/deal.II/base/quadrature_lib.h b/include/deal.II/base/quadrature_lib.h
index 890440acd4..a82e7373af 100644
--- a/include/deal.II/base/quadrature_lib.h
+++ b/include/deal.II/base/quadrature_lib.h
@@ -792,97 +792,93 @@ public:
   QSplit(const QSimplex<dim> &base, const Point<dim> &split_point);
 };
 
-namespace Simplex
+/**
+ * Integration rule for simplex entities.
+ *
+ * Users specify a number `n_points_1D` as an indication of what polynomial
+ * degree to be integrated exactly, similarly to the number of points in a
+ * QGauss quadrature object, even though the present quadrature formula is not
+ * a tensor product. The given value is translated for n_points_1D=1,2,3,4 to
+ * following number of quadrature points for 2D and 3D:
+ *   - 2D: 1, 3, 7, 15
+ *   - 3D: 1, 4, 10, 35
+ *
+ * For 1D, the quadrature rule degenerates to a
+ * `dealii::QGauss<1>(n_points_1D)`.
+ *
+ * @ingroup simplex
+ */
+template <int dim>
+class QGaussSimplex : public QSimplex<dim>
 {
+public:
   /**
-   * Integration rule for simplex entities.
-   *
-   * Users specify a number `n_points_1D` as an indication of what polynomial
-   * degree to be integrated exactly, similarly to the number of points in a
-   * QGauss quadrature object, even though the present quadrature formula is not
-   * a tensor product. The given value is translated for n_points_1D=1,2,3,4 to
-   * following number of quadrature points for 2D and 3D:
-   *   - 2D: 1, 3, 7, 15
-   *   - 3D: 1, 4, 10, 35
-   *
-   * For 1D, the quadrature rule degenerates to a
-   * `dealii::QGauss<1>(n_points_1D)`.
-   *
-   * @ingroup simplex
+   * Constructor taking the number of quadrature points in 1D direction
+   * @p n_points_1D.
    */
-  template <int dim>
-  class QGauss : public QSimplex<dim>
-  {
-  public:
-    /**
-     * Constructor taking the number of quadrature points in 1D direction
-     * @p n_points_1D.
-     */
-    explicit QGauss(const unsigned int n_points_1D);
-  };
+  explicit QGaussSimplex(const unsigned int n_points_1D);
+};
 
+/**
+ * Witherden-Vincent rules for simplex entities.
+ *
+ * Like QGauss, users should specify a number `n_points_1D` as an indication
+ * of what polynomial degree to be integrated exactly (e.g., for $n$ points,
+ * the rule can integrate polynomials of degree $2 n - 1$ exactly). The given
+ * value for n_points_1D = 1, 2, 3, 4, 5 results in the following number of
+ * quadrature points in 2D and 3D:
+ * - 2D: 1, 6, 7, 15, 19
+ * - 3D: 1, 8, 14, 35, 59
+ *
+ * For 1D, the quadrature rule degenerates to a
+ * `dealii::QGauss<1>(n_points_1D)`.
+ *
+ * These rules match the ones listed for Witherden-Vincent in the quadpy
+ * @cite quadpy library and were first described in
+ * @cite witherden2015identification.
+ *
+ * @ingroup simplex
+ */
+template <int dim>
+class QWitherdenVincent : public QSimplex<dim>
+{
+public:
   /**
-   * Witherden-Vincent rules for simplex entities.
-   *
-   * Like QGauss, users should specify a number `n_points_1D` as an indication
-   * of what polynomial degree to be integrated exactly (e.g., for $n$ points,
-   * the rule can integrate polynomials of degree $2 n - 1$ exactly). The given
-   * value for n_points_1D = 1, 2, 3, 4, 5 results in the following number of
-   * quadrature points in 2D and 3D:
-   * - 2D: 1, 6, 7, 15, 19
-   * - 3D: 1, 8, 14, 35, 59
-   *
-   * For 1D, the quadrature rule degenerates to a
-   * `dealii::QGauss<1>(n_points_1D)`.
-   *
-   * These rules match the ones listed for Witherden-Vincent in the quadpy
-   * @cite quadpy library and were first described in
-   * @cite witherden2015identification.
-   *
-   * @ingroup simplex
+   * Constructor taking the number of quadrature points in 1D direction
+   * @p n_points_1D.
    */
-  template <int dim>
-  class QWitherdenVincent : public QSimplex<dim>
-  {
-  public:
-    /**
-     * Constructor taking the number of quadrature points in 1D direction
-     * @p n_points_1D.
-     */
-    explicit QWitherdenVincent(const unsigned int n_points_1D);
-  };
+  explicit QWitherdenVincent(const unsigned int n_points_1D);
+};
 
+/**
+ * Integration rule for wedge entities.
+ */
+template <int dim>
+class QGaussWedge : public Quadrature<dim>
+{
+public:
   /**
-   * Integration rule for wedge entities.
+   * Users specify a number `n_points_1D` as an indication of what polynomial
+   * degree to be integrated exactly. For details, see the comments of
+   * QGaussSimplex.
    */
-  template <int dim>
-  class QGaussWedge : public Quadrature<dim>
-  {
-  public:
-    /**
-     * Users specify a number `n_points_1D` as an indication of what polynomial
-     * degree to be integrated exactly. For details, see the comments of
-     * Simplex::QGauss.
-     */
-    explicit QGaussWedge(const unsigned int n_points_1D);
-  };
+  explicit QGaussWedge(const unsigned int n_points_1D);
+};
 
+/**
+ * Integration rule for pyramid entities.
+ */
+template <int dim>
+class QGaussPyramid : public Quadrature<dim>
+{
+public:
   /**
-   * Integration rule for pyramid entities.
+   * Users specify a number `n_points_1D` as an indication of what polynomial
+   * degree to be integrated exactly. For details, see the comments of
+   * QGaussSimplex.
    */
-  template <int dim>
-  class QGaussPyramid : public Quadrature<dim>
-  {
-  public:
-    /**
-     * Users specify a number `n_points_1D` as an indication of what polynomial
-     * degree to be integrated exactly. For details, see the comments of
-     * Simplex::QGauss.
-     */
-    explicit QGaussPyramid(const unsigned int n_points_1D);
-  };
-
-} // namespace Simplex
+  explicit QGaussPyramid(const unsigned int n_points_1D);
+};
 
 /*@}*/
 
diff --git a/include/deal.II/fe/fe_poly.h b/include/deal.II/fe/fe_poly.h
index 50d6a5652a..199e077321 100644
--- a/include/deal.II/fe/fe_poly.h
+++ b/include/deal.II/fe/fe_poly.h
@@ -111,8 +111,7 @@ public:
    *
    * @note Some implementations of this class do not support this function,
    *   since no lexicographic ordering of the basis functions is possible
-   *   for them. Examples are: Simplex::FE_P, Simplex::FE_WedgeP, and
-   *   Simplex::FE_PyramidP.
+   *   for them. Examples are: FE_SimplexP, FE_WedgeP, and FE_PyramidP.
    */
   std::vector<unsigned int>
   get_poly_space_numbering() const;
diff --git a/include/deal.II/fe/fe_pyramid_p.h b/include/deal.II/fe/fe_pyramid_p.h
index 0079600da6..2e22b4b580 100644
--- a/include/deal.II/fe/fe_pyramid_p.h
+++ b/include/deal.II/fe/fe_pyramid_p.h
@@ -24,117 +24,114 @@
 
 DEAL_II_NAMESPACE_OPEN
 
-namespace Simplex
+/**
+ * Base class of FE_PyramidP and FE_PyramidDGP.
+ *
+ * @note Only implemented for 3D.
+ *
+ * @ingroup simplex
+ */
+template <int dim, int spacedim = dim>
+class FE_Pyramid : public dealii::FE_Poly<dim, spacedim>
 {
+public:
   /**
-   * Base class of FE_PyramidP and FE_PyramidDGP.
-   *
-   * @note Only implemented for 3D.
-   *
-   * @ingroup simplex
+   * Constructor.
    */
-  template <int dim, int spacedim = dim>
-  class FE_Pyramid : public dealii::FE_Poly<dim, spacedim>
-  {
-  public:
-    /**
-     * Constructor.
-     */
-    FE_Pyramid(const unsigned int                                degree,
-               const internal::GenericDoFsPerObject &            dpos,
-               const typename FiniteElementData<dim>::Conformity conformity);
-  };
+  FE_Pyramid(const unsigned int                                degree,
+             const internal::GenericDoFsPerObject &            dpos,
+             const typename FiniteElementData<dim>::Conformity conformity);
+};
+
+/**
+ * Implementation of a scalar Lagrange finite element on a pyramid that yields
+ * the finite element space of continuous, piecewise polynomials of
+ * degree $k$.
+ *
+ * @ingroup simplex
+ */
+template <int dim, int spacedim = dim>
+class FE_PyramidP : public FE_Pyramid<dim, spacedim>
+{
+public:
+  /**
+   * Constructor.
+   */
+  FE_PyramidP(const unsigned int degree);
+
+  /**
+   * @copydoc dealii::FiniteElement::clone()
+   */
+  std::unique_ptr<FiniteElement<dim, spacedim>>
+  clone() const override;
+
+  /**
+   * Return a string that uniquely identifies a finite element. This class
+   * returns <tt>FE_PyramidP<dim>(degree)</tt>, with @p dim and @p degree
+   * replaced by appropriate values.
+   */
+  std::string
+  get_name() const override;
+
+  /**
+   * @copydoc dealii::FiniteElement::compare_for_domination()
+   */
+  FiniteElementDomination::Domination
+  compare_for_domination(const FiniteElement<dim, spacedim> &fe_other,
+                         const unsigned int codim) const override;
+
+  /**
+   * @copydoc dealii::FiniteElement::hp_vertex_dof_identities()
+   */
+  std::vector<std::pair<unsigned int, unsigned int>>
+  hp_vertex_dof_identities(
+    const FiniteElement<dim, spacedim> &fe_other) const override;
+
+  /**
+   * @copydoc dealii::FiniteElement::hp_line_dof_identities()
+   */
+  std::vector<std::pair<unsigned int, unsigned int>>
+  hp_line_dof_identities(
+    const FiniteElement<dim, spacedim> &fe_other) const override;
+
+  /**
+   * @copydoc dealii::FiniteElement::hp_quad_dof_identities()
+   */
+  std::vector<std::pair<unsigned int, unsigned int>>
+  hp_quad_dof_identities(const FiniteElement<dim, spacedim> &fe_other,
+                         const unsigned int face_no = 0) const override;
+};
+
+/**
+ * Implementation of a scalar Lagrange finite element on a pyramid that yields
+ * the finite element space of discontinuous, piecewise polynomials of
+ * degree $k$.
+ *
+ * @ingroup simplex
+ */
+template <int dim, int spacedim = dim>
+class FE_PyramidDGP : public FE_Pyramid<dim, spacedim>
+{
+public:
+  /**
+   * Constructor.
+   */
+  FE_PyramidDGP(const unsigned int degree);
 
   /**
-   * Implementation of a scalar Lagrange finite element on a pyramid that yields
-   * the finite element space of continuous, piecewise polynomials of
-   * degree $k$.
-   *
-   * @ingroup simplex
+   * @copydoc dealii::FiniteElement::clone()
    */
-  template <int dim, int spacedim = dim>
-  class FE_PyramidP : public FE_Pyramid<dim, spacedim>
-  {
-  public:
-    /**
-     * Constructor.
-     */
-    FE_PyramidP(const unsigned int degree);
-
-    /**
-     * @copydoc dealii::FiniteElement::clone()
-     */
-    std::unique_ptr<FiniteElement<dim, spacedim>>
-    clone() const override;
-
-    /**
-     * Return a string that uniquely identifies a finite element. This class
-     * returns <tt>Simplex::FE_PyramidP<dim>(degree)</tt>, with @p dim and @p degree
-     * replaced by appropriate values.
-     */
-    std::string
-    get_name() const override;
-
-    /**
-     * @copydoc dealii::FiniteElement::compare_for_domination()
-     */
-    FiniteElementDomination::Domination
-    compare_for_domination(const FiniteElement<dim, spacedim> &fe_other,
-                           const unsigned int codim) const override;
-
-    /**
-     * @copydoc dealii::FiniteElement::hp_vertex_dof_identities()
-     */
-    std::vector<std::pair<unsigned int, unsigned int>>
-    hp_vertex_dof_identities(
-      const FiniteElement<dim, spacedim> &fe_other) const override;
-
-    /**
-     * @copydoc dealii::FiniteElement::hp_line_dof_identities()
-     */
-    std::vector<std::pair<unsigned int, unsigned int>>
-    hp_line_dof_identities(
-      const FiniteElement<dim, spacedim> &fe_other) const override;
-
-    /**
-     * @copydoc dealii::FiniteElement::hp_quad_dof_identities()
-     */
-    std::vector<std::pair<unsigned int, unsigned int>>
-    hp_quad_dof_identities(const FiniteElement<dim, spacedim> &fe_other,
-                           const unsigned int face_no = 0) const override;
-  };
+  std::unique_ptr<FiniteElement<dim, spacedim>>
+  clone() const override;
 
   /**
-   * Implementation of a scalar Lagrange finite element on a pyramid that yields
-   * the finite element space of discontinuous, piecewise polynomials of
-   * degree $k$.
-   *
-   * @ingroup simplex
+   * Return a string that uniquely identifies a finite element. This class
+   * returns <tt>FE_PyramidDGP<dim>(degree)</tt>, with @p dim and @p degree
+   * replaced by appropriate values.
    */
-  template <int dim, int spacedim = dim>
-  class FE_PyramidDGP : public FE_Pyramid<dim, spacedim>
-  {
-  public:
-    /**
-     * Constructor.
-     */
-    FE_PyramidDGP(const unsigned int degree);
-
-    /**
-     * @copydoc dealii::FiniteElement::clone()
-     */
-    std::unique_ptr<FiniteElement<dim, spacedim>>
-    clone() const override;
-
-    /**
-     * Return a string that uniquely identifies a finite element. This class
-     * returns <tt>Simplex::FE_PyramidDGP<dim>(degree)</tt>, with @p dim and @p degree
-     * replaced by appropriate values.
-     */
-    std::string
-    get_name() const override;
-  };
-} // namespace Simplex
+  std::string
+  get_name() const override;
+};
 
 DEAL_II_NAMESPACE_CLOSE
 
diff --git a/include/deal.II/fe/fe_simplex_p.h b/include/deal.II/fe/fe_simplex_p.h
index 8105d22376..43fb6b08a3 100644
--- a/include/deal.II/fe/fe_simplex_p.h
+++ b/include/deal.II/fe/fe_simplex_p.h
@@ -24,188 +24,185 @@
 
 DEAL_II_NAMESPACE_OPEN
 
-namespace Simplex
+/**
+ * Base class of FE_SimplexP and FE_SimplexDGP.
+ *
+ * @note Only implemented for 2D and 3D.
+ *
+ * @ingroup simplex
+ */
+template <int dim, int spacedim = dim>
+class FE_SimplexPoly : public dealii::FE_Poly<dim, spacedim>
 {
+public:
   /**
-   * Base class of FE_P and FE_DGP.
-   *
-   * @note Only implemented for 2D and 3D.
-   *
-   * @ingroup simplex
-   */
-  template <int dim, int spacedim = dim>
-  class FE_Poly : public dealii::FE_Poly<dim, spacedim>
-  {
-  public:
-    /**
-     * Constructor.
-     */
-    FE_Poly(const unsigned int                                degree,
-            const std::vector<unsigned int> &                 dpo_vector,
-            const typename FiniteElementData<dim>::Conformity conformity);
-
-    /**
-     * Return a list of constant modes of the element. For this element, the
-     * list consists of true arguments for all components.
-     */
-    virtual std::pair<Table<2, bool>, std::vector<unsigned int>>
-    get_constant_modes() const override;
-
-    /**
-     * @copydoc dealii::FiniteElement::get_prolongation_matrix()
-     *
-     * @note Only implemented for RefinementCase::isotropic_refinement.
-     */
-    virtual const FullMatrix<double> &
-    get_prolongation_matrix(
-      const unsigned int         child,
-      const RefinementCase<dim> &refinement_case =
-        RefinementCase<dim>::isotropic_refinement) const override;
-
-    /**
-     * @copydoc dealii::FiniteElement::get_face_interpolation_matrix()
-     */
-    void
-    get_face_interpolation_matrix(const FiniteElement<dim, spacedim> &source_fe,
-                                  FullMatrix<double> &interpolation_matrix,
-                                  const unsigned int  face_no) const override;
-
-    /**
-     * @copydoc dealii::FiniteElement::get_subface_interpolation_matrix()
-     */
-    void
-    get_subface_interpolation_matrix(
-      const FiniteElement<dim, spacedim> &x_source_fe,
-      const unsigned int                  subface,
-      FullMatrix<double> &                interpolation_matrix,
-      const unsigned int                  face_no) const override;
-
-    /**
-     * @copydoc dealii::FiniteElement::hp_constraints_are_implemented()
-     */
-    bool
-    hp_constraints_are_implemented() const override;
-
-    /**
-     * @copydoc dealii::FiniteElement::convert_generalized_support_point_values_to_dof_values()
-     */
-    virtual void
-    convert_generalized_support_point_values_to_dof_values(
-      const std::vector<Vector<double>> &support_point_values,
-      std::vector<double> &              nodal_values) const override;
-
-    mutable Threads::Mutex mutex;
-  };
-
-
-
-  /**
-   * Implementation of a scalar Lagrange finite element $P_k$ that yields
-   * the finite element space of continuous, piecewise polynomials of
-   * degree $k$.
-   *
-   * @ingroup simplex
-   */
-  template <int dim, int spacedim = dim>
-  class FE_P : public FE_Poly<dim, spacedim>
-  {
-  public:
-    /**
-     * Constructor.
-     */
-    FE_P(const unsigned int degree);
-
-    /**
-     * @copydoc dealii::FiniteElement::clone()
-     */
-    std::unique_ptr<FiniteElement<dim, spacedim>>
-    clone() const override;
-
-    /**
-     * Return a string that uniquely identifies a finite element. This class
-     * returns <tt>Simplex::FE_P<dim>(degree)</tt>, with @p dim and @p degree
-     * replaced by appropriate values.
-     */
-    std::string
-    get_name() const override;
-
-    /**
-     * @copydoc dealii::FiniteElement::compare_for_domination()
-     */
-    FiniteElementDomination::Domination
-    compare_for_domination(const FiniteElement<dim, spacedim> &fe_other,
-                           const unsigned int codim) const override;
-
-    /**
-     * @copydoc dealii::FiniteElement::hp_vertex_dof_identities()
-     */
-    std::vector<std::pair<unsigned int, unsigned int>>
-    hp_vertex_dof_identities(
-      const FiniteElement<dim, spacedim> &fe_other) const override;
-
-    /**
-     * @copydoc dealii::FiniteElement::hp_line_dof_identities()
-     */
-    std::vector<std::pair<unsigned int, unsigned int>>
-    hp_line_dof_identities(
-      const FiniteElement<dim, spacedim> &fe_other) const override;
-  };
-
-
-
-  /**
-   * Implementation of a scalar discontinuous Lagrange finite element
-   * $P_k$, sometimes denoted as $P_{-k}$, that yields the finite
-   * element space of discontinuous, piecewise polynomials of degree
-   * $k$.
+   * Constructor.
+   */
+  FE_SimplexPoly(const unsigned int                                degree,
+                 const std::vector<unsigned int> &                 dpo_vector,
+                 const typename FiniteElementData<dim>::Conformity conformity);
+
+  /**
+   * Return a list of constant modes of the element. For this element, the
+   * list consists of true arguments for all components.
+   */
+  virtual std::pair<Table<2, bool>, std::vector<unsigned int>>
+  get_constant_modes() const override;
+
+  /**
+   * @copydoc dealii::FiniteElement::get_prolongation_matrix()
    *
-   * @ingroup simplex
-   */
-  template <int dim, int spacedim = dim>
-  class FE_DGP : public FE_Poly<dim, spacedim>
-  {
-  public:
-    /**
-     * Constructor.
-     */
-    FE_DGP(const unsigned int degree);
-
-    /**
-     * @copydoc dealii::FiniteElement::clone()
-     */
-    std::unique_ptr<FiniteElement<dim, spacedim>>
-    clone() const override;
-
-    /**
-     * Return a string that uniquely identifies a finite element. This class
-     * returns <tt>Simplex::FE_DGP<dim>(degree)</tt>, with @p dim and @p degree
-     * replaced by appropriate values.
-     */
-    std::string
-    get_name() const override;
-
-    /**
-     * @copydoc dealii::FiniteElement::compare_for_domination()
-     */
-    FiniteElementDomination::Domination
-    compare_for_domination(const FiniteElement<dim, spacedim> &fe_other,
-                           const unsigned int codim) const override;
-
-    /**
-     * @copydoc dealii::FiniteElement::hp_vertex_dof_identities()
-     */
-    std::vector<std::pair<unsigned int, unsigned int>>
-    hp_vertex_dof_identities(
-      const FiniteElement<dim, spacedim> &fe_other) const override;
-
-    /**
-     * @copydoc dealii::FiniteElement::hp_line_dof_identities()
-     */
-    std::vector<std::pair<unsigned int, unsigned int>>
-    hp_line_dof_identities(
-      const FiniteElement<dim, spacedim> &fe_other) const override;
-  };
-} // namespace Simplex
+   * @note Only implemented for RefinementCase::isotropic_refinement.
+   */
+  virtual const FullMatrix<double> &
+  get_prolongation_matrix(
+    const unsigned int         child,
+    const RefinementCase<dim> &refinement_case =
+      RefinementCase<dim>::isotropic_refinement) const override;
+
+  /**
+   * @copydoc dealii::FiniteElement::get_face_interpolation_matrix()
+   */
+  void
+  get_face_interpolation_matrix(const FiniteElement<dim, spacedim> &source_fe,
+                                FullMatrix<double> &interpolation_matrix,
+                                const unsigned int  face_no) const override;
+
+  /**
+   * @copydoc dealii::FiniteElement::get_subface_interpolation_matrix()
+   */
+  void
+  get_subface_interpolation_matrix(
+    const FiniteElement<dim, spacedim> &x_source_fe,
+    const unsigned int                  subface,
+    FullMatrix<double> &                interpolation_matrix,
+    const unsigned int                  face_no) const override;
+
+  /**
+   * @copydoc dealii::FiniteElement::hp_constraints_are_implemented()
+   */
+  bool
+  hp_constraints_are_implemented() const override;
+
+  /**
+   * @copydoc dealii::FiniteElement::convert_generalized_support_point_values_to_dof_values()
+   */
+  virtual void
+  convert_generalized_support_point_values_to_dof_values(
+    const std::vector<Vector<double>> &support_point_values,
+    std::vector<double> &              nodal_values) const override;
+
+  mutable Threads::Mutex mutex;
+};
+
+
+
+/**
+ * Implementation of a scalar Lagrange finite element $P_k$ that yields
+ * the finite element space of continuous, piecewise polynomials of
+ * degree $k$.
+ *
+ * @ingroup simplex
+ */
+template <int dim, int spacedim = dim>
+class FE_SimplexP : public FE_SimplexPoly<dim, spacedim>
+{
+public:
+  /**
+   * Constructor.
+   */
+  FE_SimplexP(const unsigned int degree);
+
+  /**
+   * @copydoc dealii::FiniteElement::clone()
+   */
+  std::unique_ptr<FiniteElement<dim, spacedim>>
+  clone() const override;
+
+  /**
+   * Return a string that uniquely identifies a finite element. This class
+   * returns <tt>FE_SimplexP<dim>(degree)</tt>, with @p dim and @p degree
+   * replaced by appropriate values.
+   */
+  std::string
+  get_name() const override;
+
+  /**
+   * @copydoc dealii::FiniteElement::compare_for_domination()
+   */
+  FiniteElementDomination::Domination
+  compare_for_domination(const FiniteElement<dim, spacedim> &fe_other,
+                         const unsigned int codim) const override;
+
+  /**
+   * @copydoc dealii::FiniteElement::hp_vertex_dof_identities()
+   */
+  std::vector<std::pair<unsigned int, unsigned int>>
+  hp_vertex_dof_identities(
+    const FiniteElement<dim, spacedim> &fe_other) const override;
+
+  /**
+   * @copydoc dealii::FiniteElement::hp_line_dof_identities()
+   */
+  std::vector<std::pair<unsigned int, unsigned int>>
+  hp_line_dof_identities(
+    const FiniteElement<dim, spacedim> &fe_other) const override;
+};
+
+
+
+/**
+ * Implementation of a scalar discontinuous Lagrange finite element
+ * $P_k$, sometimes denoted as $P_{-k}$, that yields the finite
+ * element space of discontinuous, piecewise polynomials of degree
+ * $k$.
+ *
+ * @ingroup simplex
+ */
+template <int dim, int spacedim = dim>
+class FE_SimplexDGP : public FE_SimplexPoly<dim, spacedim>
+{
+public:
+  /**
+   * Constructor.
+   */
+  FE_SimplexDGP(const unsigned int degree);
+
+  /**
+   * @copydoc dealii::FiniteElement::clone()
+   */
+  std::unique_ptr<FiniteElement<dim, spacedim>>
+  clone() const override;
+
+  /**
+   * Return a string that uniquely identifies a finite element. This class
+   * returns <tt>FE_SimplexDGP<dim>(degree)</tt>, with @p dim and @p degree
+   * replaced by appropriate values.
+   */
+  std::string
+  get_name() const override;
+
+  /**
+   * @copydoc dealii::FiniteElement::compare_for_domination()
+   */
+  FiniteElementDomination::Domination
+  compare_for_domination(const FiniteElement<dim, spacedim> &fe_other,
+                         const unsigned int codim) const override;
+
+  /**
+   * @copydoc dealii::FiniteElement::hp_vertex_dof_identities()
+   */
+  std::vector<std::pair<unsigned int, unsigned int>>
+  hp_vertex_dof_identities(
+    const FiniteElement<dim, spacedim> &fe_other) const override;
+
+  /**
+   * @copydoc dealii::FiniteElement::hp_line_dof_identities()
+   */
+  std::vector<std::pair<unsigned int, unsigned int>>
+  hp_line_dof_identities(
+    const FiniteElement<dim, spacedim> &fe_other) const override;
+};
 
 DEAL_II_NAMESPACE_CLOSE
 
diff --git a/include/deal.II/fe/fe_simplex_p_bubbles.h b/include/deal.II/fe/fe_simplex_p_bubbles.h
index d6cdb8abe8..387928fa5e 100644
--- a/include/deal.II/fe/fe_simplex_p_bubbles.h
+++ b/include/deal.II/fe/fe_simplex_p_bubbles.h
@@ -24,95 +24,92 @@
 
 DEAL_II_NAMESPACE_OPEN
 
-namespace Simplex
+/**
+ * @brief Enriched version of FE_P that can be used with nodal quadrature.
+ *
+ * Many explicit time integration schemes require solving a mass matrix at
+ * each time step. There are various ways around this requirement - for
+ * example, step-48 replaces the mass matrix with a diagonal approximation,
+ * which makes the solution step trivial. In step-48, and also commonly for
+ * tensor-product elements, this is done by computing the mass matrix with a
+ * lower-order quadrature point based on the nodes of the finite element
+ * (i.e., the nodal quadrature rule one obtains by using the shape functions
+ * as an interpolatory basis).
+ *
+ * A major drawback of standard simplex-based finite elements is that they
+ * cannot be used with nodal quadrature since some of the quadrature weights
+ * end up being either zero or negative, resulting in either an unsolvable or
+ * unstable approximation to the mass matrix. For example: the shape functions
+ * of FE_P<2>(2) with support points at vertices have mean values of zero so
+ * that element cannot be used with mass lumping.
+
+ * This element avoids this issue by replacing the shape functions of FE_P
+ * with an augmented space amendable to the construction of nodal quadrature
+ * rules. For example, on the triangle a single basis function is added
+ * corresponding to interpolation at the centroid (and all other basis
+ * functions are updated to preserve the partition of unity property). This
+ * results in shape functions with positive means (i.e., a valid nodal
+ * quadrature formula). Similarly, in 3D, the polynomial space of FE_P<3>(2)
+ * is enriched with five additional degrees of freedom (where four have
+ * support points at face centroids and one has a support point at the
+ * centroid) to enable construction of valid nodal quadrature rule.
+ *
+ * Since this FE space includes bubbles (i.e., extra functions which are
+ * nonzero only on element interiors), the polynomial degrees of the component
+ * basis functions are higher than the actual approximation degree of the
+ * element. For example, with a constructor argument <code>degree = 2</code>
+ * in 3D, the polynomials are in fact cubic (degree 3) but the order of the
+ * approximation is the same as if we were using quadratic (degree 2) finite
+ * elements.
+ *
+ * The 2D quadratic element was first described in @cite fried1975finite. The
+ * 3D quadratic element implemented here was first described in
+ * @cite Geevers_2018. Higher degree elements amendable to lumping exist but
+ * are not yet implemented in this class.
+ */
+template <int dim, int spacedim = dim>
+class FE_SimplexP_Bubbles : public dealii::FE_Poly<dim, spacedim>
 {
+public:
   /**
-   * @brief Enriched version of FE_P that can be used with nodal quadrature.
-   *
-   * Many explicit time integration schemes require solving a mass matrix at
-   * each time step. There are various ways around this requirement - for
-   * example, step-48 replaces the mass matrix with a diagonal approximation,
-   * which makes the solution step trivial. In step-48, and also commonly for
-   * tensor-product elements, this is done by computing the mass matrix with a
-   * lower-order quadrature point based on the nodes of the finite element
-   * (i.e., the nodal quadrature rule one obtains by using the shape functions
-   * as an interpolatory basis).
-   *
-   * A major drawback of standard simplex-based finite elements is that they
-   * cannot be used with nodal quadrature since some of the quadrature weights
-   * end up being either zero or negative, resulting in either an unsolvable or
-   * unstable approximation to the mass matrix. For example: the shape functions
-   * of FE_P<2>(2) with support points at vertices have mean values of zero so
-   * that element cannot be used with mass lumping.
-
-   * This element avoids this issue by replacing the shape functions of FE_P
-   * with an augmented space amendable to the construction of nodal quadrature
-   * rules. For example, on the triangle a single basis function is added
-   * corresponding to interpolation at the centroid (and all other basis
-   * functions are updated to preserve the partition of unity property). This
-   * results in shape functions with positive means (i.e., a valid nodal
-   * quadrature formula). Similarly, in 3D, the polynomial space of FE_P<3>(2)
-   * is enriched with five additional degrees of freedom (where four have
-   * support points at face centroids and one has a support point at the
-   * centroid) to enable construction of valid nodal quadrature rule.
+   * Constructor, taking the approximation degree as an argument. The
+   * polynomial space is typically one degree higher than the approximation
+   * space for this element: see the general documentation of this class for
+   * more information.
    *
-   * Since this FE space includes bubbles (i.e., extra functions which are
-   * nonzero only on element interiors), the polynomial degrees of the component
-   * basis functions are higher than the actual approximation degree of the
-   * element. For example, with a constructor argument <code>degree = 2</code>
-   * in 3D, the polynomials are in fact cubic (degree 3) but the order of the
-   * approximation is the same as if we were using quadratic (degree 2) finite
-   * elements.
-   *
-   * The 2D quadratic element was first described in @cite fried1975finite. The
-   * 3D quadratic element implemented here was first described in
-   * @cite Geevers_2018. Higher degree elements amendable to lumping exist but
-   * are not yet implemented in this class.
+   * @note For <code>degree == 1</code> this element is equivalent to FE_P(1).
    */
-  template <int dim, int spacedim = dim>
-  class FE_P_Bubbles : public dealii::FE_Poly<dim, spacedim>
-  {
-  public:
-    /**
-     * Constructor, taking the approximation degree as an argument. The
-     * polynomial space is typically one degree higher than the approximation
-     * space for this element: see the general documentation of this class for
-     * more information.
-     *
-     * @note For <code>degree == 1</code> this element is equivalent to FE_P(1).
-     */
-    FE_P_Bubbles(const unsigned int degree);
+  FE_SimplexP_Bubbles(const unsigned int degree);
 
-    /**
-     * @copydoc dealii::FiniteElement::clone()
-     */
-    virtual std::unique_ptr<FiniteElement<dim, spacedim>>
-    clone() const override;
+  /**
+   * @copydoc dealii::FiniteElement::clone()
+   */
+  virtual std::unique_ptr<FiniteElement<dim, spacedim>>
+  clone() const override;
 
-    /**
-     * Return a string that uniquely identifies a finite element. This class
-     * returns <tt>Simplex::FE_F_Bubbles<dim,spacedim>(degree)</tt>, with
-     * @p dim, @p spacedim, and @p degree replaced by appropriate values. As
-     * usual, @p spacedim is omitted in the codimension zero case.
-     */
-    virtual std::string
-    get_name() const override;
+  /**
+   * Return a string that uniquely identifies a finite element. This class
+   * returns <tt>FE_SimplexP_Bubbles<dim,spacedim>(degree)</tt>, with
+   * @p dim, @p spacedim, and @p degree replaced by appropriate values. As
+   * usual, @p spacedim is omitted in the codimension zero case.
+   */
+  virtual std::string
+  get_name() const override;
 
-    /**
-     * @copydoc dealii::FiniteElement::convert_generalized_support_point_values_to_dof_values()
-     */
-    virtual void
-    convert_generalized_support_point_values_to_dof_values(
-      const std::vector<Vector<double>> &support_point_values,
-      std::vector<double> &              nodal_values) const override;
+  /**
+   * @copydoc dealii::FiniteElement::convert_generalized_support_point_values_to_dof_values()
+   */
+  virtual void
+  convert_generalized_support_point_values_to_dof_values(
+    const std::vector<Vector<double>> &support_point_values,
+    std::vector<double> &              nodal_values) const override;
 
-  protected:
-    /**
-     * Degree of the approximation (i.e., the constructor argument).
-     */
-    unsigned int approximation_degree;
-  };
-} // namespace Simplex
+protected:
+  /**
+   * Degree of the approximation (i.e., the constructor argument).
+   */
+  unsigned int approximation_degree;
+};
 
 DEAL_II_NAMESPACE_CLOSE
 
diff --git a/include/deal.II/fe/fe_wedge_p.h b/include/deal.II/fe/fe_wedge_p.h
index 3a01b2e7c3..46b7c8ce60 100644
--- a/include/deal.II/fe/fe_wedge_p.h
+++ b/include/deal.II/fe/fe_wedge_p.h
@@ -24,117 +24,114 @@
 
 DEAL_II_NAMESPACE_OPEN
 
-namespace Simplex
+/**
+ * Base class of FE_WedgeP and FE_WedgeDGP.
+ *
+ * @note Only implemented for 3D.
+ *
+ * @ingroup simplex
+ */
+template <int dim, int spacedim = dim>
+class FE_Wedge : public dealii::FE_Poly<dim, spacedim>
 {
+public:
   /**
-   * Base class of FE_WedgeP and FE_WedgeDGP.
-   *
-   * @note Only implemented for 3D.
-   *
-   * @ingroup simplex
+   * Constructor.
    */
-  template <int dim, int spacedim = dim>
-  class FE_Wedge : public dealii::FE_Poly<dim, spacedim>
-  {
-  public:
-    /**
-     * Constructor.
-     */
-    FE_Wedge(const unsigned int                                degree,
-             const internal::GenericDoFsPerObject &            dpos,
-             const typename FiniteElementData<dim>::Conformity conformity);
-  };
+  FE_Wedge(const unsigned int                                degree,
+           const internal::GenericDoFsPerObject &            dpos,
+           const typename FiniteElementData<dim>::Conformity conformity);
+};
+
+/**
+ * Implementation of a scalar Lagrange finite element on a wedge that yields
+ * the finite element space of continuous, piecewise polynomials of
+ * degree $k$.
+ *
+ * @ingroup simplex
+ */
+template <int dim, int spacedim = dim>
+class FE_WedgeP : public FE_Wedge<dim, spacedim>
+{
+public:
+  /**
+   * Constructor.
+   */
+  FE_WedgeP(const unsigned int degree);
+
+  /**
+   * @copydoc dealii::FiniteElement::clone()
+   */
+  std::unique_ptr<FiniteElement<dim, spacedim>>
+  clone() const override;
+
+  /**
+   * Return a string that uniquely identifies a finite element. This class
+   * returns <tt>FE_WedgeP<dim>(degree)</tt>, with @p dim and @p degree
+   * replaced by appropriate values.
+   */
+  std::string
+  get_name() const override;
+
+  /**
+   * @copydoc dealii::FiniteElement::compare_for_domination()
+   */
+  FiniteElementDomination::Domination
+  compare_for_domination(const FiniteElement<dim, spacedim> &fe_other,
+                         const unsigned int codim) const override;
+
+  /**
+   * @copydoc dealii::FiniteElement::hp_vertex_dof_identities()
+   */
+  std::vector<std::pair<unsigned int, unsigned int>>
+  hp_vertex_dof_identities(
+    const FiniteElement<dim, spacedim> &fe_other) const override;
+
+  /**
+   * @copydoc dealii::FiniteElement::hp_line_dof_identities()
+   */
+  std::vector<std::pair<unsigned int, unsigned int>>
+  hp_line_dof_identities(
+    const FiniteElement<dim, spacedim> &fe_other) const override;
+
+  /**
+   * @copydoc dealii::FiniteElement::hp_quad_dof_identities()
+   */
+  std::vector<std::pair<unsigned int, unsigned int>>
+  hp_quad_dof_identities(const FiniteElement<dim, spacedim> &fe_other,
+                         const unsigned int face_no = 0) const override;
+};
+
+/**
+ * Implementation of a scalar Lagrange finite element on a wedge that yields
+ * the finite element space of discontinuous, piecewise polynomials of
+ * degree $k$.
+ *
+ * @ingroup simplex
+ */
+template <int dim, int spacedim = dim>
+class FE_WedgeDGP : public FE_Wedge<dim, spacedim>
+{
+public:
+  /**
+   * Constructor.
+   */
+  FE_WedgeDGP(const unsigned int degree);
 
   /**
-   * Implementation of a scalar Lagrange finite element on a wedge that yields
-   * the finite element space of continuous, piecewise polynomials of
-   * degree $k$.
-   *
-   * @ingroup simplex
+   * @copydoc dealii::FiniteElement::clone()
    */
-  template <int dim, int spacedim = dim>
-  class FE_WedgeP : public FE_Wedge<dim, spacedim>
-  {
-  public:
-    /**
-     * Constructor.
-     */
-    FE_WedgeP(const unsigned int degree);
-
-    /**
-     * @copydoc dealii::FiniteElement::clone()
-     */
-    std::unique_ptr<FiniteElement<dim, spacedim>>
-    clone() const override;
-
-    /**
-     * Return a string that uniquely identifies a finite element. This class
-     * returns <tt>Simplex::FE_WedgeP<dim>(degree)</tt>, with @p dim and @p degree
-     * replaced by appropriate values.
-     */
-    std::string
-    get_name() const override;
-
-    /**
-     * @copydoc dealii::FiniteElement::compare_for_domination()
-     */
-    FiniteElementDomination::Domination
-    compare_for_domination(const FiniteElement<dim, spacedim> &fe_other,
-                           const unsigned int codim) const override;
-
-    /**
-     * @copydoc dealii::FiniteElement::hp_vertex_dof_identities()
-     */
-    std::vector<std::pair<unsigned int, unsigned int>>
-    hp_vertex_dof_identities(
-      const FiniteElement<dim, spacedim> &fe_other) const override;
-
-    /**
-     * @copydoc dealii::FiniteElement::hp_line_dof_identities()
-     */
-    std::vector<std::pair<unsigned int, unsigned int>>
-    hp_line_dof_identities(
-      const FiniteElement<dim, spacedim> &fe_other) const override;
-
-    /**
-     * @copydoc dealii::FiniteElement::hp_quad_dof_identities()
-     */
-    std::vector<std::pair<unsigned int, unsigned int>>
-    hp_quad_dof_identities(const FiniteElement<dim, spacedim> &fe_other,
-                           const unsigned int face_no = 0) const override;
-  };
+  std::unique_ptr<FiniteElement<dim, spacedim>>
+  clone() const override;
 
   /**
-   * Implementation of a scalar Lagrange finite element on a wedge that yields
-   * the finite element space of discontinuous, piecewise polynomials of
-   * degree $k$.
-   *
-   * @ingroup simplex
+   * Return a string that uniquely identifies a finite element. This class
+   * returns <tt>FE_WedgeDGP<dim>(degree)</tt>, with @p dim and @p degree
+   * replaced by appropriate values.
    */
-  template <int dim, int spacedim = dim>
-  class FE_WedgeDGP : public FE_Wedge<dim, spacedim>
-  {
-  public:
-    /**
-     * Constructor.
-     */
-    FE_WedgeDGP(const unsigned int degree);
-
-    /**
-     * @copydoc dealii::FiniteElement::clone()
-     */
-    std::unique_ptr<FiniteElement<dim, spacedim>>
-    clone() const override;
-
-    /**
-     * Return a string that uniquely identifies a finite element. This class
-     * returns <tt>Simplex::FE_WedgeDGP<dim>(degree)</tt>, with @p dim and @p degree
-     * replaced by appropriate values.
-     */
-    std::string
-    get_name() const override;
-  };
-} // namespace Simplex
+  std::string
+  get_name() const override;
+};
 
 DEAL_II_NAMESPACE_CLOSE
 
diff --git a/include/deal.II/grid/reference_cell.h b/include/deal.II/grid/reference_cell.h
index 99569b072a..564c9db7ba 100644
--- a/include/deal.II/grid/reference_cell.h
+++ b/include/deal.II/grid/reference_cell.h
@@ -158,9 +158,9 @@ public:
    * Return a default mapping of degree @p degree matching the current
    * reference cell. If this reference cell is a hypercube, then the returned
    * mapping is a MappingQGeneric; otherwise, it is an object of type
-   * MappingFE initialized with Simplex::FE_P (if the reference cell is a
-   * triangle or tetrahedron), with Simplex::FE_PyramidP (if the reference
-   * cell is a pyramid), or with Simplex::FE_WedgeP (if the reference cell is
+   * MappingFE initialized with FE_SimplexP (if the reference cell is a
+   * triangle or tetrahedron), with FE_PyramidP (if the reference
+   * cell is a pyramid), or with FE_WedgeP (if the reference cell is
    * a wedge).
    */
   template <int dim, int spacedim>
@@ -171,9 +171,9 @@ public:
    * Return a default linear mapping matching the current reference cell.
    * If this reference cell is a hypercube, then the returned mapping
    * is a MappingQ1; otherwise, it is an object of type MappingFE
-   * initialized with Simplex::FE_P (if the reference cell is a triangle or
-   * tetrahedron), with Simplex::FE_PyramidP (if the reference cell is a
-   * pyramid), or with Simplex::FE_WedgeP (if the reference cell is a wedge).
+   * initialized with FE_SimplexP (if the reference cell is a triangle or
+   * tetrahedron), with FE_PyramidP (if the reference cell is a
+   * pyramid), or with FE_WedgeP (if the reference cell is a wedge).
    * In other words, the term "linear" in the name of the function has to be
    * understood as $d$-linear (i.e., bilinear or trilinear) for some of the
    * coordinate directions.
@@ -184,7 +184,7 @@ public:
 
   /**
    * Return a Gauss-type quadrature matching the given reference cell (QGauss,
-   * Simplex::QGauss, Simplex::QGaussPyramid, Simplex::QGaussWedge).
+   * QGaussSimplex, QGaussPyramid, QGaussWedge).
    *
    * @param[in] n_points_1D The number of quadrature points in each direction
    * (QGauss) or an indication of what polynomial degree needs to be
@@ -1503,7 +1503,7 @@ ReferenceCell::d_linear_shape_function(const Point<dim> & xi,
 
   if (*this ==
       ReferenceCells::Triangle) // see also
-                                // Simplex::ScalarPolynomial::compute_value
+                                // BarycentricPolynomials<2>::compute_value
     {
       switch (i)
         {
@@ -1518,7 +1518,7 @@ ReferenceCell::d_linear_shape_function(const Point<dim> & xi,
 
   if (*this ==
       ReferenceCells::Tetrahedron) // see also
-                                   // Simplex::ScalarPolynomial::compute_value
+                                   // BarycentricPolynomials<3>::compute_value
     {
       switch (i)
         {
@@ -1534,9 +1534,8 @@ ReferenceCell::d_linear_shape_function(const Point<dim> & xi,
         }
     }
 
-  if (*this ==
-      ReferenceCells::Wedge) // see also
-                             // Simplex::ScalarWedgePolynomial::compute_value
+  if (*this == ReferenceCells::Wedge) // see also
+                                      // ScalarWedgePolynomial::compute_value
     {
       return ReferenceCell(ReferenceCells::Triangle)
                .d_linear_shape_function<2>(Point<2>(xi[std::min(0, dim - 1)],
@@ -1547,9 +1546,9 @@ ReferenceCell::d_linear_shape_function(const Point<dim> & xi,
                                            i / 3);
     }
 
-  if (*this == ReferenceCells::
-                 Pyramid) // see also
-                          // Simplex::ScalarPyramidPolynomial::compute_value
+  if (*this ==
+      ReferenceCells::Pyramid) // see also
+                               // ScalarPyramidPolynomial::compute_value
     {
       const double Q14 = 0.25;
       double       ration;
@@ -1597,7 +1596,7 @@ ReferenceCell::d_linear_shape_function_gradient(const Point<dim> & xi,
 
   if (*this ==
       ReferenceCells::Triangle) // see also
-                                // Simplex::ScalarPolynomial::compute_grad
+                                // BarycentricPolynomials<2>::compute_grad
     {
       switch (i)
         {
diff --git a/include/deal.II/matrix_free/matrix_free.templates.h b/include/deal.II/matrix_free/matrix_free.templates.h
index 1e0d715dd4..1d1429a6bf 100644
--- a/include/deal.II/matrix_free/matrix_free.templates.h
+++ b/include/deal.II/matrix_free/matrix_free.templates.h
@@ -1470,7 +1470,7 @@ MatrixFree<dim, Number, VectorizedArrayType>::initialize_indices(
     shape_info.size(0), shape_info.size(2));
   {
     Quadrature<dim> quad(QGauss<dim>(1));
-    Quadrature<dim> quad_simplex(Simplex::QGauss<dim>(1));
+    Quadrature<dim> quad_simplex(QGaussSimplex<dim>(1));
     for (unsigned int no = 0, c = 0; no < dof_handlers.size(); no++)
       for (unsigned int b = 0;
            b < dof_handlers[no]->get_fe(0).n_base_elements();
diff --git a/include/deal.II/matrix_free/shape_info.templates.h b/include/deal.II/matrix_free/shape_info.templates.h
index 6cf1cb2125..c3293a0f12 100644
--- a/include/deal.II/matrix_free/shape_info.templates.h
+++ b/include/deal.II/matrix_free/shape_info.templates.h
@@ -93,10 +93,10 @@ namespace internal
 
       const auto fe_poly = dynamic_cast<const FE_Poly<dim, dim> *>(&fe);
 
-      if (dynamic_cast<const Simplex::FE_P<dim, dim> *>(&fe) != nullptr ||
-          dynamic_cast<const Simplex::FE_DGP<dim, dim> *>(&fe) != nullptr ||
-          dynamic_cast<const Simplex::FE_WedgeP<dim, dim> *>(&fe) != nullptr ||
-          dynamic_cast<const Simplex::FE_PyramidP<dim, dim> *>(&fe) != nullptr)
+      if (dynamic_cast<const FE_SimplexP<dim, dim> *>(&fe) != nullptr ||
+          dynamic_cast<const FE_SimplexDGP<dim, dim> *>(&fe) != nullptr ||
+          dynamic_cast<const FE_WedgeP<dim, dim> *>(&fe) != nullptr ||
+          dynamic_cast<const FE_PyramidP<dim, dim> *>(&fe) != nullptr)
         {
           scalar_lexicographic.resize(fe.n_dofs_per_cell());
           for (unsigned int i = 0; i < scalar_lexicographic.size(); ++i)
@@ -207,10 +207,10 @@ namespace internal
 #ifdef DEAL_II_WITH_SIMPLEX_SUPPORT
               // Simplices are a special case since the polynomial family is not
               // indicative of their support
-              if (dynamic_cast<const Simplex::FE_P<dim> *>(fe_poly_ptr) ||
-                  dynamic_cast<const Simplex::FE_DGP<dim> *>(fe_poly_ptr) ||
-                  dynamic_cast<const Simplex::FE_WedgeP<dim> *>(fe_poly_ptr) ||
-                  dynamic_cast<const Simplex::FE_PyramidP<dim> *>(fe_poly_ptr))
+              if (dynamic_cast<const FE_SimplexP<dim> *>(fe_poly_ptr) ||
+                  dynamic_cast<const FE_SimplexDGP<dim> *>(fe_poly_ptr) ||
+                  dynamic_cast<const FE_WedgeP<dim> *>(fe_poly_ptr) ||
+                  dynamic_cast<const FE_PyramidP<dim> *>(fe_poly_ptr))
                 return true;
 #endif
 
@@ -246,13 +246,13 @@ namespace internal
     {
 #ifdef DEAL_II_WITH_SIMPLEX_SUPPORT
       if (quad_in.is_tensor_product() == false ||
-          dynamic_cast<const Simplex::FE_P<dim> *>(
+          dynamic_cast<const FE_SimplexP<dim> *>(
             &fe_in.base_element(base_element_number)) ||
-          dynamic_cast<const Simplex::FE_DGP<dim> *>(
+          dynamic_cast<const FE_SimplexDGP<dim> *>(
             &fe_in.base_element(base_element_number)) ||
-          dynamic_cast<const Simplex::FE_WedgeP<dim> *>(
+          dynamic_cast<const FE_WedgeP<dim> *>(
             &fe_in.base_element(base_element_number)) ||
-          dynamic_cast<const Simplex::FE_PyramidP<dim> *>(
+          dynamic_cast<const FE_PyramidP<dim> *>(
             &fe_in.base_element(base_element_number)))
         {
           // specialization for arbitrary finite elements and quadrature rules
diff --git a/include/deal.II/matrix_free/util.h b/include/deal.II/matrix_free/util.h
index dec9542a16..c1f6dce66a 100644
--- a/include/deal.II/matrix_free/util.h
+++ b/include/deal.II/matrix_free/util.h
@@ -40,8 +40,8 @@ namespace internal
     {
       if (dim == 2 || dim == 3)
         for (unsigned int i = 1; i <= 3; ++i)
-          if (quad == Simplex::QGauss<dim>(i))
-            return Simplex::QGauss<dim - 1>(i);
+          if (quad == QGaussSimplex<dim>(i))
+            return QGaussSimplex<dim - 1>(i);
 
       AssertThrow(false, ExcNotImplemented());
 
@@ -56,9 +56,9 @@ namespace internal
       if (dim == 2 || dim == 3)
         {
           for (unsigned int i = 1; i <= 4; ++i)
-            if (quad == Simplex::QGauss<dim>(i))
+            if (quad == QGaussSimplex<dim>(i))
               {
-                Simplex::QGauss<dim - 1> tri(i);
+                QGaussSimplex<dim - 1> tri(i);
 
                 if (dim == 2)
                   return {ReferenceCells::Triangle,
@@ -69,9 +69,9 @@ namespace internal
               }
 
           for (unsigned int i = 1; i <= 5; ++i)
-            if (quad == Simplex::QWitherdenVincent<dim>(i))
+            if (quad == QWitherdenVincent<dim>(i))
               {
-                Simplex::QWitherdenVincent<dim - 1> tri(i);
+                QWitherdenVincent<dim - 1> tri(i);
 
                 if (dim == 2)
                   return {ReferenceCells::Triangle,
@@ -84,10 +84,10 @@ namespace internal
 
       if (dim == 3)
         for (unsigned int i = 1; i <= 3; ++i)
-          if (quad == Simplex::QGaussWedge<dim>(i))
+          if (quad == QGaussWedge<dim>(i))
             {
-              QGauss<dim - 1>          quad(i);
-              Simplex::QGauss<dim - 1> tri(i);
+              QGauss<dim - 1>        quad(i);
+              QGaussSimplex<dim - 1> tri(i);
 
               return {
                 ReferenceCells::Wedge,
@@ -96,10 +96,10 @@ namespace internal
 
       if (dim == 3)
         for (unsigned int i = 1; i <= 2; ++i)
-          if (quad == Simplex::QGaussPyramid<dim>(i))
+          if (quad == QGaussPyramid<dim>(i))
             {
-              QGauss<dim - 1>          quad(i);
-              Simplex::QGauss<dim - 1> tri(i);
+              QGauss<dim - 1>        quad(i);
+              QGaussSimplex<dim - 1> tri(i);
 
               return {
                 ReferenceCells::Pyramid,
diff --git a/include/deal.II/numerics/data_out_dof_data.templates.h b/include/deal.II/numerics/data_out_dof_data.templates.h
index 4222b7f112..e97e2a2dd2 100644
--- a/include/deal.II/numerics/data_out_dof_data.templates.h
+++ b/include/deal.II/numerics/data_out_dof_data.templates.h
@@ -261,7 +261,7 @@ namespace internal
                   generate_simplex_evaluation_points<dim>(n_subdivisions));
               else
                 quadrature_simplex = std::make_unique<Quadrature<dim>>(
-                  Simplex::FE_P<dim, spacedim>(n_subdivisions)
+                  FE_SimplexP<dim, spacedim>(n_subdivisions)
                     .get_unit_support_points());
             }
 
@@ -275,7 +275,7 @@ namespace internal
           if (needs_wedge_setup)
             {
               quadrature_wedge = std::make_unique<Quadrature<dim>>(
-                Simplex::FE_WedgeP<dim, spacedim>(
+                FE_WedgeP<dim, spacedim>(
                   1 /*note: vtk only supports linear wedges*/)
                   .get_unit_support_points());
             }
diff --git a/source/base/polynomials_barycentric.cc b/source/base/polynomials_barycentric.cc
index d916f9e944..67616cf6c3 100644
--- a/source/base/polynomials_barycentric.cc
+++ b/source/base/polynomials_barycentric.cc
@@ -18,324 +18,316 @@
 
 DEAL_II_NAMESPACE_OPEN
 
-namespace Simplex
+namespace internal
 {
-  namespace internal
+  /**
+   * Get the highest degree of the barycentric polynomial (in Cartesian
+   * coordinates).
+   */
+  template <int dim>
+  unsigned int
+  get_degree(const std::vector<BarycentricPolynomial<dim>> &polys)
   {
-    /**
-     * Get the highest degree of the barycentric polynomial (in Cartesian
-     * coordinates).
-     */
-    template <int dim>
-    unsigned int
-    get_degree(const std::vector<BarycentricPolynomial<dim>> &polys)
-    {
-      // Since the first variable in a simplex polynomial is, e.g., in 2D,
-      //
-      // t0 = 1 - x - y
-      //
-      // (that is, it depends on the Cartesian variables), we have to compute
-      // its degree separately. An example: t0*t1*t2 has degree 1 in the affine
-      // polynomial basis but is degree 2 in the Cartesian polynomial basis.
-      std::size_t max_degree = 0;
-      for (const auto &poly : polys)
-        {
-          const TableIndices<dim + 1> degrees = poly.degrees();
+    // Since the first variable in a simplex polynomial is, e.g., in 2D,
+    //
+    // t0 = 1 - x - y
+    //
+    // (that is, it depends on the Cartesian variables), we have to compute
+    // its degree separately. An example: t0*t1*t2 has degree 1 in the affine
+    // polynomial basis but is degree 2 in the Cartesian polynomial basis.
+    std::size_t max_degree = 0;
+    for (const auto &poly : polys)
+      {
+        const TableIndices<dim + 1> degrees = poly.degrees();
 
-          const auto  degree_0 = degrees[0];
-          std::size_t degree_d = 0;
-          for (unsigned int d = 1; d < dim + 1; ++d)
-            degree_d = std::max(degree_d, degrees[d]);
+        const auto  degree_0 = degrees[0];
+        std::size_t degree_d = 0;
+        for (unsigned int d = 1; d < dim + 1; ++d)
+          degree_d = std::max(degree_d, degrees[d]);
 
-          max_degree = std::max(max_degree, degree_d + degree_0);
-        }
+        max_degree = std::max(max_degree, degree_d + degree_0);
+      }
 
-      return max_degree;
-    }
-  } // namespace internal
+    return max_degree;
+  }
+} // namespace internal
 
 
-  template <int dim>
-  BarycentricPolynomials<dim>
-  BarycentricPolynomials<dim>::get_fe_p_basis(const unsigned int degree)
-  {
-    std::vector<BarycentricPolynomial<dim>> polys;
+template <int dim>
+BarycentricPolynomials<dim>
+BarycentricPolynomials<dim>::get_fe_p_basis(const unsigned int degree)
+{
+  std::vector<BarycentricPolynomial<dim>> polys;
 
-    auto M = [](const unsigned int d) {
-      return BarycentricPolynomial<dim, double>::monomial(d);
-    };
-    switch (degree)
-      {
-        case 0:
-          polys.push_back(0 * M(0) + 1);
+  auto M = [](const unsigned int d) {
+    return BarycentricPolynomial<dim, double>::monomial(d);
+  };
+  switch (degree)
+    {
+      case 0:
+        polys.push_back(0 * M(0) + 1);
+        break;
+      case 1:
+        {
+          for (unsigned int d = 0; d < dim + 1; ++d)
+            polys.push_back(M(d));
           break;
-        case 1:
-          {
-            for (unsigned int d = 0; d < dim + 1; ++d)
-              polys.push_back(M(d));
-            break;
-          }
-        case 2:
-          {
-            for (unsigned int d = 0; d < dim + 1; ++d)
-              polys.push_back(M(d) * (2 * M(d) - 1));
-            polys.push_back(4 * M(1) * M(0));
-            if (dim >= 2)
-              {
-                polys.push_back(4 * M(1) * M(2));
-                polys.push_back(4 * M(2) * M(0));
-              }
-            if (dim == 3)
-              {
-                polys.push_back(4 * M(3) * M(0));
-                polys.push_back(4 * M(1) * M(3));
-                polys.push_back(4 * M(2) * M(3));
-              }
-            break;
-          }
-        default:
-          Assert(false, ExcNotImplemented());
-      }
+        }
+      case 2:
+        {
+          for (unsigned int d = 0; d < dim + 1; ++d)
+            polys.push_back(M(d) * (2 * M(d) - 1));
+          polys.push_back(4 * M(1) * M(0));
+          if (dim >= 2)
+            {
+              polys.push_back(4 * M(1) * M(2));
+              polys.push_back(4 * M(2) * M(0));
+            }
+          if (dim == 3)
+            {
+              polys.push_back(4 * M(3) * M(0));
+              polys.push_back(4 * M(1) * M(3));
+              polys.push_back(4 * M(2) * M(3));
+            }
+          break;
+        }
+      default:
+        Assert(false, ExcNotImplemented());
+    }
 
-    return BarycentricPolynomials<dim>(polys);
-  }
+  return BarycentricPolynomials<dim>(polys);
+}
 
 
 
-  template <int dim>
-  BarycentricPolynomials<dim>::BarycentricPolynomials(
-    const std::vector<BarycentricPolynomial<dim>> &polynomials)
-    : ScalarPolynomialsBase<dim>(internal::get_degree(polynomials),
-                                 polynomials.size())
-  {
-    polys = polynomials;
+template <int dim>
+BarycentricPolynomials<dim>::BarycentricPolynomials(
+  const std::vector<BarycentricPolynomial<dim>> &polynomials)
+  : ScalarPolynomialsBase<dim>(internal::get_degree(polynomials),
+                               polynomials.size())
+{
+  polys = polynomials;
 
-    poly_grads.reinit({polynomials.size(), dim});
-    poly_hessians.reinit({polynomials.size(), dim, dim});
-    poly_third_derivatives.reinit({polynomials.size(), dim, dim, dim});
-    poly_fourth_derivatives.reinit({polynomials.size(), dim, dim, dim, dim});
+  poly_grads.reinit({polynomials.size(), dim});
+  poly_hessians.reinit({polynomials.size(), dim, dim});
+  poly_third_derivatives.reinit({polynomials.size(), dim, dim, dim});
+  poly_fourth_derivatives.reinit({polynomials.size(), dim, dim, dim, dim});
 
-    for (std::size_t i = 0; i < polynomials.size(); ++i)
-      {
-        // gradients
+  for (std::size_t i = 0; i < polynomials.size(); ++i)
+    {
+      // gradients
+      for (unsigned int d = 0; d < dim; ++d)
+        poly_grads[i][d] = polynomials[i].derivative(d);
+
+      // hessians
+      for (unsigned int d0 = 0; d0 < dim; ++d0)
+        for (unsigned int d1 = 0; d1 < dim; ++d1)
+          poly_hessians[i][d0][d1] = poly_grads[i][d0].derivative(d1);
+
+      // third derivatives
+      for (unsigned int d0 = 0; d0 < dim; ++d0)
+        for (unsigned int d1 = 0; d1 < dim; ++d1)
+          for (unsigned int d2 = 0; d2 < dim; ++d2)
+            poly_third_derivatives[i][d0][d1][d2] =
+              poly_hessians[i][d0][d1].derivative(d2);
+
+      // fourth derivatives
+      for (unsigned int d0 = 0; d0 < dim; ++d0)
+        for (unsigned int d1 = 0; d1 < dim; ++d1)
+          for (unsigned int d2 = 0; d2 < dim; ++d2)
+            for (unsigned int d3 = 0; d3 < dim; ++d3)
+              poly_fourth_derivatives[i][d0][d1][d2][d3] =
+                poly_third_derivatives[i][d0][d1][d2].derivative(d3);
+    }
+}
+
+
+
+template <int dim>
+void
+BarycentricPolynomials<dim>::evaluate(
+  const Point<dim> &           unit_point,
+  std::vector<double> &        values,
+  std::vector<Tensor<1, dim>> &grads,
+  std::vector<Tensor<2, dim>> &grad_grads,
+  std::vector<Tensor<3, dim>> &third_derivatives,
+  std::vector<Tensor<4, dim>> &fourth_derivatives) const
+{
+  Assert(values.size() == this->n() || values.size() == 0,
+         ExcDimensionMismatch2(values.size(), this->n(), 0));
+  Assert(grads.size() == this->n() || grads.size() == 0,
+         ExcDimensionMismatch2(grads.size(), this->n(), 0));
+  Assert(grad_grads.size() == this->n() || grad_grads.size() == 0,
+         ExcDimensionMismatch2(grad_grads.size(), this->n(), 0));
+  Assert(third_derivatives.size() == this->n() || third_derivatives.size() == 0,
+         ExcDimensionMismatch2(third_derivatives.size(), this->n(), 0));
+  Assert(fourth_derivatives.size() == this->n() ||
+           fourth_derivatives.size() == 0,
+         ExcDimensionMismatch2(fourth_derivatives.size(), this->n(), 0));
+
+  for (std::size_t i = 0; i < polys.size(); ++i)
+    {
+      if (values.size() == this->n())
+        values[i] = polys[i].value(unit_point);
+
+      // gradients
+      if (grads.size() == this->n())
         for (unsigned int d = 0; d < dim; ++d)
-          poly_grads[i][d] = polynomials[i].derivative(d);
+          grads[i][d] = poly_grads[i][d].value(unit_point);
 
-        // hessians
+      // hessians
+      if (grad_grads.size() == this->n())
         for (unsigned int d0 = 0; d0 < dim; ++d0)
           for (unsigned int d1 = 0; d1 < dim; ++d1)
-            poly_hessians[i][d0][d1] = poly_grads[i][d0].derivative(d1);
+            grad_grads[i][d0][d1] = poly_hessians[i][d0][d1].value(unit_point);
 
-        // third derivatives
+      // third derivatives
+      if (third_derivatives.size() == this->n())
         for (unsigned int d0 = 0; d0 < dim; ++d0)
           for (unsigned int d1 = 0; d1 < dim; ++d1)
             for (unsigned int d2 = 0; d2 < dim; ++d2)
-              poly_third_derivatives[i][d0][d1][d2] =
-                poly_hessians[i][d0][d1].derivative(d2);
+              third_derivatives[i][d0][d1][d2] =
+                poly_third_derivatives[i][d0][d1][d2].value(unit_point);
 
-        // fourth derivatives
+      // fourth derivatives
+      if (fourth_derivatives.size() == this->n())
         for (unsigned int d0 = 0; d0 < dim; ++d0)
           for (unsigned int d1 = 0; d1 < dim; ++d1)
             for (unsigned int d2 = 0; d2 < dim; ++d2)
               for (unsigned int d3 = 0; d3 < dim; ++d3)
-                poly_fourth_derivatives[i][d0][d1][d2][d3] =
-                  poly_third_derivatives[i][d0][d1][d2].derivative(d3);
-      }
-  }
-
-
-
-  template <int dim>
-  void
-  BarycentricPolynomials<dim>::evaluate(
-    const Point<dim> &           unit_point,
-    std::vector<double> &        values,
-    std::vector<Tensor<1, dim>> &grads,
-    std::vector<Tensor<2, dim>> &grad_grads,
-    std::vector<Tensor<3, dim>> &third_derivatives,
-    std::vector<Tensor<4, dim>> &fourth_derivatives) const
-  {
-    Assert(values.size() == this->n() || values.size() == 0,
-           ExcDimensionMismatch2(values.size(), this->n(), 0));
-    Assert(grads.size() == this->n() || grads.size() == 0,
-           ExcDimensionMismatch2(grads.size(), this->n(), 0));
-    Assert(grad_grads.size() == this->n() || grad_grads.size() == 0,
-           ExcDimensionMismatch2(grad_grads.size(), this->n(), 0));
-    Assert(third_derivatives.size() == this->n() ||
-             third_derivatives.size() == 0,
-           ExcDimensionMismatch2(third_derivatives.size(), this->n(), 0));
-    Assert(fourth_derivatives.size() == this->n() ||
-             fourth_derivatives.size() == 0,
-           ExcDimensionMismatch2(fourth_derivatives.size(), this->n(), 0));
-
-    for (std::size_t i = 0; i < polys.size(); ++i)
-      {
-        if (values.size() == this->n())
-          values[i] = polys[i].value(unit_point);
-
-        // gradients
-        if (grads.size() == this->n())
-          for (unsigned int d = 0; d < dim; ++d)
-            grads[i][d] = poly_grads[i][d].value(unit_point);
-
-        // hessians
-        if (grad_grads.size() == this->n())
-          for (unsigned int d0 = 0; d0 < dim; ++d0)
-            for (unsigned int d1 = 0; d1 < dim; ++d1)
-              grad_grads[i][d0][d1] =
-                poly_hessians[i][d0][d1].value(unit_point);
-
-        // third derivatives
-        if (third_derivatives.size() == this->n())
-          for (unsigned int d0 = 0; d0 < dim; ++d0)
-            for (unsigned int d1 = 0; d1 < dim; ++d1)
-              for (unsigned int d2 = 0; d2 < dim; ++d2)
-                third_derivatives[i][d0][d1][d2] =
-                  poly_third_derivatives[i][d0][d1][d2].value(unit_point);
-
-        // fourth derivatives
-        if (fourth_derivatives.size() == this->n())
-          for (unsigned int d0 = 0; d0 < dim; ++d0)
-            for (unsigned int d1 = 0; d1 < dim; ++d1)
-              for (unsigned int d2 = 0; d2 < dim; ++d2)
-                for (unsigned int d3 = 0; d3 < dim; ++d3)
-                  fourth_derivatives[i][d0][d1][d2][d3] =
-                    poly_fourth_derivatives[i][d0][d1][d2][d3].value(
-                      unit_point);
-      }
-  }
+                fourth_derivatives[i][d0][d1][d2][d3] =
+                  poly_fourth_derivatives[i][d0][d1][d2][d3].value(unit_point);
+    }
+}
 
 
 
-  template <int dim>
-  double
-  BarycentricPolynomials<dim>::compute_value(const unsigned int i,
-                                             const Point<dim> & p) const
-  {
-    AssertIndexRange(i, this->n());
-    return polys[i].value(p);
-  }
+template <int dim>
+double
+BarycentricPolynomials<dim>::compute_value(const unsigned int i,
+                                           const Point<dim> & p) const
+{
+  AssertIndexRange(i, this->n());
+  return polys[i].value(p);
+}
 
 
 
-  template <int dim>
-  Tensor<1, dim>
-  BarycentricPolynomials<dim>::compute_1st_derivative(const unsigned int i,
-                                                      const Point<dim> &p) const
-  {
-    Tensor<1, dim> result;
-    for (unsigned int d = 0; d < dim; ++d)
-      result[d] = poly_grads[i][d].value(p);
-    return result;
-  }
+template <int dim>
+Tensor<1, dim>
+BarycentricPolynomials<dim>::compute_1st_derivative(const unsigned int i,
+                                                    const Point<dim> & p) const
+{
+  Tensor<1, dim> result;
+  for (unsigned int d = 0; d < dim; ++d)
+    result[d] = poly_grads[i][d].value(p);
+  return result;
+}
 
 
 
-  template <int dim>
-  Tensor<2, dim>
-  BarycentricPolynomials<dim>::compute_2nd_derivative(const unsigned int i,
-                                                      const Point<dim> &p) const
-  {
-    Tensor<2, dim> result;
-    for (unsigned int d0 = 0; d0 < dim; ++d0)
-      for (unsigned int d1 = 0; d1 < dim; ++d1)
-        result[d0][d1] = poly_hessians[i][d0][d1].value(p);
+template <int dim>
+Tensor<2, dim>
+BarycentricPolynomials<dim>::compute_2nd_derivative(const unsigned int i,
+                                                    const Point<dim> & p) const
+{
+  Tensor<2, dim> result;
+  for (unsigned int d0 = 0; d0 < dim; ++d0)
+    for (unsigned int d1 = 0; d1 < dim; ++d1)
+      result[d0][d1] = poly_hessians[i][d0][d1].value(p);
 
-    return result;
-  }
+  return result;
+}
 
 
 
-  template <int dim>
-  Tensor<3, dim>
-  BarycentricPolynomials<dim>::compute_3rd_derivative(const unsigned int i,
-                                                      const Point<dim> &p) const
-  {
-    Tensor<3, dim> result;
-    for (unsigned int d0 = 0; d0 < dim; ++d0)
-      for (unsigned int d1 = 0; d1 < dim; ++d1)
-        for (unsigned int d2 = 0; d2 < dim; ++d2)
-          result[d0][d1][d2] = poly_third_derivatives[i][d0][d1][d2].value(p);
+template <int dim>
+Tensor<3, dim>
+BarycentricPolynomials<dim>::compute_3rd_derivative(const unsigned int i,
+                                                    const Point<dim> & p) const
+{
+  Tensor<3, dim> result;
+  for (unsigned int d0 = 0; d0 < dim; ++d0)
+    for (unsigned int d1 = 0; d1 < dim; ++d1)
+      for (unsigned int d2 = 0; d2 < dim; ++d2)
+        result[d0][d1][d2] = poly_third_derivatives[i][d0][d1][d2].value(p);
 
-    return result;
-  }
+  return result;
+}
 
 
 
-  template <int dim>
-  Tensor<4, dim>
-  BarycentricPolynomials<dim>::compute_4th_derivative(const unsigned int i,
-                                                      const Point<dim> &p) const
-  {
-    Tensor<4, dim> result;
-    for (unsigned int d0 = 0; d0 < dim; ++d0)
-      for (unsigned int d1 = 0; d1 < dim; ++d1)
-        for (unsigned int d2 = 0; d2 < dim; ++d2)
-          for (unsigned int d3 = 0; d3 < dim; ++d3)
-            result[d0][d1][d2][d3] =
-              poly_fourth_derivatives[i][d0][d1][d2][d3].value(p);
-
-    return result;
-  }
+template <int dim>
+Tensor<4, dim>
+BarycentricPolynomials<dim>::compute_4th_derivative(const unsigned int i,
+                                                    const Point<dim> & p) const
+{
+  Tensor<4, dim> result;
+  for (unsigned int d0 = 0; d0 < dim; ++d0)
+    for (unsigned int d1 = 0; d1 < dim; ++d1)
+      for (unsigned int d2 = 0; d2 < dim; ++d2)
+        for (unsigned int d3 = 0; d3 < dim; ++d3)
+          result[d0][d1][d2][d3] =
+            poly_fourth_derivatives[i][d0][d1][d2][d3].value(p);
 
+  return result;
+}
 
 
-  template <int dim>
-  Tensor<1, dim>
-  BarycentricPolynomials<dim>::compute_grad(const unsigned int i,
-                                            const Point<dim> & p) const
-  {
-    return compute_1st_derivative(i, p);
-  }
 
+template <int dim>
+Tensor<1, dim>
+BarycentricPolynomials<dim>::compute_grad(const unsigned int i,
+                                          const Point<dim> & p) const
+{
+  return compute_1st_derivative(i, p);
+}
 
 
-  template <int dim>
-  Tensor<2, dim>
-  BarycentricPolynomials<dim>::compute_grad_grad(const unsigned int i,
-                                                 const Point<dim> & p) const
-  {
-    return compute_2nd_derivative(i, p);
-  }
-
 
+template <int dim>
+Tensor<2, dim>
+BarycentricPolynomials<dim>::compute_grad_grad(const unsigned int i,
+                                               const Point<dim> & p) const
+{
+  return compute_2nd_derivative(i, p);
+}
 
-  template <int dim>
-  std::unique_ptr<ScalarPolynomialsBase<dim>>
-  BarycentricPolynomials<dim>::clone() const
-  {
-    return std::make_unique<BarycentricPolynomials<dim>>(*this);
-  }
 
 
+template <int dim>
+std::unique_ptr<ScalarPolynomialsBase<dim>>
+BarycentricPolynomials<dim>::clone() const
+{
+  return std::make_unique<BarycentricPolynomials<dim>>(*this);
+}
 
-  template <int dim>
-  std::string
-  BarycentricPolynomials<dim>::name() const
-  {
-    return "BarycentricPolynomials<" + std::to_string(dim) + ">";
-  }
 
 
+template <int dim>
+std::string
+BarycentricPolynomials<dim>::name() const
+{
+  return "BarycentricPolynomials<" + std::to_string(dim) + ">";
+}
 
-  template <int dim>
-  std::size_t
-  BarycentricPolynomials<dim>::memory_consumption() const
-  {
-    std::size_t poly_memory = 0;
-    for (const auto &poly : polys)
-      poly_memory += poly.memory_consumption();
-    return ScalarPolynomialsBase<dim>::memory_consumption() + poly_memory +
-           poly_grads.memory_consumption() +
-           poly_hessians.memory_consumption() +
-           poly_third_derivatives.memory_consumption() +
-           poly_fourth_derivatives.memory_consumption();
-  }
 
-  template class BarycentricPolynomials<1>;
-  template class BarycentricPolynomials<2>;
-  template class BarycentricPolynomials<3>;
 
-} // namespace Simplex
+template <int dim>
+std::size_t
+BarycentricPolynomials<dim>::memory_consumption() const
+{
+  std::size_t poly_memory = 0;
+  for (const auto &poly : polys)
+    poly_memory += poly.memory_consumption();
+  return ScalarPolynomialsBase<dim>::memory_consumption() + poly_memory +
+         poly_grads.memory_consumption() + poly_hessians.memory_consumption() +
+         poly_third_derivatives.memory_consumption() +
+         poly_fourth_derivatives.memory_consumption();
+}
+
+template class BarycentricPolynomials<1>;
+template class BarycentricPolynomials<2>;
+template class BarycentricPolynomials<3>;
 
 DEAL_II_NAMESPACE_CLOSE
diff --git a/source/base/polynomials_pyramid.cc b/source/base/polynomials_pyramid.cc
index 9321dfb3a9..dbab75b527 100644
--- a/source/base/polynomials_pyramid.cc
+++ b/source/base/polynomials_pyramid.cc
@@ -19,271 +19,263 @@
 
 DEAL_II_NAMESPACE_OPEN
 
-namespace Simplex
+namespace
 {
-  namespace
+  unsigned int
+  compute_n_polynomials_pyramid(const unsigned int dim,
+                                const unsigned int degree)
   {
-    unsigned int
-    compute_n_polynomials_pyramid(const unsigned int dim,
-                                  const unsigned int degree)
-    {
-      if (dim == 3)
-        {
-          if (degree == 1)
-            return 5;
-        }
+    if (dim == 3)
+      {
+        if (degree == 1)
+          return 5;
+      }
 
-      Assert(false, ExcNotImplemented());
+    Assert(false, ExcNotImplemented());
 
-      return 0;
-    }
-  } // namespace
+    return 0;
+  }
+} // namespace
 
 
 
-  template <int dim>
-  ScalarPyramidPolynomial<dim>::ScalarPyramidPolynomial(
-    const unsigned int degree)
-    : ScalarPolynomialsBase<dim>(degree,
-                                 compute_n_polynomials_pyramid(dim, degree))
-  {}
+template <int dim>
+ScalarPyramidPolynomial<dim>::ScalarPyramidPolynomial(const unsigned int degree)
+  : ScalarPolynomialsBase<dim>(degree,
+                               compute_n_polynomials_pyramid(dim, degree))
+{}
 
 
-  template <int dim>
-  double
-  ScalarPyramidPolynomial<dim>::compute_value(const unsigned int i,
-                                              const Point<dim> & p) const
-  {
-    AssertDimension(dim, 3);
-    AssertIndexRange(this->degree(), 2);
+template <int dim>
+double
+ScalarPyramidPolynomial<dim>::compute_value(const unsigned int i,
+                                            const Point<dim> & p) const
+{
+  AssertDimension(dim, 3);
+  AssertIndexRange(this->degree(), 2);
 
-    const double Q14 = 0.25;
-    double       ration;
+  const double Q14 = 0.25;
+  double       ration;
 
-    const double r = p[0];
-    const double s = p[1];
-    const double t = p[2];
+  const double r = p[0];
+  const double s = p[1];
+  const double t = p[2];
 
-    if (fabs(t - 1.0) > 1.0e-14)
-      {
-        ration = (r * s * t) / (1.0 - t);
-      }
-    else
-      {
-        ration = 0.0;
-      }
+  if (fabs(t - 1.0) > 1.0e-14)
+    {
+      ration = (r * s * t) / (1.0 - t);
+    }
+  else
+    {
+      ration = 0.0;
+    }
 
-    if (i == 0)
-      return Q14 * ((1.0 - r) * (1.0 - s) - t + ration);
-    if (i == 1)
-      return Q14 * ((1.0 + r) * (1.0 - s) - t - ration);
-    if (i == 2)
-      return Q14 * ((1.0 - r) * (1.0 + s) - t - ration);
-    if (i == 3)
-      return Q14 * ((1.0 + r) * (1.0 + s) - t + ration);
-    else
-      return t;
-  }
+  if (i == 0)
+    return Q14 * ((1.0 - r) * (1.0 - s) - t + ration);
+  if (i == 1)
+    return Q14 * ((1.0 + r) * (1.0 - s) - t - ration);
+  if (i == 2)
+    return Q14 * ((1.0 - r) * (1.0 + s) - t - ration);
+  if (i == 3)
+    return Q14 * ((1.0 + r) * (1.0 + s) - t + ration);
+  else
+    return t;
+}
 
 
 
-  template <int dim>
-  Tensor<1, dim>
-  ScalarPyramidPolynomial<dim>::compute_grad(const unsigned int i,
-                                             const Point<dim> & p) const
-  {
-    AssertDimension(dim, 3);
-    AssertIndexRange(this->degree(), 4);
+template <int dim>
+Tensor<1, dim>
+ScalarPyramidPolynomial<dim>::compute_grad(const unsigned int i,
+                                           const Point<dim> & p) const
+{
+  AssertDimension(dim, 3);
+  AssertIndexRange(this->degree(), 4);
 
-    Tensor<1, dim> grad;
+  Tensor<1, dim> grad;
 
-    if (this->degree() == 1)
-      {
-        const double Q14 = 0.25;
-
-        const double r = p[0];
-        const double s = p[1];
-        const double t = p[2];
-
-        double rationdr;
-        double rationds;
-        double rationdt;
-
-        if (fabs(t - 1.0) > 1.0e-14)
-          {
-            rationdr = s * t / (1.0 - t);
-            rationds = r * t / (1.0 - t);
-            rationdt = r * s / ((1.0 - t) * (1.0 - t));
-          }
-        else
-          {
-            rationdr = 1.0;
-            rationds = 1.0;
-            rationdt = 1.0;
-          }
-
-
-        if (i == 0)
-          {
-            grad[0] = Q14 * (-1.0 * (1.0 - s) + rationdr);
-            grad[1] = Q14 * (-1.0 * (1.0 - r) + rationds);
-            grad[2] = Q14 * (rationdt - 1.0);
-          }
-        else if (i == 1)
-          {
-            grad[0] = Q14 * (1.0 * (1.0 - s) - rationdr);
-            grad[1] = Q14 * (-1.0 * (1.0 + r) - rationds);
-            grad[2] = Q14 * (-1.0 * rationdt - 1.0);
-          }
-        else if (i == 2)
-          {
-            grad[0] = Q14 * (-1.0 * (1.0 + s) - rationdr);
-            grad[1] = Q14 * (1.0 * (1.0 - r) - rationds);
-            grad[2] = Q14 * (-1.0 * rationdt - 1.0);
-          }
-        else if (i == 3)
-          {
-            grad[0] = Q14 * (1.0 * (1.0 + s) + rationdr);
-            grad[1] = Q14 * (1.0 * (1.0 + r) + rationds);
-            grad[2] = Q14 * (rationdt - 1.0);
-          }
-        else if (i == 4)
-          {
-            grad[0] = 0.0;
-            grad[1] = 0.0;
-            grad[2] = 1.0;
-          }
-        else
-          {
-            Assert(false, ExcNotImplemented());
-          }
-      }
+  if (this->degree() == 1)
+    {
+      const double Q14 = 0.25;
 
-    return grad;
-  }
+      const double r = p[0];
+      const double s = p[1];
+      const double t = p[2];
 
+      double rationdr;
+      double rationds;
+      double rationdt;
 
+      if (fabs(t - 1.0) > 1.0e-14)
+        {
+          rationdr = s * t / (1.0 - t);
+          rationds = r * t / (1.0 - t);
+          rationdt = r * s / ((1.0 - t) * (1.0 - t));
+        }
+      else
+        {
+          rationdr = 1.0;
+          rationds = 1.0;
+          rationdt = 1.0;
+        }
 
-  template <int dim>
-  Tensor<2, dim>
-  ScalarPyramidPolynomial<dim>::compute_grad_grad(const unsigned int i,
-                                                  const Point<dim> & p) const
-  {
-    (void)i;
-    (void)p;
 
-    Assert(false, ExcNotImplemented());
-    return Tensor<2, dim>();
-  }
+      if (i == 0)
+        {
+          grad[0] = Q14 * (-1.0 * (1.0 - s) + rationdr);
+          grad[1] = Q14 * (-1.0 * (1.0 - r) + rationds);
+          grad[2] = Q14 * (rationdt - 1.0);
+        }
+      else if (i == 1)
+        {
+          grad[0] = Q14 * (1.0 * (1.0 - s) - rationdr);
+          grad[1] = Q14 * (-1.0 * (1.0 + r) - rationds);
+          grad[2] = Q14 * (-1.0 * rationdt - 1.0);
+        }
+      else if (i == 2)
+        {
+          grad[0] = Q14 * (-1.0 * (1.0 + s) - rationdr);
+          grad[1] = Q14 * (1.0 * (1.0 - r) - rationds);
+          grad[2] = Q14 * (-1.0 * rationdt - 1.0);
+        }
+      else if (i == 3)
+        {
+          grad[0] = Q14 * (1.0 * (1.0 + s) + rationdr);
+          grad[1] = Q14 * (1.0 * (1.0 + r) + rationds);
+          grad[2] = Q14 * (rationdt - 1.0);
+        }
+      else if (i == 4)
+        {
+          grad[0] = 0.0;
+          grad[1] = 0.0;
+          grad[2] = 1.0;
+        }
+      else
+        {
+          Assert(false, ExcNotImplemented());
+        }
+    }
 
+  return grad;
+}
 
 
-  template <int dim>
-  void
-  ScalarPyramidPolynomial<dim>::evaluate(
-    const Point<dim> &           unit_point,
-    std::vector<double> &        values,
-    std::vector<Tensor<1, dim>> &grads,
-    std::vector<Tensor<2, dim>> &grad_grads,
-    std::vector<Tensor<3, dim>> &third_derivatives,
-    std::vector<Tensor<4, dim>> &fourth_derivatives) const
-  {
-    (void)grads;
-    (void)grad_grads;
-    (void)third_derivatives;
-    (void)fourth_derivatives;
-
-    if (values.size() == this->n())
-      for (unsigned int i = 0; i < this->n(); i++)
-        values[i] = compute_value(i, unit_point);
-
-    if (grads.size() == this->n())
-      for (unsigned int i = 0; i < this->n(); i++)
-        grads[i] = compute_grad(i, unit_point);
-  }
 
+template <int dim>
+Tensor<2, dim>
+ScalarPyramidPolynomial<dim>::compute_grad_grad(const unsigned int i,
+                                                const Point<dim> & p) const
+{
+  (void)i;
+  (void)p;
 
+  Assert(false, ExcNotImplemented());
+  return Tensor<2, dim>();
+}
 
-  template <int dim>
-  Tensor<1, dim>
-  ScalarPyramidPolynomial<dim>::compute_1st_derivative(
-    const unsigned int i,
-    const Point<dim> & p) const
-  {
-    return compute_grad(i, p);
-  }
 
 
+template <int dim>
+void
+ScalarPyramidPolynomial<dim>::evaluate(
+  const Point<dim> &           unit_point,
+  std::vector<double> &        values,
+  std::vector<Tensor<1, dim>> &grads,
+  std::vector<Tensor<2, dim>> &grad_grads,
+  std::vector<Tensor<3, dim>> &third_derivatives,
+  std::vector<Tensor<4, dim>> &fourth_derivatives) const
+{
+  (void)grads;
+  (void)grad_grads;
+  (void)third_derivatives;
+  (void)fourth_derivatives;
 
-  template <int dim>
-  Tensor<2, dim>
-  ScalarPyramidPolynomial<dim>::compute_2nd_derivative(
-    const unsigned int i,
-    const Point<dim> & p) const
-  {
-    (void)i;
-    (void)p;
+  if (values.size() == this->n())
+    for (unsigned int i = 0; i < this->n(); i++)
+      values[i] = compute_value(i, unit_point);
 
-    Assert(false, ExcNotImplemented());
+  if (grads.size() == this->n())
+    for (unsigned int i = 0; i < this->n(); i++)
+      grads[i] = compute_grad(i, unit_point);
+}
 
-    return {};
-  }
 
 
+template <int dim>
+Tensor<1, dim>
+ScalarPyramidPolynomial<dim>::compute_1st_derivative(const unsigned int i,
+                                                     const Point<dim> & p) const
+{
+  return compute_grad(i, p);
+}
 
-  template <int dim>
-  Tensor<3, dim>
-  ScalarPyramidPolynomial<dim>::compute_3rd_derivative(
-    const unsigned int i,
-    const Point<dim> & p) const
-  {
-    (void)i;
-    (void)p;
 
-    Assert(false, ExcNotImplemented());
 
-    return {};
-  }
+template <int dim>
+Tensor<2, dim>
+ScalarPyramidPolynomial<dim>::compute_2nd_derivative(const unsigned int i,
+                                                     const Point<dim> & p) const
+{
+  (void)i;
+  (void)p;
 
+  Assert(false, ExcNotImplemented());
 
+  return {};
+}
 
-  template <int dim>
-  Tensor<4, dim>
-  ScalarPyramidPolynomial<dim>::compute_4th_derivative(
-    const unsigned int i,
-    const Point<dim> & p) const
-  {
-    (void)i;
-    (void)p;
 
-    Assert(false, ExcNotImplemented());
 
-    return {};
-  }
+template <int dim>
+Tensor<3, dim>
+ScalarPyramidPolynomial<dim>::compute_3rd_derivative(const unsigned int i,
+                                                     const Point<dim> & p) const
+{
+  (void)i;
+  (void)p;
 
+  Assert(false, ExcNotImplemented());
 
+  return {};
+}
 
-  template <int dim>
-  std::string
-  ScalarPyramidPolynomial<dim>::name() const
-  {
-    return "ScalarPyramidPolynomial";
-  }
 
 
+template <int dim>
+Tensor<4, dim>
+ScalarPyramidPolynomial<dim>::compute_4th_derivative(const unsigned int i,
+                                                     const Point<dim> & p) const
+{
+  (void)i;
+  (void)p;
 
-  template <int dim>
-  std::unique_ptr<ScalarPolynomialsBase<dim>>
-  ScalarPyramidPolynomial<dim>::clone() const
-  {
-    return std::make_unique<ScalarPyramidPolynomial<dim>>(*this);
-  }
+  Assert(false, ExcNotImplemented());
+
+  return {};
+}
+
+
+
+template <int dim>
+std::string
+ScalarPyramidPolynomial<dim>::name() const
+{
+  return "ScalarPyramidPolynomial";
+}
+
+
+
+template <int dim>
+std::unique_ptr<ScalarPolynomialsBase<dim>>
+ScalarPyramidPolynomial<dim>::clone() const
+{
+  return std::make_unique<ScalarPyramidPolynomial<dim>>(*this);
+}
 
 
 
-  template class ScalarPyramidPolynomial<1>;
-  template class ScalarPyramidPolynomial<2>;
-  template class ScalarPyramidPolynomial<3>;
-} // namespace Simplex
+template class ScalarPyramidPolynomial<1>;
+template class ScalarPyramidPolynomial<2>;
+template class ScalarPyramidPolynomial<3>;
 
 DEAL_II_NAMESPACE_CLOSE
diff --git a/source/base/polynomials_wedge.cc b/source/base/polynomials_wedge.cc
index 8ac20bb9de..6517e62443 100644
--- a/source/base/polynomials_wedge.cc
+++ b/source/base/polynomials_wedge.cc
@@ -20,236 +20,230 @@
 
 DEAL_II_NAMESPACE_OPEN
 
-namespace Simplex
+namespace
 {
-  namespace
+  unsigned int
+  compute_n_polynomials_wedge(const unsigned int dim, const unsigned int degree)
   {
-    unsigned int
-    compute_n_polynomials_wedge(const unsigned int dim,
-                                const unsigned int degree)
-    {
-      if (dim == 3)
-        {
-          if (degree == 1)
-            return 6;
-          if (degree == 2)
-            return 18;
-        }
+    if (dim == 3)
+      {
+        if (degree == 1)
+          return 6;
+        if (degree == 2)
+          return 18;
+      }
 
-      Assert(false, ExcNotImplemented());
+    Assert(false, ExcNotImplemented());
 
-      return 0;
-    }
-  } // namespace
+    return 0;
+  }
+} // namespace
 
 
 
-  template <int dim>
-  ScalarWedgePolynomial<dim>::ScalarWedgePolynomial(const unsigned int degree)
-    : ScalarPolynomialsBase<dim>(degree,
-                                 compute_n_polynomials_wedge(dim, degree))
-    , poly_tri(BarycentricPolynomials<2>::get_fe_p_basis(degree))
-    , poly_line(BarycentricPolynomials<1>::get_fe_p_basis(degree))
-  {}
+template <int dim>
+ScalarWedgePolynomial<dim>::ScalarWedgePolynomial(const unsigned int degree)
+  : ScalarPolynomialsBase<dim>(degree, compute_n_polynomials_wedge(dim, degree))
+  , poly_tri(BarycentricPolynomials<2>::get_fe_p_basis(degree))
+  , poly_line(BarycentricPolynomials<1>::get_fe_p_basis(degree))
+{}
 
 
-  namespace
-  {
-    /**
-     * Decompose the shape-function index of a linear wedge into an index
-     * to access the right shape function within the triangle and and within
-     * the line.
-     */
-    static const constexpr ndarray<unsigned int, 6, 2> wedge_table_1{
-      {{{0, 0}}, {{1, 0}}, {{2, 0}}, {{0, 1}}, {{1, 1}}, {{2, 1}}}};
-
-    /**
-     * Decompose the shape-function index of a quadratic wedge into an index
-     * to access the right shape function within the triangle and and within
-     * the line.
-     */
-    static const constexpr ndarray<unsigned int, 18, 2> wedge_table_2{
-      {{{0, 0}},
-       {{1, 0}},
-       {{2, 0}},
-       {{0, 1}},
-       {{1, 1}},
-       {{2, 1}},
-       {{3, 0}},
-       {{4, 0}},
-       {{5, 0}},
-       {{3, 1}},
-       {{4, 1}},
-       {{5, 1}},
-       {{0, 2}},
-       {{1, 2}},
-       {{2, 2}},
-       {{3, 2}},
-       {{4, 2}},
-       {{5, 2}}}};
-  } // namespace
-
-
-
-  template <int dim>
-  double
-  ScalarWedgePolynomial<dim>::compute_value(const unsigned int i,
-                                            const Point<dim> & p) const
-  {
-    const auto pair = this->degree() == 1 ? wedge_table_1[i] : wedge_table_2[i];
+namespace
+{
+  /**
+   * Decompose the shape-function index of a linear wedge into an index
+   * to access the right shape function within the triangle and and within
+   * the line.
+   */
+  static const constexpr ndarray<unsigned int, 6, 2> wedge_table_1{
+    {{{0, 0}}, {{1, 0}}, {{2, 0}}, {{0, 1}}, {{1, 1}}, {{2, 1}}}};
+
+  /**
+   * Decompose the shape-function index of a quadratic wedge into an index
+   * to access the right shape function within the triangle and and within
+   * the line.
+   */
+  static const constexpr ndarray<unsigned int, 18, 2> wedge_table_2{{{{0, 0}},
+                                                                     {{1, 0}},
+                                                                     {{2, 0}},
+                                                                     {{0, 1}},
+                                                                     {{1, 1}},
+                                                                     {{2, 1}},
+                                                                     {{3, 0}},
+                                                                     {{4, 0}},
+                                                                     {{5, 0}},
+                                                                     {{3, 1}},
+                                                                     {{4, 1}},
+                                                                     {{5, 1}},
+                                                                     {{0, 2}},
+                                                                     {{1, 2}},
+                                                                     {{2, 2}},
+                                                                     {{3, 2}},
+                                                                     {{4, 2}},
+                                                                     {{5, 2}}}};
+} // namespace
+
+
+
+template <int dim>
+double
+ScalarWedgePolynomial<dim>::compute_value(const unsigned int i,
+                                          const Point<dim> & p) const
+{
+  const auto pair = this->degree() == 1 ? wedge_table_1[i] : wedge_table_2[i];
 
-    const Point<2> p_tri(p[0], p[1]);
-    const auto     v_tri = poly_tri.compute_value(pair[0], p_tri);
+  const Point<2> p_tri(p[0], p[1]);
+  const auto     v_tri = poly_tri.compute_value(pair[0], p_tri);
 
-    const Point<1> p_line(p[2]);
-    const auto     v_line = poly_line.compute_value(pair[1], p_line);
+  const Point<1> p_line(p[2]);
+  const auto     v_line = poly_line.compute_value(pair[1], p_line);
 
-    return v_tri * v_line;
-  }
+  return v_tri * v_line;
+}
 
 
 
-  template <int dim>
-  Tensor<1, dim>
-  ScalarWedgePolynomial<dim>::compute_grad(const unsigned int i,
-                                           const Point<dim> & p) const
-  {
-    const auto pair = this->degree() == 1 ? wedge_table_1[i] : wedge_table_2[i];
+template <int dim>
+Tensor<1, dim>
+ScalarWedgePolynomial<dim>::compute_grad(const unsigned int i,
+                                         const Point<dim> & p) const
+{
+  const auto pair = this->degree() == 1 ? wedge_table_1[i] : wedge_table_2[i];
 
-    const Point<2> p_tri(p[0], p[1]);
-    const auto     v_tri = poly_tri.compute_value(pair[0], p_tri);
-    const auto     g_tri = poly_tri.compute_grad(pair[0], p_tri);
+  const Point<2> p_tri(p[0], p[1]);
+  const auto     v_tri = poly_tri.compute_value(pair[0], p_tri);
+  const auto     g_tri = poly_tri.compute_grad(pair[0], p_tri);
 
-    const Point<1> p_line(p[2]);
-    const auto     v_line = poly_line.compute_value(pair[1], p_line);
-    const auto     g_line = poly_line.compute_grad(pair[1], p_line);
+  const Point<1> p_line(p[2]);
+  const auto     v_line = poly_line.compute_value(pair[1], p_line);
+  const auto     g_line = poly_line.compute_grad(pair[1], p_line);
 
-    Tensor<1, dim> grad;
-    grad[0] = g_tri[0] * v_line;
-    grad[1] = g_tri[1] * v_line;
-    grad[2] = v_tri * g_line[0];
+  Tensor<1, dim> grad;
+  grad[0] = g_tri[0] * v_line;
+  grad[1] = g_tri[1] * v_line;
+  grad[2] = v_tri * g_line[0];
 
-    return grad;
-  }
+  return grad;
+}
 
 
 
-  template <int dim>
-  Tensor<2, dim>
-  ScalarWedgePolynomial<dim>::compute_grad_grad(const unsigned int i,
-                                                const Point<dim> & p) const
-  {
-    (void)i;
-    (void)p;
+template <int dim>
+Tensor<2, dim>
+ScalarWedgePolynomial<dim>::compute_grad_grad(const unsigned int i,
+                                              const Point<dim> & p) const
+{
+  (void)i;
+  (void)p;
 
-    Assert(false, ExcNotImplemented());
-    return Tensor<2, dim>();
-  }
+  Assert(false, ExcNotImplemented());
+  return Tensor<2, dim>();
+}
 
 
 
-  template <int dim>
-  void
-  ScalarWedgePolynomial<dim>::evaluate(
-    const Point<dim> &           unit_point,
-    std::vector<double> &        values,
-    std::vector<Tensor<1, dim>> &grads,
-    std::vector<Tensor<2, dim>> &grad_grads,
-    std::vector<Tensor<3, dim>> &third_derivatives,
-    std::vector<Tensor<4, dim>> &fourth_derivatives) const
-  {
-    (void)grads;
-    (void)grad_grads;
-    (void)third_derivatives;
-    (void)fourth_derivatives;
-
-    if (values.size() == this->n())
-      for (unsigned int i = 0; i < this->n(); i++)
-        values[i] = compute_value(i, unit_point);
-
-    if (grads.size() == this->n())
-      for (unsigned int i = 0; i < this->n(); i++)
-        grads[i] = compute_grad(i, unit_point);
-  }
+template <int dim>
+void
+ScalarWedgePolynomial<dim>::evaluate(
+  const Point<dim> &           unit_point,
+  std::vector<double> &        values,
+  std::vector<Tensor<1, dim>> &grads,
+  std::vector<Tensor<2, dim>> &grad_grads,
+  std::vector<Tensor<3, dim>> &third_derivatives,
+  std::vector<Tensor<4, dim>> &fourth_derivatives) const
+{
+  (void)grads;
+  (void)grad_grads;
+  (void)third_derivatives;
+  (void)fourth_derivatives;
 
+  if (values.size() == this->n())
+    for (unsigned int i = 0; i < this->n(); i++)
+      values[i] = compute_value(i, unit_point);
+
+  if (grads.size() == this->n())
+    for (unsigned int i = 0; i < this->n(); i++)
+      grads[i] = compute_grad(i, unit_point);
+}
 
 
-  template <int dim>
-  Tensor<1, dim>
-  ScalarWedgePolynomial<dim>::compute_1st_derivative(const unsigned int i,
-                                                     const Point<dim> & p) const
-  {
-    return compute_grad(i, p);
-  }
 
+template <int dim>
+Tensor<1, dim>
+ScalarWedgePolynomial<dim>::compute_1st_derivative(const unsigned int i,
+                                                   const Point<dim> & p) const
+{
+  return compute_grad(i, p);
+}
 
 
-  template <int dim>
-  Tensor<2, dim>
-  ScalarWedgePolynomial<dim>::compute_2nd_derivative(const unsigned int i,
-                                                     const Point<dim> & p) const
-  {
-    (void)i;
-    (void)p;
 
-    Assert(false, ExcNotImplemented());
+template <int dim>
+Tensor<2, dim>
+ScalarWedgePolynomial<dim>::compute_2nd_derivative(const unsigned int i,
+                                                   const Point<dim> & p) const
+{
+  (void)i;
+  (void)p;
 
-    return {};
-  }
+  Assert(false, ExcNotImplemented());
 
+  return {};
+}
 
 
-  template <int dim>
-  Tensor<3, dim>
-  ScalarWedgePolynomial<dim>::compute_3rd_derivative(const unsigned int i,
-                                                     const Point<dim> & p) const
-  {
-    (void)i;
-    (void)p;
 
-    Assert(false, ExcNotImplemented());
+template <int dim>
+Tensor<3, dim>
+ScalarWedgePolynomial<dim>::compute_3rd_derivative(const unsigned int i,
+                                                   const Point<dim> & p) const
+{
+  (void)i;
+  (void)p;
 
-    return {};
-  }
+  Assert(false, ExcNotImplemented());
 
+  return {};
+}
 
 
-  template <int dim>
-  Tensor<4, dim>
-  ScalarWedgePolynomial<dim>::compute_4th_derivative(const unsigned int i,
-                                                     const Point<dim> & p) const
-  {
-    (void)i;
-    (void)p;
 
-    Assert(false, ExcNotImplemented());
+template <int dim>
+Tensor<4, dim>
+ScalarWedgePolynomial<dim>::compute_4th_derivative(const unsigned int i,
+                                                   const Point<dim> & p) const
+{
+  (void)i;
+  (void)p;
 
-    return {};
-  }
+  Assert(false, ExcNotImplemented());
 
+  return {};
+}
 
 
-  template <int dim>
-  std::string
-  ScalarWedgePolynomial<dim>::name() const
-  {
-    return "ScalarWedgePolynomial";
-  }
 
+template <int dim>
+std::string
+ScalarWedgePolynomial<dim>::name() const
+{
+  return "ScalarWedgePolynomial";
+}
 
 
-  template <int dim>
-  std::unique_ptr<ScalarPolynomialsBase<dim>>
-  ScalarWedgePolynomial<dim>::clone() const
-  {
-    return std::make_unique<ScalarWedgePolynomial<dim>>(*this);
-  }
+
+template <int dim>
+std::unique_ptr<ScalarPolynomialsBase<dim>>
+ScalarWedgePolynomial<dim>::clone() const
+{
+  return std::make_unique<ScalarWedgePolynomial<dim>>(*this);
+}
 
 
 
-  template class ScalarWedgePolynomial<1>;
-  template class ScalarWedgePolynomial<2>;
-  template class ScalarWedgePolynomial<3>;
-} // namespace Simplex
+template class ScalarWedgePolynomial<1>;
+template class ScalarWedgePolynomial<2>;
+template class ScalarWedgePolynomial<3>;
 
 DEAL_II_NAMESPACE_CLOSE
diff --git a/source/base/qprojector.cc b/source/base/qprojector.cc
index f64d67cc5a..e311e64850 100644
--- a/source/base/qprojector.cc
+++ b/source/base/qprojector.cc
@@ -135,7 +135,7 @@ QProjector<2>::project_to_face(const ReferenceCell    reference_cell,
   if (reference_cell == ReferenceCells::Triangle)
     {
       // use linear polynomial to map the reference quadrature points correctly
-      // on faces, i.e., Simplex::ScalarPolynomial<1>(1)
+      // on faces, i.e., BarycentricPolynomials<1>(1)
       for (unsigned int p = 0; p < quadrature.size(); ++p)
         switch (face_no)
           {
@@ -315,7 +315,7 @@ QProjector<2>::project_to_subface(const ReferenceCell    reference_cell,
   if (reference_cell == ReferenceCells::Triangle)
     {
       // use linear polynomial to map the reference quadrature points correctly
-      // on faces, i.e., Simplex::ScalarPolynomial<1>(1)
+      // on faces, i.e., BarycentricPolynomials<1>(1)
       for (unsigned int p = 0; p < quadrature.size(); ++p)
         switch (face_no)
           {
@@ -620,7 +620,7 @@ QProjector<2>::project_to_all_faces(const ReferenceCell       reference_cell,
 
       // linear polynomial to map the reference quadrature points correctly
       // on faces
-      const auto poly = Simplex::BarycentricPolynomials<1>::get_fe_p_basis(1);
+      const auto poly = BarycentricPolynomials<1>::get_fe_p_basis(1);
 
       // new (projected) quadrature points and weights
       std::vector<Point<2>> points;
@@ -749,7 +749,7 @@ QProjector<3>::project_to_all_faces(const ReferenceCell       reference_cell,
     std::vector<Point<3>> points;
     std::vector<double>   weights;
 
-    const auto poly_tri = Simplex::BarycentricPolynomials<2>::get_fe_p_basis(1);
+    const auto poly_tri = BarycentricPolynomials<2>::get_fe_p_basis(1);
     const TensorProductPolynomials<2> poly_quad(
       Polynomials::generate_complete_Lagrange_basis(
         {Point<1>(0.0), Point<1>(1.0)}));
diff --git a/source/base/quadrature_lib.cc b/source/base/quadrature_lib.cc
index f84f13fb6c..d2a21598e6 100644
--- a/source/base/quadrature_lib.cc
+++ b/source/base/quadrature_lib.cc
@@ -1350,45 +1350,43 @@ QSplit<dim>::QSplit(const QSimplex<dim> &base, const Point<dim> &split_point)
 
 
 
-namespace Simplex
+template <int dim>
+QGaussSimplex<dim>::QGaussSimplex(const unsigned int n_points_1D)
+  : QSimplex<dim>(Quadrature<dim>())
 {
-  template <int dim>
-  QGauss<dim>::QGauss(const unsigned int n_points_1D)
-    : QSimplex<dim>(Quadrature<dim>())
-  {
-    // fill quadrature points and quadrature weights
-    if (dim == 1)
-      {
-        const dealii::QGauss<dim> quad(n_points_1D);
+  // fill quadrature points and quadrature weights
+  if (dim == 1)
+    {
+      const dealii::QGauss<dim> quad(n_points_1D);
 
-        this->quadrature_points = quad.get_points();
-        this->weights           = quad.get_weights();
-      }
-    else if (dim == 2)
-      {
-        if (n_points_1D == 1)
-          {
-            const double p = 1.0 / 3.0;
-            this->quadrature_points.emplace_back(p, p);
-            this->weights.emplace_back(0.5);
-          }
-        else if (n_points_1D == 2)
-          {
-            const double Q23 = 2.0 / 3.0;
-            const double Q16 = 1.0 / 6.0;
-
-            this->quadrature_points.emplace_back(Q23, Q16);
-            this->quadrature_points.emplace_back(Q16, Q23);
-            this->quadrature_points.emplace_back(Q16, Q16);
-            this->weights.emplace_back(Q16);
-            this->weights.emplace_back(Q16);
-            this->weights.emplace_back(Q16);
-          }
-        else if (n_points_1D == 3)
-          {
-            const double q12 = 0.5;
+      this->quadrature_points = quad.get_points();
+      this->weights           = quad.get_weights();
+    }
+  else if (dim == 2)
+    {
+      if (n_points_1D == 1)
+        {
+          const double p = 1.0 / 3.0;
+          this->quadrature_points.emplace_back(p, p);
+          this->weights.emplace_back(0.5);
+        }
+      else if (n_points_1D == 2)
+        {
+          const double Q23 = 2.0 / 3.0;
+          const double Q16 = 1.0 / 6.0;
+
+          this->quadrature_points.emplace_back(Q23, Q16);
+          this->quadrature_points.emplace_back(Q16, Q23);
+          this->quadrature_points.emplace_back(Q16, Q16);
+          this->weights.emplace_back(Q16);
+          this->weights.emplace_back(Q16);
+          this->weights.emplace_back(Q16);
+        }
+      else if (n_points_1D == 3)
+        {
+          const double q12 = 0.5;
 
-            // clang-format off
+          // clang-format off
             this->quadrature_points.emplace_back(0.3333333333330, 0.3333333333330);
             this->quadrature_points.emplace_back(0.7974269853530, 0.1012865073230);
             this->quadrature_points.emplace_back(0.1012865073230, 0.7974269853530);
@@ -1396,51 +1394,51 @@ namespace Simplex
             this->quadrature_points.emplace_back(0.0597158717898, 0.4701420641050);
             this->quadrature_points.emplace_back(0.4701420641050, 0.0597158717898);
             this->quadrature_points.emplace_back(0.4701420641050, 0.4701420641050);
-            // clang-format on
-
-            this->weights.emplace_back(q12 * 0.225);
-            this->weights.emplace_back(q12 * 0.125939180545);
-            this->weights.emplace_back(q12 * 0.125939180545);
-            this->weights.emplace_back(q12 * 0.125939180545);
-            this->weights.emplace_back(q12 * 0.132394152789);
-            this->weights.emplace_back(q12 * 0.132394152789);
-            this->weights.emplace_back(q12 * 0.132394152789);
-          }
-        else if (n_points_1D == 4)
-          {
-            Quadrature<dim>::operator=(QWitherdenVincent<dim>(n_points_1D));
-          }
-      }
-    else if (dim == 3)
-      {
-        if (n_points_1D == 1)
-          {
-            const double Q14 = 1.0 / 4.0;
-            const double Q16 = 1.0 / 6.0;
+          // clang-format on
+
+          this->weights.emplace_back(q12 * 0.225);
+          this->weights.emplace_back(q12 * 0.125939180545);
+          this->weights.emplace_back(q12 * 0.125939180545);
+          this->weights.emplace_back(q12 * 0.125939180545);
+          this->weights.emplace_back(q12 * 0.132394152789);
+          this->weights.emplace_back(q12 * 0.132394152789);
+          this->weights.emplace_back(q12 * 0.132394152789);
+        }
+      else if (n_points_1D == 4)
+        {
+          Quadrature<dim>::operator=(QWitherdenVincent<dim>(n_points_1D));
+        }
+    }
+  else if (dim == 3)
+    {
+      if (n_points_1D == 1)
+        {
+          const double Q14 = 1.0 / 4.0;
+          const double Q16 = 1.0 / 6.0;
 
-            this->quadrature_points.emplace_back(Q14, Q14, Q14);
-            this->weights.emplace_back(Q16);
-          }
-        else if (n_points_1D == 2)
-          {
-            const double Q124 = 1.0 / 6.0 / 4.0;
-
-            const double palpha = (5.0 + 3.0 * sqrt(5.0)) / 20.0;
-            const double pbeta  = (5.0 - sqrt(5.0)) / 20.0;
-            this->quadrature_points.emplace_back(pbeta, pbeta, pbeta);
-            this->quadrature_points.emplace_back(palpha, pbeta, pbeta);
-            this->quadrature_points.emplace_back(pbeta, palpha, pbeta);
-            this->quadrature_points.emplace_back(pbeta, pbeta, palpha);
-            this->weights.emplace_back(Q124);
-            this->weights.emplace_back(Q124);
-            this->weights.emplace_back(Q124);
-            this->weights.emplace_back(Q124);
-          }
-        else if (n_points_1D == 3)
-          {
-            const double Q16 = 1.0 / 6.0;
+          this->quadrature_points.emplace_back(Q14, Q14, Q14);
+          this->weights.emplace_back(Q16);
+        }
+      else if (n_points_1D == 2)
+        {
+          const double Q124 = 1.0 / 6.0 / 4.0;
+
+          const double palpha = (5.0 + 3.0 * sqrt(5.0)) / 20.0;
+          const double pbeta  = (5.0 - sqrt(5.0)) / 20.0;
+          this->quadrature_points.emplace_back(pbeta, pbeta, pbeta);
+          this->quadrature_points.emplace_back(palpha, pbeta, pbeta);
+          this->quadrature_points.emplace_back(pbeta, palpha, pbeta);
+          this->quadrature_points.emplace_back(pbeta, pbeta, palpha);
+          this->weights.emplace_back(Q124);
+          this->weights.emplace_back(Q124);
+          this->weights.emplace_back(Q124);
+          this->weights.emplace_back(Q124);
+        }
+      else if (n_points_1D == 3)
+        {
+          const double Q16 = 1.0 / 6.0;
 
-            // clang-format off
+          // clang-format off
             this->quadrature_points.emplace_back(0.5684305841968444, 0.1438564719343852, 0.1438564719343852);
             this->quadrature_points.emplace_back(0.1438564719343852, 0.1438564719343852, 0.1438564719343852);
             this->quadrature_points.emplace_back(0.1438564719343852, 0.1438564719343852, 0.5684305841968444);
@@ -1451,319 +1449,319 @@ namespace Simplex
             this->quadrature_points.emplace_back(0.5000000000000000, 0.0000000000000000, 0.0000000000000000);
             this->quadrature_points.emplace_back(0.0000000000000000, 0.5000000000000000, 0.0000000000000000);
             this->quadrature_points.emplace_back(0.0000000000000000, 0.0000000000000000, 0.5000000000000000);
-            // clang-format on
-
-            this->weights.emplace_back(0.2177650698804054 * Q16);
-            this->weights.emplace_back(0.2177650698804054 * Q16);
-            this->weights.emplace_back(0.2177650698804054 * Q16);
-            this->weights.emplace_back(0.2177650698804054 * Q16);
-            this->weights.emplace_back(0.0214899534130631 * Q16);
-            this->weights.emplace_back(0.0214899534130631 * Q16);
-            this->weights.emplace_back(0.0214899534130631 * Q16);
-            this->weights.emplace_back(0.0214899534130631 * Q16);
-            this->weights.emplace_back(0.0214899534130631 * Q16);
-            this->weights.emplace_back(0.0214899534130631 * Q16);
-          }
-        else if (n_points_1D == 4)
-          {
-            Quadrature<dim>::operator=(QWitherdenVincent<dim>(n_points_1D));
-          }
-      }
-
-    AssertDimension(this->quadrature_points.size(), this->weights.size());
-    Assert(this->quadrature_points.size() > 0,
-           ExcNotImplemented(
-             "Simplex::QGauss is currently only implemented for "
-             "n_points_1D = 1, 2, 3, and 4 while you are asking for "
-             "n_points_1D = " +
-             Utilities::to_string(n_points_1D)));
-  }
-
-  namespace
-  {
-    template <std::size_t b_dim>
-    std::vector<std::array<double, b_dim>>
-    all_permutations(const std::array<double, b_dim> &b_point)
-    {
-      std::vector<std::array<double, b_dim>> output;
-
-      // We want all possible permutations of the barycentric coordinates.
-      // The easiest way to get all of them is to sort the input first and
-      // then use next_permutation to cycle through them all.
-      std::array<double, b_dim> temp = b_point;
-      std::sort(temp.begin(), temp.end());
-      do
+          // clang-format on
+
+          this->weights.emplace_back(0.2177650698804054 * Q16);
+          this->weights.emplace_back(0.2177650698804054 * Q16);
+          this->weights.emplace_back(0.2177650698804054 * Q16);
+          this->weights.emplace_back(0.2177650698804054 * Q16);
+          this->weights.emplace_back(0.0214899534130631 * Q16);
+          this->weights.emplace_back(0.0214899534130631 * Q16);
+          this->weights.emplace_back(0.0214899534130631 * Q16);
+          this->weights.emplace_back(0.0214899534130631 * Q16);
+          this->weights.emplace_back(0.0214899534130631 * Q16);
+          this->weights.emplace_back(0.0214899534130631 * Q16);
+        }
+      else if (n_points_1D == 4)
         {
-          output.push_back(temp);
+          Quadrature<dim>::operator=(QWitherdenVincent<dim>(n_points_1D));
         }
-      while (std::next_permutation(temp.begin(), temp.end()));
-
-      return output;
     }
-  } // namespace
-
 
+  AssertDimension(this->quadrature_points.size(), this->weights.size());
+  Assert(this->quadrature_points.size() > 0,
+         ExcNotImplemented(
+           "QGaussSimplex is currently only implemented for "
+           "n_points_1D = 1, 2, 3, and 4 while you are asking for "
+           "n_points_1D = " +
+           Utilities::to_string(n_points_1D)));
+}
 
-  template <int dim>
-  QWitherdenVincent<dim>::QWitherdenVincent(const unsigned int n_points_1D)
-    : QSimplex<dim>(Quadrature<dim>())
+namespace
+{
+  template <std::size_t b_dim>
+  std::vector<std::array<double, b_dim>>
+  all_permutations(const std::array<double, b_dim> &b_point)
   {
-    Assert(1 <= dim && dim <= 3, ExcNotImplemented());
-    // Just use Gauss in 1D: this is a high-order open rule so this is a
-    // reasonable equivalent for generic programming.
-    if (dim == 1)
-      {
-        Quadrature<dim>::operator=(dealii::QGauss<dim>(n_points_1D));
-        return;
-      }
-
-    std::array<double, dim + 1> centroid;
-    std::fill(centroid.begin(), centroid.end(), 1.0 / (dim + 1.0));
-    std::vector<std::vector<std::array<double, dim + 1>>> b_point_permutations;
-    std::vector<double>                                   b_weights;
-
-    // We can simplify the implementation of these quadrature rules
-    // by quite a bit by exploiting symmetry - we do essentially the
-    // same thing for each barycentric coordinate, so we can express
-    // our quadrature rule as permutations of barycentric points
-    // instead of writing things out explicitly.
-
-    // Apply a Barycentric permutation where one point is different.
-    auto process_point_1 = [&](const double a, const double w) {
-      const double                b = 1.0 - dim * a;
-      std::array<double, dim + 1> b_point;
-      std::fill(b_point.begin(), b_point.begin() + dim, a);
-      b_point[dim] = b;
-
-      b_weights.push_back(w);
-      b_point_permutations.push_back(all_permutations(b_point));
-    };
-
-    // Apply a Barycentric permutation where two points (in 3D) are different.
-    auto process_point_2 = [&](const double a, const double w) {
-      Assert(dim == 3, ExcInternalError());
-      const double                b = (1.0 - 2.0 * a) / 2.0;
-      std::array<double, dim + 1> b_point;
-      std::fill(b_point.begin(), b_point.begin() + dim - 1, a);
-      b_point[dim - 1] = b;
-      b_point[dim]     = b;
-
-      b_weights.push_back(w);
-      b_point_permutations.push_back(all_permutations(b_point));
-    };
-
-    // Apply a Barycentric permutation where three (or four) points
-    // are different (since there are two inputs).
-    auto process_point_3 = [&](const double a, const double b, const double w) {
-      const double                c = 1.0 - (dim - 1.0) * a - b;
-      std::array<double, dim + 1> b_point;
-      std::fill(b_point.begin(), b_point.begin() + dim - 1, a);
-      b_point[dim - 1] = b;
-      b_point[dim]     = c;
-
-      b_weights.push_back(w);
-      b_point_permutations.push_back(all_permutations(b_point));
-    };
-
-    if (n_points_1D == 1)
+    std::vector<std::array<double, b_dim>> output;
+
+    // We want all possible permutations of the barycentric coordinates.
+    // The easiest way to get all of them is to sort the input first and
+    // then use next_permutation to cycle through them all.
+    std::array<double, b_dim> temp = b_point;
+    std::sort(temp.begin(), temp.end());
+    do
       {
-        b_point_permutations.push_back({centroid});
-        b_weights.push_back(1.0);
-      }
-    else if (n_points_1D == 2)
-      {
-        // This is WV-4 in 2D and WV-3 in 3D
-        if (dim == 2)
-          {
-            process_point_1(9.1576213509770743e-02, 1.0995174365532187e-01);
-            process_point_1(4.4594849091596489e-01, 2.2338158967801147e-01);
-          }
-        else if (dim == 3)
-          {
-            process_point_1(3.281633025163817e-01, 1.362178425370874e-01);
-            process_point_1(1.080472498984286e-01, 1.137821574629126e-01);
-          }
+        output.push_back(temp);
       }
-    else if (n_points_1D == 3)
-      {
-        // This is the WV-5 rule in both 2D and 3D
-        if (dim == 2)
-          {
-            b_weights.push_back(0.225);
-            b_point_permutations.push_back({centroid});
+    while (std::next_permutation(temp.begin(), temp.end()));
 
-            process_point_1(1.0128650732345634e-01, 1.2593918054482714e-01);
-            process_point_1(4.7014206410511511e-01, 1.3239415278850619e-01);
-          }
-        else if (dim == 3)
-          {
-            process_point_1(3.108859192633006e-01, 1.126879257180159e-01);
-            process_point_1(9.273525031089125e-02, 7.349304311636196e-02);
+    return output;
+  }
+} // namespace
 
-            process_point_2(4.550370412564964e-02, 4.254602077708147e-02);
-          }
-      }
-    else if (n_points_1D == 4)
-      {
-        // This is the WV-7 rule in both 2D and 3D
-        if (dim == 2)
-          {
-            process_point_1(3.3730648554587850e-02, 1.6545050110792131e-02);
-            process_point_1(4.7430969250471822e-01, 7.7086646185986069e-02);
-            process_point_1(2.4157738259540357e-01, 1.2794417123015558e-01);
-            process_point_3(4.7036644652595216e-02,
-                            1.9868331479735168e-01,
-                            5.5878732903199779e-02);
-          }
-        else if (dim == 3)
-          {
-            b_point_permutations.push_back({centroid});
-            b_weights.push_back(9.548528946413085e-02);
-
-            process_point_1(3.157011497782028e-01, 4.232958120996703e-02);
-            process_point_2(5.048982259839635e-02, 3.189692783285758e-02);
-
-            process_point_3(1.888338310260010e-01,
-                            5.751716375870000e-01,
-                            3.720713072833462e-02);
-            process_point_3(2.126547254148314e-02,
-                            8.108302410985486e-01,
-                            8.110770829903342e-03);
-          }
-      }
-    else if (n_points_1D == 5)
-      {
-        // This is the WV-9 rule in both 2D and 3D
-        if (dim == 2)
-          {
-            b_point_permutations.push_back({centroid});
-            b_weights.push_back(9.7135796282798836e-02);
 
-            process_point_1(4.4729513394452691e-02, 2.5577675658698031e-02);
-            process_point_1(4.8968251919873762e-01, 3.1334700227139071e-02);
-            process_point_1(4.3708959149293664e-01, 7.7827541004774278e-02);
-            process_point_1(1.8820353561903275e-01, 7.9647738927210249e-02);
 
-            process_point_3(3.6838412054736258e-02,
-                            2.2196298916076568e-01,
-                            4.3283539377289376e-02);
-          }
-        else if (dim == 3)
-          {
-            b_point_permutations.push_back({centroid});
-            b_weights.push_back(5.801054891248025e-02);
-
-            process_point_1(6.198169755222693e-10, 6.431928175925639e-05);
-            process_point_1(1.607745353952616e-01, 2.317333846242546e-02);
-            process_point_1(3.222765218214210e-01, 2.956291233542929e-02);
-            process_point_1(4.510891834541358e-02, 8.063979979616182e-03);
-
-            process_point_2(1.122965460043761e-01, 3.813408010370246e-02);
-
-            process_point_3(4.588714487524592e-01,
-                            2.554579233041310e-03,
-                            8.384422198298552e-03);
-            process_point_3(3.377587068533860e-02,
-                            7.183503264420745e-01,
-                            1.023455935274533e-02);
-            process_point_3(1.836413698099279e-01,
-                            3.441591057817528e-02,
-                            2.052491596798814e-02);
-          }
-      }
-    else if (n_points_1D == 6)
-      {
-        // There is no WV-11 rule in 3D yet
-        if (dim == 2)
-          {
-            b_point_permutations.push_back({centroid});
-            b_weights.push_back(8.5761179732224219e-02);
-
-            process_point_1(2.8485417614371900e-02, 1.0431870512894697e-02);
-            process_point_1(4.9589190096589092e-01, 1.6606273054585369e-02);
-            process_point_1(1.0263548271224643e-01, 3.8630759237019321e-02);
-            process_point_1(4.3846592676435220e-01, 6.7316154079468296e-02);
-            process_point_1(2.1021995670317828e-01, 7.0515684111716576e-02);
-
-            process_point_3(7.3254276860644785e-03,
-                            1.4932478865208237e-01,
-                            1.0290289572953278e-02);
-            process_point_3(4.6010500165429957e-02,
-                            2.8958112563770588e-01,
-                            4.0332476640500554e-02);
-          }
-        else if (dim == 3)
-          {
-            Assert(false, ExcNotImplemented());
-          }
-      }
-    else
-      {
-        Assert(false, ExcNotImplemented());
-      }
+template <int dim>
+QWitherdenVincent<dim>::QWitherdenVincent(const unsigned int n_points_1D)
+  : QSimplex<dim>(Quadrature<dim>())
+{
+  Assert(1 <= dim && dim <= 3, ExcNotImplemented());
+  // Just use Gauss in 1D: this is a high-order open rule so this is a
+  // reasonable equivalent for generic programming.
+  if (dim == 1)
+    {
+      Quadrature<dim>::operator=(dealii::QGauss<dim>(n_points_1D));
+      return;
+    }
 
-    Assert(b_point_permutations.size() == b_weights.size(), ExcInternalError());
-    for (unsigned int permutation_n = 0; permutation_n < b_weights.size();
-         ++permutation_n)
-      {
-        for (const std::array<double, dim + 1> &b_point :
-             b_point_permutations[permutation_n])
-          {
-            const double volume = (dim == 2 ? 1.0 / 2.0 : 1.0 / 6.0);
-            this->weights.emplace_back(volume * b_weights[permutation_n]);
-            Point<dim> c_point;
-            std::copy(b_point.begin(),
-                      b_point.begin() + dim,
-                      c_point.begin_raw());
-            this->quadrature_points.emplace_back(c_point);
-          }
-      }
-  }
+  std::array<double, dim + 1> centroid;
+  std::fill(centroid.begin(), centroid.end(), 1.0 / (dim + 1.0));
+  std::vector<std::vector<std::array<double, dim + 1>>> b_point_permutations;
+  std::vector<double>                                   b_weights;
+
+  // We can simplify the implementation of these quadrature rules
+  // by quite a bit by exploiting symmetry - we do essentially the
+  // same thing for each barycentric coordinate, so we can express
+  // our quadrature rule as permutations of barycentric points
+  // instead of writing things out explicitly.
+
+  // Apply a Barycentric permutation where one point is different.
+  auto process_point_1 = [&](const double a, const double w) {
+    const double                b = 1.0 - dim * a;
+    std::array<double, dim + 1> b_point;
+    std::fill(b_point.begin(), b_point.begin() + dim, a);
+    b_point[dim] = b;
+
+    b_weights.push_back(w);
+    b_point_permutations.push_back(all_permutations(b_point));
+  };
+
+  // Apply a Barycentric permutation where two points (in 3D) are different.
+  auto process_point_2 = [&](const double a, const double w) {
+    Assert(dim == 3, ExcInternalError());
+    const double                b = (1.0 - 2.0 * a) / 2.0;
+    std::array<double, dim + 1> b_point;
+    std::fill(b_point.begin(), b_point.begin() + dim - 1, a);
+    b_point[dim - 1] = b;
+    b_point[dim]     = b;
+
+    b_weights.push_back(w);
+    b_point_permutations.push_back(all_permutations(b_point));
+  };
+
+  // Apply a Barycentric permutation where three (or four) points
+  // are different (since there are two inputs).
+  auto process_point_3 = [&](const double a, const double b, const double w) {
+    const double                c = 1.0 - (dim - 1.0) * a - b;
+    std::array<double, dim + 1> b_point;
+    std::fill(b_point.begin(), b_point.begin() + dim - 1, a);
+    b_point[dim - 1] = b;
+    b_point[dim]     = c;
+
+    b_weights.push_back(w);
+    b_point_permutations.push_back(all_permutations(b_point));
+  };
+
+  if (n_points_1D == 1)
+    {
+      b_point_permutations.push_back({centroid});
+      b_weights.push_back(1.0);
+    }
+  else if (n_points_1D == 2)
+    {
+      // This is WV-4 in 2D and WV-3 in 3D
+      if (dim == 2)
+        {
+          process_point_1(9.1576213509770743e-02, 1.0995174365532187e-01);
+          process_point_1(4.4594849091596489e-01, 2.2338158967801147e-01);
+        }
+      else if (dim == 3)
+        {
+          process_point_1(3.281633025163817e-01, 1.362178425370874e-01);
+          process_point_1(1.080472498984286e-01, 1.137821574629126e-01);
+        }
+    }
+  else if (n_points_1D == 3)
+    {
+      // This is the WV-5 rule in both 2D and 3D
+      if (dim == 2)
+        {
+          b_weights.push_back(0.225);
+          b_point_permutations.push_back({centroid});
 
+          process_point_1(1.0128650732345634e-01, 1.2593918054482714e-01);
+          process_point_1(4.7014206410511511e-01, 1.3239415278850619e-01);
+        }
+      else if (dim == 3)
+        {
+          process_point_1(3.108859192633006e-01, 1.126879257180159e-01);
+          process_point_1(9.273525031089125e-02, 7.349304311636196e-02);
 
+          process_point_2(4.550370412564964e-02, 4.254602077708147e-02);
+        }
+    }
+  else if (n_points_1D == 4)
+    {
+      // This is the WV-7 rule in both 2D and 3D
+      if (dim == 2)
+        {
+          process_point_1(3.3730648554587850e-02, 1.6545050110792131e-02);
+          process_point_1(4.7430969250471822e-01, 7.7086646185986069e-02);
+          process_point_1(2.4157738259540357e-01, 1.2794417123015558e-01);
+          process_point_3(4.7036644652595216e-02,
+                          1.9868331479735168e-01,
+                          5.5878732903199779e-02);
+        }
+      else if (dim == 3)
+        {
+          b_point_permutations.push_back({centroid});
+          b_weights.push_back(9.548528946413085e-02);
+
+          process_point_1(3.157011497782028e-01, 4.232958120996703e-02);
+          process_point_2(5.048982259839635e-02, 3.189692783285758e-02);
+
+          process_point_3(1.888338310260010e-01,
+                          5.751716375870000e-01,
+                          3.720713072833462e-02);
+          process_point_3(2.126547254148314e-02,
+                          8.108302410985486e-01,
+                          8.110770829903342e-03);
+        }
+    }
+  else if (n_points_1D == 5)
+    {
+      // This is the WV-9 rule in both 2D and 3D
+      if (dim == 2)
+        {
+          b_point_permutations.push_back({centroid});
+          b_weights.push_back(9.7135796282798836e-02);
 
-  template <int dim>
-  QGaussWedge<dim>::QGaussWedge(const unsigned int n_points)
-    : Quadrature<dim>()
-  {
-    AssertDimension(dim, 3);
+          process_point_1(4.4729513394452691e-02, 2.5577675658698031e-02);
+          process_point_1(4.8968251919873762e-01, 3.1334700227139071e-02);
+          process_point_1(4.3708959149293664e-01, 7.7827541004774278e-02);
+          process_point_1(1.8820353561903275e-01, 7.9647738927210249e-02);
 
-    Simplex::QGauss<2> quad_tri(n_points);
-    QGauss<1>          quad_line(n_points);
+          process_point_3(3.6838412054736258e-02,
+                          2.2196298916076568e-01,
+                          4.3283539377289376e-02);
+        }
+      else if (dim == 3)
+        {
+          b_point_permutations.push_back({centroid});
+          b_weights.push_back(5.801054891248025e-02);
+
+          process_point_1(6.198169755222693e-10, 6.431928175925639e-05);
+          process_point_1(1.607745353952616e-01, 2.317333846242546e-02);
+          process_point_1(3.222765218214210e-01, 2.956291233542929e-02);
+          process_point_1(4.510891834541358e-02, 8.063979979616182e-03);
+
+          process_point_2(1.122965460043761e-01, 3.813408010370246e-02);
+
+          process_point_3(4.588714487524592e-01,
+                          2.554579233041310e-03,
+                          8.384422198298552e-03);
+          process_point_3(3.377587068533860e-02,
+                          7.183503264420745e-01,
+                          1.023455935274533e-02);
+          process_point_3(1.836413698099279e-01,
+                          3.441591057817528e-02,
+                          2.052491596798814e-02);
+        }
+    }
+  else if (n_points_1D == 6)
+    {
+      // There is no WV-11 rule in 3D yet
+      if (dim == 2)
+        {
+          b_point_permutations.push_back({centroid});
+          b_weights.push_back(8.5761179732224219e-02);
+
+          process_point_1(2.8485417614371900e-02, 1.0431870512894697e-02);
+          process_point_1(4.9589190096589092e-01, 1.6606273054585369e-02);
+          process_point_1(1.0263548271224643e-01, 3.8630759237019321e-02);
+          process_point_1(4.3846592676435220e-01, 6.7316154079468296e-02);
+          process_point_1(2.1021995670317828e-01, 7.0515684111716576e-02);
+
+          process_point_3(7.3254276860644785e-03,
+                          1.4932478865208237e-01,
+                          1.0290289572953278e-02);
+          process_point_3(4.6010500165429957e-02,
+                          2.8958112563770588e-01,
+                          4.0332476640500554e-02);
+        }
+      else if (dim == 3)
+        {
+          Assert(false, ExcNotImplemented());
+        }
+    }
+  else
+    {
+      Assert(false, ExcNotImplemented());
+    }
 
-    for (unsigned int i = 0; i < quad_line.size(); ++i)
-      for (unsigned int j = 0; j < quad_tri.size(); ++j)
+  Assert(b_point_permutations.size() == b_weights.size(), ExcInternalError());
+  for (unsigned int permutation_n = 0; permutation_n < b_weights.size();
+       ++permutation_n)
+    {
+      for (const std::array<double, dim + 1> &b_point :
+           b_point_permutations[permutation_n])
         {
-          this->quadrature_points.emplace_back(quad_tri.point(j)[0],
-                                               quad_tri.point(j)[1],
-                                               quad_line.point(i)[0]);
-          this->weights.emplace_back(quad_tri.weight(j) * quad_line.weight(i));
+          const double volume = (dim == 2 ? 1.0 / 2.0 : 1.0 / 6.0);
+          this->weights.emplace_back(volume * b_weights[permutation_n]);
+          Point<dim> c_point;
+          std::copy(b_point.begin(),
+                    b_point.begin() + dim,
+                    c_point.begin_raw());
+          this->quadrature_points.emplace_back(c_point);
         }
+    }
+}
 
-    AssertDimension(this->quadrature_points.size(), this->weights.size());
-    Assert(this->quadrature_points.size() > 0,
-           ExcMessage("No valid quadrature points!"));
-  }
 
 
+template <int dim>
+QGaussWedge<dim>::QGaussWedge(const unsigned int n_points)
+  : Quadrature<dim>()
+{
+  AssertDimension(dim, 3);
 
-  template <int dim>
-  QGaussPyramid<dim>::QGaussPyramid(const unsigned int n_points_1D)
-    : Quadrature<dim>()
-  {
-    AssertDimension(dim, 3);
+  QGaussSimplex<2> quad_tri(n_points);
+  QGauss<1>        quad_line(n_points);
 
-    if (n_points_1D == 1)
+  for (unsigned int i = 0; i < quad_line.size(); ++i)
+    for (unsigned int j = 0; j < quad_tri.size(); ++j)
       {
-        const double Q14 = 1.0 / 4.0;
-        const double Q43 = 4.0 / 3.0;
-
-        this->quadrature_points.emplace_back(0, 0, Q14);
-        this->weights.emplace_back(Q43);
+        this->quadrature_points.emplace_back(quad_tri.point(j)[0],
+                                             quad_tri.point(j)[1],
+                                             quad_line.point(i)[0]);
+        this->weights.emplace_back(quad_tri.weight(j) * quad_line.weight(i));
       }
-    else if (n_points_1D == 2)
-      {
-        // clang-format off
+
+  AssertDimension(this->quadrature_points.size(), this->weights.size());
+  Assert(this->quadrature_points.size() > 0,
+         ExcMessage("No valid quadrature points!"));
+}
+
+
+
+template <int dim>
+QGaussPyramid<dim>::QGaussPyramid(const unsigned int n_points_1D)
+  : Quadrature<dim>()
+{
+  AssertDimension(dim, 3);
+
+  if (n_points_1D == 1)
+    {
+      const double Q14 = 1.0 / 4.0;
+      const double Q43 = 4.0 / 3.0;
+
+      this->quadrature_points.emplace_back(0, 0, Q14);
+      this->weights.emplace_back(Q43);
+    }
+  else if (n_points_1D == 2)
+    {
+      // clang-format off
         this->quadrature_points.emplace_back(-0.26318405556971, -0.26318405556971, 0.54415184401122);
         this->quadrature_points.emplace_back(-0.50661630334979, -0.50661630334979, 0.12251482265544);
         this->quadrature_points.emplace_back(-0.26318405556971, +0.26318405556971, 0.54415184401122);
@@ -1772,24 +1770,22 @@ namespace Simplex
         this->quadrature_points.emplace_back(+0.50661630334979, -0.50661630334979, 0.12251482265544);
         this->quadrature_points.emplace_back(+0.26318405556971, +0.26318405556971, 0.54415184401122);
         this->quadrature_points.emplace_back(+0.50661630334979, +0.50661630334979, 0.12251482265544);
-        // clang-format on
-
-        this->weights.emplace_back(0.10078588207983);
-        this->weights.emplace_back(0.23254745125351);
-        this->weights.emplace_back(0.10078588207983);
-        this->weights.emplace_back(0.23254745125351);
-        this->weights.emplace_back(0.10078588207983);
-        this->weights.emplace_back(0.23254745125351);
-        this->weights.emplace_back(0.10078588207983);
-        this->weights.emplace_back(0.23254745125351);
-      }
-
-    AssertDimension(this->quadrature_points.size(), this->weights.size());
-    Assert(this->quadrature_points.size() > 0,
-           ExcMessage("No valid quadrature points!"));
-  }
+      // clang-format on
+
+      this->weights.emplace_back(0.10078588207983);
+      this->weights.emplace_back(0.23254745125351);
+      this->weights.emplace_back(0.10078588207983);
+      this->weights.emplace_back(0.23254745125351);
+      this->weights.emplace_back(0.10078588207983);
+      this->weights.emplace_back(0.23254745125351);
+      this->weights.emplace_back(0.10078588207983);
+      this->weights.emplace_back(0.23254745125351);
+    }
 
-} // namespace Simplex
+  AssertDimension(this->quadrature_points.size(), this->weights.size());
+  Assert(this->quadrature_points.size() > 0,
+         ExcMessage("No valid quadrature points!"));
+}
 
 
 
@@ -1839,18 +1835,18 @@ template class QSplit<1>;
 template class QSplit<2>;
 template class QSplit<3>;
 
-template class Simplex::QGauss<1>;
-template class Simplex::QGauss<2>;
-template class Simplex::QGauss<3>;
-template class Simplex::QGaussWedge<1>;
-template class Simplex::QGaussWedge<2>;
-template class Simplex::QGaussWedge<3>;
-template class Simplex::QGaussPyramid<1>;
-template class Simplex::QGaussPyramid<2>;
-template class Simplex::QGaussPyramid<3>;
-
-template class Simplex::QWitherdenVincent<1>;
-template class Simplex::QWitherdenVincent<2>;
-template class Simplex::QWitherdenVincent<3>;
+template class QGaussSimplex<1>;
+template class QGaussSimplex<2>;
+template class QGaussSimplex<3>;
+template class QGaussWedge<1>;
+template class QGaussWedge<2>;
+template class QGaussWedge<3>;
+template class QGaussPyramid<1>;
+template class QGaussPyramid<2>;
+template class QGaussPyramid<3>;
+
+template class QWitherdenVincent<1>;
+template class QWitherdenVincent<2>;
+template class QWitherdenVincent<3>;
 
 DEAL_II_NAMESPACE_CLOSE
diff --git a/source/fe/fe_dgq.cc b/source/fe/fe_dgq.cc
index 73acc4e8d5..f131faba73 100644
--- a/source/fe/fe_dgq.cc
+++ b/source/fe/fe_dgq.cc
@@ -698,8 +698,8 @@ FE_DGQ<dim, spacedim>::compare_for_domination(
       else
         return FiniteElementDomination::other_element_dominates;
     }
-  else if (const Simplex::FE_DGP<dim, spacedim> *fe_dgp_other =
-             dynamic_cast<const Simplex::FE_DGP<dim, spacedim> *>(&fe_other))
+  else if (const FE_SimplexDGP<dim, spacedim> *fe_dgp_other =
+             dynamic_cast<const FE_SimplexDGP<dim, spacedim> *>(&fe_other))
     {
       if (this->degree < fe_dgp_other->degree)
         return FiniteElementDomination::this_element_dominates;
diff --git a/source/fe/fe_pyramid_p.cc b/source/fe/fe_pyramid_p.cc
index fe286a52ed..97e450c0f0 100644
--- a/source/fe/fe_pyramid_p.cc
+++ b/source/fe/fe_pyramid_p.cc
@@ -29,285 +29,281 @@
 
 DEAL_II_NAMESPACE_OPEN
 
-namespace Simplex
+namespace
 {
-  namespace
+  /**
+   * Helper function to set up the dpo vector of FE_PyramidP for a given @p degree.
+   */
+  internal::GenericDoFsPerObject
+  get_dpo_vector_fe_pyramid_p(const unsigned int degree)
   {
-    /**
-     * Helper function to set up the dpo vector of FE_PyramidP for a given @p degree.
-     */
-    internal::GenericDoFsPerObject
-    get_dpo_vector_fe_pyramid_p(const unsigned int degree)
-    {
-      internal::GenericDoFsPerObject dpo;
-
-      if (degree == 1)
-        {
-          dpo.dofs_per_object_exclusive  = {{1}, {0}, {0, 0, 0, 0, 0}, {0}};
-          dpo.dofs_per_object_inclusive  = {{1}, {2}, {4, 3, 3, 3, 3}, {5}};
-          dpo.object_index               = {{}, {5}, {5}, {5}};
-          dpo.first_object_index_on_face = {{},
-                                            {4, 3, 3, 3, 3},
-                                            {4, 3, 3, 3, 3}};
-        }
-      else
-        {
-          Assert(false, ExcNotImplemented());
-        }
-
-      return dpo;
-    }
-
-    /**
-     * Helper function to set up the dpo vector of FE_PyramidDGP for a given @p degree.
-     */
-    internal::GenericDoFsPerObject
-    get_dpo_vector_fe_pyramid_dgp(const unsigned int degree)
-    {
-      unsigned int n_dofs = 0;
+    internal::GenericDoFsPerObject dpo;
 
-      if (degree == 1)
-        n_dofs = 5;
-      else
+    if (degree == 1)
+      {
+        dpo.dofs_per_object_exclusive  = {{1}, {0}, {0, 0, 0, 0, 0}, {0}};
+        dpo.dofs_per_object_inclusive  = {{1}, {2}, {4, 3, 3, 3, 3}, {5}};
+        dpo.object_index               = {{}, {5}, {5}, {5}};
+        dpo.first_object_index_on_face = {{}, {4, 3, 3, 3, 3}, {4, 3, 3, 3, 3}};
+      }
+    else
+      {
         Assert(false, ExcNotImplemented());
+      }
 
-      return internal::expand(3, {{0, 0, 0, n_dofs}}, ReferenceCells::Pyramid);
-    }
-  } // namespace
-
-
-  template <int dim, int spacedim>
-  FE_Pyramid<dim, spacedim>::FE_Pyramid(
-    const unsigned int                                degree,
-    const internal::GenericDoFsPerObject &            dpos,
-    const typename FiniteElementData<dim>::Conformity conformity)
-    : dealii::FE_Poly<dim, spacedim>(
-        Simplex::ScalarPyramidPolynomial<dim>(degree),
-        FiniteElementData<dim>(dpos,
-                               ReferenceCells::Pyramid,
-                               1,
-                               degree,
-                               conformity),
-        std::vector<bool>(
-          FiniteElementData<dim>(dpos, ReferenceCells::Pyramid, 1, degree)
-            .dofs_per_cell,
-          true),
-        std::vector<ComponentMask>(
-          FiniteElementData<dim>(dpos, ReferenceCells::Pyramid, 1, degree)
-            .dofs_per_cell,
-          std::vector<bool>(1, true)))
-  {
-    AssertDimension(dim, 3);
+    return dpo;
+  }
 
+  /**
+   * Helper function to set up the dpo vector of FE_PyramidDGP for a given @p degree.
+   */
+  internal::GenericDoFsPerObject
+  get_dpo_vector_fe_pyramid_dgp(const unsigned int degree)
+  {
+    unsigned int n_dofs = 0;
 
     if (degree == 1)
-      {
-        this->unit_support_points.emplace_back(-1.0, -1.0, 0.0);
-        this->unit_support_points.emplace_back(+1.0, -1.0, 0.0);
-        this->unit_support_points.emplace_back(-1.0, +1.0, 0.0);
-        this->unit_support_points.emplace_back(+1.0, +1.0, 0.0);
-        this->unit_support_points.emplace_back(+0.0, +0.0, 1.0);
-      }
+      n_dofs = 5;
+    else
+      Assert(false, ExcNotImplemented());
+
+    return internal::expand(3, {{0, 0, 0, n_dofs}}, ReferenceCells::Pyramid);
   }
+} // namespace
+
+
+template <int dim, int spacedim>
+FE_Pyramid<dim, spacedim>::FE_Pyramid(
+  const unsigned int                                degree,
+  const internal::GenericDoFsPerObject &            dpos,
+  const typename FiniteElementData<dim>::Conformity conformity)
+  : dealii::FE_Poly<dim, spacedim>(
+      ScalarPyramidPolynomial<dim>(degree),
+      FiniteElementData<dim>(dpos,
+                             ReferenceCells::Pyramid,
+                             1,
+                             degree,
+                             conformity),
+      std::vector<bool>(
+        FiniteElementData<dim>(dpos, ReferenceCells::Pyramid, 1, degree)
+          .dofs_per_cell,
+        true),
+      std::vector<ComponentMask>(
+        FiniteElementData<dim>(dpos, ReferenceCells::Pyramid, 1, degree)
+          .dofs_per_cell,
+        std::vector<bool>(1, true)))
+{
+  AssertDimension(dim, 3);
 
 
+  if (degree == 1)
+    {
+      this->unit_support_points.emplace_back(-1.0, -1.0, 0.0);
+      this->unit_support_points.emplace_back(+1.0, -1.0, 0.0);
+      this->unit_support_points.emplace_back(-1.0, +1.0, 0.0);
+      this->unit_support_points.emplace_back(+1.0, +1.0, 0.0);
+      this->unit_support_points.emplace_back(+0.0, +0.0, 1.0);
+    }
+}
 
-  template <int dim, int spacedim>
-  FE_PyramidP<dim, spacedim>::FE_PyramidP(const unsigned int degree)
-    : FE_Pyramid<dim, spacedim>(degree,
-                                get_dpo_vector_fe_pyramid_p(degree),
-                                FiniteElementData<dim>::H1)
-  {}
 
 
+template <int dim, int spacedim>
+FE_PyramidP<dim, spacedim>::FE_PyramidP(const unsigned int degree)
+  : FE_Pyramid<dim, spacedim>(degree,
+                              get_dpo_vector_fe_pyramid_p(degree),
+                              FiniteElementData<dim>::H1)
+{}
 
-  template <int dim, int spacedim>
-  std::unique_ptr<FiniteElement<dim, spacedim>>
-  FE_PyramidP<dim, spacedim>::clone() const
-  {
-    return std::make_unique<FE_PyramidP<dim, spacedim>>(*this);
-  }
 
 
+template <int dim, int spacedim>
+std::unique_ptr<FiniteElement<dim, spacedim>>
+FE_PyramidP<dim, spacedim>::clone() const
+{
+  return std::make_unique<FE_PyramidP<dim, spacedim>>(*this);
+}
 
-  template <int dim, int spacedim>
-  std::string
-  FE_PyramidP<dim, spacedim>::get_name() const
-  {
-    std::ostringstream namebuf;
-    namebuf << "FE_PyramidP<" << dim << ">(" << this->degree << ")";
 
-    return namebuf.str();
-  }
 
+template <int dim, int spacedim>
+std::string
+FE_PyramidP<dim, spacedim>::get_name() const
+{
+  std::ostringstream namebuf;
+  namebuf << "FE_PyramidP<" << dim << ">(" << this->degree << ")";
 
+  return namebuf.str();
+}
 
-  template <int dim, int spacedim>
-  FiniteElementDomination::Domination
-  FE_PyramidP<dim, spacedim>::compare_for_domination(
-    const FiniteElement<dim, spacedim> &fe_other,
-    const unsigned int                  codim) const
-  {
-    Assert(codim <= dim, ExcImpossibleInDim(dim));
-
-    // vertex/line/face domination
-    // (if fe_other is derived from FE_DGP)
-    // ------------------------------------
-    if (codim > 0)
-      if (dynamic_cast<const FE_DGP<dim, spacedim> *>(&fe_other) != nullptr)
-        // there are no requirements between continuous and discontinuous
-        // elements
-        return FiniteElementDomination::no_requirements;
 
-    // vertex/line/face domination
-    // (if fe_other is not derived from FE_DGP)
-    // & cell domination
-    // ----------------------------------------
-    if (const FE_PyramidP<dim, spacedim> *fe_pp_other =
-          dynamic_cast<const FE_PyramidP<dim, spacedim> *>(&fe_other))
-      {
-        if (this->degree < fe_pp_other->degree)
-          return FiniteElementDomination::this_element_dominates;
-        else if (this->degree == fe_pp_other->degree)
-          return FiniteElementDomination::either_element_can_dominate;
-        else
-          return FiniteElementDomination::other_element_dominates;
-      }
-    else if (const FE_P<dim, spacedim> *fe_p_other =
-               dynamic_cast<const FE_P<dim, spacedim> *>(&fe_other))
-      {
-        if (this->degree < fe_p_other->degree)
-          return FiniteElementDomination::this_element_dominates;
-        else if (this->degree == fe_p_other->degree)
-          return FiniteElementDomination::either_element_can_dominate;
-        else
-          return FiniteElementDomination::other_element_dominates;
-      }
-    else if (const FE_Q<dim, spacedim> *fe_q_other =
-               dynamic_cast<const FE_Q<dim, spacedim> *>(&fe_other))
-      {
-        if (this->degree < fe_q_other->degree)
-          return FiniteElementDomination::this_element_dominates;
-        else if (this->degree == fe_q_other->degree)
-          return FiniteElementDomination::either_element_can_dominate;
-        else
-          return FiniteElementDomination::other_element_dominates;
-      }
-    else if (const FE_Nothing<dim, spacedim> *fe_nothing =
-               dynamic_cast<const FE_Nothing<dim, spacedim> *>(&fe_other))
-      {
-        if (fe_nothing->is_dominating())
-          return FiniteElementDomination::other_element_dominates;
-        else
-          // the FE_Nothing has no degrees of freedom and it is typically used
-          // in a context where we don't require any continuity along the
-          // interface
-          return FiniteElementDomination::no_requirements;
-      }
 
-    Assert(false, ExcNotImplemented());
-    return FiniteElementDomination::neither_element_dominates;
-  }
+template <int dim, int spacedim>
+FiniteElementDomination::Domination
+FE_PyramidP<dim, spacedim>::compare_for_domination(
+  const FiniteElement<dim, spacedim> &fe_other,
+  const unsigned int                  codim) const
+{
+  Assert(codim <= dim, ExcImpossibleInDim(dim));
+
+  // vertex/line/face domination
+  // (if fe_other is derived from FE_SimplexDGP)
+  // ------------------------------------
+  if (codim > 0)
+    if (dynamic_cast<const FE_SimplexDGP<dim, spacedim> *>(&fe_other) !=
+        nullptr)
+      // there are no requirements between continuous and discontinuous
+      // elements
+      return FiniteElementDomination::no_requirements;
+
+  // vertex/line/face domination
+  // (if fe_other is not derived from FE_SimplexDGP)
+  // & cell domination
+  // ----------------------------------------
+  if (const FE_PyramidP<dim, spacedim> *fe_pp_other =
+        dynamic_cast<const FE_PyramidP<dim, spacedim> *>(&fe_other))
+    {
+      if (this->degree < fe_pp_other->degree)
+        return FiniteElementDomination::this_element_dominates;
+      else if (this->degree == fe_pp_other->degree)
+        return FiniteElementDomination::either_element_can_dominate;
+      else
+        return FiniteElementDomination::other_element_dominates;
+    }
+  else if (const FE_SimplexP<dim, spacedim> *fe_p_other =
+             dynamic_cast<const FE_SimplexP<dim, spacedim> *>(&fe_other))
+    {
+      if (this->degree < fe_p_other->degree)
+        return FiniteElementDomination::this_element_dominates;
+      else if (this->degree == fe_p_other->degree)
+        return FiniteElementDomination::either_element_can_dominate;
+      else
+        return FiniteElementDomination::other_element_dominates;
+    }
+  else if (const FE_Q<dim, spacedim> *fe_q_other =
+             dynamic_cast<const FE_Q<dim, spacedim> *>(&fe_other))
+    {
+      if (this->degree < fe_q_other->degree)
+        return FiniteElementDomination::this_element_dominates;
+      else if (this->degree == fe_q_other->degree)
+        return FiniteElementDomination::either_element_can_dominate;
+      else
+        return FiniteElementDomination::other_element_dominates;
+    }
+  else if (const FE_Nothing<dim, spacedim> *fe_nothing =
+             dynamic_cast<const FE_Nothing<dim, spacedim> *>(&fe_other))
+    {
+      if (fe_nothing->is_dominating())
+        return FiniteElementDomination::other_element_dominates;
+      else
+        // the FE_Nothing has no degrees of freedom and it is typically used
+        // in a context where we don't require any continuity along the
+        // interface
+        return FiniteElementDomination::no_requirements;
+    }
 
+  Assert(false, ExcNotImplemented());
+  return FiniteElementDomination::neither_element_dominates;
+}
 
 
-  template <int dim, int spacedim>
-  std::vector<std::pair<unsigned int, unsigned int>>
-  FE_PyramidP<dim, spacedim>::hp_vertex_dof_identities(
-    const FiniteElement<dim, spacedim> &fe_other) const
-  {
-    (void)fe_other;
 
-    Assert((dynamic_cast<const Simplex::FE_P<dim, spacedim> *>(&fe_other)) ||
-             (dynamic_cast<const FE_Q<dim, spacedim> *>(&fe_other)),
-           ExcNotImplemented());
+template <int dim, int spacedim>
+std::vector<std::pair<unsigned int, unsigned int>>
+FE_PyramidP<dim, spacedim>::hp_vertex_dof_identities(
+  const FiniteElement<dim, spacedim> &fe_other) const
+{
+  (void)fe_other;
 
-    return {{0, 0}};
-  }
+  Assert((dynamic_cast<const FE_SimplexP<dim, spacedim> *>(&fe_other)) ||
+           (dynamic_cast<const FE_Q<dim, spacedim> *>(&fe_other)),
+         ExcNotImplemented());
 
+  return {{0, 0}};
+}
 
 
-  template <int dim, int spacedim>
-  std::vector<std::pair<unsigned int, unsigned int>>
-  FE_PyramidP<dim, spacedim>::hp_line_dof_identities(
-    const FiniteElement<dim, spacedim> &fe_other) const
-  {
-    (void)fe_other;
 
-    Assert((dynamic_cast<const Simplex::FE_P<dim, spacedim> *>(&fe_other)) ||
-             (dynamic_cast<const FE_Q<dim, spacedim> *>(&fe_other)),
-           ExcNotImplemented());
+template <int dim, int spacedim>
+std::vector<std::pair<unsigned int, unsigned int>>
+FE_PyramidP<dim, spacedim>::hp_line_dof_identities(
+  const FiniteElement<dim, spacedim> &fe_other) const
+{
+  (void)fe_other;
+
+  Assert((dynamic_cast<const FE_SimplexP<dim, spacedim> *>(&fe_other)) ||
+           (dynamic_cast<const FE_Q<dim, spacedim> *>(&fe_other)),
+         ExcNotImplemented());
 
-    std::vector<std::pair<unsigned int, unsigned int>> result;
+  std::vector<std::pair<unsigned int, unsigned int>> result;
 
-    for (unsigned int i = 0; i < this->degree - 1; ++i)
-      result.emplace_back(i, i);
+  for (unsigned int i = 0; i < this->degree - 1; ++i)
+    result.emplace_back(i, i);
 
-    return result;
-  }
+  return result;
+}
 
 
 
-  template <int dim, int spacedim>
-  std::vector<std::pair<unsigned int, unsigned int>>
-  FE_PyramidP<dim, spacedim>::hp_quad_dof_identities(
-    const FiniteElement<dim, spacedim> &fe_other,
-    const unsigned int                  face_no) const
-  {
-    (void)fe_other;
+template <int dim, int spacedim>
+std::vector<std::pair<unsigned int, unsigned int>>
+FE_PyramidP<dim, spacedim>::hp_quad_dof_identities(
+  const FiniteElement<dim, spacedim> &fe_other,
+  const unsigned int                  face_no) const
+{
+  (void)fe_other;
 
 
-    AssertIndexRange(face_no, 5);
+  AssertIndexRange(face_no, 5);
 
-    if (face_no == 0)
-      {
-        Assert((dynamic_cast<const FE_Q<dim, spacedim> *>(&fe_other)),
-               ExcNotImplemented());
-      }
-    else
-      {
-        Assert((dynamic_cast<const Simplex::FE_P<dim, spacedim> *>(&fe_other)),
-               ExcNotImplemented());
-      }
+  if (face_no == 0)
+    {
+      Assert((dynamic_cast<const FE_Q<dim, spacedim> *>(&fe_other)),
+             ExcNotImplemented());
+    }
+  else
+    {
+      Assert((dynamic_cast<const FE_SimplexP<dim, spacedim> *>(&fe_other)),
+             ExcNotImplemented());
+    }
 
-    std::vector<std::pair<unsigned int, unsigned int>> result;
+  std::vector<std::pair<unsigned int, unsigned int>> result;
 
-    for (unsigned int i = 0; i < this->n_dofs_per_quad(face_no); ++i)
-      result.emplace_back(i, i);
+  for (unsigned int i = 0; i < this->n_dofs_per_quad(face_no); ++i)
+    result.emplace_back(i, i);
 
-    return result;
-  }
+  return result;
+}
 
 
 
-  template <int dim, int spacedim>
-  FE_PyramidDGP<dim, spacedim>::FE_PyramidDGP(const unsigned int degree)
-    : FE_Pyramid<dim, spacedim>(degree,
-                                get_dpo_vector_fe_pyramid_dgp(degree),
-                                FiniteElementData<dim>::L2)
-  {}
+template <int dim, int spacedim>
+FE_PyramidDGP<dim, spacedim>::FE_PyramidDGP(const unsigned int degree)
+  : FE_Pyramid<dim, spacedim>(degree,
+                              get_dpo_vector_fe_pyramid_dgp(degree),
+                              FiniteElementData<dim>::L2)
+{}
 
 
 
-  template <int dim, int spacedim>
-  std::unique_ptr<FiniteElement<dim, spacedim>>
-  FE_PyramidDGP<dim, spacedim>::clone() const
-  {
-    return std::make_unique<FE_PyramidDGP<dim, spacedim>>(*this);
-  }
+template <int dim, int spacedim>
+std::unique_ptr<FiniteElement<dim, spacedim>>
+FE_PyramidDGP<dim, spacedim>::clone() const
+{
+  return std::make_unique<FE_PyramidDGP<dim, spacedim>>(*this);
+}
 
 
 
-  template <int dim, int spacedim>
-  std::string
-  FE_PyramidDGP<dim, spacedim>::get_name() const
-  {
-    std::ostringstream namebuf;
-    namebuf << "FE_PyramidDGP<" << dim << ">(" << this->degree << ")";
+template <int dim, int spacedim>
+std::string
+FE_PyramidDGP<dim, spacedim>::get_name() const
+{
+  std::ostringstream namebuf;
+  namebuf << "FE_PyramidDGP<" << dim << ">(" << this->degree << ")";
 
-    return namebuf.str();
-  }
-} // namespace Simplex
+  return namebuf.str();
+}
 
 // explicit instantiations
 #include "fe_pyramid_p.inst"
diff --git a/source/fe/fe_pyramid_p.inst.in b/source/fe/fe_pyramid_p.inst.in
index cce82dcff2..5c0a0ecaab 100644
--- a/source/fe/fe_pyramid_p.inst.in
+++ b/source/fe/fe_pyramid_p.inst.in
@@ -18,11 +18,8 @@
 for (deal_II_dimension : DIMENSIONS; deal_II_space_dimension : DIMENSIONS)
   {
 #if deal_II_dimension <= deal_II_space_dimension
-    template class Simplex::FE_Pyramid<deal_II_dimension,
-                                       deal_II_space_dimension>;
-    template class Simplex::FE_PyramidP<deal_II_dimension,
-                                        deal_II_space_dimension>;
-    template class Simplex::FE_PyramidDGP<deal_II_dimension,
-                                          deal_II_space_dimension>;
+    template class FE_Pyramid<deal_II_dimension, deal_II_space_dimension>;
+    template class FE_PyramidP<deal_II_dimension, deal_II_space_dimension>;
+    template class FE_PyramidDGP<deal_II_dimension, deal_II_space_dimension>;
 #endif
   }
diff --git a/source/fe/fe_q.cc b/source/fe/fe_q.cc
index 39db78bb5c..5d0226c94a 100644
--- a/source/fe/fe_q.cc
+++ b/source/fe/fe_q.cc
@@ -210,8 +210,8 @@ FE_Q<dim, spacedim>::compare_for_domination(
       else
         return FiniteElementDomination::other_element_dominates;
     }
-  else if (const Simplex::FE_P<dim, spacedim> *fe_p_other =
-             dynamic_cast<const Simplex::FE_P<dim, spacedim> *>(&fe_other))
+  else if (const FE_SimplexP<dim, spacedim> *fe_p_other =
+             dynamic_cast<const FE_SimplexP<dim, spacedim> *>(&fe_other))
     {
       if (this->degree < fe_p_other->degree)
         return FiniteElementDomination::this_element_dominates;
@@ -220,8 +220,8 @@ FE_Q<dim, spacedim>::compare_for_domination(
       else
         return FiniteElementDomination::other_element_dominates;
     }
-  else if (const Simplex::FE_WedgeP<dim, spacedim> *fe_wp_other =
-             dynamic_cast<const Simplex::FE_WedgeP<dim, spacedim> *>(&fe_other))
+  else if (const FE_WedgeP<dim, spacedim> *fe_wp_other =
+             dynamic_cast<const FE_WedgeP<dim, spacedim> *>(&fe_other))
     {
       if (this->degree < fe_wp_other->degree)
         return FiniteElementDomination::this_element_dominates;
@@ -230,9 +230,8 @@ FE_Q<dim, spacedim>::compare_for_domination(
       else
         return FiniteElementDomination::other_element_dominates;
     }
-  else if (const Simplex::FE_PyramidP<dim, spacedim> *fe_pp_other =
-             dynamic_cast<const Simplex::FE_PyramidP<dim, spacedim> *>(
-               &fe_other))
+  else if (const FE_PyramidP<dim, spacedim> *fe_pp_other =
+             dynamic_cast<const FE_PyramidP<dim, spacedim> *>(&fe_other))
     {
       if (this->degree < fe_pp_other->degree)
         return FiniteElementDomination::this_element_dominates;
diff --git a/source/fe/fe_q_base.cc b/source/fe/fe_q_base.cc
index c663f75efe..924e5b4cbd 100644
--- a/source/fe/fe_q_base.cc
+++ b/source/fe/fe_q_base.cc
@@ -634,7 +634,7 @@ FE_Q_Base<dim, spacedim>::get_subface_interpolation_matrix(
 
   // see if source is a Q or P element
   if ((dynamic_cast<const FE_Q_Base<dim, spacedim> *>(&source_fe) != nullptr) ||
-      (dynamic_cast<const Simplex::FE_Poly<dim, spacedim> *>(&source_fe) !=
+      (dynamic_cast<const FE_SimplexPoly<dim, spacedim> *>(&source_fe) !=
        nullptr))
     {
       // have this test in here since a table of size 2x0 reports its size as
@@ -744,7 +744,7 @@ FE_Q_Base<dim, spacedim>::hp_vertex_dof_identities(
       // should have identical value
       return {{0U, 0U}};
     }
-  else if (dynamic_cast<const Simplex::FE_P<dim, spacedim> *>(&fe_other) !=
+  else if (dynamic_cast<const FE_SimplexP<dim, spacedim> *>(&fe_other) !=
            nullptr)
     {
       // there should be exactly one single DoF of each FE at a vertex, and they
@@ -815,8 +815,8 @@ FE_Q_Base<dim, spacedim>::hp_line_dof_identities(
 
       return identities;
     }
-  else if (const Simplex::FE_P<dim, spacedim> *fe_p_other =
-             dynamic_cast<const Simplex::FE_P<dim, spacedim> *>(&fe_other))
+  else if (const FE_SimplexP<dim, spacedim> *fe_p_other =
+             dynamic_cast<const FE_SimplexP<dim, spacedim> *>(&fe_other))
     {
       // DoFs are located along lines, so two dofs are identical if they are
       // located at identical positions. If we had only equidistant points, we
@@ -826,7 +826,7 @@ FE_Q_Base<dim, spacedim>::hp_line_dof_identities(
       // first coordinate direction. For FE_Q, we take the lexicographic
       // ordering of the line support points in the first direction (i.e.,
       // x-direction), which we access between index 1 and p-1 (index 0 and p
-      // are vertex dofs). For FE_P, they are currently hard-coded and we
+      // are vertex dofs). For FE_SimplexP, they are currently hard-coded and we
       // iterate over points on the first line which begin after the 3 vertex
       // points in the complete list of unit support points
 
diff --git a/source/fe/fe_simplex_p.cc b/source/fe/fe_simplex_p.cc
index 9adbe33f9e..9f32a2f293 100644
--- a/source/fe/fe_simplex_p.cc
+++ b/source/fe/fe_simplex_p.cc
@@ -26,836 +26,834 @@
 
 DEAL_II_NAMESPACE_OPEN
 
-namespace Simplex
+namespace
 {
-  namespace
+  /**
+   * Helper function to set up the dpo vector of FE_SimplexP for a given @p dim and
+   * @p degree.
+   */
+  std::vector<unsigned int>
+  get_dpo_vector_fe_p(const unsigned int dim, const unsigned int degree)
   {
-    /**
-     * Helper function to set up the dpo vector of FE_P for a given @p dim and
-     * @p degree.
-     */
-    std::vector<unsigned int>
-    get_dpo_vector_fe_p(const unsigned int dim, const unsigned int degree)
-    {
-      std::vector<unsigned int> dpo(dim + 1, 0U);
+    std::vector<unsigned int> dpo(dim + 1, 0U);
 
-      if (degree == 1)
-        {
-          // one dof at each vertex
-          dpo[0] = 1;
-        }
-      else if (degree == 2)
-        {
-          // one dof at each vertex and in the middle of each line
-          dpo[0] = 1;
-          dpo[1] = 1;
-          dpo[2] = 0;
-        }
-      else
-        {
-          Assert(false, ExcNotImplemented());
-        }
+    if (degree == 1)
+      {
+        // one dof at each vertex
+        dpo[0] = 1;
+      }
+    else if (degree == 2)
+      {
+        // one dof at each vertex and in the middle of each line
+        dpo[0] = 1;
+        dpo[1] = 1;
+        dpo[2] = 0;
+      }
+    else
+      {
+        Assert(false, ExcNotImplemented());
+      }
 
-      return dpo;
-    }
+    return dpo;
+  }
 
-    /**
-     * Set up a vector that contains the unit (reference) cell support points
-     * for FE_Poly and sufficiently similar elements.
-     */
-    template <int dim>
-    std::vector<Point<dim>>
-    unit_support_points_fe_poly(const unsigned int degree)
-    {
-      std::vector<Point<dim>> unit_points;
+  /**
+   * Set up a vector that contains the unit (reference) cell support points
+   * for FE_SimplexPoly and sufficiently similar elements.
+   */
+  template <int dim>
+  std::vector<Point<dim>>
+  unit_support_points_fe_poly(const unsigned int degree)
+  {
+    std::vector<Point<dim>> unit_points;
 
-      // Piecewise constants are a special case: use a support point at the
-      // centroid and only the centroid
-      if (degree == 0)
-        {
-          Point<dim> centroid;
-          std::fill(centroid.begin_raw(),
-                    centroid.end_raw(),
-                    1.0 / double(dim + 1));
-          unit_points.emplace_back(centroid);
-          return unit_points;
-        }
+    // Piecewise constants are a special case: use a support point at the
+    // centroid and only the centroid
+    if (degree == 0)
+      {
+        Point<dim> centroid;
+        std::fill(centroid.begin_raw(),
+                  centroid.end_raw(),
+                  1.0 / double(dim + 1));
+        unit_points.emplace_back(centroid);
+        return unit_points;
+      }
 
-      if (dim == 1)
-        {
-          // We don't really have dim = 1 support for simplex elements yet, but
-          // its convenient for populating the face array
-          Assert(degree <= 2, ExcNotImplemented());
-          if (degree >= 1)
-            {
-              unit_points.emplace_back(0.0);
-              unit_points.emplace_back(1.0);
-
-              if (degree == 2)
-                unit_points.emplace_back(0.5);
-            }
-        }
-      else if (dim == 2)
-        {
-          Assert(degree <= 2, ExcNotImplemented());
-          if (degree >= 1)
-            {
-              unit_points.emplace_back(0.0, 0.0);
-              unit_points.emplace_back(1.0, 0.0);
-              unit_points.emplace_back(0.0, 1.0);
-
-              if (degree == 2)
-                {
-                  unit_points.emplace_back(0.5, 0.0);
-                  unit_points.emplace_back(0.5, 0.5);
-                  unit_points.emplace_back(0.0, 0.5);
-                }
-            }
-        }
-      else if (dim == 3)
-        {
-          Assert(degree <= 2, ExcNotImplemented());
-          if (degree >= 1)
-            {
-              unit_points.emplace_back(0.0, 0.0, 0.0);
-              unit_points.emplace_back(1.0, 0.0, 0.0);
-              unit_points.emplace_back(0.0, 1.0, 0.0);
-              unit_points.emplace_back(0.0, 0.0, 1.0);
-
-              if (degree == 2)
-                {
-                  unit_points.emplace_back(0.5, 0.0, 0.0);
-                  unit_points.emplace_back(0.5, 0.5, 0.0);
-                  unit_points.emplace_back(0.0, 0.5, 0.0);
-                  unit_points.emplace_back(0.0, 0.0, 0.5);
-                  unit_points.emplace_back(0.5, 0.0, 0.5);
-                  unit_points.emplace_back(0.0, 0.5, 0.5);
-                }
-            }
-        }
-      else
-        {
-          Assert(false, ExcNotImplemented());
-        }
+    if (dim == 1)
+      {
+        // We don't really have dim = 1 support for simplex elements yet, but
+        // its convenient for populating the face array
+        Assert(degree <= 2, ExcNotImplemented());
+        if (degree >= 1)
+          {
+            unit_points.emplace_back(0.0);
+            unit_points.emplace_back(1.0);
 
-      return unit_points;
-    }
+            if (degree == 2)
+              unit_points.emplace_back(0.5);
+          }
+      }
+    else if (dim == 2)
+      {
+        Assert(degree <= 2, ExcNotImplemented());
+        if (degree >= 1)
+          {
+            unit_points.emplace_back(0.0, 0.0);
+            unit_points.emplace_back(1.0, 0.0);
+            unit_points.emplace_back(0.0, 1.0);
+
+            if (degree == 2)
+              {
+                unit_points.emplace_back(0.5, 0.0);
+                unit_points.emplace_back(0.5, 0.5);
+                unit_points.emplace_back(0.0, 0.5);
+              }
+          }
+      }
+    else if (dim == 3)
+      {
+        Assert(degree <= 2, ExcNotImplemented());
+        if (degree >= 1)
+          {
+            unit_points.emplace_back(0.0, 0.0, 0.0);
+            unit_points.emplace_back(1.0, 0.0, 0.0);
+            unit_points.emplace_back(0.0, 1.0, 0.0);
+            unit_points.emplace_back(0.0, 0.0, 1.0);
+
+            if (degree == 2)
+              {
+                unit_points.emplace_back(0.5, 0.0, 0.0);
+                unit_points.emplace_back(0.5, 0.5, 0.0);
+                unit_points.emplace_back(0.0, 0.5, 0.0);
+                unit_points.emplace_back(0.0, 0.0, 0.5);
+                unit_points.emplace_back(0.5, 0.0, 0.5);
+                unit_points.emplace_back(0.0, 0.5, 0.5);
+              }
+          }
+      }
+    else
+      {
+        Assert(false, ExcNotImplemented());
+      }
 
-    /**
-     * Set up a vector that contains the unit (reference) cell's faces support
-     * points for FE_Poly and sufficiently similar elements.
-     */
-    template <int dim>
-    std::vector<std::vector<Point<dim - 1>>>
-    unit_face_support_points_fe_poly(const unsigned int degree)
-    {
-      // this concept doesn't exist in 1D so just return an empty vector
-      if (dim == 1)
-        return {};
+    return unit_points;
+  }
 
-      std::vector<std::vector<Point<dim - 1>>> unit_face_points;
+  /**
+   * Set up a vector that contains the unit (reference) cell's faces support
+   * points for FE_SimplexPoly and sufficiently similar elements.
+   */
+  template <int dim>
+  std::vector<std::vector<Point<dim - 1>>>
+  unit_face_support_points_fe_poly(const unsigned int degree)
+  {
+    // this concept doesn't exist in 1D so just return an empty vector
+    if (dim == 1)
+      return {};
 
-      // all faces have the same support points
-      for (auto face_n :
-           (dim == 2 ? ReferenceCells::Triangle : ReferenceCells::Tetrahedron)
-             .face_indices())
-        {
-          (void)face_n;
-          unit_face_points.emplace_back(
-            unit_support_points_fe_poly<dim - 1>(degree));
-        }
+    std::vector<std::vector<Point<dim - 1>>> unit_face_points;
 
-      return unit_face_points;
-    }
+    // all faces have the same support points
+    for (auto face_n :
+         (dim == 2 ? ReferenceCells::Triangle : ReferenceCells::Tetrahedron)
+           .face_indices())
+      {
+        (void)face_n;
+        unit_face_points.emplace_back(
+          unit_support_points_fe_poly<dim - 1>(degree));
+      }
 
-    /**
-     * Specify the constraints which the dofs on the two sides of a cell
-     * interface underlie if the line connects two cells of which one is refined
-     * once.
-     */
-    template <int dim>
-    FullMatrix<double>
-    constraints_fe_poly(const unsigned int /*degree*/)
-    {
-      // no constraints in 1d
-      // constraints in 3d not implemented yet
-      return FullMatrix<double>();
-    }
+    return unit_face_points;
+  }
 
-    template <>
-    FullMatrix<double>
-    constraints_fe_poly<2>(const unsigned int degree)
-    {
-      const unsigned int dim = 2;
+  /**
+   * Specify the constraints which the dofs on the two sides of a cell
+   * interface underlie if the line connects two cells of which one is refined
+   * once.
+   */
+  template <int dim>
+  FullMatrix<double>
+  constraints_fe_poly(const unsigned int /*degree*/)
+  {
+    // no constraints in 1d
+    // constraints in 3d not implemented yet
+    return FullMatrix<double>();
+  }
 
-      Assert(degree <= 2, ExcNotImplemented());
+  template <>
+  FullMatrix<double>
+  constraints_fe_poly<2>(const unsigned int degree)
+  {
+    const unsigned int dim = 2;
 
-      // the following implements the 2d case
-      // (the 3d case is not implemented yet)
-      //
-      // consult FE_Q_Base::Implementation::initialize_constraints()
-      // for more information
+    Assert(degree <= 2, ExcNotImplemented());
 
-      std::vector<Point<dim - 1>> constraint_points;
-      // midpoint
-      constraint_points.emplace_back(0.5);
-      if (degree == 2)
-        {
-          // midpoint on subface 0
-          constraint_points.emplace_back(0.25);
-          // midpoint on subface 1
-          constraint_points.emplace_back(0.75);
-        }
+    // the following implements the 2d case
+    // (the 3d case is not implemented yet)
+    //
+    // consult FE_Q_Base::Implementation::initialize_constraints()
+    // for more information
 
-      // Now construct relation between destination (child) and source (mother)
-      // dofs.
+    std::vector<Point<dim - 1>> constraint_points;
+    // midpoint
+    constraint_points.emplace_back(0.5);
+    if (degree == 2)
+      {
+        // midpoint on subface 0
+        constraint_points.emplace_back(0.25);
+        // midpoint on subface 1
+        constraint_points.emplace_back(0.75);
+      }
 
-      const unsigned int n_dofs_constrained = constraint_points.size();
-      unsigned int       n_dofs_per_face    = degree + 1;
-      FullMatrix<double> interface_constraints(n_dofs_constrained,
-                                               n_dofs_per_face);
+    // Now construct relation between destination (child) and source (mother)
+    // dofs.
 
-      const auto poly =
-        Simplex::BarycentricPolynomials<dim - 1>::get_fe_p_basis(degree);
+    const unsigned int n_dofs_constrained = constraint_points.size();
+    unsigned int       n_dofs_per_face    = degree + 1;
+    FullMatrix<double> interface_constraints(n_dofs_constrained,
+                                             n_dofs_per_face);
 
-      for (unsigned int i = 0; i < n_dofs_constrained; ++i)
-        for (unsigned int j = 0; j < n_dofs_per_face; ++j)
-          {
-            interface_constraints(i, j) =
-              poly.compute_value(j, constraint_points[i]);
-
-            // if the value is small up to round-off, then simply set it to zero
-            // to avoid unwanted fill-in of the constraint matrices (which would
-            // then increase the number of other DoFs a constrained DoF would
-            // couple to)
-            if (std::fabs(interface_constraints(i, j)) < 1e-13)
-              interface_constraints(i, j) = 0;
-          }
-      return interface_constraints;
-    }
+    const auto poly = BarycentricPolynomials<dim - 1>::get_fe_p_basis(degree);
 
-    /**
-     * Helper function to set up the dpo vector of FE_DGP for a given @p dim and
-     * @p degree.
-     */
-    std::vector<unsigned int>
-    get_dpo_vector_fe_dgp(const unsigned int dim, const unsigned int degree)
-    {
-      std::vector<unsigned int> dpo(dim + 1, 0U);
-
-      // all dofs are internal
-      if (dim == 2 && degree == 1)
-        dpo[dim] = 3;
-      else if (dim == 2 && degree == 2)
-        dpo[dim] = 6;
-      else if (dim == 3 && degree == 1)
-        dpo[dim] = 4;
-      else if (dim == 3 && degree == 2)
-        dpo[dim] = 10;
-      else
+    for (unsigned int i = 0; i < n_dofs_constrained; ++i)
+      for (unsigned int j = 0; j < n_dofs_per_face; ++j)
         {
-          Assert(false, ExcNotImplemented());
+          interface_constraints(i, j) =
+            poly.compute_value(j, constraint_points[i]);
+
+          // if the value is small up to round-off, then simply set it to zero
+          // to avoid unwanted fill-in of the constraint matrices (which would
+          // then increase the number of other DoFs a constrained DoF would
+          // couple to)
+          if (std::fabs(interface_constraints(i, j)) < 1e-13)
+            interface_constraints(i, j) = 0;
         }
+    return interface_constraints;
+  }
 
-      return dpo;
-    }
-  } // namespace
-
-
+  /**
+   * Helper function to set up the dpo vector of FE_SimplexDGP for a given @p dim and
+   * @p degree.
+   */
+  std::vector<unsigned int>
+  get_dpo_vector_fe_dgp(const unsigned int dim, const unsigned int degree)
+  {
+    std::vector<unsigned int> dpo(dim + 1, 0U);
+
+    // all dofs are internal
+    if (dim == 2 && degree == 1)
+      dpo[dim] = 3;
+    else if (dim == 2 && degree == 2)
+      dpo[dim] = 6;
+    else if (dim == 3 && degree == 1)
+      dpo[dim] = 4;
+    else if (dim == 3 && degree == 2)
+      dpo[dim] = 10;
+    else
+      {
+        Assert(false, ExcNotImplemented());
+      }
 
-  template <int dim, int spacedim>
-  FE_Poly<dim, spacedim>::FE_Poly(
-    const unsigned int                                degree,
-    const std::vector<unsigned int> &                 dpo_vector,
-    const typename FiniteElementData<dim>::Conformity conformity)
-    : dealii::FE_Poly<dim, spacedim>(
-        BarycentricPolynomials<dim>::get_fe_p_basis(degree),
+    return dpo;
+  }
+} // namespace
+
+
+
+template <int dim, int spacedim>
+FE_SimplexPoly<dim, spacedim>::FE_SimplexPoly(
+  const unsigned int                                degree,
+  const std::vector<unsigned int> &                 dpo_vector,
+  const typename FiniteElementData<dim>::Conformity conformity)
+  : dealii::FE_Poly<dim, spacedim>(
+      BarycentricPolynomials<dim>::get_fe_p_basis(degree),
+      FiniteElementData<dim>(dpo_vector,
+                             dim == 2 ? ReferenceCells::Triangle :
+                                        ReferenceCells::Tetrahedron,
+                             1,
+                             degree,
+                             conformity),
+      std::vector<bool>(FiniteElementData<dim>(dpo_vector,
+                                               dim == 2 ?
+                                                 ReferenceCells::Triangle :
+                                                 ReferenceCells::Tetrahedron,
+                                               1,
+                                               degree)
+                          .dofs_per_cell,
+                        true),
+      std::vector<ComponentMask>(
         FiniteElementData<dim>(dpo_vector,
                                dim == 2 ? ReferenceCells::Triangle :
                                           ReferenceCells::Tetrahedron,
                                1,
-                               degree,
-                               conformity),
-        std::vector<bool>(FiniteElementData<dim>(dpo_vector,
-                                                 dim == 2 ?
-                                                   ReferenceCells::Triangle :
-                                                   ReferenceCells::Tetrahedron,
-                                                 1,
-                                                 degree)
-                            .dofs_per_cell,
-                          true),
-        std::vector<ComponentMask>(
-          FiniteElementData<dim>(dpo_vector,
-                                 dim == 2 ? ReferenceCells::Triangle :
-                                            ReferenceCells::Tetrahedron,
-                                 1,
-                                 degree)
-            .dofs_per_cell,
-          std::vector<bool>(1, true)))
-  {
-    this->unit_support_points = unit_support_points_fe_poly<dim>(degree);
-    // Discontinuous elements don't have face support points
-    if (conformity == FiniteElementData<dim>::Conformity::H1)
-      this->unit_face_support_points =
-        unit_face_support_points_fe_poly<dim>(degree);
-    this->interface_constraints = constraints_fe_poly<dim>(degree);
-  }
+                               degree)
+          .dofs_per_cell,
+        std::vector<bool>(1, true)))
+{
+  this->unit_support_points = unit_support_points_fe_poly<dim>(degree);
+  // Discontinuous elements don't have face support points
+  if (conformity == FiniteElementData<dim>::Conformity::H1)
+    this->unit_face_support_points =
+      unit_face_support_points_fe_poly<dim>(degree);
+  this->interface_constraints = constraints_fe_poly<dim>(degree);
+}
 
 
 
-  template <int dim, int spacedim>
-  std::pair<Table<2, bool>, std::vector<unsigned int>>
-  FE_Poly<dim, spacedim>::get_constant_modes() const
-  {
-    Table<2, bool> constant_modes(1, this->n_dofs_per_cell());
-    constant_modes.fill(true);
-    return std::pair<Table<2, bool>, std::vector<unsigned int>>(
-      constant_modes, std::vector<unsigned int>(1, 0));
-  }
+template <int dim, int spacedim>
+std::pair<Table<2, bool>, std::vector<unsigned int>>
+FE_SimplexPoly<dim, spacedim>::get_constant_modes() const
+{
+  Table<2, bool> constant_modes(1, this->n_dofs_per_cell());
+  constant_modes.fill(true);
+  return std::pair<Table<2, bool>, std::vector<unsigned int>>(
+    constant_modes, std::vector<unsigned int>(1, 0));
+}
 
 
 
-  template <int dim, int spacedim>
-  const FullMatrix<double> &
-  FE_Poly<dim, spacedim>::get_prolongation_matrix(
-    const unsigned int         child,
-    const RefinementCase<dim> &refinement_case) const
-  {
-    Assert(refinement_case == RefinementCase<dim>::isotropic_refinement,
-           ExcNotImplemented());
-    AssertDimension(dim, spacedim);
+template <int dim, int spacedim>
+const FullMatrix<double> &
+FE_SimplexPoly<dim, spacedim>::get_prolongation_matrix(
+  const unsigned int         child,
+  const RefinementCase<dim> &refinement_case) const
+{
+  Assert(refinement_case == RefinementCase<dim>::isotropic_refinement,
+         ExcNotImplemented());
+  AssertDimension(dim, spacedim);
 
-    // initialization upon first request
-    if (this->prolongation[refinement_case - 1][child].n() == 0)
-      {
-        std::lock_guard<std::mutex> lock(this->mutex);
+  // initialization upon first request
+  if (this->prolongation[refinement_case - 1][child].n() == 0)
+    {
+      std::lock_guard<std::mutex> lock(this->mutex);
 
-        // if matrix got updated while waiting for the lock
-        if (this->prolongation[refinement_case - 1][child].n() ==
-            this->n_dofs_per_cell())
-          return this->prolongation[refinement_case - 1][child];
+      // if matrix got updated while waiting for the lock
+      if (this->prolongation[refinement_case - 1][child].n() ==
+          this->n_dofs_per_cell())
+        return this->prolongation[refinement_case - 1][child];
 
-        // now do the work. need to get a non-const version of data in order to
-        // be able to modify them inside a const function
-        auto &this_nonconst = const_cast<FE_Poly<dim, spacedim> &>(*this);
+      // now do the work. need to get a non-const version of data in order to
+      // be able to modify them inside a const function
+      auto &this_nonconst = const_cast<FE_SimplexPoly<dim, spacedim> &>(*this);
 
-        std::vector<std::vector<FullMatrix<double>>> isotropic_matrices(
-          RefinementCase<dim>::isotropic_refinement);
-        isotropic_matrices.back().resize(
-          GeometryInfo<dim>::n_children(RefinementCase<dim>(refinement_case)),
-          FullMatrix<double>(this->n_dofs_per_cell(), this->n_dofs_per_cell()));
+      std::vector<std::vector<FullMatrix<double>>> isotropic_matrices(
+        RefinementCase<dim>::isotropic_refinement);
+      isotropic_matrices.back().resize(
+        GeometryInfo<dim>::n_children(RefinementCase<dim>(refinement_case)),
+        FullMatrix<double>(this->n_dofs_per_cell(), this->n_dofs_per_cell()));
 
-        FETools::compute_embedding_matrices(*this, isotropic_matrices, true);
+      FETools::compute_embedding_matrices(*this, isotropic_matrices, true);
 
-        this_nonconst.prolongation[refinement_case - 1].swap(
-          isotropic_matrices.back());
-      }
+      this_nonconst.prolongation[refinement_case - 1].swap(
+        isotropic_matrices.back());
+    }
 
-    // finally return the matrix
-    return this->prolongation[refinement_case - 1][child];
-  }
+  // finally return the matrix
+  return this->prolongation[refinement_case - 1][child];
+}
 
 
 
-  template <int dim, int spacedim>
-  void
-  FE_Poly<dim, spacedim>::get_face_interpolation_matrix(
-    const FiniteElement<dim, spacedim> &source_fe,
-    FullMatrix<double> &                interpolation_matrix,
-    const unsigned int                  face_no) const
-  {
-    Assert(interpolation_matrix.m() == source_fe.n_dofs_per_face(face_no),
-           ExcDimensionMismatch(interpolation_matrix.m(),
-                                source_fe.n_dofs_per_face(face_no)));
+template <int dim, int spacedim>
+void
+FE_SimplexPoly<dim, spacedim>::get_face_interpolation_matrix(
+  const FiniteElement<dim, spacedim> &source_fe,
+  FullMatrix<double> &                interpolation_matrix,
+  const unsigned int                  face_no) const
+{
+  Assert(interpolation_matrix.m() == source_fe.n_dofs_per_face(face_no),
+         ExcDimensionMismatch(interpolation_matrix.m(),
+                              source_fe.n_dofs_per_face(face_no)));
+
+  // see if source is a P or Q element
+  if ((dynamic_cast<const FE_SimplexPoly<dim, spacedim> *>(&source_fe) !=
+       nullptr) ||
+      (dynamic_cast<const FE_Q_Base<dim, spacedim> *>(&source_fe) != nullptr))
+    {
+      const Quadrature<dim - 1> quad_face_support(
+        source_fe.get_unit_face_support_points(face_no));
 
-    // see if source is a P or Q element
-    if ((dynamic_cast<const FE_Poly<dim, spacedim> *>(&source_fe) != nullptr) ||
-        (dynamic_cast<const FE_Q_Base<dim, spacedim> *>(&source_fe) != nullptr))
-      {
-        const Quadrature<dim - 1> quad_face_support(
-          source_fe.get_unit_face_support_points(face_no));
-
-        const double eps = 2e-13 * this->degree * (dim - 1);
-
-        std::vector<Point<dim>> face_quadrature_points(
-          quad_face_support.size());
-        QProjector<dim>::project_to_face(this->reference_cell(),
-                                         quad_face_support,
-                                         face_no,
-                                         face_quadrature_points);
-
-        for (unsigned int i = 0; i < source_fe.n_dofs_per_face(face_no); ++i)
-          for (unsigned int j = 0; j < this->n_dofs_per_face(face_no); ++j)
-            {
-              double matrix_entry =
-                this->shape_value(this->face_to_cell_index(j, 0),
-                                  face_quadrature_points[i]);
-
-              // Correct the interpolated value. I.e. if it is close to 1 or
-              // 0, make it exactly 1 or 0. Unfortunately, this is required to
-              // avoid problems with higher order elements.
-              if (std::fabs(matrix_entry - 1.0) < eps)
-                matrix_entry = 1.0;
-              if (std::fabs(matrix_entry) < eps)
-                matrix_entry = 0.0;
-
-              interpolation_matrix(i, j) = matrix_entry;
-            }
+      const double eps = 2e-13 * this->degree * (dim - 1);
 
-#ifdef DEBUG
-        for (unsigned int j = 0; j < source_fe.n_dofs_per_face(face_no); ++j)
+      std::vector<Point<dim>> face_quadrature_points(quad_face_support.size());
+      QProjector<dim>::project_to_face(this->reference_cell(),
+                                       quad_face_support,
+                                       face_no,
+                                       face_quadrature_points);
+
+      for (unsigned int i = 0; i < source_fe.n_dofs_per_face(face_no); ++i)
+        for (unsigned int j = 0; j < this->n_dofs_per_face(face_no); ++j)
           {
-            double sum = 0.;
+            double matrix_entry =
+              this->shape_value(this->face_to_cell_index(j, 0),
+                                face_quadrature_points[i]);
+
+            // Correct the interpolated value. I.e. if it is close to 1 or
+            // 0, make it exactly 1 or 0. Unfortunately, this is required to
+            // avoid problems with higher order elements.
+            if (std::fabs(matrix_entry - 1.0) < eps)
+              matrix_entry = 1.0;
+            if (std::fabs(matrix_entry) < eps)
+              matrix_entry = 0.0;
+
+            interpolation_matrix(i, j) = matrix_entry;
+          }
 
-            for (unsigned int i = 0; i < this->n_dofs_per_face(face_no); ++i)
-              sum += interpolation_matrix(j, i);
+#ifdef DEBUG
+      for (unsigned int j = 0; j < source_fe.n_dofs_per_face(face_no); ++j)
+        {
+          double sum = 0.;
 
-            Assert(std::fabs(sum - 1) < eps, ExcInternalError());
-          }
-#endif
-      }
-    else if (dynamic_cast<const FE_Nothing<dim> *>(&source_fe) != nullptr)
-      {
-        // nothing to do here, the FE_Nothing has no degrees of freedom anyway
-      }
-    else
-      AssertThrow(
-        false,
-        (typename FiniteElement<dim,
-                                spacedim>::ExcInterpolationNotImplemented()));
-  }
+          for (unsigned int i = 0; i < this->n_dofs_per_face(face_no); ++i)
+            sum += interpolation_matrix(j, i);
 
+          Assert(std::fabs(sum - 1) < eps, ExcInternalError());
+        }
+#endif
+    }
+  else if (dynamic_cast<const FE_Nothing<dim> *>(&source_fe) != nullptr)
+    {
+      // nothing to do here, the FE_Nothing has no degrees of freedom anyway
+    }
+  else
+    AssertThrow(
+      false,
+      (typename FiniteElement<dim,
+                              spacedim>::ExcInterpolationNotImplemented()));
+}
+
+
+
+template <int dim, int spacedim>
+void
+FE_SimplexPoly<dim, spacedim>::get_subface_interpolation_matrix(
+  const FiniteElement<dim, spacedim> &source_fe,
+  const unsigned int                  subface,
+  FullMatrix<double> &                interpolation_matrix,
+  const unsigned int                  face_no) const
+{
+  Assert(interpolation_matrix.m() == source_fe.n_dofs_per_face(face_no),
+         ExcDimensionMismatch(interpolation_matrix.m(),
+                              source_fe.n_dofs_per_face(face_no)));
+
+  // see if source is a P or Q element
+  if ((dynamic_cast<const FE_SimplexPoly<dim, spacedim> *>(&source_fe) !=
+       nullptr) ||
+      (dynamic_cast<const FE_Q_Base<dim, spacedim> *>(&source_fe) != nullptr))
+    {
+      const Quadrature<dim - 1> quad_face_support(
+        source_fe.get_unit_face_support_points(face_no));
 
+      const double eps = 2e-13 * this->degree * (dim - 1);
 
-  template <int dim, int spacedim>
-  void
-  FE_Poly<dim, spacedim>::get_subface_interpolation_matrix(
-    const FiniteElement<dim, spacedim> &source_fe,
-    const unsigned int                  subface,
-    FullMatrix<double> &                interpolation_matrix,
-    const unsigned int                  face_no) const
-  {
-    Assert(interpolation_matrix.m() == source_fe.n_dofs_per_face(face_no),
-           ExcDimensionMismatch(interpolation_matrix.m(),
-                                source_fe.n_dofs_per_face(face_no)));
+      std::vector<Point<dim>> subface_quadrature_points(
+        quad_face_support.size());
+      QProjector<dim>::project_to_subface(this->reference_cell(),
+                                          quad_face_support,
+                                          face_no,
+                                          subface,
+                                          subface_quadrature_points);
 
-    // see if source is a P or Q element
-    if ((dynamic_cast<const FE_Poly<dim, spacedim> *>(&source_fe) != nullptr) ||
-        (dynamic_cast<const FE_Q_Base<dim, spacedim> *>(&source_fe) != nullptr))
-      {
-        const Quadrature<dim - 1> quad_face_support(
-          source_fe.get_unit_face_support_points(face_no));
-
-        const double eps = 2e-13 * this->degree * (dim - 1);
-
-        std::vector<Point<dim>> subface_quadrature_points(
-          quad_face_support.size());
-        QProjector<dim>::project_to_subface(this->reference_cell(),
-                                            quad_face_support,
-                                            face_no,
-                                            subface,
-                                            subface_quadrature_points);
-
-        for (unsigned int i = 0; i < source_fe.n_dofs_per_face(face_no); ++i)
-          for (unsigned int j = 0; j < this->n_dofs_per_face(face_no); ++j)
-            {
-              double matrix_entry =
-                this->shape_value(this->face_to_cell_index(j, 0),
-                                  subface_quadrature_points[i]);
-
-              // Correct the interpolated value. I.e. if it is close to 1 or
-              // 0, make it exactly 1 or 0. Unfortunately, this is required to
-              // avoid problems with higher order elements.
-              if (std::fabs(matrix_entry - 1.0) < eps)
-                matrix_entry = 1.0;
-              if (std::fabs(matrix_entry) < eps)
-                matrix_entry = 0.0;
-
-              interpolation_matrix(i, j) = matrix_entry;
-            }
+      for (unsigned int i = 0; i < source_fe.n_dofs_per_face(face_no); ++i)
+        for (unsigned int j = 0; j < this->n_dofs_per_face(face_no); ++j)
+          {
+            double matrix_entry =
+              this->shape_value(this->face_to_cell_index(j, 0),
+                                subface_quadrature_points[i]);
+
+            // Correct the interpolated value. I.e. if it is close to 1 or
+            // 0, make it exactly 1 or 0. Unfortunately, this is required to
+            // avoid problems with higher order elements.
+            if (std::fabs(matrix_entry - 1.0) < eps)
+              matrix_entry = 1.0;
+            if (std::fabs(matrix_entry) < eps)
+              matrix_entry = 0.0;
+
+            interpolation_matrix(i, j) = matrix_entry;
+          }
 
 #ifdef DEBUG
-        for (unsigned int j = 0; j < source_fe.n_dofs_per_face(face_no); ++j)
-          {
-            double sum = 0.;
+      for (unsigned int j = 0; j < source_fe.n_dofs_per_face(face_no); ++j)
+        {
+          double sum = 0.;
 
-            for (unsigned int i = 0; i < this->n_dofs_per_face(face_no); ++i)
-              sum += interpolation_matrix(j, i);
+          for (unsigned int i = 0; i < this->n_dofs_per_face(face_no); ++i)
+            sum += interpolation_matrix(j, i);
 
-            Assert(std::fabs(sum - 1) < eps, ExcInternalError());
-          }
+          Assert(std::fabs(sum - 1) < eps, ExcInternalError());
+        }
 #endif
-      }
-    else if (dynamic_cast<const FE_Nothing<dim> *>(&source_fe) != nullptr)
-      {
-        // nothing to do here, the FE_Nothing has no degrees of freedom anyway
-      }
-    else
-      AssertThrow(
-        false,
-        (typename FiniteElement<dim,
-                                spacedim>::ExcInterpolationNotImplemented()));
-  }
-
+    }
+  else if (dynamic_cast<const FE_Nothing<dim> *>(&source_fe) != nullptr)
+    {
+      // nothing to do here, the FE_Nothing has no degrees of freedom anyway
+    }
+  else
+    AssertThrow(
+      false,
+      (typename FiniteElement<dim,
+                              spacedim>::ExcInterpolationNotImplemented()));
+}
 
 
-  template <int dim, int spacedim>
-  bool
-  FE_Poly<dim, spacedim>::hp_constraints_are_implemented() const
-  {
-    return true;
-  }
 
+template <int dim, int spacedim>
+bool
+FE_SimplexPoly<dim, spacedim>::hp_constraints_are_implemented() const
+{
+  return true;
+}
 
 
-  template <int dim, int spacedim>
-  void
-  FE_Poly<dim, spacedim>::
-    convert_generalized_support_point_values_to_dof_values(
-      const std::vector<Vector<double>> &support_point_values,
-      std::vector<double> &              nodal_values) const
-  {
-    AssertDimension(support_point_values.size(),
-                    this->get_unit_support_points().size());
-    AssertDimension(support_point_values.size(), nodal_values.size());
-    AssertDimension(this->dofs_per_cell, nodal_values.size());
 
-    for (unsigned int i = 0; i < this->dofs_per_cell; ++i)
-      {
-        AssertDimension(support_point_values[i].size(), 1);
+template <int dim, int spacedim>
+void
+FE_SimplexPoly<dim, spacedim>::
+  convert_generalized_support_point_values_to_dof_values(
+    const std::vector<Vector<double>> &support_point_values,
+    std::vector<double> &              nodal_values) const
+{
+  AssertDimension(support_point_values.size(),
+                  this->get_unit_support_points().size());
+  AssertDimension(support_point_values.size(), nodal_values.size());
+  AssertDimension(this->dofs_per_cell, nodal_values.size());
 
-        nodal_values[i] = support_point_values[i](0);
-      }
-  }
+  for (unsigned int i = 0; i < this->dofs_per_cell; ++i)
+    {
+      AssertDimension(support_point_values[i].size(), 1);
 
+      nodal_values[i] = support_point_values[i](0);
+    }
+}
 
 
-  template <int dim, int spacedim>
-  FE_P<dim, spacedim>::FE_P(const unsigned int degree)
-    : FE_Poly<dim, spacedim>(degree,
-                             get_dpo_vector_fe_p(dim, degree),
-                             FiniteElementData<dim>::H1)
-  {}
 
+template <int dim, int spacedim>
+FE_SimplexP<dim, spacedim>::FE_SimplexP(const unsigned int degree)
+  : FE_SimplexPoly<dim, spacedim>(degree,
+                                  get_dpo_vector_fe_p(dim, degree),
+                                  FiniteElementData<dim>::H1)
+{}
 
 
-  template <int dim, int spacedim>
-  std::unique_ptr<FiniteElement<dim, spacedim>>
-  FE_P<dim, spacedim>::clone() const
-  {
-    return std::make_unique<FE_P<dim, spacedim>>(*this);
-  }
 
+template <int dim, int spacedim>
+std::unique_ptr<FiniteElement<dim, spacedim>>
+FE_SimplexP<dim, spacedim>::clone() const
+{
+  return std::make_unique<FE_SimplexP<dim, spacedim>>(*this);
+}
 
 
-  template <int dim, int spacedim>
-  std::string
-  FE_P<dim, spacedim>::get_name() const
-  {
-    std::ostringstream namebuf;
-    namebuf << "FE_P<" << dim << ">(" << this->degree << ")";
 
-    return namebuf.str();
-  }
+template <int dim, int spacedim>
+std::string
+FE_SimplexP<dim, spacedim>::get_name() const
+{
+  std::ostringstream namebuf;
+  namebuf << "FE_SimplexP<" << dim << ">(" << this->degree << ")";
 
+  return namebuf.str();
+}
 
 
-  template <int dim, int spacedim>
-  FiniteElementDomination::Domination
-  FE_P<dim, spacedim>::compare_for_domination(
-    const FiniteElement<dim, spacedim> &fe_other,
-    const unsigned int                  codim) const
-  {
-    Assert(codim <= dim, ExcImpossibleInDim(dim));
-
-    // vertex/line/face domination
-    // (if fe_other is derived from FE_DGP)
-    // ------------------------------------
-    if (codim > 0)
-      if (dynamic_cast<const FE_DGP<dim, spacedim> *>(&fe_other) != nullptr)
-        // there are no requirements between continuous and discontinuous
-        // elements
-        return FiniteElementDomination::no_requirements;
 
-    // vertex/line/face domination
-    // (if fe_other is not derived from FE_DGP)
-    // & cell domination
-    // ----------------------------------------
-    if (const FE_P<dim, spacedim> *fe_p_other =
-          dynamic_cast<const FE_P<dim, spacedim> *>(&fe_other))
-      {
-        if (this->degree < fe_p_other->degree)
-          return FiniteElementDomination::this_element_dominates;
-        else if (this->degree == fe_p_other->degree)
-          return FiniteElementDomination::either_element_can_dominate;
-        else
-          return FiniteElementDomination::other_element_dominates;
-      }
-    else if (const FE_Q<dim, spacedim> *fe_q_other =
-               dynamic_cast<const FE_Q<dim, spacedim> *>(&fe_other))
-      {
-        if (this->degree < fe_q_other->degree)
-          return FiniteElementDomination::this_element_dominates;
-        else if (this->degree == fe_q_other->degree)
-          return FiniteElementDomination::either_element_can_dominate;
-        else
-          return FiniteElementDomination::other_element_dominates;
-      }
-    else if (const FE_Nothing<dim, spacedim> *fe_nothing =
-               dynamic_cast<const FE_Nothing<dim, spacedim> *>(&fe_other))
-      {
-        if (fe_nothing->is_dominating())
-          return FiniteElementDomination::other_element_dominates;
-        else
-          // the FE_Nothing has no degrees of freedom and it is typically used
-          // in a context where we don't require any continuity along the
-          // interface
-          return FiniteElementDomination::no_requirements;
-      }
+template <int dim, int spacedim>
+FiniteElementDomination::Domination
+FE_SimplexP<dim, spacedim>::compare_for_domination(
+  const FiniteElement<dim, spacedim> &fe_other,
+  const unsigned int                  codim) const
+{
+  Assert(codim <= dim, ExcImpossibleInDim(dim));
+
+  // vertex/line/face domination
+  // (if fe_other is derived from FE_SimplexDGP)
+  // ------------------------------------
+  if (codim > 0)
+    if (dynamic_cast<const FE_SimplexDGP<dim, spacedim> *>(&fe_other) !=
+        nullptr)
+      // there are no requirements between continuous and discontinuous
+      // elements
+      return FiniteElementDomination::no_requirements;
 
-    Assert(false, ExcNotImplemented());
-    return FiniteElementDomination::neither_element_dominates;
-  }
+  // vertex/line/face domination
+  // (if fe_other is not derived from FE_SimplexDGP)
+  // & cell domination
+  // ----------------------------------------
+  if (const FE_SimplexP<dim, spacedim> *fe_p_other =
+        dynamic_cast<const FE_SimplexP<dim, spacedim> *>(&fe_other))
+    {
+      if (this->degree < fe_p_other->degree)
+        return FiniteElementDomination::this_element_dominates;
+      else if (this->degree == fe_p_other->degree)
+        return FiniteElementDomination::either_element_can_dominate;
+      else
+        return FiniteElementDomination::other_element_dominates;
+    }
+  else if (const FE_Q<dim, spacedim> *fe_q_other =
+             dynamic_cast<const FE_Q<dim, spacedim> *>(&fe_other))
+    {
+      if (this->degree < fe_q_other->degree)
+        return FiniteElementDomination::this_element_dominates;
+      else if (this->degree == fe_q_other->degree)
+        return FiniteElementDomination::either_element_can_dominate;
+      else
+        return FiniteElementDomination::other_element_dominates;
+    }
+  else if (const FE_Nothing<dim, spacedim> *fe_nothing =
+             dynamic_cast<const FE_Nothing<dim, spacedim> *>(&fe_other))
+    {
+      if (fe_nothing->is_dominating())
+        return FiniteElementDomination::other_element_dominates;
+      else
+        // the FE_Nothing has no degrees of freedom and it is typically used
+        // in a context where we don't require any continuity along the
+        // interface
+        return FiniteElementDomination::no_requirements;
+    }
 
+  Assert(false, ExcNotImplemented());
+  return FiniteElementDomination::neither_element_dominates;
+}
 
 
-  template <int dim, int spacedim>
-  std::vector<std::pair<unsigned int, unsigned int>>
-  FE_P<dim, spacedim>::hp_vertex_dof_identities(
-    const FiniteElement<dim, spacedim> &fe_other) const
-  {
-    AssertDimension(dim, 2);
 
-    if (dynamic_cast<const FE_P<dim, spacedim> *>(&fe_other) != nullptr)
-      {
-        // there should be exactly one single DoF of each FE at a vertex, and
-        // they should have identical value
-        return {{0U, 0U}};
-      }
-    else if (dynamic_cast<const FE_Q<dim, spacedim> *>(&fe_other) != nullptr)
-      {
-        // there should be exactly one single DoF of each FE at a vertex, and
-        // they should have identical value
-        return {{0U, 0U}};
-      }
-    else if (dynamic_cast<const FE_Nothing<dim> *>(&fe_other) != nullptr)
-      {
-        // the FE_Nothing has no degrees of freedom, so there are no
-        // equivalencies to be recorded
-        return {};
-      }
-    else if (fe_other.n_unique_faces() == 1 && fe_other.n_dofs_per_face(0) == 0)
-      {
-        // if the other element has no elements on faces at all,
-        // then it would be impossible to enforce any kind of
-        // continuity even if we knew exactly what kind of element
-        // we have -- simply because the other element declares
-        // that it is discontinuous because it has no DoFs on
-        // its faces. in that case, just state that we have no
-        // constraints to declare
-        return {};
-      }
-    else
-      {
-        Assert(false, ExcNotImplemented());
-        return {};
-      }
-  }
+template <int dim, int spacedim>
+std::vector<std::pair<unsigned int, unsigned int>>
+FE_SimplexP<dim, spacedim>::hp_vertex_dof_identities(
+  const FiniteElement<dim, spacedim> &fe_other) const
+{
+  AssertDimension(dim, 2);
 
+  if (dynamic_cast<const FE_SimplexP<dim, spacedim> *>(&fe_other) != nullptr)
+    {
+      // there should be exactly one single DoF of each FE at a vertex, and
+      // they should have identical value
+      return {{0U, 0U}};
+    }
+  else if (dynamic_cast<const FE_Q<dim, spacedim> *>(&fe_other) != nullptr)
+    {
+      // there should be exactly one single DoF of each FE at a vertex, and
+      // they should have identical value
+      return {{0U, 0U}};
+    }
+  else if (dynamic_cast<const FE_Nothing<dim> *>(&fe_other) != nullptr)
+    {
+      // the FE_Nothing has no degrees of freedom, so there are no
+      // equivalencies to be recorded
+      return {};
+    }
+  else if (fe_other.n_unique_faces() == 1 && fe_other.n_dofs_per_face(0) == 0)
+    {
+      // if the other element has no elements on faces at all,
+      // then it would be impossible to enforce any kind of
+      // continuity even if we knew exactly what kind of element
+      // we have -- simply because the other element declares
+      // that it is discontinuous because it has no DoFs on
+      // its faces. in that case, just state that we have no
+      // constraints to declare
+      return {};
+    }
+  else
+    {
+      Assert(false, ExcNotImplemented());
+      return {};
+    }
+}
 
 
-  template <int dim, int spacedim>
-  std::vector<std::pair<unsigned int, unsigned int>>
-  FE_P<dim, spacedim>::hp_line_dof_identities(
-    const FiniteElement<dim, spacedim> &fe_other) const
-  {
-    AssertDimension(dim, 2);
-    Assert(this->degree <= 2, ExcNotImplemented());
 
-    if (const FE_P<dim, spacedim> *fe_p_other =
-          dynamic_cast<const FE_P<dim, spacedim> *>(&fe_other))
-      {
-        // dofs are located along lines, so two dofs are identical if they are
-        // located at identical positions.
-        // Therefore, read the points in unit_support_points for the
-        // first coordinate direction. For FE_P, they are currently hard-coded
-        // and we iterate over points on the first line which begin after the 3
-        // vertex points in the complete list of unit support points
+template <int dim, int spacedim>
+std::vector<std::pair<unsigned int, unsigned int>>
+FE_SimplexP<dim, spacedim>::hp_line_dof_identities(
+  const FiniteElement<dim, spacedim> &fe_other) const
+{
+  AssertDimension(dim, 2);
+  Assert(this->degree <= 2, ExcNotImplemented());
 
-        Assert(fe_p_other->degree <= 2, ExcNotImplemented());
+  if (const FE_SimplexP<dim, spacedim> *fe_p_other =
+        dynamic_cast<const FE_SimplexP<dim, spacedim> *>(&fe_other))
+    {
+      // dofs are located along lines, so two dofs are identical if they are
+      // located at identical positions.
+      // Therefore, read the points in unit_support_points for the
+      // first coordinate direction. For FE_SimplexP, they are currently
+      // hard-coded and we iterate over points on the first line which begin
+      // after the 3 vertex points in the complete list of unit support points
 
-        std::vector<std::pair<unsigned int, unsigned int>> identities;
+      Assert(fe_p_other->degree <= 2, ExcNotImplemented());
 
-        for (unsigned int i = 0; i < this->degree - 1; ++i)
-          for (unsigned int j = 0; j < fe_p_other->degree - 1; ++j)
-            if (std::fabs(this->unit_support_points[i + 3][0] -
-                          fe_p_other->unit_support_points[i + 3][0]) < 1e-14)
-              identities.emplace_back(i, j);
+      std::vector<std::pair<unsigned int, unsigned int>> identities;
 
-        return identities;
-      }
-    else if (const FE_Q<dim, spacedim> *fe_q_other =
-               dynamic_cast<const FE_Q<dim, spacedim> *>(&fe_other))
-      {
-        // dofs are located along lines, so two dofs are identical if they are
-        // located at identical positions. if we had only equidistant points, we
-        // could simply check for similarity like (i+1)*q == (j+1)*p, but we
-        // might have other support points (e.g. Gauss-Lobatto
-        // points). Therefore, read the points in unit_support_points for the
-        // first coordinate direction. For FE_Q, we take the lexicographic
-        // ordering of the line support points in the first direction (i.e.,
-        // x-direction), which we access between index 1 and p-1 (index 0 and p
-        // are vertex dofs). For FE_P, they are currently hard-coded and we
-        // iterate over points on the first line which begin after the 3 vertex
-        // points in the complete list of unit support points
-
-        const std::vector<unsigned int> &index_map_inverse_q_other =
-          fe_q_other->get_poly_space_numbering_inverse();
-
-        std::vector<std::pair<unsigned int, unsigned int>> identities;
-
-        for (unsigned int i = 0; i < this->degree - 1; ++i)
-          for (unsigned int j = 0; j < fe_q_other->degree - 1; ++j)
-            if (std::fabs(this->unit_support_points[i + 3][0] -
-                          fe_q_other->get_unit_support_points()
-                            [index_map_inverse_q_other[j + 1]][0]) < 1e-14)
-              identities.emplace_back(i, j);
-
-        return identities;
-      }
-    else if (dynamic_cast<const FE_Nothing<dim> *>(&fe_other) != nullptr)
-      {
-        // the FE_Nothing has no degrees of freedom, so there are no
-        // equivalencies to be recorded
-        return {};
-      }
-    else if (fe_other.n_unique_faces() == 1 && fe_other.n_dofs_per_face(0) == 0)
-      {
-        // if the other element has no elements on faces at all,
-        // then it would be impossible to enforce any kind of
-        // continuity even if we knew exactly what kind of element
-        // we have -- simply because the other element declares
-        // that it is discontinuous because it has no DoFs on
-        // its faces. in that case, just state that we have no
-        // constraints to declare
-        return {};
-      }
-    else
-      {
-        Assert(false, ExcNotImplemented());
-        return {};
-      }
-  }
+      for (unsigned int i = 0; i < this->degree - 1; ++i)
+        for (unsigned int j = 0; j < fe_p_other->degree - 1; ++j)
+          if (std::fabs(this->unit_support_points[i + 3][0] -
+                        fe_p_other->unit_support_points[i + 3][0]) < 1e-14)
+            identities.emplace_back(i, j);
 
+      return identities;
+    }
+  else if (const FE_Q<dim, spacedim> *fe_q_other =
+             dynamic_cast<const FE_Q<dim, spacedim> *>(&fe_other))
+    {
+      // dofs are located along lines, so two dofs are identical if they are
+      // located at identical positions. if we had only equidistant points, we
+      // could simply check for similarity like (i+1)*q == (j+1)*p, but we
+      // might have other support points (e.g. Gauss-Lobatto
+      // points). Therefore, read the points in unit_support_points for the
+      // first coordinate direction. For FE_Q, we take the lexicographic
+      // ordering of the line support points in the first direction (i.e.,
+      // x-direction), which we access between index 1 and p-1 (index 0 and p
+      // are vertex dofs). For FE_SimplexP, they are currently hard-coded and we
+      // iterate over points on the first line which begin after the 3 vertex
+      // points in the complete list of unit support points
+
+      const std::vector<unsigned int> &index_map_inverse_q_other =
+        fe_q_other->get_poly_space_numbering_inverse();
+
+      std::vector<std::pair<unsigned int, unsigned int>> identities;
+
+      for (unsigned int i = 0; i < this->degree - 1; ++i)
+        for (unsigned int j = 0; j < fe_q_other->degree - 1; ++j)
+          if (std::fabs(this->unit_support_points[i + 3][0] -
+                        fe_q_other->get_unit_support_points()
+                          [index_map_inverse_q_other[j + 1]][0]) < 1e-14)
+            identities.emplace_back(i, j);
+
+      return identities;
+    }
+  else if (dynamic_cast<const FE_Nothing<dim> *>(&fe_other) != nullptr)
+    {
+      // the FE_Nothing has no degrees of freedom, so there are no
+      // equivalencies to be recorded
+      return {};
+    }
+  else if (fe_other.n_unique_faces() == 1 && fe_other.n_dofs_per_face(0) == 0)
+    {
+      // if the other element has no elements on faces at all,
+      // then it would be impossible to enforce any kind of
+      // continuity even if we knew exactly what kind of element
+      // we have -- simply because the other element declares
+      // that it is discontinuous because it has no DoFs on
+      // its faces. in that case, just state that we have no
+      // constraints to declare
+      return {};
+    }
+  else
+    {
+      Assert(false, ExcNotImplemented());
+      return {};
+    }
+}
 
 
-  template <int dim, int spacedim>
-  FE_DGP<dim, spacedim>::FE_DGP(const unsigned int degree)
-    : FE_Poly<dim, spacedim>(degree,
-                             get_dpo_vector_fe_dgp(dim, degree),
-                             FiniteElementData<dim>::L2)
-  {}
 
+template <int dim, int spacedim>
+FE_SimplexDGP<dim, spacedim>::FE_SimplexDGP(const unsigned int degree)
+  : FE_SimplexPoly<dim, spacedim>(degree,
+                                  get_dpo_vector_fe_dgp(dim, degree),
+                                  FiniteElementData<dim>::L2)
+{}
 
 
-  template <int dim, int spacedim>
-  std::unique_ptr<FiniteElement<dim, spacedim>>
-  FE_DGP<dim, spacedim>::clone() const
-  {
-    return std::make_unique<FE_DGP<dim, spacedim>>(*this);
-  }
 
+template <int dim, int spacedim>
+std::unique_ptr<FiniteElement<dim, spacedim>>
+FE_SimplexDGP<dim, spacedim>::clone() const
+{
+  return std::make_unique<FE_SimplexDGP<dim, spacedim>>(*this);
+}
 
 
-  template <int dim, int spacedim>
-  std::string
-  FE_DGP<dim, spacedim>::get_name() const
-  {
-    std::ostringstream namebuf;
-    namebuf << "FE_DGP<" << dim << ">(" << this->degree << ")";
 
-    return namebuf.str();
-  }
+template <int dim, int spacedim>
+std::string
+FE_SimplexDGP<dim, spacedim>::get_name() const
+{
+  std::ostringstream namebuf;
+  namebuf << "FE_SimplexDGP<" << dim << ">(" << this->degree << ")";
 
+  return namebuf.str();
+}
 
-  template <int dim, int spacedim>
-  FiniteElementDomination::Domination
-  FE_DGP<dim, spacedim>::compare_for_domination(
-    const FiniteElement<dim, spacedim> &fe_other,
-    const unsigned int                  codim) const
-  {
-    Assert(codim <= dim, ExcImpossibleInDim(dim));
-
-    // vertex/line/face domination
-    // ---------------------------
-    if (codim > 0)
-      // this is a discontinuous element, so by definition there will
-      // be no constraints wherever this element comes together with
-      // any other kind of element
-      return FiniteElementDomination::no_requirements;
 
-    // cell domination
-    // ---------------
-    if (const FE_DGP<dim, spacedim> *fe_dgp_other =
-          dynamic_cast<const FE_DGP<dim, spacedim> *>(&fe_other))
-      {
-        if (this->degree < fe_dgp_other->degree)
-          return FiniteElementDomination::this_element_dominates;
-        else if (this->degree == fe_dgp_other->degree)
-          return FiniteElementDomination::either_element_can_dominate;
-        else
-          return FiniteElementDomination::other_element_dominates;
-      }
-    else if (const FE_DGQ<dim, spacedim> *fe_dgq_other =
-               dynamic_cast<const FE_DGQ<dim, spacedim> *>(&fe_other))
-      {
-        if (this->degree < fe_dgq_other->degree)
-          return FiniteElementDomination::this_element_dominates;
-        else if (this->degree == fe_dgq_other->degree)
-          return FiniteElementDomination::either_element_can_dominate;
-        else
-          return FiniteElementDomination::other_element_dominates;
-      }
-    else if (const FE_Nothing<dim, spacedim> *fe_nothing =
-               dynamic_cast<const FE_Nothing<dim, spacedim> *>(&fe_other))
-      {
-        if (fe_nothing->is_dominating())
-          return FiniteElementDomination::other_element_dominates;
-        else
-          // the FE_Nothing has no degrees of freedom and it is typically used
-          // in a context where we don't require any continuity along the
-          // interface
-          return FiniteElementDomination::no_requirements;
-      }
+template <int dim, int spacedim>
+FiniteElementDomination::Domination
+FE_SimplexDGP<dim, spacedim>::compare_for_domination(
+  const FiniteElement<dim, spacedim> &fe_other,
+  const unsigned int                  codim) const
+{
+  Assert(codim <= dim, ExcImpossibleInDim(dim));
+
+  // vertex/line/face domination
+  // ---------------------------
+  if (codim > 0)
+    // this is a discontinuous element, so by definition there will
+    // be no constraints wherever this element comes together with
+    // any other kind of element
+    return FiniteElementDomination::no_requirements;
+
+  // cell domination
+  // ---------------
+  if (const FE_SimplexDGP<dim, spacedim> *fe_dgp_other =
+        dynamic_cast<const FE_SimplexDGP<dim, spacedim> *>(&fe_other))
+    {
+      if (this->degree < fe_dgp_other->degree)
+        return FiniteElementDomination::this_element_dominates;
+      else if (this->degree == fe_dgp_other->degree)
+        return FiniteElementDomination::either_element_can_dominate;
+      else
+        return FiniteElementDomination::other_element_dominates;
+    }
+  else if (const FE_DGQ<dim, spacedim> *fe_dgq_other =
+             dynamic_cast<const FE_DGQ<dim, spacedim> *>(&fe_other))
+    {
+      if (this->degree < fe_dgq_other->degree)
+        return FiniteElementDomination::this_element_dominates;
+      else if (this->degree == fe_dgq_other->degree)
+        return FiniteElementDomination::either_element_can_dominate;
+      else
+        return FiniteElementDomination::other_element_dominates;
+    }
+  else if (const FE_Nothing<dim, spacedim> *fe_nothing =
+             dynamic_cast<const FE_Nothing<dim, spacedim> *>(&fe_other))
+    {
+      if (fe_nothing->is_dominating())
+        return FiniteElementDomination::other_element_dominates;
+      else
+        // the FE_Nothing has no degrees of freedom and it is typically used
+        // in a context where we don't require any continuity along the
+        // interface
+        return FiniteElementDomination::no_requirements;
+    }
 
-    Assert(false, ExcNotImplemented());
-    return FiniteElementDomination::neither_element_dominates;
-  }
+  Assert(false, ExcNotImplemented());
+  return FiniteElementDomination::neither_element_dominates;
+}
 
 
 
-  template <int dim, int spacedim>
-  std::vector<std::pair<unsigned int, unsigned int>>
-  FE_DGP<dim, spacedim>::hp_vertex_dof_identities(
-    const FiniteElement<dim, spacedim> &fe_other) const
-  {
-    (void)fe_other;
+template <int dim, int spacedim>
+std::vector<std::pair<unsigned int, unsigned int>>
+FE_SimplexDGP<dim, spacedim>::hp_vertex_dof_identities(
+  const FiniteElement<dim, spacedim> &fe_other) const
+{
+  (void)fe_other;
 
-    return {};
-  }
+  return {};
+}
 
 
 
-  template <int dim, int spacedim>
-  std::vector<std::pair<unsigned int, unsigned int>>
-  FE_DGP<dim, spacedim>::hp_line_dof_identities(
-    const FiniteElement<dim, spacedim> &fe_other) const
-  {
-    (void)fe_other;
+template <int dim, int spacedim>
+std::vector<std::pair<unsigned int, unsigned int>>
+FE_SimplexDGP<dim, spacedim>::hp_line_dof_identities(
+  const FiniteElement<dim, spacedim> &fe_other) const
+{
+  (void)fe_other;
 
-    return {};
-  }
-} // namespace Simplex
+  return {};
+}
 
 // explicit instantiations
 #include "fe_simplex_p.inst"
diff --git a/source/fe/fe_simplex_p.inst.in b/source/fe/fe_simplex_p.inst.in
index 0f29f676d1..32befcab59 100644
--- a/source/fe/fe_simplex_p.inst.in
+++ b/source/fe/fe_simplex_p.inst.in
@@ -18,8 +18,8 @@
 for (deal_II_dimension : DIMENSIONS; deal_II_space_dimension : DIMENSIONS)
   {
 #if deal_II_dimension <= deal_II_space_dimension
-    template class Simplex::FE_Poly<deal_II_dimension, deal_II_space_dimension>;
-    template class Simplex::FE_P<deal_II_dimension, deal_II_space_dimension>;
-    template class Simplex::FE_DGP<deal_II_dimension, deal_II_space_dimension>;
+    template class FE_SimplexPoly<deal_II_dimension, deal_II_space_dimension>;
+    template class FE_SimplexP<deal_II_dimension, deal_II_space_dimension>;
+    template class FE_SimplexDGP<deal_II_dimension, deal_II_space_dimension>;
 #endif
   }
diff --git a/source/fe/fe_simplex_p_bubbles.cc b/source/fe/fe_simplex_p_bubbles.cc
index 8c2ee43f53..50da7e1241 100644
--- a/source/fe/fe_simplex_p_bubbles.cc
+++ b/source/fe/fe_simplex_p_bubbles.cc
@@ -26,363 +26,353 @@
 
 DEAL_II_NAMESPACE_OPEN
 
-namespace Simplex
+namespace
 {
-  namespace
+  /**
+   * Set up a vector that contains the unit (reference) cell support points
+   * for FE_Poly and sufficiently similar elements.
+   */
+  template <int dim>
+  std::vector<Point<dim>>
+  unit_support_points_fe_poly_bubbles(const unsigned int degree)
   {
-    /**
-     * Set up a vector that contains the unit (reference) cell support points
-     * for FE_Poly and sufficiently similar elements.
-     */
-    template <int dim>
-    std::vector<Point<dim>>
-    unit_support_points_fe_poly_bubbles(const unsigned int degree)
-    {
-      std::vector<Point<dim>> unit_points;
-
-      // Piecewise constants are a special case: use a support point at the
-      // centroid and only the centroid
-      if (degree == 0)
-        {
-          Point<dim> centroid;
-          std::fill(centroid.begin_raw(),
-                    centroid.end_raw(),
-                    1.0 / double(dim + 1));
-          unit_points.emplace_back(centroid);
-          return unit_points;
-        }
-
-      if (dim == 1)
-        {
-          // We don't really have dim = 1 support for simplex elements yet, but
-          // its convenient for populating the face array
-          Assert(degree <= 2, ExcNotImplemented());
-          if (degree >= 1)
-            {
-              unit_points.emplace_back(0.0);
-              unit_points.emplace_back(1.0);
-
-              if (degree == 2)
-                unit_points.emplace_back(0.5);
-            }
-        }
-      else if (dim == 2)
-        {
-          Assert(degree <= 2, ExcNotImplemented());
-          if (degree >= 1)
-            {
-              unit_points.emplace_back(0.0, 0.0);
-              unit_points.emplace_back(1.0, 0.0);
-              unit_points.emplace_back(0.0, 1.0);
-
-              if (degree == 2)
-                {
-                  unit_points.emplace_back(0.5, 0.0);
-                  unit_points.emplace_back(0.5, 0.5);
-                  unit_points.emplace_back(0.0, 0.5);
-                }
-            }
-        }
-      else if (dim == 3)
-        {
-          Assert(degree <= 2, ExcNotImplemented());
-          if (degree >= 1)
-            {
-              unit_points.emplace_back(0.0, 0.0, 0.0);
-              unit_points.emplace_back(1.0, 0.0, 0.0);
-              unit_points.emplace_back(0.0, 1.0, 0.0);
-              unit_points.emplace_back(0.0, 0.0, 1.0);
-
-              if (degree == 2)
-                {
-                  unit_points.emplace_back(0.5, 0.0, 0.0);
-                  unit_points.emplace_back(0.5, 0.5, 0.0);
-                  unit_points.emplace_back(0.0, 0.5, 0.0);
-                  unit_points.emplace_back(0.0, 0.0, 0.5);
-                  unit_points.emplace_back(0.5, 0.0, 0.5);
-                  unit_points.emplace_back(0.0, 0.5, 0.5);
-                }
-            }
-        }
-      else
-        {
-          Assert(false, ExcNotImplemented());
-        }
+    std::vector<Point<dim>> unit_points;
 
-      return unit_points;
-    }
-  } // namespace
+    // Piecewise constants are a special case: use a support point at the
+    // centroid and only the centroid
+    if (degree == 0)
+      {
+        Point<dim> centroid;
+        std::fill(centroid.begin_raw(),
+                  centroid.end_raw(),
+                  1.0 / double(dim + 1));
+        unit_points.emplace_back(centroid);
+        return unit_points;
+      }
+
+    if (dim == 1)
+      {
+        // We don't really have dim = 1 support for simplex elements yet, but
+        // its convenient for populating the face array
+        Assert(degree <= 2, ExcNotImplemented());
+        if (degree >= 1)
+          {
+            unit_points.emplace_back(0.0);
+            unit_points.emplace_back(1.0);
+
+            if (degree == 2)
+              unit_points.emplace_back(0.5);
+          }
+      }
+    else if (dim == 2)
+      {
+        Assert(degree <= 2, ExcNotImplemented());
+        if (degree >= 1)
+          {
+            unit_points.emplace_back(0.0, 0.0);
+            unit_points.emplace_back(1.0, 0.0);
+            unit_points.emplace_back(0.0, 1.0);
+
+            if (degree == 2)
+              {
+                unit_points.emplace_back(0.5, 0.0);
+                unit_points.emplace_back(0.5, 0.5);
+                unit_points.emplace_back(0.0, 0.5);
+              }
+          }
+      }
+    else if (dim == 3)
+      {
+        Assert(degree <= 2, ExcNotImplemented());
+        if (degree >= 1)
+          {
+            unit_points.emplace_back(0.0, 0.0, 0.0);
+            unit_points.emplace_back(1.0, 0.0, 0.0);
+            unit_points.emplace_back(0.0, 1.0, 0.0);
+            unit_points.emplace_back(0.0, 0.0, 1.0);
+
+            if (degree == 2)
+              {
+                unit_points.emplace_back(0.5, 0.0, 0.0);
+                unit_points.emplace_back(0.5, 0.5, 0.0);
+                unit_points.emplace_back(0.0, 0.5, 0.0);
+                unit_points.emplace_back(0.0, 0.0, 0.5);
+                unit_points.emplace_back(0.5, 0.0, 0.5);
+                unit_points.emplace_back(0.0, 0.5, 0.5);
+              }
+          }
+      }
+    else
+      {
+        Assert(false, ExcNotImplemented());
+      }
+
+    return unit_points;
+  }
+} // namespace
 
-  namespace FE_P_BubblesImplementation
+namespace FE_P_BubblesImplementation
+{
+  template <int dim>
+  std::vector<unsigned int>
+  get_dpo_vector(const unsigned int degree)
   {
-    template <int dim>
-    std::vector<unsigned int>
-    get_dpo_vector(const unsigned int degree)
-    {
-      std::vector<unsigned int> dpo(dim + 1);
-      if (degree == 0)
-        {
-          dpo[dim] = 1; // single interior dof
-        }
-      else
-        {
-          Assert(degree == 1 || degree == 2, ExcNotImplemented());
-          dpo[0] = 1; // vertex dofs
-
-          if (degree == 2)
-            {
-              dpo[1] = 1; // line dofs
-
-              if (dim > 1)
-                dpo[dim] = 1; // the internal bubble function
-              if (dim == 3)
-                dpo[dim - 1] = 1; // face bubble functions
-            }
-        }
-
-      return dpo;
-    }
+    std::vector<unsigned int> dpo(dim + 1);
+    if (degree == 0)
+      {
+        dpo[dim] = 1; // single interior dof
+      }
+    else
+      {
+        Assert(degree == 1 || degree == 2, ExcNotImplemented());
+        dpo[0] = 1; // vertex dofs
+
+        if (degree == 2)
+          {
+            dpo[1] = 1; // line dofs
+
+            if (dim > 1)
+              dpo[dim] = 1; // the internal bubble function
+            if (dim == 3)
+              dpo[dim - 1] = 1; // face bubble functions
+          }
+      }
 
+    return dpo;
+  }
 
 
-    template <int dim>
-    std::vector<Point<dim>>
-    unit_support_points(const unsigned int degree)
-    {
-      Assert(degree < 3, ExcNotImplemented());
-      std::vector<Point<dim>> points =
-        unit_support_points_fe_poly_bubbles<dim>(degree);
-
-      Point<dim> centroid;
-      std::fill(centroid.begin_raw(),
-                centroid.end_raw(),
-                1.0 / double(dim + 1));
-
-      switch (dim)
-        {
-          case 1:
-            // nothing more to do
+
+  template <int dim>
+  std::vector<Point<dim>>
+  unit_support_points(const unsigned int degree)
+  {
+    Assert(degree < 3, ExcNotImplemented());
+    std::vector<Point<dim>> points =
+      unit_support_points_fe_poly_bubbles<dim>(degree);
+
+    Point<dim> centroid;
+    std::fill(centroid.begin_raw(), centroid.end_raw(), 1.0 / double(dim + 1));
+
+    switch (dim)
+      {
+        case 1:
+          // nothing more to do
+          return points;
+        case 2:
+          {
+            if (degree == 2)
+              points.push_back(centroid);
             return points;
-          case 2:
-            {
-              if (degree == 2)
+          }
+        case 3:
+          {
+            if (degree == 2)
+              {
+                const double q13 = 1.0 / 3.0;
+                points.emplace_back(q13, q13, 0.0);
+                points.emplace_back(q13, 0.0, q13);
+                points.emplace_back(0.0, q13, q13);
+                points.emplace_back(q13, q13, q13);
                 points.push_back(centroid);
-              return points;
-            }
-          case 3:
-            {
-              if (degree == 2)
-                {
-                  const double q13 = 1.0 / 3.0;
-                  points.emplace_back(q13, q13, 0.0);
-                  points.emplace_back(q13, 0.0, q13);
-                  points.emplace_back(0.0, q13, q13);
-                  points.emplace_back(q13, q13, q13);
-                  points.push_back(centroid);
-                }
-              return points;
-            }
-          default:
-            Assert(false, ExcNotImplemented());
-        }
-      return points;
-    }
+              }
+            return points;
+          }
+        default:
+          Assert(false, ExcNotImplemented());
+      }
+    return points;
+  }
 
 
 
-    template <int dim>
-    BarycentricPolynomials<dim>
-    get_basis(const unsigned int degree)
-    {
-      Point<dim> centroid;
-      std::fill(centroid.begin_raw(),
-                centroid.end_raw(),
-                1.0 / double(dim + 1));
-
-      auto M = [](const unsigned int d) {
-        return BarycentricPolynomial<dim, double>::monomial(d);
-      };
-
-      switch (degree)
-        {
-          // we don't need to add bubbles to P0 or P1
-          case 0:
-          case 1:
-            return BarycentricPolynomials<dim>::get_fe_p_basis(degree);
-          case 2:
-            {
-              const auto fe_p =
-                BarycentricPolynomials<dim>::get_fe_p_basis(degree);
-              // no further work is needed in 1D
-              if (dim == 1)
-                return fe_p;
-
-              // in 2D and 3D we add a centroid bubble function
-              auto c_bubble = BarycentricPolynomial<dim>() + 1;
-              for (unsigned int d = 0; d < dim + 1; ++d)
-                c_bubble = c_bubble * M(d);
-              c_bubble = c_bubble / c_bubble.value(centroid);
-
-              std::vector<BarycentricPolynomial<dim>> bubble_functions;
-              if (dim == 2)
-                {
-                  bubble_functions.push_back(c_bubble);
-                }
-              else if (dim == 3)
-                {
-                  // need 'face bubble' functions in addition to the centroid.
-                  // Furthermore we need to subtract them off from the other
-                  // functions so that we end up with an interpolatory basis
-                  auto b0 = 27 * M(0) * M(1) * M(2);
-                  bubble_functions.push_back(b0 -
-                                             b0.value(centroid) * c_bubble);
-                  auto b1 = 27 * M(0) * M(1) * M(3);
-                  bubble_functions.push_back(b1 -
-                                             b1.value(centroid) * c_bubble);
-                  auto b2 = 27 * M(0) * M(2) * M(3);
-                  bubble_functions.push_back(b2 -
-                                             b2.value(centroid) * c_bubble);
-                  auto b3 = 27 * M(1) * M(2) * M(3);
-                  bubble_functions.push_back(b3 -
-                                             b3.value(centroid) * c_bubble);
-
-                  bubble_functions.push_back(c_bubble);
-                }
-
-              // Extract out the support points for the extra bubble (both
-              // volume and face) functions:
-              const std::vector<Point<dim>> support_points =
-                unit_support_points<dim>(degree);
-              const std::vector<Point<dim>> bubble_support_points(
-                support_points.begin() + fe_p.n(), support_points.end());
-              Assert(bubble_support_points.size() == bubble_functions.size(),
-                     ExcInternalError());
-              const unsigned int n_bubbles = bubble_support_points.size();
-
-              // Assemble the final basis:
-              std::vector<BarycentricPolynomial<dim>> lump_polys;
-              for (unsigned int i = 0; i < fe_p.n(); ++i)
-                {
-                  BarycentricPolynomial<dim> p = fe_p[i];
-
-                  for (unsigned int j = 0; j < n_bubbles; ++j)
-                    {
-                      p = p - p.value(bubble_support_points[j]) *
-                                bubble_functions[j];
-                    }
-
-                  lump_polys.push_back(p);
-                }
-
-              for (auto &p : bubble_functions)
-                lump_polys.push_back(std::move(p));
-
-                // Sanity check:
+  template <int dim>
+  BarycentricPolynomials<dim>
+  get_basis(const unsigned int degree)
+  {
+    Point<dim> centroid;
+    std::fill(centroid.begin_raw(), centroid.end_raw(), 1.0 / double(dim + 1));
+
+    auto M = [](const unsigned int d) {
+      return BarycentricPolynomial<dim, double>::monomial(d);
+    };
+
+    switch (degree)
+      {
+        // we don't need to add bubbles to P0 or P1
+        case 0:
+        case 1:
+          return BarycentricPolynomials<dim>::get_fe_p_basis(degree);
+        case 2:
+          {
+            const auto fe_p =
+              BarycentricPolynomials<dim>::get_fe_p_basis(degree);
+            // no further work is needed in 1D
+            if (dim == 1)
+              return fe_p;
+
+            // in 2D and 3D we add a centroid bubble function
+            auto c_bubble = BarycentricPolynomial<dim>() + 1;
+            for (unsigned int d = 0; d < dim + 1; ++d)
+              c_bubble = c_bubble * M(d);
+            c_bubble = c_bubble / c_bubble.value(centroid);
+
+            std::vector<BarycentricPolynomial<dim>> bubble_functions;
+            if (dim == 2)
+              {
+                bubble_functions.push_back(c_bubble);
+              }
+            else if (dim == 3)
+              {
+                // need 'face bubble' functions in addition to the centroid.
+                // Furthermore we need to subtract them off from the other
+                // functions so that we end up with an interpolatory basis
+                auto b0 = 27 * M(0) * M(1) * M(2);
+                bubble_functions.push_back(b0 - b0.value(centroid) * c_bubble);
+                auto b1 = 27 * M(0) * M(1) * M(3);
+                bubble_functions.push_back(b1 - b1.value(centroid) * c_bubble);
+                auto b2 = 27 * M(0) * M(2) * M(3);
+                bubble_functions.push_back(b2 - b2.value(centroid) * c_bubble);
+                auto b3 = 27 * M(1) * M(2) * M(3);
+                bubble_functions.push_back(b3 - b3.value(centroid) * c_bubble);
+
+                bubble_functions.push_back(c_bubble);
+              }
+
+            // Extract out the support points for the extra bubble (both
+            // volume and face) functions:
+            const std::vector<Point<dim>> support_points =
+              unit_support_points<dim>(degree);
+            const std::vector<Point<dim>> bubble_support_points(
+              support_points.begin() + fe_p.n(), support_points.end());
+            Assert(bubble_support_points.size() == bubble_functions.size(),
+                   ExcInternalError());
+            const unsigned int n_bubbles = bubble_support_points.size();
+
+            // Assemble the final basis:
+            std::vector<BarycentricPolynomial<dim>> lump_polys;
+            for (unsigned int i = 0; i < fe_p.n(); ++i)
+              {
+                BarycentricPolynomial<dim> p = fe_p[i];
+
+                for (unsigned int j = 0; j < n_bubbles; ++j)
+                  {
+                    p = p -
+                        p.value(bubble_support_points[j]) * bubble_functions[j];
+                  }
+
+                lump_polys.push_back(p);
+              }
+
+            for (auto &p : bubble_functions)
+              lump_polys.push_back(std::move(p));
+
+              // Sanity check:
 #ifdef DEBUG
-              BarycentricPolynomial<dim> unity;
-              for (const auto &p : lump_polys)
-                unity = unity + p;
-
-              Point<dim> test;
-              for (unsigned int d = 0; d < dim; ++d)
-                test[d] = 2.0;
-              Assert(std::abs(unity.value(test) - 1.0) < 1e-10,
-                     ExcInternalError());
+            BarycentricPolynomial<dim> unity;
+            for (const auto &p : lump_polys)
+              unity = unity + p;
+
+            Point<dim> test;
+            for (unsigned int d = 0; d < dim; ++d)
+              test[d] = 2.0;
+            Assert(std::abs(unity.value(test) - 1.0) < 1e-10,
+                   ExcInternalError());
 #endif
 
-              return BarycentricPolynomials<dim>(lump_polys);
-            }
-          default:
-            Assert(degree < 3, ExcNotImplemented());
-        }
+            return BarycentricPolynomials<dim>(lump_polys);
+          }
+        default:
+          Assert(degree < 3, ExcNotImplemented());
+      }
 
-      Assert(degree < 3, ExcNotImplemented());
-      // bogus return to placate compilers
-      return BarycentricPolynomials<dim>::get_fe_p_basis(degree);
-    }
+    Assert(degree < 3, ExcNotImplemented());
+    // bogus return to placate compilers
+    return BarycentricPolynomials<dim>::get_fe_p_basis(degree);
+  }
 
 
 
-    template <int dim>
-    FiniteElementData<dim>
-    get_fe_data(const unsigned int degree)
-    {
-      // It's not efficient, but delegate computation of the degree of the
-      // finite element (which is different from the input argument) to the
-      // basis.
-      const auto polys = get_basis<dim>(degree);
-      return FiniteElementData<dim>(get_dpo_vector<dim>(degree),
-                                    ReferenceCells::get_simplex<dim>(),
-                                    1, // n_components
-                                    polys.degree(),
-                                    FiniteElementData<dim>::H1);
-    }
-  } // namespace FE_P_BubblesImplementation
-
-
-
-  template <int dim, int spacedim>
-  FE_P_Bubbles<dim, spacedim>::FE_P_Bubbles(const unsigned int degree)
-    : dealii::FE_Poly<dim, spacedim>(
-        FE_P_BubblesImplementation::get_basis<dim>(degree),
-        FE_P_BubblesImplementation::get_fe_data<dim>(degree),
-        std::vector<bool>(
-          FE_P_BubblesImplementation::get_fe_data<dim>(degree).dofs_per_cell,
-          true),
-        std::vector<ComponentMask>(
-          FE_P_BubblesImplementation::get_fe_data<dim>(degree).dofs_per_cell,
-          std::vector<bool>(1, true)))
-    , approximation_degree(degree)
+  template <int dim>
+  FiniteElementData<dim>
+  get_fe_data(const unsigned int degree)
   {
-    this->unit_support_points =
-      FE_P_BubblesImplementation::unit_support_points<dim>(degree);
-
-    // TODO
-    // this->unit_face_support_points =
-    //   unit_face_support_points_fe_poly<dim>(degree);
+    // It's not efficient, but delegate computation of the degree of the
+    // finite element (which is different from the input argument) to the
+    // basis.
+    const auto polys = get_basis<dim>(degree);
+    return FiniteElementData<dim>(get_dpo_vector<dim>(degree),
+                                  ReferenceCells::get_simplex<dim>(),
+                                  1, // n_components
+                                  polys.degree(),
+                                  FiniteElementData<dim>::H1);
   }
+} // namespace FE_P_BubblesImplementation
+
+
+
+template <int dim, int spacedim>
+FE_SimplexP_Bubbles<dim, spacedim>::FE_SimplexP_Bubbles(
+  const unsigned int degree)
+  : dealii::FE_Poly<dim, spacedim>(
+      FE_P_BubblesImplementation::get_basis<dim>(degree),
+      FE_P_BubblesImplementation::get_fe_data<dim>(degree),
+      std::vector<bool>(
+        FE_P_BubblesImplementation::get_fe_data<dim>(degree).dofs_per_cell,
+        true),
+      std::vector<ComponentMask>(
+        FE_P_BubblesImplementation::get_fe_data<dim>(degree).dofs_per_cell,
+        std::vector<bool>(1, true)))
+  , approximation_degree(degree)
+{
+  this->unit_support_points =
+    FE_P_BubblesImplementation::unit_support_points<dim>(degree);
 
+  // TODO
+  // this->unit_face_support_points =
+  //   unit_face_support_points_fe_poly<dim>(degree);
+}
 
 
-  template <int dim, int spacedim>
-  std::string
-  FE_P_Bubbles<dim, spacedim>::get_name() const
-  {
-    return "Simplex::FE_P_Bubbles<" + Utilities::dim_string(dim, spacedim) +
-           ">" + "(" + std::to_string(approximation_degree) + ")";
-  }
 
+template <int dim, int spacedim>
+std::string
+FE_SimplexP_Bubbles<dim, spacedim>::get_name() const
+{
+  return "FE_SimplexP_Bubbles<" + Utilities::dim_string(dim, spacedim) + ">" +
+         "(" + std::to_string(approximation_degree) + ")";
+}
 
 
-  template <int dim, int spacedim>
-  void
-  FE_P_Bubbles<dim, spacedim>::
-    convert_generalized_support_point_values_to_dof_values(
-      const std::vector<Vector<double>> &support_point_values,
-      std::vector<double> &              nodal_values) const
-  {
-    AssertDimension(support_point_values.size(),
-                    this->get_unit_support_points().size());
-    AssertDimension(support_point_values.size(), nodal_values.size());
-    AssertDimension(this->dofs_per_cell, nodal_values.size());
 
-    for (unsigned int i = 0; i < this->dofs_per_cell; ++i)
-      {
-        AssertDimension(support_point_values[i].size(), 1);
+template <int dim, int spacedim>
+void
+FE_SimplexP_Bubbles<dim, spacedim>::
+  convert_generalized_support_point_values_to_dof_values(
+    const std::vector<Vector<double>> &support_point_values,
+    std::vector<double> &              nodal_values) const
+{
+  AssertDimension(support_point_values.size(),
+                  this->get_unit_support_points().size());
+  AssertDimension(support_point_values.size(), nodal_values.size());
+  AssertDimension(this->dofs_per_cell, nodal_values.size());
 
-        nodal_values[i] = support_point_values[i](0);
-      }
-  }
+  for (unsigned int i = 0; i < this->dofs_per_cell; ++i)
+    {
+      AssertDimension(support_point_values[i].size(), 1);
 
+      nodal_values[i] = support_point_values[i](0);
+    }
+}
 
 
-  template <int dim, int spacedim>
-  std::unique_ptr<FiniteElement<dim, spacedim>>
-  FE_P_Bubbles<dim, spacedim>::clone() const
-  {
-    return std::make_unique<FE_P_Bubbles<dim, spacedim>>(*this);
-  }
-} // namespace Simplex
+
+template <int dim, int spacedim>
+std::unique_ptr<FiniteElement<dim, spacedim>>
+FE_SimplexP_Bubbles<dim, spacedim>::clone() const
+{
+  return std::make_unique<FE_SimplexP_Bubbles<dim, spacedim>>(*this);
+}
 
 // explicit instantiations
 #include "fe_simplex_p_bubbles.inst"
diff --git a/source/fe/fe_simplex_p_bubbles.inst.in b/source/fe/fe_simplex_p_bubbles.inst.in
index ca82953a46..d428c679c1 100644
--- a/source/fe/fe_simplex_p_bubbles.inst.in
+++ b/source/fe/fe_simplex_p_bubbles.inst.in
@@ -18,7 +18,7 @@
 for (deal_II_dimension : DIMENSIONS; deal_II_space_dimension : DIMENSIONS)
   {
 #if deal_II_dimension <= deal_II_space_dimension
-    template class Simplex::FE_P_Bubbles<deal_II_dimension,
-                                         deal_II_space_dimension>;
+    template class FE_SimplexP_Bubbles<deal_II_dimension,
+                                       deal_II_space_dimension>;
 #endif
   }
diff --git a/source/fe/fe_wedge_p.cc b/source/fe/fe_wedge_p.cc
index 1a1d1fd0ca..4f4d4cf995 100644
--- a/source/fe/fe_wedge_p.cc
+++ b/source/fe/fe_wedge_p.cc
@@ -29,295 +29,289 @@
 
 DEAL_II_NAMESPACE_OPEN
 
-namespace Simplex
+namespace
 {
-  namespace
+  /**
+   * Helper function to set up the dpo vector of FE_WedgeP for a given @p degree.
+   */
+  internal::GenericDoFsPerObject
+  get_dpo_vector_fe_wedge_p(const unsigned int degree)
   {
-    /**
-     * Helper function to set up the dpo vector of FE_WedgeP for a given @p degree.
-     */
-    internal::GenericDoFsPerObject
-    get_dpo_vector_fe_wedge_p(const unsigned int degree)
-    {
-      internal::GenericDoFsPerObject dpo;
-
-      if (degree == 1)
-        {
-          dpo.dofs_per_object_exclusive  = {{1}, {0}, {0, 0, 0, 0, 0}, {0}};
-          dpo.dofs_per_object_inclusive  = {{1}, {2}, {3, 3, 4, 4, 4}, {6}};
-          dpo.object_index               = {{}, {6}, {6}, {6}};
-          dpo.first_object_index_on_face = {{},
-                                            {3, 3, 4, 4, 4},
-                                            {3, 3, 4, 4, 4}};
-        }
-      else if (degree == 2)
-        {
-          dpo.dofs_per_object_exclusive = {{1}, {1}, {0, 0, 1, 1, 1}, {0}};
-          dpo.dofs_per_object_inclusive = {{1}, {3}, {6, 6, 9, 9, 9}, {18}};
-          dpo.object_index              = {{}, {6}, {15, 15, 15, 16, 17}, {18}};
-          dpo.first_object_index_on_face = {{},
-                                            {3, 3, 4, 4, 4},
-                                            {6, 6, 8, 8, 8}};
-        }
-      else
-        {
-          Assert(false, ExcNotImplemented());
-        }
-
-      return dpo;
-    }
-
-    /**
-     * Helper function to set up the dpo vector of FE_WedgeDGP for a given @p degree.
-     */
-    internal::GenericDoFsPerObject
-    get_dpo_vector_fe_wedge_dgp(const unsigned int degree)
-    {
-      unsigned int n_dofs = 0;
+    internal::GenericDoFsPerObject dpo;
 
-      if (degree == 1)
-        n_dofs = 6;
-      else if (degree == 2)
-        n_dofs = 18;
-      else
+    if (degree == 1)
+      {
+        dpo.dofs_per_object_exclusive  = {{1}, {0}, {0, 0, 0, 0, 0}, {0}};
+        dpo.dofs_per_object_inclusive  = {{1}, {2}, {3, 3, 4, 4, 4}, {6}};
+        dpo.object_index               = {{}, {6}, {6}, {6}};
+        dpo.first_object_index_on_face = {{}, {3, 3, 4, 4, 4}, {3, 3, 4, 4, 4}};
+      }
+    else if (degree == 2)
+      {
+        dpo.dofs_per_object_exclusive  = {{1}, {1}, {0, 0, 1, 1, 1}, {0}};
+        dpo.dofs_per_object_inclusive  = {{1}, {3}, {6, 6, 9, 9, 9}, {18}};
+        dpo.object_index               = {{}, {6}, {15, 15, 15, 16, 17}, {18}};
+        dpo.first_object_index_on_face = {{}, {3, 3, 4, 4, 4}, {6, 6, 8, 8, 8}};
+      }
+    else
+      {
         Assert(false, ExcNotImplemented());
+      }
 
-      return internal::expand(3, {{0, 0, 0, n_dofs}}, ReferenceCells::Wedge);
-    }
-  } // namespace
-
-  template <int dim, int spacedim>
-  FE_Wedge<dim, spacedim>::FE_Wedge(
-    const unsigned int                                degree,
-    const internal::GenericDoFsPerObject &            dpos,
-    const typename FiniteElementData<dim>::Conformity conformity)
-    : dealii::FE_Poly<dim, spacedim>(
-        Simplex::ScalarWedgePolynomial<dim>(degree),
-        FiniteElementData<dim>(dpos,
-                               ReferenceCells::Wedge,
-                               1,
-                               degree,
-                               conformity),
-        std::vector<bool>(
-          FiniteElementData<dim>(dpos, ReferenceCells::Wedge, 1, degree)
-            .dofs_per_cell,
-          true),
-        std::vector<ComponentMask>(
-          FiniteElementData<dim>(dpos, ReferenceCells::Wedge, 1, degree)
-            .dofs_per_cell,
-          std::vector<bool>(1, true)))
+    return dpo;
+  }
+
+  /**
+   * Helper function to set up the dpo vector of FE_WedgeDGP for a given @p degree.
+   */
+  internal::GenericDoFsPerObject
+  get_dpo_vector_fe_wedge_dgp(const unsigned int degree)
   {
-    AssertDimension(dim, 3);
+    unsigned int n_dofs = 0;
 
     if (degree == 1)
-      {
-        this->unit_support_points.emplace_back(0.0, 0.0, 0.0);
-        this->unit_support_points.emplace_back(1.0, 0.0, 0.0);
-        this->unit_support_points.emplace_back(0.0, 1.0, 0.0);
-        this->unit_support_points.emplace_back(0.0, 0.0, 1.0);
-        this->unit_support_points.emplace_back(1.0, 0.0, 1.0);
-        this->unit_support_points.emplace_back(0.0, 1.0, 1.0);
-      }
-  }
+      n_dofs = 6;
+    else if (degree == 2)
+      n_dofs = 18;
+    else
+      Assert(false, ExcNotImplemented());
 
+    return internal::expand(3, {{0, 0, 0, n_dofs}}, ReferenceCells::Wedge);
+  }
+} // namespace
+
+template <int dim, int spacedim>
+FE_Wedge<dim, spacedim>::FE_Wedge(
+  const unsigned int                                degree,
+  const internal::GenericDoFsPerObject &            dpos,
+  const typename FiniteElementData<dim>::Conformity conformity)
+  : dealii::FE_Poly<dim, spacedim>(
+      ScalarWedgePolynomial<dim>(degree),
+      FiniteElementData<dim>(dpos,
+                             ReferenceCells::Wedge,
+                             1,
+                             degree,
+                             conformity),
+      std::vector<bool>(
+        FiniteElementData<dim>(dpos, ReferenceCells::Wedge, 1, degree)
+          .dofs_per_cell,
+        true),
+      std::vector<ComponentMask>(
+        FiniteElementData<dim>(dpos, ReferenceCells::Wedge, 1, degree)
+          .dofs_per_cell,
+        std::vector<bool>(1, true)))
+{
+  AssertDimension(dim, 3);
 
+  if (degree == 1)
+    {
+      this->unit_support_points.emplace_back(0.0, 0.0, 0.0);
+      this->unit_support_points.emplace_back(1.0, 0.0, 0.0);
+      this->unit_support_points.emplace_back(0.0, 1.0, 0.0);
+      this->unit_support_points.emplace_back(0.0, 0.0, 1.0);
+      this->unit_support_points.emplace_back(1.0, 0.0, 1.0);
+      this->unit_support_points.emplace_back(0.0, 1.0, 1.0);
+    }
+}
 
-  template <int dim, int spacedim>
-  FE_WedgeP<dim, spacedim>::FE_WedgeP(const unsigned int degree)
-    : FE_Wedge<dim, spacedim>(degree,
-                              get_dpo_vector_fe_wedge_p(degree),
-                              FiniteElementData<dim>::H1)
-  {}
 
 
+template <int dim, int spacedim>
+FE_WedgeP<dim, spacedim>::FE_WedgeP(const unsigned int degree)
+  : FE_Wedge<dim, spacedim>(degree,
+                            get_dpo_vector_fe_wedge_p(degree),
+                            FiniteElementData<dim>::H1)
+{}
 
-  template <int dim, int spacedim>
-  std::unique_ptr<FiniteElement<dim, spacedim>>
-  FE_WedgeP<dim, spacedim>::clone() const
-  {
-    return std::make_unique<FE_WedgeP<dim, spacedim>>(*this);
-  }
 
 
+template <int dim, int spacedim>
+std::unique_ptr<FiniteElement<dim, spacedim>>
+FE_WedgeP<dim, spacedim>::clone() const
+{
+  return std::make_unique<FE_WedgeP<dim, spacedim>>(*this);
+}
 
-  template <int dim, int spacedim>
-  std::string
-  FE_WedgeP<dim, spacedim>::get_name() const
-  {
-    std::ostringstream namebuf;
-    namebuf << "FE_WedgeP<" << dim << ">(" << this->degree << ")";
 
-    return namebuf.str();
-  }
 
+template <int dim, int spacedim>
+std::string
+FE_WedgeP<dim, spacedim>::get_name() const
+{
+  std::ostringstream namebuf;
+  namebuf << "FE_WedgeP<" << dim << ">(" << this->degree << ")";
 
+  return namebuf.str();
+}
 
-  template <int dim, int spacedim>
-  FiniteElementDomination::Domination
-  FE_WedgeP<dim, spacedim>::compare_for_domination(
-    const FiniteElement<dim, spacedim> &fe_other,
-    const unsigned int                  codim) const
-  {
-    Assert(codim <= dim, ExcImpossibleInDim(dim));
-
-    // vertex/line/face domination
-    // (if fe_other is derived from FE_DGP)
-    // ------------------------------------
-    if (codim > 0)
-      if (dynamic_cast<const FE_DGP<dim, spacedim> *>(&fe_other) != nullptr)
-        // there are no requirements between continuous and discontinuous
-        // elements
-        return FiniteElementDomination::no_requirements;
 
 
-    // vertex/line/face domination
-    // (if fe_other is not derived from FE_DGP)
-    // & cell domination
-    // ----------------------------------------
-    if (const FE_WedgeP<dim, spacedim> *fe_wp_other =
-          dynamic_cast<const FE_WedgeP<dim, spacedim> *>(&fe_other))
-      {
-        if (this->degree < fe_wp_other->degree)
-          return FiniteElementDomination::this_element_dominates;
-        else if (this->degree == fe_wp_other->degree)
-          return FiniteElementDomination::either_element_can_dominate;
-        else
-          return FiniteElementDomination::other_element_dominates;
-      }
-    else if (const FE_P<dim, spacedim> *fe_p_other =
-               dynamic_cast<const FE_P<dim, spacedim> *>(&fe_other))
-      {
-        if (this->degree < fe_p_other->degree)
-          return FiniteElementDomination::this_element_dominates;
-        else if (this->degree == fe_p_other->degree)
-          return FiniteElementDomination::either_element_can_dominate;
-        else
-          return FiniteElementDomination::other_element_dominates;
-      }
-    else if (const FE_Q<dim, spacedim> *fe_q_other =
-               dynamic_cast<const FE_Q<dim, spacedim> *>(&fe_other))
-      {
-        if (this->degree < fe_q_other->degree)
-          return FiniteElementDomination::this_element_dominates;
-        else if (this->degree == fe_q_other->degree)
-          return FiniteElementDomination::either_element_can_dominate;
-        else
-          return FiniteElementDomination::other_element_dominates;
-      }
-    else if (const FE_Nothing<dim> *fe_nothing =
-               dynamic_cast<const FE_Nothing<dim> *>(&fe_other))
-      {
-        if (fe_nothing->is_dominating())
-          return FiniteElementDomination::other_element_dominates;
-        else
-          // the FE_Nothing has no degrees of freedom and it is typically used
-          // in a context where we don't require any continuity along the
-          // interface
-          return FiniteElementDomination::no_requirements;
-      }
+template <int dim, int spacedim>
+FiniteElementDomination::Domination
+FE_WedgeP<dim, spacedim>::compare_for_domination(
+  const FiniteElement<dim, spacedim> &fe_other,
+  const unsigned int                  codim) const
+{
+  Assert(codim <= dim, ExcImpossibleInDim(dim));
+
+  // vertex/line/face domination
+  // (if fe_other is derived from FE_SimplexDGP)
+  // ------------------------------------
+  if (codim > 0)
+    if (dynamic_cast<const FE_SimplexDGP<dim, spacedim> *>(&fe_other) !=
+        nullptr)
+      // there are no requirements between continuous and discontinuous
+      // elements
+      return FiniteElementDomination::no_requirements;
+
+
+  // vertex/line/face domination
+  // (if fe_other is not derived from FE_SimplexDGP)
+  // & cell domination
+  // ----------------------------------------
+  if (const FE_WedgeP<dim, spacedim> *fe_wp_other =
+        dynamic_cast<const FE_WedgeP<dim, spacedim> *>(&fe_other))
+    {
+      if (this->degree < fe_wp_other->degree)
+        return FiniteElementDomination::this_element_dominates;
+      else if (this->degree == fe_wp_other->degree)
+        return FiniteElementDomination::either_element_can_dominate;
+      else
+        return FiniteElementDomination::other_element_dominates;
+    }
+  else if (const FE_SimplexP<dim, spacedim> *fe_p_other =
+             dynamic_cast<const FE_SimplexP<dim, spacedim> *>(&fe_other))
+    {
+      if (this->degree < fe_p_other->degree)
+        return FiniteElementDomination::this_element_dominates;
+      else if (this->degree == fe_p_other->degree)
+        return FiniteElementDomination::either_element_can_dominate;
+      else
+        return FiniteElementDomination::other_element_dominates;
+    }
+  else if (const FE_Q<dim, spacedim> *fe_q_other =
+             dynamic_cast<const FE_Q<dim, spacedim> *>(&fe_other))
+    {
+      if (this->degree < fe_q_other->degree)
+        return FiniteElementDomination::this_element_dominates;
+      else if (this->degree == fe_q_other->degree)
+        return FiniteElementDomination::either_element_can_dominate;
+      else
+        return FiniteElementDomination::other_element_dominates;
+    }
+  else if (const FE_Nothing<dim> *fe_nothing =
+             dynamic_cast<const FE_Nothing<dim> *>(&fe_other))
+    {
+      if (fe_nothing->is_dominating())
+        return FiniteElementDomination::other_element_dominates;
+      else
+        // the FE_Nothing has no degrees of freedom and it is typically used
+        // in a context where we don't require any continuity along the
+        // interface
+        return FiniteElementDomination::no_requirements;
+    }
 
-    Assert(false, ExcNotImplemented());
-    return FiniteElementDomination::neither_element_dominates;
-  }
+  Assert(false, ExcNotImplemented());
+  return FiniteElementDomination::neither_element_dominates;
+}
 
 
 
-  template <int dim, int spacedim>
-  std::vector<std::pair<unsigned int, unsigned int>>
-  FE_WedgeP<dim, spacedim>::hp_vertex_dof_identities(
-    const FiniteElement<dim, spacedim> &fe_other) const
-  {
-    (void)fe_other;
+template <int dim, int spacedim>
+std::vector<std::pair<unsigned int, unsigned int>>
+FE_WedgeP<dim, spacedim>::hp_vertex_dof_identities(
+  const FiniteElement<dim, spacedim> &fe_other) const
+{
+  (void)fe_other;
 
-    Assert((dynamic_cast<const Simplex::FE_P<dim, spacedim> *>(&fe_other)) ||
-             (dynamic_cast<const FE_Q<dim, spacedim> *>(&fe_other)),
-           ExcNotImplemented());
+  Assert((dynamic_cast<const FE_SimplexP<dim, spacedim> *>(&fe_other)) ||
+           (dynamic_cast<const FE_Q<dim, spacedim> *>(&fe_other)),
+         ExcNotImplemented());
 
-    return {{0, 0}};
-  }
+  return {{0, 0}};
+}
 
 
 
-  template <int dim, int spacedim>
-  std::vector<std::pair<unsigned int, unsigned int>>
-  FE_WedgeP<dim, spacedim>::hp_line_dof_identities(
-    const FiniteElement<dim, spacedim> &fe_other) const
-  {
-    (void)fe_other;
+template <int dim, int spacedim>
+std::vector<std::pair<unsigned int, unsigned int>>
+FE_WedgeP<dim, spacedim>::hp_line_dof_identities(
+  const FiniteElement<dim, spacedim> &fe_other) const
+{
+  (void)fe_other;
 
-    Assert((dynamic_cast<const Simplex::FE_P<dim, spacedim> *>(&fe_other)) ||
-             (dynamic_cast<const FE_Q<dim, spacedim> *>(&fe_other)),
-           ExcNotImplemented());
+  Assert((dynamic_cast<const FE_SimplexP<dim, spacedim> *>(&fe_other)) ||
+           (dynamic_cast<const FE_Q<dim, spacedim> *>(&fe_other)),
+         ExcNotImplemented());
 
-    std::vector<std::pair<unsigned int, unsigned int>> result;
+  std::vector<std::pair<unsigned int, unsigned int>> result;
 
-    for (unsigned int i = 0; i < this->degree - 1; ++i)
-      result.emplace_back(i, i);
+  for (unsigned int i = 0; i < this->degree - 1; ++i)
+    result.emplace_back(i, i);
 
-    return result;
-  }
+  return result;
+}
 
 
 
-  template <int dim, int spacedim>
-  std::vector<std::pair<unsigned int, unsigned int>>
-  FE_WedgeP<dim, spacedim>::hp_quad_dof_identities(
-    const FiniteElement<dim, spacedim> &fe_other,
-    const unsigned int                  face_no) const
-  {
-    (void)fe_other;
+template <int dim, int spacedim>
+std::vector<std::pair<unsigned int, unsigned int>>
+FE_WedgeP<dim, spacedim>::hp_quad_dof_identities(
+  const FiniteElement<dim, spacedim> &fe_other,
+  const unsigned int                  face_no) const
+{
+  (void)fe_other;
 
-    AssertIndexRange(face_no, 5);
+  AssertIndexRange(face_no, 5);
 
-    if (face_no < 2)
-      {
-        Assert((dynamic_cast<const Simplex::FE_P<dim, spacedim> *>(&fe_other)),
-               ExcNotImplemented());
-      }
-    else
-      {
-        Assert((dynamic_cast<const FE_Q<dim, spacedim> *>(&fe_other)),
-               ExcNotImplemented());
-      }
+  if (face_no < 2)
+    {
+      Assert((dynamic_cast<const FE_SimplexP<dim, spacedim> *>(&fe_other)),
+             ExcNotImplemented());
+    }
+  else
+    {
+      Assert((dynamic_cast<const FE_Q<dim, spacedim> *>(&fe_other)),
+             ExcNotImplemented());
+    }
 
-    std::vector<std::pair<unsigned int, unsigned int>> result;
+  std::vector<std::pair<unsigned int, unsigned int>> result;
 
-    for (unsigned int i = 0; i < this->n_dofs_per_quad(face_no); ++i)
-      result.emplace_back(i, i);
+  for (unsigned int i = 0; i < this->n_dofs_per_quad(face_no); ++i)
+    result.emplace_back(i, i);
 
-    return result;
-  }
+  return result;
+}
 
 
 
-  template <int dim, int spacedim>
-  FE_WedgeDGP<dim, spacedim>::FE_WedgeDGP(const unsigned int degree)
-    : FE_Wedge<dim, spacedim>(degree,
-                              get_dpo_vector_fe_wedge_dgp(degree),
-                              FiniteElementData<dim>::L2)
-  {}
+template <int dim, int spacedim>
+FE_WedgeDGP<dim, spacedim>::FE_WedgeDGP(const unsigned int degree)
+  : FE_Wedge<dim, spacedim>(degree,
+                            get_dpo_vector_fe_wedge_dgp(degree),
+                            FiniteElementData<dim>::L2)
+{}
 
 
 
-  template <int dim, int spacedim>
-  std::unique_ptr<FiniteElement<dim, spacedim>>
-  FE_WedgeDGP<dim, spacedim>::clone() const
-  {
-    return std::make_unique<FE_WedgeDGP<dim, spacedim>>(*this);
-  }
+template <int dim, int spacedim>
+std::unique_ptr<FiniteElement<dim, spacedim>>
+FE_WedgeDGP<dim, spacedim>::clone() const
+{
+  return std::make_unique<FE_WedgeDGP<dim, spacedim>>(*this);
+}
 
 
 
-  template <int dim, int spacedim>
-  std::string
-  FE_WedgeDGP<dim, spacedim>::get_name() const
-  {
-    std::ostringstream namebuf;
-    namebuf << "FE_WedgeDGP<" << dim << ">(" << this->degree << ")";
+template <int dim, int spacedim>
+std::string
+FE_WedgeDGP<dim, spacedim>::get_name() const
+{
+  std::ostringstream namebuf;
+  namebuf << "FE_WedgeDGP<" << dim << ">(" << this->degree << ")";
 
-    return namebuf.str();
-  }
-} // namespace Simplex
+  return namebuf.str();
+}
 
 // explicit instantiations
 #include "fe_wedge_p.inst"
diff --git a/source/fe/fe_wedge_p.inst.in b/source/fe/fe_wedge_p.inst.in
index 9b6ee61535..1aaddea045 100644
--- a/source/fe/fe_wedge_p.inst.in
+++ b/source/fe/fe_wedge_p.inst.in
@@ -18,11 +18,8 @@
 for (deal_II_dimension : DIMENSIONS; deal_II_space_dimension : DIMENSIONS)
   {
 #if deal_II_dimension <= deal_II_space_dimension
-    template class Simplex::FE_Wedge<deal_II_dimension,
-                                     deal_II_space_dimension>;
-    template class Simplex::FE_WedgeP<deal_II_dimension,
-                                      deal_II_space_dimension>;
-    template class Simplex::FE_WedgeDGP<deal_II_dimension,
-                                        deal_II_space_dimension>;
+    template class FE_Wedge<deal_II_dimension, deal_II_space_dimension>;
+    template class FE_WedgeP<deal_II_dimension, deal_II_space_dimension>;
+    template class FE_WedgeDGP<deal_II_dimension, deal_II_space_dimension>;
 #endif
   }
diff --git a/source/grid/reference_cell.cc b/source/grid/reference_cell.cc
index a9bc30f535..9bafdb90a2 100644
--- a/source/grid/reference_cell.cc
+++ b/source/grid/reference_cell.cc
@@ -74,13 +74,13 @@ ReferenceCell::get_default_mapping(const unsigned int degree) const
     return std::make_unique<MappingQGeneric<dim, spacedim>>(degree);
   else if (is_simplex())
     return std::make_unique<MappingFE<dim, spacedim>>(
-      Simplex::FE_P<dim, spacedim>(degree));
+      FE_SimplexP<dim, spacedim>(degree));
   else if (*this == ReferenceCells::Pyramid)
     return std::make_unique<MappingFE<dim, spacedim>>(
-      Simplex::FE_PyramidP<dim, spacedim>(degree));
+      FE_PyramidP<dim, spacedim>(degree));
   else if (*this == ReferenceCells::Wedge)
     return std::make_unique<MappingFE<dim, spacedim>>(
-      Simplex::FE_WedgeP<dim, spacedim>(degree));
+      FE_WedgeP<dim, spacedim>(degree));
   else
     {
       Assert(false, ExcNotImplemented());
@@ -104,19 +104,19 @@ ReferenceCell::get_default_linear_mapping() const
   else if (is_simplex())
     {
       static const MappingFE<dim, spacedim> mapping(
-        Simplex::FE_P<dim, spacedim>(1));
+        FE_SimplexP<dim, spacedim>(1));
       return mapping;
     }
   else if (*this == ReferenceCells::Pyramid)
     {
       static const MappingFE<dim, spacedim> mapping(
-        Simplex::FE_PyramidP<dim, spacedim>(1));
+        FE_PyramidP<dim, spacedim>(1));
       return mapping;
     }
   else if (*this == ReferenceCells::Wedge)
     {
       static const MappingFE<dim, spacedim> mapping(
-        Simplex::FE_WedgeP<dim, spacedim>(1));
+        FE_WedgeP<dim, spacedim>(1));
       return mapping;
     }
   else
@@ -138,11 +138,11 @@ ReferenceCell::get_gauss_type_quadrature(const unsigned n_points_1D) const
   if (is_hyper_cube())
     return QGauss<dim>(n_points_1D);
   else if (is_simplex())
-    return Simplex::QGauss<dim>(n_points_1D);
+    return QGaussSimplex<dim>(n_points_1D);
   else if (*this == ReferenceCells::Pyramid)
-    return Simplex::QGaussPyramid<dim>(n_points_1D);
+    return QGaussPyramid<dim>(n_points_1D);
   else if (*this == ReferenceCells::Wedge)
-    return Simplex::QGaussWedge<dim>(n_points_1D);
+    return QGaussWedge<dim>(n_points_1D);
   else
     Assert(false, ExcNotImplemented());
 
diff --git a/tests/matrix_free/compute_diagonal_05.cc b/tests/matrix_free/compute_diagonal_05.cc
index 5daa7c3d05..b504d144f3 100644
--- a/tests/matrix_free/compute_diagonal_05.cc
+++ b/tests/matrix_free/compute_diagonal_05.cc
@@ -19,7 +19,7 @@
 
 #include <deal.II/base/quadrature_lib.h>
 
-#include <deal.II/fe/fe_p.h>
+#include <deal.II/fe/fe_simplex_p.h>
 #include <deal.II/fe/mapping_fe.h>
 
 #include <deal.II/grid/grid_generator.h>
@@ -40,8 +40,8 @@ test()
   const unsigned int fe_degree = 2;
   const unsigned int n_points  = 3;
 
-  const Simplex::FE_P<dim> fe_q(fe_degree);
-  const FESystem<dim>      fe(fe_q, n_components);
+  const FE_SimplexP<dim> fe_q(fe_degree);
+  const FESystem<dim>    fe(fe_q, n_components);
 
   // setup dof-handlers
   DoFHandler<dim> dof_handler(tria);
@@ -49,7 +49,7 @@ test()
 
   AffineConstraints<Number> constraint;
 
-  MappingFE<dim> mapping(Simplex::FE_P<dim>{1});
+  MappingFE<dim> mapping(FE_SimplexP<dim>{1});
 
   VectorTools::interpolate_boundary_values(mapping,
                                            dof_handler,
@@ -63,7 +63,7 @@ test()
   typename MatrixFree<dim, Number, VectorizedArrayType>::AdditionalData
     additional_data;
   additional_data.mapping_update_flags = update_values | update_gradients;
-  Simplex::QGauss<dim> quad(fe_degree + 1);
+  QGaussSimplex<dim> quad(fe_degree + 1);
 
   MatrixFree<dim, Number, VectorizedArrayType> matrix_free;
   matrix_free.reinit(mapping, dof_handler, constraint, quad, additional_data);
diff --git a/tests/multigrid-global-coarsening/multigrid_a_01.cc b/tests/multigrid-global-coarsening/multigrid_a_01.cc
index f461708bfe..42f5eec640 100644
--- a/tests/multigrid-global-coarsening/multigrid_a_01.cc
+++ b/tests/multigrid-global-coarsening/multigrid_a_01.cc
@@ -55,9 +55,9 @@ test(const unsigned int n_refinements,
 
       if (do_simplex_mesh)
         {
-          fe      = std::make_unique<Simplex::FE_P<dim>>(fe_degree_fine);
-          quad    = std::make_unique<Simplex::QGauss<dim>>(fe_degree_fine + 1);
-          mapping = std::make_unique<MappingFE<dim>>(Simplex::FE_P<dim>(1));
+          fe      = std::make_unique<FE_SimplexP<dim>>(fe_degree_fine);
+          quad    = std::make_unique<QGaussSimplex<dim>>(fe_degree_fine + 1);
+          mapping = std::make_unique<MappingFE<dim>>(FE_SimplexP<dim>(1));
         }
       else
         {
diff --git a/tests/multigrid-global-coarsening/multigrid_p_01.cc b/tests/multigrid-global-coarsening/multigrid_p_01.cc
index bcd3e39ba1..945ded4808 100644
--- a/tests/multigrid-global-coarsening/multigrid_p_01.cc
+++ b/tests/multigrid-global-coarsening/multigrid_p_01.cc
@@ -90,9 +90,9 @@ test(const unsigned int n_refinements,
 
       if (do_simplex_mesh)
         {
-          fe   = std::make_unique<Simplex::FE_P<dim>>(level_degrees[l]);
-          quad = std::make_unique<Simplex::QGauss<dim>>(level_degrees[l] + 1);
-          mapping = std::make_unique<MappingFE<dim>>(Simplex::FE_P<dim>(1));
+          fe      = std::make_unique<FE_SimplexP<dim>>(level_degrees[l]);
+          quad    = std::make_unique<QGaussSimplex<dim>>(level_degrees[l] + 1);
+          mapping = std::make_unique<MappingFE<dim>>(FE_SimplexP<dim>(1));
         }
       else
         {
diff --git a/tests/simplex/barycentric_01.cc b/tests/simplex/barycentric_01.cc
index 277d7220be..3b1c726d9f 100644
--- a/tests/simplex/barycentric_01.cc
+++ b/tests/simplex/barycentric_01.cc
@@ -13,7 +13,7 @@
 //
 // ---------------------------------------------------------------------
 
-// Test Simplex::BarycentricPolynomial and Simplex::BarycentricPolynomials.
+// Test BarycentricPolynomial and BarycentricPolynomials.
 
 #include <deal.II/base/point.h>
 #include <deal.II/base/polynomials_barycentric.h>
@@ -33,14 +33,14 @@ main()
 {
   initlog();
 
-  Simplex::BarycentricPolynomial<2> bp2({1, 0, 0}, 1.0);
+  BarycentricPolynomial<2> bp2({1, 0, 0}, 1.0);
   deallog << bp2 << std::endl;
 
   // test some basic algebra with barycentric polynomials
   {
     deallog << "1D:" << std::endl;
-    const auto bp1_0 = Simplex::BarycentricPolynomial<1>::monomial(0);
-    const auto bp1_1 = Simplex::BarycentricPolynomial<1>::monomial(1);
+    const auto bp1_0 = BarycentricPolynomial<1>::monomial(0);
+    const auto bp1_1 = BarycentricPolynomial<1>::monomial(1);
 
     deallog << "bp1_0 = " << bp1_0 << std::endl;
     deallog << "bp1_1 = " << bp1_1 << std::endl;
@@ -50,13 +50,13 @@ main()
 
   {
     deallog << std::endl << "2D:" << std::endl;
-    const auto bp2_0 = Simplex::BarycentricPolynomial<2>::monomial(0) * 2;
+    const auto bp2_0 = BarycentricPolynomial<2>::monomial(0) * 2;
     deallog << "bp2_0 = " << bp2_0 << std::endl;
 
-    const auto bp2_1 = 3.0 * Simplex::BarycentricPolynomial<2>::monomial(1);
+    const auto bp2_1 = 3.0 * BarycentricPolynomial<2>::monomial(1);
     deallog << "bp2_1 = " << bp2_1 << std::endl;
 
-    const auto bp2_2 = Simplex::BarycentricPolynomial<2>::monomial(2);
+    const auto bp2_2 = BarycentricPolynomial<2>::monomial(2);
     deallog << "bp2_2 = " << bp2_2 << std::endl;
 
     const auto prod1 = bp2_0 + bp2_1;
@@ -81,11 +81,11 @@ main()
   {
     deallog << std::endl << "Test with TRI6" << std::endl;
 
-    const auto t1 = Simplex::BarycentricPolynomial<2>::monomial(0);
-    const auto t2 = Simplex::BarycentricPolynomial<2>::monomial(1);
-    const auto t3 = Simplex::BarycentricPolynomial<2>::monomial(2);
+    const auto t1 = BarycentricPolynomial<2>::monomial(0);
+    const auto t2 = BarycentricPolynomial<2>::monomial(1);
+    const auto t3 = BarycentricPolynomial<2>::monomial(2);
 
-    std::vector<Simplex::BarycentricPolynomial<2>> p2;
+    std::vector<BarycentricPolynomial<2>> p2;
     p2.push_back(t1 * (2 * t1 - 1));
     p2.push_back(t2 * (2 * t2 - 1));
     p2.push_back(t3 * (2 * t3 - 1));
@@ -93,7 +93,7 @@ main()
     p2.push_back(4 * t2 * t3);
     p2.push_back(4 * t3 * t1);
 
-    Simplex::FE_P<2> fe(2);
+    FE_SimplexP<2> fe(2);
     for (unsigned int i = 0; i < 6; ++i)
       {
         deallog << "p = " << p2[i] << std::endl;
@@ -111,10 +111,10 @@ main()
 
   {
     deallog << std::endl << "Test with TET4" << std::endl;
-    const auto tet4 = Simplex::BarycentricPolynomials<3>::get_fe_p_basis(1);
+    const auto tet4 = BarycentricPolynomials<3>::get_fe_p_basis(1);
 
-    Simplex::FE_P<3> fe(1);
-    const auto &     points = fe.get_unit_support_points();
+    FE_SimplexP<3> fe(1);
+    const auto &   points = fe.get_unit_support_points();
     for (unsigned int i = 0; i < 4; ++i)
       {
         Assert(points.size() == 4, ExcInternalError());
@@ -142,10 +142,10 @@ main()
 
   {
     deallog << "Test with TET10" << std::endl;
-    const auto tet10 = Simplex::BarycentricPolynomials<3>::get_fe_p_basis(2);
+    const auto tet10 = BarycentricPolynomials<3>::get_fe_p_basis(2);
 
-    Simplex::FE_P<3> fe(2);
-    const auto &     points = fe.get_unit_support_points();
+    FE_SimplexP<3> fe(2);
+    const auto &   points = fe.get_unit_support_points();
     for (unsigned int i = 0; i < 10; ++i)
       {
         Assert(points.size() == 10, ExcInternalError());
diff --git a/tests/simplex/cell_measure_01.cc b/tests/simplex/cell_measure_01.cc
index 12488df21f..1bd815328f 100644
--- a/tests/simplex/cell_measure_01.cc
+++ b/tests/simplex/cell_measure_01.cc
@@ -50,9 +50,9 @@ process(const std::vector<Point<spacedim>> &vertices,
   AssertDimension(reference_cells.size(), 1);
 
   if (reference_cells[0] == ReferenceCells::get_simplex<dim>())
-    mapping = std::make_shared<MappingFE<dim>>(Simplex::FE_P<dim>(1));
+    mapping = std::make_shared<MappingFE<dim>>(FE_SimplexP<dim>(1));
   else if (reference_cells[0] == ReferenceCells::Wedge)
-    mapping = std::make_shared<MappingFE<dim>>(Simplex::FE_WedgeP<dim>(1));
+    mapping = std::make_shared<MappingFE<dim>>(FE_WedgeP<dim>(1));
   else
     AssertThrow(false, ExcNotImplemented());
 
diff --git a/tests/simplex/compute_point_locations_01.cc b/tests/simplex/compute_point_locations_01.cc
index 7f01defc34..ca8a201748 100644
--- a/tests/simplex/compute_point_locations_01.cc
+++ b/tests/simplex/compute_point_locations_01.cc
@@ -39,7 +39,7 @@ test_in_unit_cube(const std::vector<Point<dim>> &points)
   Triangulation<dim> tria;
   GridGenerator::subdivided_hyper_cube_with_simplices(tria, 1);
 
-  MappingFE<dim> mapping(Simplex::FE_P<dim>(1));
+  MappingFE<dim> mapping(FE_SimplexP<dim>(1));
 
   const auto tria_cache =
     std::make_unique<GridTools::Cache<dim>>(tria, mapping);
diff --git a/tests/simplex/compute_projection_matrices_01.cc b/tests/simplex/compute_projection_matrices_01.cc
index 0eb96bc768..663d92862f 100644
--- a/tests/simplex/compute_projection_matrices_01.cc
+++ b/tests/simplex/compute_projection_matrices_01.cc
@@ -14,7 +14,7 @@
 // ---------------------------------------------------------------------
 
 
-// Test Simplex::FE_Poly::get_prolongation_matrix()
+// Test FE_SimplexPoly::get_prolongation_matrix()
 // (and indirectly FETools::compute_embedding_matrices() for simplices).
 
 
@@ -65,8 +65,8 @@ main()
   const int dim      = 2;
   const int spacedim = 2;
 
-  Simplex::FE_P<dim, spacedim> fe(2);
-  MappingFE<dim>               mapping(Simplex::FE_P<dim>(1));
+  FE_SimplexP<dim, spacedim> fe(2);
+  MappingFE<dim>             mapping(FE_SimplexP<dim>(1));
 
   const unsigned int n_refinements = 2;
 
diff --git a/tests/simplex/data_out_write_hdf5_01.cc b/tests/simplex/data_out_write_hdf5_01.cc
index bcae95fde2..eb79d2c4d3 100644
--- a/tests/simplex/data_out_write_hdf5_01.cc
+++ b/tests/simplex/data_out_write_hdf5_01.cc
@@ -68,7 +68,7 @@ test(const FiniteElement<dim, spacedim> &fe, const unsigned int n_components)
 
   Vector<double> solution(dof_handler.n_dofs());
 
-  MappingFE<dim> mapping(Simplex::FE_P<dim>(1));
+  MappingFE<dim> mapping(FE_SimplexP<dim>(1));
 
   VectorTools::interpolate(mapping,
                            dof_handler,
@@ -126,18 +126,16 @@ main(int argc, char **argv)
 
   {
     const unsigned int dim = 2;
-    test<dim>(Simplex::FE_P<dim>(2), 1);
-    test<dim>(FESystem<dim>(Simplex::FE_P<dim>(2), dim), dim);
-    test<dim>(
-      FESystem<dim>(Simplex::FE_P<dim>(2), dim, Simplex::FE_P<dim>(1), 1),
-      dim + 1);
+    test<dim>(FE_SimplexP<dim>(2), 1);
+    test<dim>(FESystem<dim>(FE_SimplexP<dim>(2), dim), dim);
+    test<dim>(FESystem<dim>(FE_SimplexP<dim>(2), dim, FE_SimplexP<dim>(1), 1),
+              dim + 1);
   }
   {
     const unsigned int dim = 3;
-    test<dim>(Simplex::FE_P<dim>(2), 1);
-    test<dim>(FESystem<dim>(Simplex::FE_P<dim>(2), dim), dim);
-    test<dim>(
-      FESystem<dim>(Simplex::FE_P<dim>(2), dim, Simplex::FE_P<dim>(1), 1),
-      dim + 1);
+    test<dim>(FE_SimplexP<dim>(2), 1);
+    test<dim>(FESystem<dim>(FE_SimplexP<dim>(2), dim), dim);
+    test<dim>(FESystem<dim>(FE_SimplexP<dim>(2), dim, FE_SimplexP<dim>(1), 1),
+              dim + 1);
   }
 }
diff --git a/tests/simplex/data_out_write_hdf5_02.cc b/tests/simplex/data_out_write_hdf5_02.cc
index 038c15220b..98746efe15 100644
--- a/tests/simplex/data_out_write_hdf5_02.cc
+++ b/tests/simplex/data_out_write_hdf5_02.cc
@@ -91,7 +91,7 @@ test(const FiniteElement<dim, spacedim> &fe, const unsigned int n_components)
 
   solution.reinit(owned_dofs, locally_relevant_dofs, comm);
 
-  MappingFE<dim> mapping(Simplex::FE_P<dim>(1));
+  MappingFE<dim> mapping(FE_SimplexP<dim>(1));
 
   VectorTools::interpolate(mapping,
                            dof_handler,
@@ -149,18 +149,16 @@ main(int argc, char **argv)
 
   {
     const unsigned int dim = 2;
-    test<dim>(Simplex::FE_P<dim>(2), 1);
-    test<dim>(FESystem<dim>(Simplex::FE_P<dim>(2), dim), dim);
-    test<dim>(
-      FESystem<dim>(Simplex::FE_P<dim>(2), dim, Simplex::FE_P<dim>(1), 1),
-      dim + 1);
+    test<dim>(FE_SimplexP<dim>(2), 1);
+    test<dim>(FESystem<dim>(FE_SimplexP<dim>(2), dim), dim);
+    test<dim>(FESystem<dim>(FE_SimplexP<dim>(2), dim, FE_SimplexP<dim>(1), 1),
+              dim + 1);
   }
   {
     const unsigned int dim = 3;
-    test<dim>(Simplex::FE_P<dim>(2), 1);
-    test<dim>(FESystem<dim>(Simplex::FE_P<dim>(2), dim), dim);
-    test<dim>(
-      FESystem<dim>(Simplex::FE_P<dim>(2), dim, Simplex::FE_P<dim>(1), 1),
-      dim + 1);
+    test<dim>(FE_SimplexP<dim>(2), 1);
+    test<dim>(FESystem<dim>(FE_SimplexP<dim>(2), dim), dim);
+    test<dim>(FESystem<dim>(FE_SimplexP<dim>(2), dim, FE_SimplexP<dim>(1), 1),
+              dim + 1);
   }
 }
diff --git a/tests/simplex/data_out_write_vtk_01.cc b/tests/simplex/data_out_write_vtk_01.cc
index b2d6b36480..c90accdb79 100644
--- a/tests/simplex/data_out_write_vtk_01.cc
+++ b/tests/simplex/data_out_write_vtk_01.cc
@@ -70,7 +70,7 @@ test(const FiniteElement<dim, spacedim> &fe,
 
   Vector<double> solution(dof_handler.n_dofs());
 
-  MappingFE<dim> mapping(Simplex::FE_P<dim>(1));
+  MappingFE<dim> mapping(FE_SimplexP<dim>(1));
 
   AffineConstraints<double> dummy;
   dummy.close();
@@ -78,7 +78,7 @@ test(const FiniteElement<dim, spacedim> &fe,
   VectorTools::project(mapping,
                        dof_handler,
                        dummy,
-                       Simplex::QGauss<dim>(fe.tensor_degree() + 1),
+                       QGaussSimplex<dim>(fe.tensor_degree() + 1),
                        RightHandSideFunction<dim>(n_components),
                        solution);
 
@@ -122,13 +122,13 @@ main()
       if (do_high_order)
         {
           const unsigned int dim = 2;
-          test<dim>(Simplex::FE_P<dim>(2) /*=degree*/, 1, do_high_order);
-          test<dim>(FESystem<dim>(Simplex::FE_P<dim>(2 /*=degree*/), dim),
+          test<dim>(FE_SimplexP<dim>(2) /*=degree*/, 1, do_high_order);
+          test<dim>(FESystem<dim>(FE_SimplexP<dim>(2 /*=degree*/), dim),
                     dim,
                     do_high_order);
-          test<dim>(FESystem<dim>(Simplex::FE_P<dim>(2 /*=degree*/),
+          test<dim>(FESystem<dim>(FE_SimplexP<dim>(2 /*=degree*/),
                                   dim,
-                                  Simplex::FE_P<dim>(1 /*=degree*/),
+                                  FE_SimplexP<dim>(1 /*=degree*/),
                                   1),
                     dim + 1,
                     do_high_order);
@@ -138,13 +138,13 @@ main()
           false /*TODO: higher-order output not working for 3D*/)
         {
           const unsigned int dim = 3;
-          test<dim>(Simplex::FE_P<dim>(2) /*=degree*/, 1, do_high_order);
-          test<dim>(FESystem<dim>(Simplex::FE_P<dim>(2 /*=degree*/), dim),
+          test<dim>(FE_SimplexP<dim>(2) /*=degree*/, 1, do_high_order);
+          test<dim>(FESystem<dim>(FE_SimplexP<dim>(2 /*=degree*/), dim),
                     dim,
                     do_high_order);
-          test<dim>(FESystem<dim>(Simplex::FE_P<dim>(2 /*=degree*/),
+          test<dim>(FESystem<dim>(FE_SimplexP<dim>(2 /*=degree*/),
                                   dim,
-                                  Simplex::FE_P<dim>(1 /*=degree*/),
+                                  FE_SimplexP<dim>(1 /*=degree*/),
                                   1),
                     dim + 1,
                     do_high_order);
diff --git a/tests/simplex/data_out_write_vtk_02.cc b/tests/simplex/data_out_write_vtk_02.cc
index d88279770d..e76a757062 100644
--- a/tests/simplex/data_out_write_vtk_02.cc
+++ b/tests/simplex/data_out_write_vtk_02.cc
@@ -69,11 +69,11 @@ test(const FiniteElement<dim, spacedim> &fe_0,
 
   hp::FECollection<dim, spacedim> fe(fe_0, fe_1);
 
-  hp::QCollection<dim> quadrature(Simplex::QGauss<dim>(degree + 1),
+  hp::QCollection<dim> quadrature(QGaussSimplex<dim>(degree + 1),
                                   QGauss<dim>(degree + 1));
 
   hp::MappingCollection<dim, spacedim> mapping(
-    MappingFE<dim, spacedim>(Simplex::FE_P<dim, spacedim>(1)),
+    MappingFE<dim, spacedim>(FE_SimplexP<dim, spacedim>(1)),
     MappingQGeneric<dim, spacedim>(1));
 
   Triangulation<dim, spacedim> tria;
@@ -149,15 +149,15 @@ main()
       if (true)
         {
           const unsigned int dim = 2;
-          test<dim>(Simplex::FE_P<dim>(2), FE_Q<dim>(2), 1, do_high_order);
+          test<dim>(FE_SimplexP<dim>(2), FE_Q<dim>(2), 1, do_high_order);
 
-          test<dim>(FESystem<dim>(Simplex::FE_P<dim>(2), dim),
+          test<dim>(FESystem<dim>(FE_SimplexP<dim>(2), dim),
                     FESystem<dim>(FE_Q<dim>(2), dim),
                     dim,
                     do_high_order);
 
           test<dim>(
-            FESystem<dim>(Simplex::FE_P<dim>(2), dim, Simplex::FE_P<dim>(1), 1),
+            FESystem<dim>(FE_SimplexP<dim>(2), dim, FE_SimplexP<dim>(1), 1),
             FESystem<dim>(FE_Q<dim>(2), dim, FE_Q<dim>(1), 1),
             dim + 1,
             do_high_order);
diff --git a/tests/simplex/data_out_write_vtu_01.cc b/tests/simplex/data_out_write_vtu_01.cc
index a58cbf2307..b84e31460a 100644
--- a/tests/simplex/data_out_write_vtu_01.cc
+++ b/tests/simplex/data_out_write_vtu_01.cc
@@ -66,7 +66,7 @@ test(const FiniteElement<dim, spacedim> &fe, const unsigned int n_components)
 
   Vector<double> solution(dof_handler.n_dofs());
 
-  MappingFE<dim> mapping(Simplex::FE_P<dim>(1));
+  MappingFE<dim> mapping(FE_SimplexP<dim>(1));
 
   VectorTools::interpolate(mapping,
                            dof_handler,
@@ -102,21 +102,21 @@ main()
 
   {
     const unsigned int dim = 2;
-    test<dim>(Simplex::FE_P<dim>(2) /*=degree*/, 1);
-    test<dim>(FESystem<dim>(Simplex::FE_P<dim>(2 /*=degree*/), dim), dim);
-    test<dim>(FESystem<dim>(Simplex::FE_P<dim>(2 /*=degree*/),
+    test<dim>(FE_SimplexP<dim>(2) /*=degree*/, 1);
+    test<dim>(FESystem<dim>(FE_SimplexP<dim>(2 /*=degree*/), dim), dim);
+    test<dim>(FESystem<dim>(FE_SimplexP<dim>(2 /*=degree*/),
                             dim,
-                            Simplex::FE_P<dim>(1 /*=degree*/),
+                            FE_SimplexP<dim>(1 /*=degree*/),
                             1),
               dim + 1);
   }
   {
     const unsigned int dim = 3;
-    test<dim>(Simplex::FE_P<dim>(2) /*=degree*/, 1);
-    test<dim>(FESystem<dim>(Simplex::FE_P<dim>(2 /*=degree*/), dim), dim);
-    test<dim>(FESystem<dim>(Simplex::FE_P<dim>(2 /*=degree*/),
+    test<dim>(FE_SimplexP<dim>(2) /*=degree*/, 1);
+    test<dim>(FESystem<dim>(FE_SimplexP<dim>(2 /*=degree*/), dim), dim);
+    test<dim>(FESystem<dim>(FE_SimplexP<dim>(2 /*=degree*/),
                             dim,
-                            Simplex::FE_P<dim>(1 /*=degree*/),
+                            FE_SimplexP<dim>(1 /*=degree*/),
                             1),
               dim + 1);
   }
diff --git a/tests/simplex/extract_boundary_dofs.cc b/tests/simplex/extract_boundary_dofs.cc
index 9329aca91d..2de79fa1b0 100644
--- a/tests/simplex/extract_boundary_dofs.cc
+++ b/tests/simplex/extract_boundary_dofs.cc
@@ -45,8 +45,8 @@ test()
 
   GridGenerator::subdivided_hyper_cube_with_simplices(tr, 4);
 
-  const Simplex::FE_P<dim> fe(2);
-  DoFHandler<dim>          dofh(tr);
+  const FE_SimplexP<dim> fe(2);
+  DoFHandler<dim>        dofh(tr);
   dofh.distribute_dofs(fe);
 
   IndexSet relevant_set, boundary_dofs;
diff --git a/tests/simplex/fe_lib_01.cc b/tests/simplex/fe_lib_01.cc
index 50460a2f09..7ea90033fe 100644
--- a/tests/simplex/fe_lib_01.cc
+++ b/tests/simplex/fe_lib_01.cc
@@ -14,7 +14,7 @@
 // ---------------------------------------------------------------------
 
 
-// Test n_dofs_per-methods of Simplex::FE_P  and Simplex::FE_DGP.
+// Test n_dofs_per-methods of FE_SimplexP  and FE_SimplexDGP.
 
 
 #include <deal.II/fe/fe_pyramid_p.h>
@@ -59,23 +59,23 @@ main()
 {
   initlog();
 
-  test(Simplex::FE_P<2>(1));
-  test(Simplex::FE_P<2>(2));
-  test(Simplex::FE_P<3>(1));
-  test(Simplex::FE_P<3>(2));
+  test(FE_SimplexP<2>(1));
+  test(FE_SimplexP<2>(2));
+  test(FE_SimplexP<3>(1));
+  test(FE_SimplexP<3>(2));
 
-  test(Simplex::FE_DGP<2>(1));
-  test(Simplex::FE_DGP<2>(2));
-  test(Simplex::FE_DGP<3>(1));
-  test(Simplex::FE_DGP<3>(2));
+  test(FE_SimplexDGP<2>(1));
+  test(FE_SimplexDGP<2>(2));
+  test(FE_SimplexDGP<3>(1));
+  test(FE_SimplexDGP<3>(2));
 
-  test(Simplex::FE_WedgeP<3>(1));
-  test(Simplex::FE_WedgeP<3>(2));
+  test(FE_WedgeP<3>(1));
+  test(FE_WedgeP<3>(2));
 
-  test(Simplex::FE_WedgeDGP<3>(1));
-  test(Simplex::FE_WedgeDGP<3>(2));
+  test(FE_WedgeDGP<3>(1));
+  test(FE_WedgeDGP<3>(2));
 
-  test(Simplex::FE_PyramidP<3>(1));
+  test(FE_PyramidP<3>(1));
 
-  test(Simplex::FE_PyramidDGP<3>(1));
+  test(FE_PyramidDGP<3>(1));
 }
diff --git a/tests/simplex/fe_lib_01.output b/tests/simplex/fe_lib_01.output
index ec3b0b86fd..ccea093a59 100644
--- a/tests/simplex/fe_lib_01.output
+++ b/tests/simplex/fe_lib_01.output
@@ -1,5 +1,5 @@
 
-DEAL::FE_P<2>(1): 
+DEAL::FE_SimplexP<2>(1): 
 DEAL::  n_dofs_per_vertex(): 1
 DEAL::  n_dofs_per_line():   0
 DEAL::  n_dofs_per_quad():   0 
@@ -8,7 +8,7 @@ DEAL::  n_dofs_per_face():   2 2 2
 DEAL::  n_dofs_per_cell():   3
 DEAL::  tensor_degree():     1
 DEAL::
-DEAL::FE_P<2>(2): 
+DEAL::FE_SimplexP<2>(2): 
 DEAL::  n_dofs_per_vertex(): 1
 DEAL::  n_dofs_per_line():   1
 DEAL::  n_dofs_per_quad():   0 
@@ -17,7 +17,7 @@ DEAL::  n_dofs_per_face():   3 3 3
 DEAL::  n_dofs_per_cell():   6
 DEAL::  tensor_degree():     2
 DEAL::
-DEAL::FE_P<3>(1): 
+DEAL::FE_SimplexP<3>(1): 
 DEAL::  n_dofs_per_vertex(): 1
 DEAL::  n_dofs_per_line():   0
 DEAL::  n_dofs_per_quad():   0 0 0 0 
@@ -26,7 +26,7 @@ DEAL::  n_dofs_per_face():   3 3 3 3
 DEAL::  n_dofs_per_cell():   4
 DEAL::  tensor_degree():     1
 DEAL::
-DEAL::FE_P<3>(2): 
+DEAL::FE_SimplexP<3>(2): 
 DEAL::  n_dofs_per_vertex(): 1
 DEAL::  n_dofs_per_line():   1
 DEAL::  n_dofs_per_quad():   0 0 0 0 
@@ -35,7 +35,7 @@ DEAL::  n_dofs_per_face():   6 6 6 6
 DEAL::  n_dofs_per_cell():   10
 DEAL::  tensor_degree():     2
 DEAL::
-DEAL::FE_DGP<2>(1): 
+DEAL::FE_SimplexDGP<2>(1): 
 DEAL::  n_dofs_per_vertex(): 0
 DEAL::  n_dofs_per_line():   0
 DEAL::  n_dofs_per_quad():   3 
@@ -44,7 +44,7 @@ DEAL::  n_dofs_per_face():   0 0 0
 DEAL::  n_dofs_per_cell():   3
 DEAL::  tensor_degree():     1
 DEAL::
-DEAL::FE_DGP<2>(2): 
+DEAL::FE_SimplexDGP<2>(2): 
 DEAL::  n_dofs_per_vertex(): 0
 DEAL::  n_dofs_per_line():   0
 DEAL::  n_dofs_per_quad():   6 
@@ -53,7 +53,7 @@ DEAL::  n_dofs_per_face():   0 0 0
 DEAL::  n_dofs_per_cell():   6
 DEAL::  tensor_degree():     2
 DEAL::
-DEAL::FE_DGP<3>(1): 
+DEAL::FE_SimplexDGP<3>(1): 
 DEAL::  n_dofs_per_vertex(): 0
 DEAL::  n_dofs_per_line():   0
 DEAL::  n_dofs_per_quad():   0 0 0 0 
@@ -62,7 +62,7 @@ DEAL::  n_dofs_per_face():   0 0 0 0
 DEAL::  n_dofs_per_cell():   4
 DEAL::  tensor_degree():     1
 DEAL::
-DEAL::FE_DGP<3>(2): 
+DEAL::FE_SimplexDGP<3>(2): 
 DEAL::  n_dofs_per_vertex(): 0
 DEAL::  n_dofs_per_line():   0
 DEAL::  n_dofs_per_quad():   0 0 0 0 
diff --git a/tests/simplex/fe_lib_02.cc b/tests/simplex/fe_lib_02.cc
index bb96eef5f3..a4cda1f0f8 100644
--- a/tests/simplex/fe_lib_02.cc
+++ b/tests/simplex/fe_lib_02.cc
@@ -14,7 +14,7 @@
 // ---------------------------------------------------------------------
 
 
-// Evaluate Simplex::FE_P  and Simplex::FE_DGP at quadrature points.
+// Evaluate FE_SimplexP  and FE_SimplexDGP at quadrature points.
 
 
 #include <deal.II/base/quadrature_lib.h>
@@ -55,12 +55,12 @@ main()
 {
   initlog();
 
-  test(Simplex::FE_P<2>(1), Simplex::QGauss<2>(2));
-  test(Simplex::FE_P<2>(2), Simplex::QGauss<2>(3));
-  test(Simplex::FE_P<3>(1), Simplex::QGauss<3>(2));
-  test(Simplex::FE_P<3>(2), Simplex::QGauss<3>(3));
-  test(Simplex::FE_DGP<2>(1), Simplex::QGauss<2>(2));
-  test(Simplex::FE_DGP<2>(2), Simplex::QGauss<2>(3));
-  test(Simplex::FE_DGP<3>(1), Simplex::QGauss<3>(2));
-  test(Simplex::FE_DGP<3>(2), Simplex::QGauss<3>(3));
+  test(FE_SimplexP<2>(1), QGaussSimplex<2>(2));
+  test(FE_SimplexP<2>(2), QGaussSimplex<2>(3));
+  test(FE_SimplexP<3>(1), QGaussSimplex<3>(2));
+  test(FE_SimplexP<3>(2), QGaussSimplex<3>(3));
+  test(FE_SimplexDGP<2>(1), QGaussSimplex<2>(2));
+  test(FE_SimplexDGP<2>(2), QGaussSimplex<2>(3));
+  test(FE_SimplexDGP<3>(1), QGaussSimplex<3>(2));
+  test(FE_SimplexDGP<3>(2), QGaussSimplex<3>(3));
 }
diff --git a/tests/simplex/fe_lib_02.output b/tests/simplex/fe_lib_02.output
index 0d6e3ad17f..cceed5719b 100644
--- a/tests/simplex/fe_lib_02.output
+++ b/tests/simplex/fe_lib_02.output
@@ -1,105 +1,105 @@
 
-DEAL:FE_P<2>(1)::0.666667 0.166667 : 
-DEAL:FE_P<2>(1)::0.166667 0.666667 0.166667 -1.00000 -1.00000 1.00000 0.00000 0.00000 1.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 
-DEAL:FE_P<2>(1)::0.166667 0.666667 : 
-DEAL:FE_P<2>(1)::0.166667 0.166667 0.666667 -1.00000 -1.00000 1.00000 0.00000 0.00000 1.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 
-DEAL:FE_P<2>(1)::0.166667 0.166667 : 
-DEAL:FE_P<2>(1)::0.666667 0.166667 0.166667 -1.00000 -1.00000 1.00000 0.00000 0.00000 1.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 
-DEAL:FE_P<2>(1)::
-DEAL:FE_P<2>(2)::0.333333 0.333333 : 
-DEAL:FE_P<2>(2)::-0.111111 -0.111111 -0.111111 0.444444 0.444444 0.444444 -0.333333 -0.333333 0.333333 0.00000 0.00000 0.333333 3.99969e-12 -1.33333 1.33333 1.33333 -1.33333 3.99991e-12 4.00000 4.00000 4.00000 4.00000 4.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 4.00000 -8.00000 -4.00000 -4.00000 0.00000 0.00000 4.00000 4.00000 0.00000 0.00000 -4.00000 -4.00000 -8.00000 
-DEAL:FE_P<2>(2)::0.797427 0.101287 : 
-DEAL:FE_P<2>(2)::-0.0807686 0.474353 -0.0807686 0.323074 0.323074 0.0410358 0.594854 0.594854 2.18971 0.00000 0.00000 -0.594854 -2.78456 -3.18971 0.405146 3.18971 -0.405146 3.99980e-12 4.00000 4.00000 4.00000 4.00000 4.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 4.00000 -8.00000 -4.00000 -4.00000 0.00000 0.00000 4.00000 4.00000 0.00000 0.00000 -4.00000 -4.00000 -8.00000 
-DEAL:FE_P<2>(2)::0.101287 0.797427 : 
-DEAL:FE_P<2>(2)::-0.0807686 -0.0807686 0.474353 0.0410358 0.323074 0.323074 0.594854 0.594854 -0.594854 0.00000 0.00000 2.18971 3.99991e-12 -0.405146 3.18971 0.405146 -3.18971 -2.78456 4.00000 4.00000 4.00000 4.00000 4.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 4.00000 -8.00000 -4.00000 -4.00000 0.00000 0.00000 4.00000 4.00000 0.00000 0.00000 -4.00000 -4.00000 -8.00000 
-DEAL:FE_P<2>(2)::0.101287 0.101287 : 
-DEAL:FE_P<2>(2)::0.474353 -0.0807686 -0.0807686 0.323074 0.0410358 0.323074 -2.18971 -2.18971 -0.594854 0.00000 0.00000 -0.594854 2.78456 -0.405146 0.405146 0.405146 -0.405146 2.78456 4.00000 4.00000 4.00000 4.00000 4.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 4.00000 -8.00000 -4.00000 -4.00000 0.00000 0.00000 4.00000 4.00000 0.00000 0.00000 -4.00000 -4.00000 -8.00000 
-DEAL:FE_P<2>(2)::0.0597159 0.470142 : 
-DEAL:FE_P<2>(2)::-0.0280749 -0.0525839 -0.0280749 0.112300 0.112300 0.884134 -0.880568 -0.880568 -0.761137 0.00000 0.00000 0.880568 1.64170 -0.238863 1.88057 0.238863 -1.88057 8.00249e-13 4.00000 4.00000 4.00000 4.00000 4.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 4.00000 -8.00000 -4.00000 -4.00000 0.00000 0.00000 4.00000 4.00000 0.00000 0.00000 -4.00000 -4.00000 -8.00000 
-DEAL:FE_P<2>(2)::0.470142 0.0597159 : 
-DEAL:FE_P<2>(2)::-0.0280749 -0.0280749 -0.0525839 0.884134 0.112300 0.112300 -0.880568 -0.880568 0.880568 0.00000 0.00000 -0.761137 8.00165e-13 -1.88057 0.238863 1.88057 -0.238863 1.64170 4.00000 4.00000 4.00000 4.00000 4.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 4.00000 -8.00000 -4.00000 -4.00000 0.00000 0.00000 4.00000 4.00000 0.00000 0.00000 -4.00000 -4.00000 -8.00000 
-DEAL:FE_P<2>(2)::0.470142 0.470142 : 
-DEAL:FE_P<2>(2)::-0.0525839 -0.0280749 -0.0280749 0.112300 0.884134 0.112300 0.761137 0.761137 0.880568 0.00000 0.00000 0.880568 -1.64170 -1.88057 1.88057 1.88057 -1.88057 -1.64170 4.00000 4.00000 4.00000 4.00000 4.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 4.00000 -8.00000 -4.00000 -4.00000 0.00000 0.00000 4.00000 4.00000 0.00000 0.00000 -4.00000 -4.00000 -8.00000 
-DEAL:FE_P<2>(2)::
-DEAL:FE_P<3>(1)::0.138197 0.138197 0.138197 : 
-DEAL:FE_P<3>(1)::0.585410 0.138197 0.138197 0.138197 -1.00000 -1.00000 -1.00000 1.00000 0.00000 0.00000 0.00000 1.00000 0.00000 0.00000 0.00000 1.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 
-DEAL:FE_P<3>(1)::0.585410 0.138197 0.138197 : 
-DEAL:FE_P<3>(1)::0.138197 0.585410 0.138197 0.138197 -1.00000 -1.00000 -1.00000 1.00000 0.00000 0.00000 0.00000 1.00000 0.00000 0.00000 0.00000 1.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 
-DEAL:FE_P<3>(1)::0.138197 0.585410 0.138197 : 
-DEAL:FE_P<3>(1)::0.138197 0.138197 0.585410 0.138197 -1.00000 -1.00000 -1.00000 1.00000 0.00000 0.00000 0.00000 1.00000 0.00000 0.00000 0.00000 1.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 
-DEAL:FE_P<3>(1)::0.138197 0.138197 0.585410 : 
-DEAL:FE_P<3>(1)::0.138197 0.138197 0.138197 0.585410 -1.00000 -1.00000 -1.00000 1.00000 0.00000 0.00000 0.00000 1.00000 0.00000 0.00000 0.00000 1.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 
-DEAL:FE_P<3>(1)::
-DEAL:FE_P<3>(2)::0.568431 0.143856 0.143856 : 
-DEAL:FE_P<3>(2)::-0.102467 0.0777961 -0.102467 -0.102467 0.327090 0.327090 0.0827787 0.0827787 0.327090 0.0827787 0.424574 0.424574 0.424574 1.27372 0.00000 0.00000 0.00000 -0.424574 0.00000 0.00000 0.00000 -0.424574 -1.69830 -2.27372 -2.27372 0.575426 2.27372 0.00000 -0.575426 -2.22045e-16 -0.575426 -0.575426 -0.575426 -2.22045e-16 0.575426 0.00000 2.27372 0.00000 0.575426 0.575426 4.00000 4.00000 4.00000 4.00000 4.00000 4.00000 4.00000 4.00000 4.00000 4.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 4.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 4.00000 -8.00000 -4.00000 -4.00000 -4.00000 0.00000 0.00000 -4.00000 0.00000 0.00000 0.00000 4.00000 0.00000 4.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 -4.00000 0.00000 -4.00000 -8.00000 -4.00000 0.00000 -4.00000 0.00000 0.00000 0.00000 -4.00000 0.00000 0.00000 -4.00000 -4.00000 -4.00000 -8.00000 0.00000 0.00000 4.00000 0.00000 0.00000 0.00000 4.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 4.00000 0.00000 4.00000 0.00000 
-DEAL:FE_P<3>(2)::0.143856 0.143856 0.143856 : 
-DEAL:FE_P<3>(2)::0.0777961 -0.102467 -0.102467 -0.102467 0.327090 0.0827787 0.327090 0.327090 0.0827787 0.0827787 -1.27372 -1.27372 -1.27372 -0.424574 0.00000 0.00000 0.00000 -0.424574 0.00000 0.00000 0.00000 -0.424574 1.69830 -0.575426 -0.575426 0.575426 0.575426 0.00000 -0.575426 1.69830 -0.575426 -0.575426 -0.575426 1.69830 0.575426 0.00000 0.575426 0.00000 0.575426 0.575426 4.00000 4.00000 4.00000 4.00000 4.00000 4.00000 4.00000 4.00000 4.00000 4.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 4.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 4.00000 -8.00000 -4.00000 -4.00000 -4.00000 0.00000 0.00000 -4.00000 0.00000 0.00000 0.00000 4.00000 0.00000 4.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 -4.00000 0.00000 -4.00000 -8.00000 -4.00000 0.00000 -4.00000 0.00000 0.00000 0.00000 -4.00000 0.00000 0.00000 -4.00000 -4.00000 -4.00000 -8.00000 0.00000 0.00000 4.00000 0.00000 0.00000 0.00000 4.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 4.00000 0.00000 4.00000 0.00000 
-DEAL:FE_P<3>(2)::0.143856 0.143856 0.568431 : 
-DEAL:FE_P<3>(2)::-0.102467 -0.102467 -0.102467 0.0777961 0.0827787 0.0827787 0.0827787 0.327090 0.327090 0.327090 0.424574 0.424574 0.424574 -0.424574 0.00000 0.00000 0.00000 -0.424574 0.00000 0.00000 0.00000 1.27372 -3.33067e-16 -0.575426 -0.575426 0.575426 0.575426 0.00000 -0.575426 -3.33067e-16 -0.575426 -2.27372 -2.27372 -1.69830 2.27372 0.00000 0.575426 0.00000 2.27372 0.575426 4.00000 4.00000 4.00000 4.00000 4.00000 4.00000 4.00000 4.00000 4.00000 4.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 4.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 4.00000 -8.00000 -4.00000 -4.00000 -4.00000 0.00000 0.00000 -4.00000 0.00000 0.00000 0.00000 4.00000 0.00000 4.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 -4.00000 0.00000 -4.00000 -8.00000 -4.00000 0.00000 -4.00000 0.00000 0.00000 0.00000 -4.00000 0.00000 0.00000 -4.00000 -4.00000 -4.00000 -8.00000 0.00000 0.00000 4.00000 0.00000 0.00000 0.00000 4.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 4.00000 0.00000 4.00000 0.00000 
-DEAL:FE_P<3>(2)::0.143856 0.568431 0.143856 : 
-DEAL:FE_P<3>(2)::-0.102467 -0.102467 0.0777961 -0.102467 0.0827787 0.327090 0.327090 0.0827787 0.0827787 0.327090 0.424574 0.424574 0.424574 -0.424574 0.00000 0.00000 0.00000 1.27372 0.00000 0.00000 0.00000 -0.424574 -2.22045e-16 -0.575426 -0.575426 2.27372 0.575426 0.00000 -2.27372 -1.69830 -2.27372 -0.575426 -0.575426 -2.22045e-16 0.575426 0.00000 0.575426 0.00000 0.575426 2.27372 4.00000 4.00000 4.00000 4.00000 4.00000 4.00000 4.00000 4.00000 4.00000 4.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 4.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 4.00000 -8.00000 -4.00000 -4.00000 -4.00000 0.00000 0.00000 -4.00000 0.00000 0.00000 0.00000 4.00000 0.00000 4.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 -4.00000 0.00000 -4.00000 -8.00000 -4.00000 0.00000 -4.00000 0.00000 0.00000 0.00000 -4.00000 0.00000 0.00000 -4.00000 -4.00000 -4.00000 -8.00000 0.00000 0.00000 4.00000 0.00000 0.00000 0.00000 4.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 4.00000 0.00000 4.00000 0.00000 
-DEAL:FE_P<3>(2)::0.00000 0.500000 0.500000 : 
-DEAL:FE_P<3>(2)::0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 1.00000 1.00000 1.00000 1.00000 -1.00000 0.00000 0.00000 0.00000 1.00000 0.00000 0.00000 0.00000 1.00000 0.00000 0.00000 0.00000 2.00000 0.00000 0.00000 -2.00000 -2.00000 -2.00000 -2.00000 -2.00000 -2.00000 2.00000 0.00000 0.00000 0.00000 2.00000 2.00000 4.00000 4.00000 4.00000 4.00000 4.00000 4.00000 4.00000 4.00000 4.00000 4.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 4.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 4.00000 -8.00000 -4.00000 -4.00000 -4.00000 0.00000 0.00000 -4.00000 0.00000 0.00000 0.00000 4.00000 0.00000 4.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 -4.00000 0.00000 -4.00000 -8.00000 -4.00000 0.00000 -4.00000 0.00000 0.00000 0.00000 -4.00000 0.00000 0.00000 -4.00000 -4.00000 -4.00000 -8.00000 0.00000 0.00000 4.00000 0.00000 0.00000 0.00000 4.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 4.00000 0.00000 4.00000 0.00000 
-DEAL:FE_P<3>(2)::0.500000 0.00000 0.500000 : 
-DEAL:FE_P<3>(2)::0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 1.00000 0.00000 1.00000 1.00000 1.00000 1.00000 0.00000 0.00000 0.00000 -1.00000 0.00000 0.00000 0.00000 1.00000 -2.00000 -2.00000 -2.00000 0.00000 2.00000 0.00000 0.00000 0.00000 0.00000 -2.00000 -2.00000 -2.00000 2.00000 0.00000 2.00000 0.00000 2.00000 0.00000 4.00000 4.00000 4.00000 4.00000 4.00000 4.00000 4.00000 4.00000 4.00000 4.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 4.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 4.00000 -8.00000 -4.00000 -4.00000 -4.00000 0.00000 0.00000 -4.00000 0.00000 0.00000 0.00000 4.00000 0.00000 4.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 -4.00000 0.00000 -4.00000 -8.00000 -4.00000 0.00000 -4.00000 0.00000 0.00000 0.00000 -4.00000 0.00000 0.00000 -4.00000 -4.00000 -4.00000 -8.00000 0.00000 0.00000 4.00000 0.00000 0.00000 0.00000 4.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 4.00000 0.00000 4.00000 0.00000 
-DEAL:FE_P<3>(2)::0.500000 0.500000 0.00000 : 
-DEAL:FE_P<3>(2)::0.00000 0.00000 0.00000 0.00000 0.00000 1.00000 0.00000 0.00000 0.00000 0.00000 1.00000 1.00000 1.00000 1.00000 0.00000 0.00000 0.00000 1.00000 0.00000 0.00000 0.00000 -1.00000 -2.00000 -2.00000 -2.00000 2.00000 2.00000 0.00000 -2.00000 -2.00000 -2.00000 0.00000 0.00000 0.00000 0.00000 0.00000 2.00000 0.00000 0.00000 2.00000 4.00000 4.00000 4.00000 4.00000 4.00000 4.00000 4.00000 4.00000 4.00000 4.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 4.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 4.00000 -8.00000 -4.00000 -4.00000 -4.00000 0.00000 0.00000 -4.00000 0.00000 0.00000 0.00000 4.00000 0.00000 4.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 -4.00000 0.00000 -4.00000 -8.00000 -4.00000 0.00000 -4.00000 0.00000 0.00000 0.00000 -4.00000 0.00000 0.00000 -4.00000 -4.00000 -4.00000 -8.00000 0.00000 0.00000 4.00000 0.00000 0.00000 0.00000 4.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 4.00000 0.00000 4.00000 0.00000 
-DEAL:FE_P<3>(2)::0.500000 0.00000 0.00000 : 
-DEAL:FE_P<3>(2)::0.00000 0.00000 0.00000 0.00000 1.00000 0.00000 0.00000 0.00000 0.00000 0.00000 -1.00000 -1.00000 -1.00000 1.00000 0.00000 0.00000 0.00000 -1.00000 0.00000 0.00000 0.00000 -1.00000 0.00000 -2.00000 -2.00000 0.00000 2.00000 0.00000 0.00000 2.00000 0.00000 0.00000 0.00000 2.00000 0.00000 0.00000 2.00000 0.00000 0.00000 0.00000 4.00000 4.00000 4.00000 4.00000 4.00000 4.00000 4.00000 4.00000 4.00000 4.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 4.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 4.00000 -8.00000 -4.00000 -4.00000 -4.00000 0.00000 0.00000 -4.00000 0.00000 0.00000 0.00000 4.00000 0.00000 4.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 -4.00000 0.00000 -4.00000 -8.00000 -4.00000 0.00000 -4.00000 0.00000 0.00000 0.00000 -4.00000 0.00000 0.00000 -4.00000 -4.00000 -4.00000 -8.00000 0.00000 0.00000 4.00000 0.00000 0.00000 0.00000 4.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 4.00000 0.00000 4.00000 0.00000 
-DEAL:FE_P<3>(2)::0.00000 0.500000 0.00000 : 
-DEAL:FE_P<3>(2)::0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 1.00000 0.00000 0.00000 0.00000 -1.00000 -1.00000 -1.00000 -1.00000 0.00000 0.00000 0.00000 1.00000 0.00000 0.00000 0.00000 -1.00000 2.00000 0.00000 0.00000 2.00000 0.00000 0.00000 -2.00000 0.00000 -2.00000 0.00000 0.00000 2.00000 0.00000 0.00000 0.00000 0.00000 0.00000 2.00000 4.00000 4.00000 4.00000 4.00000 4.00000 4.00000 4.00000 4.00000 4.00000 4.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 4.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 4.00000 -8.00000 -4.00000 -4.00000 -4.00000 0.00000 0.00000 -4.00000 0.00000 0.00000 0.00000 4.00000 0.00000 4.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 -4.00000 0.00000 -4.00000 -8.00000 -4.00000 0.00000 -4.00000 0.00000 0.00000 0.00000 -4.00000 0.00000 0.00000 -4.00000 -4.00000 -4.00000 -8.00000 0.00000 0.00000 4.00000 0.00000 0.00000 0.00000 4.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 4.00000 0.00000 4.00000 0.00000 
-DEAL:FE_P<3>(2)::0.00000 0.00000 0.500000 : 
-DEAL:FE_P<3>(2)::0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 1.00000 0.00000 0.00000 -1.00000 -1.00000 -1.00000 -1.00000 0.00000 0.00000 0.00000 -1.00000 0.00000 0.00000 0.00000 1.00000 2.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 2.00000 0.00000 -2.00000 -2.00000 0.00000 2.00000 0.00000 0.00000 0.00000 2.00000 0.00000 4.00000 4.00000 4.00000 4.00000 4.00000 4.00000 4.00000 4.00000 4.00000 4.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 4.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 4.00000 -8.00000 -4.00000 -4.00000 -4.00000 0.00000 0.00000 -4.00000 0.00000 0.00000 0.00000 4.00000 0.00000 4.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 -4.00000 0.00000 -4.00000 -8.00000 -4.00000 0.00000 -4.00000 0.00000 0.00000 0.00000 -4.00000 0.00000 0.00000 -4.00000 -4.00000 -4.00000 -8.00000 0.00000 0.00000 4.00000 0.00000 0.00000 0.00000 4.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 4.00000 0.00000 4.00000 0.00000 
-DEAL:FE_P<3>(2)::
-DEAL:FE_DGP<2>(1)::0.666667 0.166667 : 
-DEAL:FE_DGP<2>(1)::0.166667 0.666667 0.166667 -1.00000 -1.00000 1.00000 0.00000 0.00000 1.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 
-DEAL:FE_DGP<2>(1)::0.166667 0.666667 : 
-DEAL:FE_DGP<2>(1)::0.166667 0.166667 0.666667 -1.00000 -1.00000 1.00000 0.00000 0.00000 1.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 
-DEAL:FE_DGP<2>(1)::0.166667 0.166667 : 
-DEAL:FE_DGP<2>(1)::0.666667 0.166667 0.166667 -1.00000 -1.00000 1.00000 0.00000 0.00000 1.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 
-DEAL:FE_DGP<2>(1)::
-DEAL:FE_DGP<2>(2)::0.333333 0.333333 : 
-DEAL:FE_DGP<2>(2)::-0.111111 -0.111111 -0.111111 0.444444 0.444444 0.444444 -0.333333 -0.333333 0.333333 0.00000 0.00000 0.333333 3.99969e-12 -1.33333 1.33333 1.33333 -1.33333 3.99991e-12 4.00000 4.00000 4.00000 4.00000 4.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 4.00000 -8.00000 -4.00000 -4.00000 0.00000 0.00000 4.00000 4.00000 0.00000 0.00000 -4.00000 -4.00000 -8.00000 
-DEAL:FE_DGP<2>(2)::0.797427 0.101287 : 
-DEAL:FE_DGP<2>(2)::-0.0807686 0.474353 -0.0807686 0.323074 0.323074 0.0410358 0.594854 0.594854 2.18971 0.00000 0.00000 -0.594854 -2.78456 -3.18971 0.405146 3.18971 -0.405146 3.99980e-12 4.00000 4.00000 4.00000 4.00000 4.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 4.00000 -8.00000 -4.00000 -4.00000 0.00000 0.00000 4.00000 4.00000 0.00000 0.00000 -4.00000 -4.00000 -8.00000 
-DEAL:FE_DGP<2>(2)::0.101287 0.797427 : 
-DEAL:FE_DGP<2>(2)::-0.0807686 -0.0807686 0.474353 0.0410358 0.323074 0.323074 0.594854 0.594854 -0.594854 0.00000 0.00000 2.18971 3.99991e-12 -0.405146 3.18971 0.405146 -3.18971 -2.78456 4.00000 4.00000 4.00000 4.00000 4.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 4.00000 -8.00000 -4.00000 -4.00000 0.00000 0.00000 4.00000 4.00000 0.00000 0.00000 -4.00000 -4.00000 -8.00000 
-DEAL:FE_DGP<2>(2)::0.101287 0.101287 : 
-DEAL:FE_DGP<2>(2)::0.474353 -0.0807686 -0.0807686 0.323074 0.0410358 0.323074 -2.18971 -2.18971 -0.594854 0.00000 0.00000 -0.594854 2.78456 -0.405146 0.405146 0.405146 -0.405146 2.78456 4.00000 4.00000 4.00000 4.00000 4.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 4.00000 -8.00000 -4.00000 -4.00000 0.00000 0.00000 4.00000 4.00000 0.00000 0.00000 -4.00000 -4.00000 -8.00000 
-DEAL:FE_DGP<2>(2)::0.0597159 0.470142 : 
-DEAL:FE_DGP<2>(2)::-0.0280749 -0.0525839 -0.0280749 0.112300 0.112300 0.884134 -0.880568 -0.880568 -0.761137 0.00000 0.00000 0.880568 1.64170 -0.238863 1.88057 0.238863 -1.88057 8.00249e-13 4.00000 4.00000 4.00000 4.00000 4.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 4.00000 -8.00000 -4.00000 -4.00000 0.00000 0.00000 4.00000 4.00000 0.00000 0.00000 -4.00000 -4.00000 -8.00000 
-DEAL:FE_DGP<2>(2)::0.470142 0.0597159 : 
-DEAL:FE_DGP<2>(2)::-0.0280749 -0.0280749 -0.0525839 0.884134 0.112300 0.112300 -0.880568 -0.880568 0.880568 0.00000 0.00000 -0.761137 8.00165e-13 -1.88057 0.238863 1.88057 -0.238863 1.64170 4.00000 4.00000 4.00000 4.00000 4.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 4.00000 -8.00000 -4.00000 -4.00000 0.00000 0.00000 4.00000 4.00000 0.00000 0.00000 -4.00000 -4.00000 -8.00000 
-DEAL:FE_DGP<2>(2)::0.470142 0.470142 : 
-DEAL:FE_DGP<2>(2)::-0.0525839 -0.0280749 -0.0280749 0.112300 0.884134 0.112300 0.761137 0.761137 0.880568 0.00000 0.00000 0.880568 -1.64170 -1.88057 1.88057 1.88057 -1.88057 -1.64170 4.00000 4.00000 4.00000 4.00000 4.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 4.00000 -8.00000 -4.00000 -4.00000 0.00000 0.00000 4.00000 4.00000 0.00000 0.00000 -4.00000 -4.00000 -8.00000 
-DEAL:FE_DGP<2>(2)::
-DEAL:FE_DGP<3>(1)::0.138197 0.138197 0.138197 : 
-DEAL:FE_DGP<3>(1)::0.585410 0.138197 0.138197 0.138197 -1.00000 -1.00000 -1.00000 1.00000 0.00000 0.00000 0.00000 1.00000 0.00000 0.00000 0.00000 1.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 
-DEAL:FE_DGP<3>(1)::0.585410 0.138197 0.138197 : 
-DEAL:FE_DGP<3>(1)::0.138197 0.585410 0.138197 0.138197 -1.00000 -1.00000 -1.00000 1.00000 0.00000 0.00000 0.00000 1.00000 0.00000 0.00000 0.00000 1.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 
-DEAL:FE_DGP<3>(1)::0.138197 0.585410 0.138197 : 
-DEAL:FE_DGP<3>(1)::0.138197 0.138197 0.585410 0.138197 -1.00000 -1.00000 -1.00000 1.00000 0.00000 0.00000 0.00000 1.00000 0.00000 0.00000 0.00000 1.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 
-DEAL:FE_DGP<3>(1)::0.138197 0.138197 0.585410 : 
-DEAL:FE_DGP<3>(1)::0.138197 0.138197 0.138197 0.585410 -1.00000 -1.00000 -1.00000 1.00000 0.00000 0.00000 0.00000 1.00000 0.00000 0.00000 0.00000 1.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 
-DEAL:FE_DGP<3>(1)::
-DEAL:FE_DGP<3>(2)::0.568431 0.143856 0.143856 : 
-DEAL:FE_DGP<3>(2)::-0.102467 0.0777961 -0.102467 -0.102467 0.327090 0.327090 0.0827787 0.0827787 0.327090 0.0827787 0.424574 0.424574 0.424574 1.27372 0.00000 0.00000 0.00000 -0.424574 0.00000 0.00000 0.00000 -0.424574 -1.69830 -2.27372 -2.27372 0.575426 2.27372 0.00000 -0.575426 -2.22045e-16 -0.575426 -0.575426 -0.575426 -2.22045e-16 0.575426 0.00000 2.27372 0.00000 0.575426 0.575426 4.00000 4.00000 4.00000 4.00000 4.00000 4.00000 4.00000 4.00000 4.00000 4.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 4.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 4.00000 -8.00000 -4.00000 -4.00000 -4.00000 0.00000 0.00000 -4.00000 0.00000 0.00000 0.00000 4.00000 0.00000 4.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 -4.00000 0.00000 -4.00000 -8.00000 -4.00000 0.00000 -4.00000 0.00000 0.00000 0.00000 -4.00000 0.00000 0.00000 -4.00000 -4.00000 -4.00000 -8.00000 0.00000 0.00000 4.00000 0.00000 0.00000 0.00000 4.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 4.00000 0.00000 4.00000 0.00000 
-DEAL:FE_DGP<3>(2)::0.143856 0.143856 0.143856 : 
-DEAL:FE_DGP<3>(2)::0.0777961 -0.102467 -0.102467 -0.102467 0.327090 0.0827787 0.327090 0.327090 0.0827787 0.0827787 -1.27372 -1.27372 -1.27372 -0.424574 0.00000 0.00000 0.00000 -0.424574 0.00000 0.00000 0.00000 -0.424574 1.69830 -0.575426 -0.575426 0.575426 0.575426 0.00000 -0.575426 1.69830 -0.575426 -0.575426 -0.575426 1.69830 0.575426 0.00000 0.575426 0.00000 0.575426 0.575426 4.00000 4.00000 4.00000 4.00000 4.00000 4.00000 4.00000 4.00000 4.00000 4.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 4.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 4.00000 -8.00000 -4.00000 -4.00000 -4.00000 0.00000 0.00000 -4.00000 0.00000 0.00000 0.00000 4.00000 0.00000 4.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 -4.00000 0.00000 -4.00000 -8.00000 -4.00000 0.00000 -4.00000 0.00000 0.00000 0.00000 -4.00000 0.00000 0.00000 -4.00000 -4.00000 -4.00000 -8.00000 0.00000 0.00000 4.00000 0.00000 0.00000 0.00000 4.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 4.00000 0.00000 4.00000 0.00000 
-DEAL:FE_DGP<3>(2)::0.143856 0.143856 0.568431 : 
-DEAL:FE_DGP<3>(2)::-0.102467 -0.102467 -0.102467 0.0777961 0.0827787 0.0827787 0.0827787 0.327090 0.327090 0.327090 0.424574 0.424574 0.424574 -0.424574 0.00000 0.00000 0.00000 -0.424574 0.00000 0.00000 0.00000 1.27372 -3.33067e-16 -0.575426 -0.575426 0.575426 0.575426 0.00000 -0.575426 -3.33067e-16 -0.575426 -2.27372 -2.27372 -1.69830 2.27372 0.00000 0.575426 0.00000 2.27372 0.575426 4.00000 4.00000 4.00000 4.00000 4.00000 4.00000 4.00000 4.00000 4.00000 4.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 4.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 4.00000 -8.00000 -4.00000 -4.00000 -4.00000 0.00000 0.00000 -4.00000 0.00000 0.00000 0.00000 4.00000 0.00000 4.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 -4.00000 0.00000 -4.00000 -8.00000 -4.00000 0.00000 -4.00000 0.00000 0.00000 0.00000 -4.00000 0.00000 0.00000 -4.00000 -4.00000 -4.00000 -8.00000 0.00000 0.00000 4.00000 0.00000 0.00000 0.00000 4.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 4.00000 0.00000 4.00000 0.00000 
-DEAL:FE_DGP<3>(2)::0.143856 0.568431 0.143856 : 
-DEAL:FE_DGP<3>(2)::-0.102467 -0.102467 0.0777961 -0.102467 0.0827787 0.327090 0.327090 0.0827787 0.0827787 0.327090 0.424574 0.424574 0.424574 -0.424574 0.00000 0.00000 0.00000 1.27372 0.00000 0.00000 0.00000 -0.424574 -2.22045e-16 -0.575426 -0.575426 2.27372 0.575426 0.00000 -2.27372 -1.69830 -2.27372 -0.575426 -0.575426 -2.22045e-16 0.575426 0.00000 0.575426 0.00000 0.575426 2.27372 4.00000 4.00000 4.00000 4.00000 4.00000 4.00000 4.00000 4.00000 4.00000 4.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 4.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 4.00000 -8.00000 -4.00000 -4.00000 -4.00000 0.00000 0.00000 -4.00000 0.00000 0.00000 0.00000 4.00000 0.00000 4.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 -4.00000 0.00000 -4.00000 -8.00000 -4.00000 0.00000 -4.00000 0.00000 0.00000 0.00000 -4.00000 0.00000 0.00000 -4.00000 -4.00000 -4.00000 -8.00000 0.00000 0.00000 4.00000 0.00000 0.00000 0.00000 4.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 4.00000 0.00000 4.00000 0.00000 
-DEAL:FE_DGP<3>(2)::0.00000 0.500000 0.500000 : 
-DEAL:FE_DGP<3>(2)::0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 1.00000 1.00000 1.00000 1.00000 -1.00000 0.00000 0.00000 0.00000 1.00000 0.00000 0.00000 0.00000 1.00000 0.00000 0.00000 0.00000 2.00000 0.00000 0.00000 -2.00000 -2.00000 -2.00000 -2.00000 -2.00000 -2.00000 2.00000 0.00000 0.00000 0.00000 2.00000 2.00000 4.00000 4.00000 4.00000 4.00000 4.00000 4.00000 4.00000 4.00000 4.00000 4.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 4.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 4.00000 -8.00000 -4.00000 -4.00000 -4.00000 0.00000 0.00000 -4.00000 0.00000 0.00000 0.00000 4.00000 0.00000 4.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 -4.00000 0.00000 -4.00000 -8.00000 -4.00000 0.00000 -4.00000 0.00000 0.00000 0.00000 -4.00000 0.00000 0.00000 -4.00000 -4.00000 -4.00000 -8.00000 0.00000 0.00000 4.00000 0.00000 0.00000 0.00000 4.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 4.00000 0.00000 4.00000 0.00000 
-DEAL:FE_DGP<3>(2)::0.500000 0.00000 0.500000 : 
-DEAL:FE_DGP<3>(2)::0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 1.00000 0.00000 1.00000 1.00000 1.00000 1.00000 0.00000 0.00000 0.00000 -1.00000 0.00000 0.00000 0.00000 1.00000 -2.00000 -2.00000 -2.00000 0.00000 2.00000 0.00000 0.00000 0.00000 0.00000 -2.00000 -2.00000 -2.00000 2.00000 0.00000 2.00000 0.00000 2.00000 0.00000 4.00000 4.00000 4.00000 4.00000 4.00000 4.00000 4.00000 4.00000 4.00000 4.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 4.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 4.00000 -8.00000 -4.00000 -4.00000 -4.00000 0.00000 0.00000 -4.00000 0.00000 0.00000 0.00000 4.00000 0.00000 4.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 -4.00000 0.00000 -4.00000 -8.00000 -4.00000 0.00000 -4.00000 0.00000 0.00000 0.00000 -4.00000 0.00000 0.00000 -4.00000 -4.00000 -4.00000 -8.00000 0.00000 0.00000 4.00000 0.00000 0.00000 0.00000 4.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 4.00000 0.00000 4.00000 0.00000 
-DEAL:FE_DGP<3>(2)::0.500000 0.500000 0.00000 : 
-DEAL:FE_DGP<3>(2)::0.00000 0.00000 0.00000 0.00000 0.00000 1.00000 0.00000 0.00000 0.00000 0.00000 1.00000 1.00000 1.00000 1.00000 0.00000 0.00000 0.00000 1.00000 0.00000 0.00000 0.00000 -1.00000 -2.00000 -2.00000 -2.00000 2.00000 2.00000 0.00000 -2.00000 -2.00000 -2.00000 0.00000 0.00000 0.00000 0.00000 0.00000 2.00000 0.00000 0.00000 2.00000 4.00000 4.00000 4.00000 4.00000 4.00000 4.00000 4.00000 4.00000 4.00000 4.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 4.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 4.00000 -8.00000 -4.00000 -4.00000 -4.00000 0.00000 0.00000 -4.00000 0.00000 0.00000 0.00000 4.00000 0.00000 4.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 -4.00000 0.00000 -4.00000 -8.00000 -4.00000 0.00000 -4.00000 0.00000 0.00000 0.00000 -4.00000 0.00000 0.00000 -4.00000 -4.00000 -4.00000 -8.00000 0.00000 0.00000 4.00000 0.00000 0.00000 0.00000 4.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 4.00000 0.00000 4.00000 0.00000 
-DEAL:FE_DGP<3>(2)::0.500000 0.00000 0.00000 : 
-DEAL:FE_DGP<3>(2)::0.00000 0.00000 0.00000 0.00000 1.00000 0.00000 0.00000 0.00000 0.00000 0.00000 -1.00000 -1.00000 -1.00000 1.00000 0.00000 0.00000 0.00000 -1.00000 0.00000 0.00000 0.00000 -1.00000 0.00000 -2.00000 -2.00000 0.00000 2.00000 0.00000 0.00000 2.00000 0.00000 0.00000 0.00000 2.00000 0.00000 0.00000 2.00000 0.00000 0.00000 0.00000 4.00000 4.00000 4.00000 4.00000 4.00000 4.00000 4.00000 4.00000 4.00000 4.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 4.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 4.00000 -8.00000 -4.00000 -4.00000 -4.00000 0.00000 0.00000 -4.00000 0.00000 0.00000 0.00000 4.00000 0.00000 4.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 -4.00000 0.00000 -4.00000 -8.00000 -4.00000 0.00000 -4.00000 0.00000 0.00000 0.00000 -4.00000 0.00000 0.00000 -4.00000 -4.00000 -4.00000 -8.00000 0.00000 0.00000 4.00000 0.00000 0.00000 0.00000 4.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 4.00000 0.00000 4.00000 0.00000 
-DEAL:FE_DGP<3>(2)::0.00000 0.500000 0.00000 : 
-DEAL:FE_DGP<3>(2)::0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 1.00000 0.00000 0.00000 0.00000 -1.00000 -1.00000 -1.00000 -1.00000 0.00000 0.00000 0.00000 1.00000 0.00000 0.00000 0.00000 -1.00000 2.00000 0.00000 0.00000 2.00000 0.00000 0.00000 -2.00000 0.00000 -2.00000 0.00000 0.00000 2.00000 0.00000 0.00000 0.00000 0.00000 0.00000 2.00000 4.00000 4.00000 4.00000 4.00000 4.00000 4.00000 4.00000 4.00000 4.00000 4.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 4.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 4.00000 -8.00000 -4.00000 -4.00000 -4.00000 0.00000 0.00000 -4.00000 0.00000 0.00000 0.00000 4.00000 0.00000 4.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 -4.00000 0.00000 -4.00000 -8.00000 -4.00000 0.00000 -4.00000 0.00000 0.00000 0.00000 -4.00000 0.00000 0.00000 -4.00000 -4.00000 -4.00000 -8.00000 0.00000 0.00000 4.00000 0.00000 0.00000 0.00000 4.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 4.00000 0.00000 4.00000 0.00000 
-DEAL:FE_DGP<3>(2)::0.00000 0.00000 0.500000 : 
-DEAL:FE_DGP<3>(2)::0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 1.00000 0.00000 0.00000 -1.00000 -1.00000 -1.00000 -1.00000 0.00000 0.00000 0.00000 -1.00000 0.00000 0.00000 0.00000 1.00000 2.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 2.00000 0.00000 -2.00000 -2.00000 0.00000 2.00000 0.00000 0.00000 0.00000 2.00000 0.00000 4.00000 4.00000 4.00000 4.00000 4.00000 4.00000 4.00000 4.00000 4.00000 4.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 4.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 4.00000 -8.00000 -4.00000 -4.00000 -4.00000 0.00000 0.00000 -4.00000 0.00000 0.00000 0.00000 4.00000 0.00000 4.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 -4.00000 0.00000 -4.00000 -8.00000 -4.00000 0.00000 -4.00000 0.00000 0.00000 0.00000 -4.00000 0.00000 0.00000 -4.00000 -4.00000 -4.00000 -8.00000 0.00000 0.00000 4.00000 0.00000 0.00000 0.00000 4.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 4.00000 0.00000 4.00000 0.00000 
-DEAL:FE_DGP<3>(2)::
+DEAL:FE_SimplexP<2>(1)::0.666667 0.166667 : 
+DEAL:FE_SimplexP<2>(1)::0.166667 0.666667 0.166667 -1.00000 -1.00000 1.00000 0.00000 0.00000 1.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 
+DEAL:FE_SimplexP<2>(1)::0.166667 0.666667 : 
+DEAL:FE_SimplexP<2>(1)::0.166667 0.166667 0.666667 -1.00000 -1.00000 1.00000 0.00000 0.00000 1.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 
+DEAL:FE_SimplexP<2>(1)::0.166667 0.166667 : 
+DEAL:FE_SimplexP<2>(1)::0.666667 0.166667 0.166667 -1.00000 -1.00000 1.00000 0.00000 0.00000 1.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 
+DEAL:FE_SimplexP<2>(1)::
+DEAL:FE_SimplexP<2>(2)::0.333333 0.333333 : 
+DEAL:FE_SimplexP<2>(2)::-0.111111 -0.111111 -0.111111 0.444444 0.444444 0.444444 -0.333333 -0.333333 0.333333 0.00000 0.00000 0.333333 3.99991e-12 -1.33333 1.33333 1.33333 -1.33333 3.99991e-12 4.00000 4.00000 4.00000 4.00000 4.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 4.00000 -8.00000 -4.00000 -4.00000 0.00000 0.00000 4.00000 4.00000 0.00000 0.00000 -4.00000 -4.00000 -8.00000 
+DEAL:FE_SimplexP<2>(2)::0.797427 0.101287 : 
+DEAL:FE_SimplexP<2>(2)::-0.0807686 0.474353 -0.0807686 0.323074 0.323074 0.0410358 0.594854 0.594854 2.18971 0.00000 0.00000 -0.594854 -2.78456 -3.18971 0.405146 3.18971 -0.405146 3.99980e-12 4.00000 4.00000 4.00000 4.00000 4.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 4.00000 -8.00000 -4.00000 -4.00000 0.00000 0.00000 4.00000 4.00000 0.00000 0.00000 -4.00000 -4.00000 -8.00000 
+DEAL:FE_SimplexP<2>(2)::0.101287 0.797427 : 
+DEAL:FE_SimplexP<2>(2)::-0.0807686 -0.0807686 0.474353 0.0410358 0.323074 0.323074 0.594854 0.594854 -0.594854 0.00000 0.00000 2.18971 3.99963e-12 -0.405146 3.18971 0.405146 -3.18971 -2.78456 4.00000 4.00000 4.00000 4.00000 4.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 4.00000 -8.00000 -4.00000 -4.00000 0.00000 0.00000 4.00000 4.00000 0.00000 0.00000 -4.00000 -4.00000 -8.00000 
+DEAL:FE_SimplexP<2>(2)::0.101287 0.101287 : 
+DEAL:FE_SimplexP<2>(2)::0.474353 -0.0807686 -0.0807686 0.323074 0.0410358 0.323074 -2.18971 -2.18971 -0.594854 0.00000 0.00000 -0.594854 2.78456 -0.405146 0.405146 0.405146 -0.405146 2.78456 4.00000 4.00000 4.00000 4.00000 4.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 4.00000 -8.00000 -4.00000 -4.00000 0.00000 0.00000 4.00000 4.00000 0.00000 0.00000 -4.00000 -4.00000 -8.00000 
+DEAL:FE_SimplexP<2>(2)::0.0597159 0.470142 : 
+DEAL:FE_SimplexP<2>(2)::-0.0280749 -0.0525839 -0.0280749 0.112300 0.112300 0.884134 -0.880568 -0.880568 -0.761137 0.00000 0.00000 0.880568 1.64170 -0.238863 1.88057 0.238863 -1.88057 8.00249e-13 4.00000 4.00000 4.00000 4.00000 4.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 4.00000 -8.00000 -4.00000 -4.00000 0.00000 0.00000 4.00000 4.00000 0.00000 0.00000 -4.00000 -4.00000 -8.00000 
+DEAL:FE_SimplexP<2>(2)::0.470142 0.0597159 : 
+DEAL:FE_SimplexP<2>(2)::-0.0280749 -0.0280749 -0.0525839 0.884134 0.112300 0.112300 -0.880568 -0.880568 0.880568 0.00000 0.00000 -0.761137 8.00027e-13 -1.88057 0.238863 1.88057 -0.238863 1.64170 4.00000 4.00000 4.00000 4.00000 4.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 4.00000 -8.00000 -4.00000 -4.00000 0.00000 0.00000 4.00000 4.00000 0.00000 0.00000 -4.00000 -4.00000 -8.00000 
+DEAL:FE_SimplexP<2>(2)::0.470142 0.470142 : 
+DEAL:FE_SimplexP<2>(2)::-0.0525839 -0.0280749 -0.0280749 0.112300 0.884134 0.112300 0.761137 0.761137 0.880568 0.00000 0.00000 0.880568 -1.64170 -1.88057 1.88057 1.88057 -1.88057 -1.64170 4.00000 4.00000 4.00000 4.00000 4.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 4.00000 -8.00000 -4.00000 -4.00000 0.00000 0.00000 4.00000 4.00000 0.00000 0.00000 -4.00000 -4.00000 -8.00000 
+DEAL:FE_SimplexP<2>(2)::
+DEAL:FE_SimplexP<3>(1)::0.138197 0.138197 0.138197 : 
+DEAL:FE_SimplexP<3>(1)::0.585410 0.138197 0.138197 0.138197 -1.00000 -1.00000 -1.00000 1.00000 0.00000 0.00000 0.00000 1.00000 0.00000 0.00000 0.00000 1.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 
+DEAL:FE_SimplexP<3>(1)::0.585410 0.138197 0.138197 : 
+DEAL:FE_SimplexP<3>(1)::0.138197 0.585410 0.138197 0.138197 -1.00000 -1.00000 -1.00000 1.00000 0.00000 0.00000 0.00000 1.00000 0.00000 0.00000 0.00000 1.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 
+DEAL:FE_SimplexP<3>(1)::0.138197 0.585410 0.138197 : 
+DEAL:FE_SimplexP<3>(1)::0.138197 0.138197 0.585410 0.138197 -1.00000 -1.00000 -1.00000 1.00000 0.00000 0.00000 0.00000 1.00000 0.00000 0.00000 0.00000 1.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 
+DEAL:FE_SimplexP<3>(1)::0.138197 0.138197 0.585410 : 
+DEAL:FE_SimplexP<3>(1)::0.138197 0.138197 0.138197 0.585410 -1.00000 -1.00000 -1.00000 1.00000 0.00000 0.00000 0.00000 1.00000 0.00000 0.00000 0.00000 1.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 
+DEAL:FE_SimplexP<3>(1)::
+DEAL:FE_SimplexP<3>(2)::0.568431 0.143856 0.143856 : 
+DEAL:FE_SimplexP<3>(2)::-0.102467 0.0777961 -0.102467 -0.102467 0.327090 0.327090 0.0827787 0.0827787 0.327090 0.0827787 0.424574 0.424574 0.424574 1.27372 0.00000 0.00000 0.00000 -0.424574 0.00000 0.00000 0.00000 -0.424574 -1.69830 -2.27372 -2.27372 0.575426 2.27372 0.00000 -0.575426 -2.22045e-16 -0.575426 -0.575426 -0.575426 -2.22045e-16 0.575426 0.00000 2.27372 0.00000 0.575426 0.575426 4.00000 4.00000 4.00000 4.00000 4.00000 4.00000 4.00000 4.00000 4.00000 4.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 4.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 4.00000 -8.00000 -4.00000 -4.00000 -4.00000 0.00000 0.00000 -4.00000 0.00000 0.00000 0.00000 4.00000 0.00000 4.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 -4.00000 0.00000 -4.00000 -8.00000 -4.00000 0.00000 -4.00000 0.00000 0.00000 0.00000 -4.00000 0.00000 0.00000 -4.00000 -4.00000 -4.00000 -8.00000 0.00000 0.00000 4.00000 0.00000 0.00000 0.00000 4.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 4.00000 0.00000 4.00000 0.00000 
+DEAL:FE_SimplexP<3>(2)::0.143856 0.143856 0.143856 : 
+DEAL:FE_SimplexP<3>(2)::0.0777961 -0.102467 -0.102467 -0.102467 0.327090 0.0827787 0.327090 0.327090 0.0827787 0.0827787 -1.27372 -1.27372 -1.27372 -0.424574 0.00000 0.00000 0.00000 -0.424574 0.00000 0.00000 0.00000 -0.424574 1.69830 -0.575426 -0.575426 0.575426 0.575426 0.00000 -0.575426 1.69830 -0.575426 -0.575426 -0.575426 1.69830 0.575426 0.00000 0.575426 0.00000 0.575426 0.575426 4.00000 4.00000 4.00000 4.00000 4.00000 4.00000 4.00000 4.00000 4.00000 4.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 4.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 4.00000 -8.00000 -4.00000 -4.00000 -4.00000 0.00000 0.00000 -4.00000 0.00000 0.00000 0.00000 4.00000 0.00000 4.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 -4.00000 0.00000 -4.00000 -8.00000 -4.00000 0.00000 -4.00000 0.00000 0.00000 0.00000 -4.00000 0.00000 0.00000 -4.00000 -4.00000 -4.00000 -8.00000 0.00000 0.00000 4.00000 0.00000 0.00000 0.00000 4.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 4.00000 0.00000 4.00000 0.00000 
+DEAL:FE_SimplexP<3>(2)::0.143856 0.143856 0.568431 : 
+DEAL:FE_SimplexP<3>(2)::-0.102467 -0.102467 -0.102467 0.0777961 0.0827787 0.0827787 0.0827787 0.327090 0.327090 0.327090 0.424574 0.424574 0.424574 -0.424574 0.00000 0.00000 0.00000 -0.424574 0.00000 0.00000 0.00000 1.27372 -3.33067e-16 -0.575426 -0.575426 0.575426 0.575426 0.00000 -0.575426 -3.33067e-16 -0.575426 -2.27372 -2.27372 -1.69830 2.27372 0.00000 0.575426 0.00000 2.27372 0.575426 4.00000 4.00000 4.00000 4.00000 4.00000 4.00000 4.00000 4.00000 4.00000 4.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 4.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 4.00000 -8.00000 -4.00000 -4.00000 -4.00000 0.00000 0.00000 -4.00000 0.00000 0.00000 0.00000 4.00000 0.00000 4.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 -4.00000 0.00000 -4.00000 -8.00000 -4.00000 0.00000 -4.00000 0.00000 0.00000 0.00000 -4.00000 0.00000 0.00000 -4.00000 -4.00000 -4.00000 -8.00000 0.00000 0.00000 4.00000 0.00000 0.00000 0.00000 4.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 4.00000 0.00000 4.00000 0.00000 
+DEAL:FE_SimplexP<3>(2)::0.143856 0.568431 0.143856 : 
+DEAL:FE_SimplexP<3>(2)::-0.102467 -0.102467 0.0777961 -0.102467 0.0827787 0.327090 0.327090 0.0827787 0.0827787 0.327090 0.424574 0.424574 0.424574 -0.424574 0.00000 0.00000 0.00000 1.27372 0.00000 0.00000 0.00000 -0.424574 -2.22045e-16 -0.575426 -0.575426 2.27372 0.575426 0.00000 -2.27372 -1.69830 -2.27372 -0.575426 -0.575426 -2.22045e-16 0.575426 0.00000 0.575426 0.00000 0.575426 2.27372 4.00000 4.00000 4.00000 4.00000 4.00000 4.00000 4.00000 4.00000 4.00000 4.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 4.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 4.00000 -8.00000 -4.00000 -4.00000 -4.00000 0.00000 0.00000 -4.00000 0.00000 0.00000 0.00000 4.00000 0.00000 4.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 -4.00000 0.00000 -4.00000 -8.00000 -4.00000 0.00000 -4.00000 0.00000 0.00000 0.00000 -4.00000 0.00000 0.00000 -4.00000 -4.00000 -4.00000 -8.00000 0.00000 0.00000 4.00000 0.00000 0.00000 0.00000 4.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 4.00000 0.00000 4.00000 0.00000 
+DEAL:FE_SimplexP<3>(2)::0.00000 0.500000 0.500000 : 
+DEAL:FE_SimplexP<3>(2)::0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 1.00000 1.00000 1.00000 1.00000 -1.00000 0.00000 0.00000 0.00000 1.00000 0.00000 0.00000 0.00000 1.00000 0.00000 0.00000 0.00000 2.00000 0.00000 0.00000 -2.00000 -2.00000 -2.00000 -2.00000 -2.00000 -2.00000 2.00000 0.00000 0.00000 0.00000 2.00000 2.00000 4.00000 4.00000 4.00000 4.00000 4.00000 4.00000 4.00000 4.00000 4.00000 4.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 4.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 4.00000 -8.00000 -4.00000 -4.00000 -4.00000 0.00000 0.00000 -4.00000 0.00000 0.00000 0.00000 4.00000 0.00000 4.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 -4.00000 0.00000 -4.00000 -8.00000 -4.00000 0.00000 -4.00000 0.00000 0.00000 0.00000 -4.00000 0.00000 0.00000 -4.00000 -4.00000 -4.00000 -8.00000 0.00000 0.00000 4.00000 0.00000 0.00000 0.00000 4.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 4.00000 0.00000 4.00000 0.00000 
+DEAL:FE_SimplexP<3>(2)::0.500000 0.00000 0.500000 : 
+DEAL:FE_SimplexP<3>(2)::0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 1.00000 0.00000 1.00000 1.00000 1.00000 1.00000 0.00000 0.00000 0.00000 -1.00000 0.00000 0.00000 0.00000 1.00000 -2.00000 -2.00000 -2.00000 0.00000 2.00000 0.00000 0.00000 0.00000 0.00000 -2.00000 -2.00000 -2.00000 2.00000 0.00000 2.00000 0.00000 2.00000 0.00000 4.00000 4.00000 4.00000 4.00000 4.00000 4.00000 4.00000 4.00000 4.00000 4.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 4.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 4.00000 -8.00000 -4.00000 -4.00000 -4.00000 0.00000 0.00000 -4.00000 0.00000 0.00000 0.00000 4.00000 0.00000 4.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 -4.00000 0.00000 -4.00000 -8.00000 -4.00000 0.00000 -4.00000 0.00000 0.00000 0.00000 -4.00000 0.00000 0.00000 -4.00000 -4.00000 -4.00000 -8.00000 0.00000 0.00000 4.00000 0.00000 0.00000 0.00000 4.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 4.00000 0.00000 4.00000 0.00000 
+DEAL:FE_SimplexP<3>(2)::0.500000 0.500000 0.00000 : 
+DEAL:FE_SimplexP<3>(2)::0.00000 0.00000 0.00000 0.00000 0.00000 1.00000 0.00000 0.00000 0.00000 0.00000 1.00000 1.00000 1.00000 1.00000 0.00000 0.00000 0.00000 1.00000 0.00000 0.00000 0.00000 -1.00000 -2.00000 -2.00000 -2.00000 2.00000 2.00000 0.00000 -2.00000 -2.00000 -2.00000 0.00000 0.00000 0.00000 0.00000 0.00000 2.00000 0.00000 0.00000 2.00000 4.00000 4.00000 4.00000 4.00000 4.00000 4.00000 4.00000 4.00000 4.00000 4.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 4.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 4.00000 -8.00000 -4.00000 -4.00000 -4.00000 0.00000 0.00000 -4.00000 0.00000 0.00000 0.00000 4.00000 0.00000 4.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 -4.00000 0.00000 -4.00000 -8.00000 -4.00000 0.00000 -4.00000 0.00000 0.00000 0.00000 -4.00000 0.00000 0.00000 -4.00000 -4.00000 -4.00000 -8.00000 0.00000 0.00000 4.00000 0.00000 0.00000 0.00000 4.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 4.00000 0.00000 4.00000 0.00000 
+DEAL:FE_SimplexP<3>(2)::0.500000 0.00000 0.00000 : 
+DEAL:FE_SimplexP<3>(2)::0.00000 0.00000 0.00000 0.00000 1.00000 0.00000 0.00000 0.00000 0.00000 0.00000 -1.00000 -1.00000 -1.00000 1.00000 0.00000 0.00000 0.00000 -1.00000 0.00000 0.00000 0.00000 -1.00000 0.00000 -2.00000 -2.00000 0.00000 2.00000 0.00000 0.00000 2.00000 0.00000 0.00000 0.00000 2.00000 0.00000 0.00000 2.00000 0.00000 0.00000 0.00000 4.00000 4.00000 4.00000 4.00000 4.00000 4.00000 4.00000 4.00000 4.00000 4.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 4.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 4.00000 -8.00000 -4.00000 -4.00000 -4.00000 0.00000 0.00000 -4.00000 0.00000 0.00000 0.00000 4.00000 0.00000 4.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 -4.00000 0.00000 -4.00000 -8.00000 -4.00000 0.00000 -4.00000 0.00000 0.00000 0.00000 -4.00000 0.00000 0.00000 -4.00000 -4.00000 -4.00000 -8.00000 0.00000 0.00000 4.00000 0.00000 0.00000 0.00000 4.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 4.00000 0.00000 4.00000 0.00000 
+DEAL:FE_SimplexP<3>(2)::0.00000 0.500000 0.00000 : 
+DEAL:FE_SimplexP<3>(2)::0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 1.00000 0.00000 0.00000 0.00000 -1.00000 -1.00000 -1.00000 -1.00000 0.00000 0.00000 0.00000 1.00000 0.00000 0.00000 0.00000 -1.00000 2.00000 0.00000 0.00000 2.00000 0.00000 0.00000 -2.00000 0.00000 -2.00000 0.00000 0.00000 2.00000 0.00000 0.00000 0.00000 0.00000 0.00000 2.00000 4.00000 4.00000 4.00000 4.00000 4.00000 4.00000 4.00000 4.00000 4.00000 4.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 4.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 4.00000 -8.00000 -4.00000 -4.00000 -4.00000 0.00000 0.00000 -4.00000 0.00000 0.00000 0.00000 4.00000 0.00000 4.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 -4.00000 0.00000 -4.00000 -8.00000 -4.00000 0.00000 -4.00000 0.00000 0.00000 0.00000 -4.00000 0.00000 0.00000 -4.00000 -4.00000 -4.00000 -8.00000 0.00000 0.00000 4.00000 0.00000 0.00000 0.00000 4.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 4.00000 0.00000 4.00000 0.00000 
+DEAL:FE_SimplexP<3>(2)::0.00000 0.00000 0.500000 : 
+DEAL:FE_SimplexP<3>(2)::0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 1.00000 0.00000 0.00000 -1.00000 -1.00000 -1.00000 -1.00000 0.00000 0.00000 0.00000 -1.00000 0.00000 0.00000 0.00000 1.00000 2.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 2.00000 0.00000 -2.00000 -2.00000 0.00000 2.00000 0.00000 0.00000 0.00000 2.00000 0.00000 4.00000 4.00000 4.00000 4.00000 4.00000 4.00000 4.00000 4.00000 4.00000 4.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 4.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 4.00000 -8.00000 -4.00000 -4.00000 -4.00000 0.00000 0.00000 -4.00000 0.00000 0.00000 0.00000 4.00000 0.00000 4.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 -4.00000 0.00000 -4.00000 -8.00000 -4.00000 0.00000 -4.00000 0.00000 0.00000 0.00000 -4.00000 0.00000 0.00000 -4.00000 -4.00000 -4.00000 -8.00000 0.00000 0.00000 4.00000 0.00000 0.00000 0.00000 4.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 4.00000 0.00000 4.00000 0.00000 
+DEAL:FE_SimplexP<3>(2)::
+DEAL:FE_SimplexDGP<2>(1)::0.666667 0.166667 : 
+DEAL:FE_SimplexDGP<2>(1)::0.166667 0.666667 0.166667 -1.00000 -1.00000 1.00000 0.00000 0.00000 1.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 
+DEAL:FE_SimplexDGP<2>(1)::0.166667 0.666667 : 
+DEAL:FE_SimplexDGP<2>(1)::0.166667 0.166667 0.666667 -1.00000 -1.00000 1.00000 0.00000 0.00000 1.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 
+DEAL:FE_SimplexDGP<2>(1)::0.166667 0.166667 : 
+DEAL:FE_SimplexDGP<2>(1)::0.666667 0.166667 0.166667 -1.00000 -1.00000 1.00000 0.00000 0.00000 1.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 
+DEAL:FE_SimplexDGP<2>(1)::
+DEAL:FE_SimplexDGP<2>(2)::0.333333 0.333333 : 
+DEAL:FE_SimplexDGP<2>(2)::-0.111111 -0.111111 -0.111111 0.444444 0.444444 0.444444 -0.333333 -0.333333 0.333333 0.00000 0.00000 0.333333 3.99991e-12 -1.33333 1.33333 1.33333 -1.33333 3.99991e-12 4.00000 4.00000 4.00000 4.00000 4.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 4.00000 -8.00000 -4.00000 -4.00000 0.00000 0.00000 4.00000 4.00000 0.00000 0.00000 -4.00000 -4.00000 -8.00000 
+DEAL:FE_SimplexDGP<2>(2)::0.797427 0.101287 : 
+DEAL:FE_SimplexDGP<2>(2)::-0.0807686 0.474353 -0.0807686 0.323074 0.323074 0.0410358 0.594854 0.594854 2.18971 0.00000 0.00000 -0.594854 -2.78456 -3.18971 0.405146 3.18971 -0.405146 3.99980e-12 4.00000 4.00000 4.00000 4.00000 4.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 4.00000 -8.00000 -4.00000 -4.00000 0.00000 0.00000 4.00000 4.00000 0.00000 0.00000 -4.00000 -4.00000 -8.00000 
+DEAL:FE_SimplexDGP<2>(2)::0.101287 0.797427 : 
+DEAL:FE_SimplexDGP<2>(2)::-0.0807686 -0.0807686 0.474353 0.0410358 0.323074 0.323074 0.594854 0.594854 -0.594854 0.00000 0.00000 2.18971 3.99963e-12 -0.405146 3.18971 0.405146 -3.18971 -2.78456 4.00000 4.00000 4.00000 4.00000 4.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 4.00000 -8.00000 -4.00000 -4.00000 0.00000 0.00000 4.00000 4.00000 0.00000 0.00000 -4.00000 -4.00000 -8.00000 
+DEAL:FE_SimplexDGP<2>(2)::0.101287 0.101287 : 
+DEAL:FE_SimplexDGP<2>(2)::0.474353 -0.0807686 -0.0807686 0.323074 0.0410358 0.323074 -2.18971 -2.18971 -0.594854 0.00000 0.00000 -0.594854 2.78456 -0.405146 0.405146 0.405146 -0.405146 2.78456 4.00000 4.00000 4.00000 4.00000 4.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 4.00000 -8.00000 -4.00000 -4.00000 0.00000 0.00000 4.00000 4.00000 0.00000 0.00000 -4.00000 -4.00000 -8.00000 
+DEAL:FE_SimplexDGP<2>(2)::0.0597159 0.470142 : 
+DEAL:FE_SimplexDGP<2>(2)::-0.0280749 -0.0525839 -0.0280749 0.112300 0.112300 0.884134 -0.880568 -0.880568 -0.761137 0.00000 0.00000 0.880568 1.64170 -0.238863 1.88057 0.238863 -1.88057 8.00249e-13 4.00000 4.00000 4.00000 4.00000 4.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 4.00000 -8.00000 -4.00000 -4.00000 0.00000 0.00000 4.00000 4.00000 0.00000 0.00000 -4.00000 -4.00000 -8.00000 
+DEAL:FE_SimplexDGP<2>(2)::0.470142 0.0597159 : 
+DEAL:FE_SimplexDGP<2>(2)::-0.0280749 -0.0280749 -0.0525839 0.884134 0.112300 0.112300 -0.880568 -0.880568 0.880568 0.00000 0.00000 -0.761137 8.00027e-13 -1.88057 0.238863 1.88057 -0.238863 1.64170 4.00000 4.00000 4.00000 4.00000 4.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 4.00000 -8.00000 -4.00000 -4.00000 0.00000 0.00000 4.00000 4.00000 0.00000 0.00000 -4.00000 -4.00000 -8.00000 
+DEAL:FE_SimplexDGP<2>(2)::0.470142 0.470142 : 
+DEAL:FE_SimplexDGP<2>(2)::-0.0525839 -0.0280749 -0.0280749 0.112300 0.884134 0.112300 0.761137 0.761137 0.880568 0.00000 0.00000 0.880568 -1.64170 -1.88057 1.88057 1.88057 -1.88057 -1.64170 4.00000 4.00000 4.00000 4.00000 4.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 4.00000 -8.00000 -4.00000 -4.00000 0.00000 0.00000 4.00000 4.00000 0.00000 0.00000 -4.00000 -4.00000 -8.00000 
+DEAL:FE_SimplexDGP<2>(2)::
+DEAL:FE_SimplexDGP<3>(1)::0.138197 0.138197 0.138197 : 
+DEAL:FE_SimplexDGP<3>(1)::0.585410 0.138197 0.138197 0.138197 -1.00000 -1.00000 -1.00000 1.00000 0.00000 0.00000 0.00000 1.00000 0.00000 0.00000 0.00000 1.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 
+DEAL:FE_SimplexDGP<3>(1)::0.585410 0.138197 0.138197 : 
+DEAL:FE_SimplexDGP<3>(1)::0.138197 0.585410 0.138197 0.138197 -1.00000 -1.00000 -1.00000 1.00000 0.00000 0.00000 0.00000 1.00000 0.00000 0.00000 0.00000 1.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 
+DEAL:FE_SimplexDGP<3>(1)::0.138197 0.585410 0.138197 : 
+DEAL:FE_SimplexDGP<3>(1)::0.138197 0.138197 0.585410 0.138197 -1.00000 -1.00000 -1.00000 1.00000 0.00000 0.00000 0.00000 1.00000 0.00000 0.00000 0.00000 1.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 
+DEAL:FE_SimplexDGP<3>(1)::0.138197 0.138197 0.585410 : 
+DEAL:FE_SimplexDGP<3>(1)::0.138197 0.138197 0.138197 0.585410 -1.00000 -1.00000 -1.00000 1.00000 0.00000 0.00000 0.00000 1.00000 0.00000 0.00000 0.00000 1.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 
+DEAL:FE_SimplexDGP<3>(1)::
+DEAL:FE_SimplexDGP<3>(2)::0.568431 0.143856 0.143856 : 
+DEAL:FE_SimplexDGP<3>(2)::-0.102467 0.0777961 -0.102467 -0.102467 0.327090 0.327090 0.0827787 0.0827787 0.327090 0.0827787 0.424574 0.424574 0.424574 1.27372 0.00000 0.00000 0.00000 -0.424574 0.00000 0.00000 0.00000 -0.424574 -1.69830 -2.27372 -2.27372 0.575426 2.27372 0.00000 -0.575426 -2.22045e-16 -0.575426 -0.575426 -0.575426 -2.22045e-16 0.575426 0.00000 2.27372 0.00000 0.575426 0.575426 4.00000 4.00000 4.00000 4.00000 4.00000 4.00000 4.00000 4.00000 4.00000 4.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 4.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 4.00000 -8.00000 -4.00000 -4.00000 -4.00000 0.00000 0.00000 -4.00000 0.00000 0.00000 0.00000 4.00000 0.00000 4.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 -4.00000 0.00000 -4.00000 -8.00000 -4.00000 0.00000 -4.00000 0.00000 0.00000 0.00000 -4.00000 0.00000 0.00000 -4.00000 -4.00000 -4.00000 -8.00000 0.00000 0.00000 4.00000 0.00000 0.00000 0.00000 4.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 4.00000 0.00000 4.00000 0.00000 
+DEAL:FE_SimplexDGP<3>(2)::0.143856 0.143856 0.143856 : 
+DEAL:FE_SimplexDGP<3>(2)::0.0777961 -0.102467 -0.102467 -0.102467 0.327090 0.0827787 0.327090 0.327090 0.0827787 0.0827787 -1.27372 -1.27372 -1.27372 -0.424574 0.00000 0.00000 0.00000 -0.424574 0.00000 0.00000 0.00000 -0.424574 1.69830 -0.575426 -0.575426 0.575426 0.575426 0.00000 -0.575426 1.69830 -0.575426 -0.575426 -0.575426 1.69830 0.575426 0.00000 0.575426 0.00000 0.575426 0.575426 4.00000 4.00000 4.00000 4.00000 4.00000 4.00000 4.00000 4.00000 4.00000 4.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 4.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 4.00000 -8.00000 -4.00000 -4.00000 -4.00000 0.00000 0.00000 -4.00000 0.00000 0.00000 0.00000 4.00000 0.00000 4.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 -4.00000 0.00000 -4.00000 -8.00000 -4.00000 0.00000 -4.00000 0.00000 0.00000 0.00000 -4.00000 0.00000 0.00000 -4.00000 -4.00000 -4.00000 -8.00000 0.00000 0.00000 4.00000 0.00000 0.00000 0.00000 4.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 4.00000 0.00000 4.00000 0.00000 
+DEAL:FE_SimplexDGP<3>(2)::0.143856 0.143856 0.568431 : 
+DEAL:FE_SimplexDGP<3>(2)::-0.102467 -0.102467 -0.102467 0.0777961 0.0827787 0.0827787 0.0827787 0.327090 0.327090 0.327090 0.424574 0.424574 0.424574 -0.424574 0.00000 0.00000 0.00000 -0.424574 0.00000 0.00000 0.00000 1.27372 -3.33067e-16 -0.575426 -0.575426 0.575426 0.575426 0.00000 -0.575426 -3.33067e-16 -0.575426 -2.27372 -2.27372 -1.69830 2.27372 0.00000 0.575426 0.00000 2.27372 0.575426 4.00000 4.00000 4.00000 4.00000 4.00000 4.00000 4.00000 4.00000 4.00000 4.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 4.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 4.00000 -8.00000 -4.00000 -4.00000 -4.00000 0.00000 0.00000 -4.00000 0.00000 0.00000 0.00000 4.00000 0.00000 4.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 -4.00000 0.00000 -4.00000 -8.00000 -4.00000 0.00000 -4.00000 0.00000 0.00000 0.00000 -4.00000 0.00000 0.00000 -4.00000 -4.00000 -4.00000 -8.00000 0.00000 0.00000 4.00000 0.00000 0.00000 0.00000 4.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 4.00000 0.00000 4.00000 0.00000 
+DEAL:FE_SimplexDGP<3>(2)::0.143856 0.568431 0.143856 : 
+DEAL:FE_SimplexDGP<3>(2)::-0.102467 -0.102467 0.0777961 -0.102467 0.0827787 0.327090 0.327090 0.0827787 0.0827787 0.327090 0.424574 0.424574 0.424574 -0.424574 0.00000 0.00000 0.00000 1.27372 0.00000 0.00000 0.00000 -0.424574 -2.22045e-16 -0.575426 -0.575426 2.27372 0.575426 0.00000 -2.27372 -1.69830 -2.27372 -0.575426 -0.575426 -2.22045e-16 0.575426 0.00000 0.575426 0.00000 0.575426 2.27372 4.00000 4.00000 4.00000 4.00000 4.00000 4.00000 4.00000 4.00000 4.00000 4.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 4.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 4.00000 -8.00000 -4.00000 -4.00000 -4.00000 0.00000 0.00000 -4.00000 0.00000 0.00000 0.00000 4.00000 0.00000 4.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 -4.00000 0.00000 -4.00000 -8.00000 -4.00000 0.00000 -4.00000 0.00000 0.00000 0.00000 -4.00000 0.00000 0.00000 -4.00000 -4.00000 -4.00000 -8.00000 0.00000 0.00000 4.00000 0.00000 0.00000 0.00000 4.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 4.00000 0.00000 4.00000 0.00000 
+DEAL:FE_SimplexDGP<3>(2)::0.00000 0.500000 0.500000 : 
+DEAL:FE_SimplexDGP<3>(2)::0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 1.00000 1.00000 1.00000 1.00000 -1.00000 0.00000 0.00000 0.00000 1.00000 0.00000 0.00000 0.00000 1.00000 0.00000 0.00000 0.00000 2.00000 0.00000 0.00000 -2.00000 -2.00000 -2.00000 -2.00000 -2.00000 -2.00000 2.00000 0.00000 0.00000 0.00000 2.00000 2.00000 4.00000 4.00000 4.00000 4.00000 4.00000 4.00000 4.00000 4.00000 4.00000 4.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 4.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 4.00000 -8.00000 -4.00000 -4.00000 -4.00000 0.00000 0.00000 -4.00000 0.00000 0.00000 0.00000 4.00000 0.00000 4.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 -4.00000 0.00000 -4.00000 -8.00000 -4.00000 0.00000 -4.00000 0.00000 0.00000 0.00000 -4.00000 0.00000 0.00000 -4.00000 -4.00000 -4.00000 -8.00000 0.00000 0.00000 4.00000 0.00000 0.00000 0.00000 4.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 4.00000 0.00000 4.00000 0.00000 
+DEAL:FE_SimplexDGP<3>(2)::0.500000 0.00000 0.500000 : 
+DEAL:FE_SimplexDGP<3>(2)::0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 1.00000 0.00000 1.00000 1.00000 1.00000 1.00000 0.00000 0.00000 0.00000 -1.00000 0.00000 0.00000 0.00000 1.00000 -2.00000 -2.00000 -2.00000 0.00000 2.00000 0.00000 0.00000 0.00000 0.00000 -2.00000 -2.00000 -2.00000 2.00000 0.00000 2.00000 0.00000 2.00000 0.00000 4.00000 4.00000 4.00000 4.00000 4.00000 4.00000 4.00000 4.00000 4.00000 4.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 4.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 4.00000 -8.00000 -4.00000 -4.00000 -4.00000 0.00000 0.00000 -4.00000 0.00000 0.00000 0.00000 4.00000 0.00000 4.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 -4.00000 0.00000 -4.00000 -8.00000 -4.00000 0.00000 -4.00000 0.00000 0.00000 0.00000 -4.00000 0.00000 0.00000 -4.00000 -4.00000 -4.00000 -8.00000 0.00000 0.00000 4.00000 0.00000 0.00000 0.00000 4.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 4.00000 0.00000 4.00000 0.00000 
+DEAL:FE_SimplexDGP<3>(2)::0.500000 0.500000 0.00000 : 
+DEAL:FE_SimplexDGP<3>(2)::0.00000 0.00000 0.00000 0.00000 0.00000 1.00000 0.00000 0.00000 0.00000 0.00000 1.00000 1.00000 1.00000 1.00000 0.00000 0.00000 0.00000 1.00000 0.00000 0.00000 0.00000 -1.00000 -2.00000 -2.00000 -2.00000 2.00000 2.00000 0.00000 -2.00000 -2.00000 -2.00000 0.00000 0.00000 0.00000 0.00000 0.00000 2.00000 0.00000 0.00000 2.00000 4.00000 4.00000 4.00000 4.00000 4.00000 4.00000 4.00000 4.00000 4.00000 4.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 4.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 4.00000 -8.00000 -4.00000 -4.00000 -4.00000 0.00000 0.00000 -4.00000 0.00000 0.00000 0.00000 4.00000 0.00000 4.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 -4.00000 0.00000 -4.00000 -8.00000 -4.00000 0.00000 -4.00000 0.00000 0.00000 0.00000 -4.00000 0.00000 0.00000 -4.00000 -4.00000 -4.00000 -8.00000 0.00000 0.00000 4.00000 0.00000 0.00000 0.00000 4.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 4.00000 0.00000 4.00000 0.00000 
+DEAL:FE_SimplexDGP<3>(2)::0.500000 0.00000 0.00000 : 
+DEAL:FE_SimplexDGP<3>(2)::0.00000 0.00000 0.00000 0.00000 1.00000 0.00000 0.00000 0.00000 0.00000 0.00000 -1.00000 -1.00000 -1.00000 1.00000 0.00000 0.00000 0.00000 -1.00000 0.00000 0.00000 0.00000 -1.00000 0.00000 -2.00000 -2.00000 0.00000 2.00000 0.00000 0.00000 2.00000 0.00000 0.00000 0.00000 2.00000 0.00000 0.00000 2.00000 0.00000 0.00000 0.00000 4.00000 4.00000 4.00000 4.00000 4.00000 4.00000 4.00000 4.00000 4.00000 4.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 4.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 4.00000 -8.00000 -4.00000 -4.00000 -4.00000 0.00000 0.00000 -4.00000 0.00000 0.00000 0.00000 4.00000 0.00000 4.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 -4.00000 0.00000 -4.00000 -8.00000 -4.00000 0.00000 -4.00000 0.00000 0.00000 0.00000 -4.00000 0.00000 0.00000 -4.00000 -4.00000 -4.00000 -8.00000 0.00000 0.00000 4.00000 0.00000 0.00000 0.00000 4.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 4.00000 0.00000 4.00000 0.00000 
+DEAL:FE_SimplexDGP<3>(2)::0.00000 0.500000 0.00000 : 
+DEAL:FE_SimplexDGP<3>(2)::0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 1.00000 0.00000 0.00000 0.00000 -1.00000 -1.00000 -1.00000 -1.00000 0.00000 0.00000 0.00000 1.00000 0.00000 0.00000 0.00000 -1.00000 2.00000 0.00000 0.00000 2.00000 0.00000 0.00000 -2.00000 0.00000 -2.00000 0.00000 0.00000 2.00000 0.00000 0.00000 0.00000 0.00000 0.00000 2.00000 4.00000 4.00000 4.00000 4.00000 4.00000 4.00000 4.00000 4.00000 4.00000 4.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 4.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 4.00000 -8.00000 -4.00000 -4.00000 -4.00000 0.00000 0.00000 -4.00000 0.00000 0.00000 0.00000 4.00000 0.00000 4.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 -4.00000 0.00000 -4.00000 -8.00000 -4.00000 0.00000 -4.00000 0.00000 0.00000 0.00000 -4.00000 0.00000 0.00000 -4.00000 -4.00000 -4.00000 -8.00000 0.00000 0.00000 4.00000 0.00000 0.00000 0.00000 4.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 4.00000 0.00000 4.00000 0.00000 
+DEAL:FE_SimplexDGP<3>(2)::0.00000 0.00000 0.500000 : 
+DEAL:FE_SimplexDGP<3>(2)::0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 1.00000 0.00000 0.00000 -1.00000 -1.00000 -1.00000 -1.00000 0.00000 0.00000 0.00000 -1.00000 0.00000 0.00000 0.00000 1.00000 2.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 2.00000 0.00000 -2.00000 -2.00000 0.00000 2.00000 0.00000 0.00000 0.00000 2.00000 0.00000 4.00000 4.00000 4.00000 4.00000 4.00000 4.00000 4.00000 4.00000 4.00000 4.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 4.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 4.00000 -8.00000 -4.00000 -4.00000 -4.00000 0.00000 0.00000 -4.00000 0.00000 0.00000 0.00000 4.00000 0.00000 4.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 -4.00000 0.00000 -4.00000 -8.00000 -4.00000 0.00000 -4.00000 0.00000 0.00000 0.00000 -4.00000 0.00000 0.00000 -4.00000 -4.00000 -4.00000 -8.00000 0.00000 0.00000 4.00000 0.00000 0.00000 0.00000 4.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 4.00000 0.00000 4.00000 0.00000 
+DEAL:FE_SimplexDGP<3>(2)::
diff --git a/tests/simplex/fe_p_bubbles_01.cc b/tests/simplex/fe_p_bubbles_01.cc
index c79de2e615..db2fb66e21 100644
--- a/tests/simplex/fe_p_bubbles_01.cc
+++ b/tests/simplex/fe_p_bubbles_01.cc
@@ -14,7 +14,7 @@
 // ---------------------------------------------------------------------
 
 
-// Evaluate Simplex::FE_P_Bubbles.
+// Evaluate FE_SimplexP_Bubbles.
 
 
 #include <deal.II/base/quadrature_lib.h>
@@ -61,7 +61,7 @@ test_unit_support_points()
   for (unsigned int degree = 0; degree < 3; ++degree)
     {
       deallog << "approximation degree = " << degree << std::endl;
-      Simplex::FE_P_Bubbles<dim, spacedim> fe(degree);
+      FE_SimplexP_Bubbles<dim, spacedim> fe(degree);
       deallog << "element tensor degree = " << fe.tensor_degree() << std::endl;
       Quadrature<dim> quad(fe.get_unit_support_points());
       test(fe, quad);
diff --git a/tests/simplex/fe_p_bubbles_01.with_simplex_support=on.out b/tests/simplex/fe_p_bubbles_01.with_simplex_support=on.out
deleted file mode 100644
index 858f6dd7ea..0000000000
--- a/tests/simplex/fe_p_bubbles_01.with_simplex_support=on.out
+++ /dev/null
@@ -1,181 +0,0 @@
-
-DEAL::Test support points for dim = 1 and spacedim = 1
-DEAL::approximation degree = 0
-DEAL::element tensor degree = 0
-DEAL:Simplex::FE_P_Bubbles<1>(0)::0.500000 : 
-DEAL:Simplex::FE_P_Bubbles<1>(0)::1.00000 0.00000 0.00000 
-DEAL:Simplex::FE_P_Bubbles<1>(0)::
-DEAL::approximation degree = 1
-DEAL::element tensor degree = 1
-DEAL:Simplex::FE_P_Bubbles<1>(1)::0.00000 : 
-DEAL:Simplex::FE_P_Bubbles<1>(1)::1.00000 0.00000 -1.00000 1.00000 0.00000 0.00000 
-DEAL:Simplex::FE_P_Bubbles<1>(1)::1.00000 : 
-DEAL:Simplex::FE_P_Bubbles<1>(1)::0.00000 1.00000 -1.00000 1.00000 0.00000 0.00000 
-DEAL:Simplex::FE_P_Bubbles<1>(1)::
-DEAL::approximation degree = 2
-DEAL::element tensor degree = 2
-DEAL:Simplex::FE_P_Bubbles<1>(2)::0.00000 : 
-DEAL:Simplex::FE_P_Bubbles<1>(2)::1.00000 0.00000 0.00000 -3.00000 -1.00000 4.00000 4.00000 4.00000 -8.00000 
-DEAL:Simplex::FE_P_Bubbles<1>(2)::1.00000 : 
-DEAL:Simplex::FE_P_Bubbles<1>(2)::0.00000 1.00000 0.00000 1.00000 3.00000 -4.00000 4.00000 4.00000 -8.00000 
-DEAL:Simplex::FE_P_Bubbles<1>(2)::0.500000 : 
-DEAL:Simplex::FE_P_Bubbles<1>(2)::0.00000 0.00000 1.00000 -1.00000 1.00000 0.00000 4.00000 4.00000 -8.00000 
-DEAL:Simplex::FE_P_Bubbles<1>(2)::
-DEAL::Test support points for dim = 1 and spacedim = 2
-DEAL::approximation degree = 0
-DEAL::element tensor degree = 0
-DEAL:Simplex::FE_P_Bubbles<1,2>(0)::0.500000 : 
-DEAL:Simplex::FE_P_Bubbles<1,2>(0)::1.00000 0.00000 0.00000 
-DEAL:Simplex::FE_P_Bubbles<1,2>(0)::
-DEAL::approximation degree = 1
-DEAL::element tensor degree = 1
-DEAL:Simplex::FE_P_Bubbles<1,2>(1)::0.00000 : 
-DEAL:Simplex::FE_P_Bubbles<1,2>(1)::1.00000 0.00000 -1.00000 1.00000 0.00000 0.00000 
-DEAL:Simplex::FE_P_Bubbles<1,2>(1)::1.00000 : 
-DEAL:Simplex::FE_P_Bubbles<1,2>(1)::0.00000 1.00000 -1.00000 1.00000 0.00000 0.00000 
-DEAL:Simplex::FE_P_Bubbles<1,2>(1)::
-DEAL::approximation degree = 2
-DEAL::element tensor degree = 2
-DEAL:Simplex::FE_P_Bubbles<1,2>(2)::0.00000 : 
-DEAL:Simplex::FE_P_Bubbles<1,2>(2)::1.00000 0.00000 0.00000 -3.00000 -1.00000 4.00000 4.00000 4.00000 -8.00000 
-DEAL:Simplex::FE_P_Bubbles<1,2>(2)::1.00000 : 
-DEAL:Simplex::FE_P_Bubbles<1,2>(2)::0.00000 1.00000 0.00000 1.00000 3.00000 -4.00000 4.00000 4.00000 -8.00000 
-DEAL:Simplex::FE_P_Bubbles<1,2>(2)::0.500000 : 
-DEAL:Simplex::FE_P_Bubbles<1,2>(2)::0.00000 0.00000 1.00000 -1.00000 1.00000 0.00000 4.00000 4.00000 -8.00000 
-DEAL:Simplex::FE_P_Bubbles<1,2>(2)::
-DEAL::Test support points for dim = 1 and spacedim = 3
-DEAL::approximation degree = 0
-DEAL::element tensor degree = 0
-DEAL:Simplex::FE_P_Bubbles<1,3>(0)::0.500000 : 
-DEAL:Simplex::FE_P_Bubbles<1,3>(0)::1.00000 0.00000 0.00000 
-DEAL:Simplex::FE_P_Bubbles<1,3>(0)::
-DEAL::approximation degree = 1
-DEAL::element tensor degree = 1
-DEAL:Simplex::FE_P_Bubbles<1,3>(1)::0.00000 : 
-DEAL:Simplex::FE_P_Bubbles<1,3>(1)::1.00000 0.00000 -1.00000 1.00000 0.00000 0.00000 
-DEAL:Simplex::FE_P_Bubbles<1,3>(1)::1.00000 : 
-DEAL:Simplex::FE_P_Bubbles<1,3>(1)::0.00000 1.00000 -1.00000 1.00000 0.00000 0.00000 
-DEAL:Simplex::FE_P_Bubbles<1,3>(1)::
-DEAL::approximation degree = 2
-DEAL::element tensor degree = 2
-DEAL:Simplex::FE_P_Bubbles<1,3>(2)::0.00000 : 
-DEAL:Simplex::FE_P_Bubbles<1,3>(2)::1.00000 0.00000 0.00000 -3.00000 -1.00000 4.00000 4.00000 4.00000 -8.00000 
-DEAL:Simplex::FE_P_Bubbles<1,3>(2)::1.00000 : 
-DEAL:Simplex::FE_P_Bubbles<1,3>(2)::0.00000 1.00000 0.00000 1.00000 3.00000 -4.00000 4.00000 4.00000 -8.00000 
-DEAL:Simplex::FE_P_Bubbles<1,3>(2)::0.500000 : 
-DEAL:Simplex::FE_P_Bubbles<1,3>(2)::0.00000 0.00000 1.00000 -1.00000 1.00000 0.00000 4.00000 4.00000 -8.00000 
-DEAL:Simplex::FE_P_Bubbles<1,3>(2)::
-DEAL::Test support points for dim = 2 and spacedim = 2
-DEAL::approximation degree = 0
-DEAL::element tensor degree = 0
-DEAL:Simplex::FE_P_Bubbles<2>(0)::0.333333 0.333333 : 
-DEAL:Simplex::FE_P_Bubbles<2>(0)::1.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 
-DEAL:Simplex::FE_P_Bubbles<2>(0)::
-DEAL::approximation degree = 1
-DEAL::element tensor degree = 1
-DEAL:Simplex::FE_P_Bubbles<2>(1)::0.00000 0.00000 : 
-DEAL:Simplex::FE_P_Bubbles<2>(1)::1.00000 0.00000 0.00000 -1.00000 -1.00000 1.00000 0.00000 0.00000 1.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 
-DEAL:Simplex::FE_P_Bubbles<2>(1)::1.00000 0.00000 : 
-DEAL:Simplex::FE_P_Bubbles<2>(1)::0.00000 1.00000 0.00000 -1.00000 -1.00000 1.00000 0.00000 0.00000 1.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 
-DEAL:Simplex::FE_P_Bubbles<2>(1)::0.00000 1.00000 : 
-DEAL:Simplex::FE_P_Bubbles<2>(1)::0.00000 0.00000 1.00000 -1.00000 -1.00000 1.00000 0.00000 0.00000 1.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 
-DEAL:Simplex::FE_P_Bubbles<2>(1)::
-DEAL::approximation degree = 2
-DEAL::element tensor degree = 3
-DEAL:Simplex::FE_P_Bubbles<2>(2)::0.00000 0.00000 : 
-DEAL:Simplex::FE_P_Bubbles<2>(2)::1.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 -3.00000 -3.00000 -1.00000 0.00000 0.00000 -1.00000 4.00000 0.00000 0.00000 0.00000 0.00000 4.00000 0.00000 0.00000 4.00000 7.00000 7.00000 4.00000 4.00000 3.00000 3.00000 0.00000 0.00000 3.00000 3.00000 4.00000 -8.00000 -16.0000 -16.0000 0.00000 0.00000 -8.00000 -8.00000 0.00000 0.00000 -16.0000 -16.0000 -8.00000 0.00000 27.0000 27.0000 0.00000 
-DEAL:Simplex::FE_P_Bubbles<2>(2)::1.00000 0.00000 : 
-DEAL:Simplex::FE_P_Bubbles<2>(2)::0.00000 1.00000 0.00000 0.00000 0.00000 0.00000 0.00000 1.00000 1.00000 3.00000 0.00000 0.00000 -1.00000 -4.00000 -4.00000 0.00000 4.00000 0.00000 0.00000 0.00000 0.00000 4.00000 1.00000 1.00000 -2.00000 4.00000 -3.00000 -3.00000 -6.00000 0.00000 -3.00000 -3.00000 -2.00000 -8.00000 8.00000 8.00000 24.0000 0.00000 16.0000 16.0000 24.0000 0.00000 8.00000 8.00000 16.0000 0.00000 -27.0000 -27.0000 -54.0000 
-DEAL:Simplex::FE_P_Bubbles<2>(2)::0.00000 1.00000 : 
-DEAL:Simplex::FE_P_Bubbles<2>(2)::0.00000 0.00000 1.00000 0.00000 0.00000 0.00000 0.00000 1.00000 1.00000 -1.00000 0.00000 0.00000 3.00000 0.00000 0.00000 4.00000 0.00000 -4.00000 -4.00000 0.00000 0.00000 -2.00000 1.00000 1.00000 4.00000 -2.00000 -3.00000 -3.00000 0.00000 -6.00000 -3.00000 -3.00000 4.00000 16.0000 8.00000 8.00000 0.00000 24.0000 16.0000 16.0000 0.00000 24.0000 8.00000 8.00000 -8.00000 -54.0000 -27.0000 -27.0000 0.00000 
-DEAL:Simplex::FE_P_Bubbles<2>(2)::0.500000 0.00000 : 
-DEAL:Simplex::FE_P_Bubbles<2>(2)::0.00000 0.00000 0.00000 1.00000 0.00000 0.00000 0.00000 -1.00000 -0.250000 1.00000 0.750000 0.00000 -0.250000 0.00000 -5.00000 0.00000 -1.00000 0.00000 -1.00000 0.00000 6.75000 4.00000 4.00000 4.00000 1.00000 4.00000 0.00000 0.00000 -3.00000 0.00000 0.00000 0.00000 1.00000 -8.00000 -4.00000 -4.00000 12.0000 0.00000 4.00000 4.00000 12.0000 0.00000 -4.00000 -4.00000 4.00000 0.00000 0.00000 0.00000 -27.0000 
-DEAL:Simplex::FE_P_Bubbles<2>(2)::0.500000 0.500000 : 
-DEAL:Simplex::FE_P_Bubbles<2>(2)::0.00000 0.00000 0.00000 0.00000 1.00000 0.00000 0.00000 0.250000 0.250000 0.250000 -0.750000 -0.750000 0.250000 1.00000 1.00000 5.00000 5.00000 1.00000 1.00000 -6.75000 -6.75000 1.00000 1.00000 1.00000 1.00000 1.00000 -3.00000 -3.00000 -3.00000 -3.00000 -3.00000 -3.00000 1.00000 4.00000 8.00000 8.00000 12.0000 12.0000 16.0000 16.0000 12.0000 12.0000 8.00000 8.00000 4.00000 -27.0000 -27.0000 -27.0000 -27.0000 
-DEAL:Simplex::FE_P_Bubbles<2>(2)::0.00000 0.500000 : 
-DEAL:Simplex::FE_P_Bubbles<2>(2)::0.00000 0.00000 0.00000 0.00000 0.00000 1.00000 0.00000 -0.250000 -1.00000 -0.250000 0.00000 0.750000 1.00000 -1.00000 0.00000 -1.00000 0.00000 -5.00000 0.00000 6.75000 0.00000 1.00000 4.00000 4.00000 4.00000 1.00000 0.00000 0.00000 0.00000 -3.00000 0.00000 0.00000 4.00000 4.00000 -4.00000 -4.00000 0.00000 12.0000 4.00000 4.00000 0.00000 12.0000 -4.00000 -4.00000 -8.00000 -27.0000 0.00000 0.00000 0.00000 
-DEAL:Simplex::FE_P_Bubbles<2>(2)::0.333333 0.333333 : 
-DEAL:Simplex::FE_P_Bubbles<2>(2)::0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 1.00000 -0.333333 -0.333333 0.333333 1.11022e-16 1.11022e-16 0.333333 2.22045e-16 -1.33333 1.33333 1.33333 -1.33333 2.22045e-16 4.44089e-16 4.44089e-16 2.00000 3.00000 3.00000 2.00000 2.00000 -1.00000 -1.00000 -2.00000 -2.00000 -1.00000 -1.00000 2.00000 0.00000 -8.88178e-16 -8.88178e-16 8.00000 8.00000 8.00000 8.00000 8.00000 8.00000 -8.88178e-16 -8.88178e-16 0.00000 -18.0000 -9.00000 -9.00000 -18.0000 
-DEAL:Simplex::FE_P_Bubbles<2>(2)::
-DEAL::Test support points for dim = 2 and spacedim = 3
-DEAL::approximation degree = 0
-DEAL::element tensor degree = 0
-DEAL:Simplex::FE_P_Bubbles<2,3>(0)::0.333333 0.333333 : 
-DEAL:Simplex::FE_P_Bubbles<2,3>(0)::1.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 
-DEAL:Simplex::FE_P_Bubbles<2,3>(0)::
-DEAL::approximation degree = 1
-DEAL::element tensor degree = 1
-DEAL:Simplex::FE_P_Bubbles<2,3>(1)::0.00000 0.00000 : 
-DEAL:Simplex::FE_P_Bubbles<2,3>(1)::1.00000 0.00000 0.00000 -1.00000 -1.00000 1.00000 0.00000 0.00000 1.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 
-DEAL:Simplex::FE_P_Bubbles<2,3>(1)::1.00000 0.00000 : 
-DEAL:Simplex::FE_P_Bubbles<2,3>(1)::0.00000 1.00000 0.00000 -1.00000 -1.00000 1.00000 0.00000 0.00000 1.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 
-DEAL:Simplex::FE_P_Bubbles<2,3>(1)::0.00000 1.00000 : 
-DEAL:Simplex::FE_P_Bubbles<2,3>(1)::0.00000 0.00000 1.00000 -1.00000 -1.00000 1.00000 0.00000 0.00000 1.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 
-DEAL:Simplex::FE_P_Bubbles<2,3>(1)::
-DEAL::approximation degree = 2
-DEAL::element tensor degree = 3
-DEAL:Simplex::FE_P_Bubbles<2,3>(2)::0.00000 0.00000 : 
-DEAL:Simplex::FE_P_Bubbles<2,3>(2)::1.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 -3.00000 -3.00000 -1.00000 0.00000 0.00000 -1.00000 4.00000 0.00000 0.00000 0.00000 0.00000 4.00000 0.00000 0.00000 4.00000 7.00000 7.00000 4.00000 4.00000 3.00000 3.00000 0.00000 0.00000 3.00000 3.00000 4.00000 -8.00000 -16.0000 -16.0000 0.00000 0.00000 -8.00000 -8.00000 0.00000 0.00000 -16.0000 -16.0000 -8.00000 0.00000 27.0000 27.0000 0.00000 
-DEAL:Simplex::FE_P_Bubbles<2,3>(2)::1.00000 0.00000 : 
-DEAL:Simplex::FE_P_Bubbles<2,3>(2)::0.00000 1.00000 0.00000 0.00000 0.00000 0.00000 0.00000 1.00000 1.00000 3.00000 0.00000 0.00000 -1.00000 -4.00000 -4.00000 0.00000 4.00000 0.00000 0.00000 0.00000 0.00000 4.00000 1.00000 1.00000 -2.00000 4.00000 -3.00000 -3.00000 -6.00000 0.00000 -3.00000 -3.00000 -2.00000 -8.00000 8.00000 8.00000 24.0000 0.00000 16.0000 16.0000 24.0000 0.00000 8.00000 8.00000 16.0000 0.00000 -27.0000 -27.0000 -54.0000 
-DEAL:Simplex::FE_P_Bubbles<2,3>(2)::0.00000 1.00000 : 
-DEAL:Simplex::FE_P_Bubbles<2,3>(2)::0.00000 0.00000 1.00000 0.00000 0.00000 0.00000 0.00000 1.00000 1.00000 -1.00000 0.00000 0.00000 3.00000 0.00000 0.00000 4.00000 0.00000 -4.00000 -4.00000 0.00000 0.00000 -2.00000 1.00000 1.00000 4.00000 -2.00000 -3.00000 -3.00000 0.00000 -6.00000 -3.00000 -3.00000 4.00000 16.0000 8.00000 8.00000 0.00000 24.0000 16.0000 16.0000 0.00000 24.0000 8.00000 8.00000 -8.00000 -54.0000 -27.0000 -27.0000 0.00000 
-DEAL:Simplex::FE_P_Bubbles<2,3>(2)::0.500000 0.00000 : 
-DEAL:Simplex::FE_P_Bubbles<2,3>(2)::0.00000 0.00000 0.00000 1.00000 0.00000 0.00000 0.00000 -1.00000 -0.250000 1.00000 0.750000 0.00000 -0.250000 0.00000 -5.00000 0.00000 -1.00000 0.00000 -1.00000 0.00000 6.75000 4.00000 4.00000 4.00000 1.00000 4.00000 0.00000 0.00000 -3.00000 0.00000 0.00000 0.00000 1.00000 -8.00000 -4.00000 -4.00000 12.0000 0.00000 4.00000 4.00000 12.0000 0.00000 -4.00000 -4.00000 4.00000 0.00000 0.00000 0.00000 -27.0000 
-DEAL:Simplex::FE_P_Bubbles<2,3>(2)::0.500000 0.500000 : 
-DEAL:Simplex::FE_P_Bubbles<2,3>(2)::0.00000 0.00000 0.00000 0.00000 1.00000 0.00000 0.00000 0.250000 0.250000 0.250000 -0.750000 -0.750000 0.250000 1.00000 1.00000 5.00000 5.00000 1.00000 1.00000 -6.75000 -6.75000 1.00000 1.00000 1.00000 1.00000 1.00000 -3.00000 -3.00000 -3.00000 -3.00000 -3.00000 -3.00000 1.00000 4.00000 8.00000 8.00000 12.0000 12.0000 16.0000 16.0000 12.0000 12.0000 8.00000 8.00000 4.00000 -27.0000 -27.0000 -27.0000 -27.0000 
-DEAL:Simplex::FE_P_Bubbles<2,3>(2)::0.00000 0.500000 : 
-DEAL:Simplex::FE_P_Bubbles<2,3>(2)::0.00000 0.00000 0.00000 0.00000 0.00000 1.00000 0.00000 -0.250000 -1.00000 -0.250000 0.00000 0.750000 1.00000 -1.00000 0.00000 -1.00000 0.00000 -5.00000 0.00000 6.75000 0.00000 1.00000 4.00000 4.00000 4.00000 1.00000 0.00000 0.00000 0.00000 -3.00000 0.00000 0.00000 4.00000 4.00000 -4.00000 -4.00000 0.00000 12.0000 4.00000 4.00000 0.00000 12.0000 -4.00000 -4.00000 -8.00000 -27.0000 0.00000 0.00000 0.00000 
-DEAL:Simplex::FE_P_Bubbles<2,3>(2)::0.333333 0.333333 : 
-DEAL:Simplex::FE_P_Bubbles<2,3>(2)::0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 1.00000 -0.333333 -0.333333 0.333333 1.11022e-16 1.11022e-16 0.333333 2.22045e-16 -1.33333 1.33333 1.33333 -1.33333 2.22045e-16 4.44089e-16 4.44089e-16 2.00000 3.00000 3.00000 2.00000 2.00000 -1.00000 -1.00000 -2.00000 -2.00000 -1.00000 -1.00000 2.00000 0.00000 -8.88178e-16 -8.88178e-16 8.00000 8.00000 8.00000 8.00000 8.00000 8.00000 -8.88178e-16 -8.88178e-16 0.00000 -18.0000 -9.00000 -9.00000 -18.0000 
-DEAL:Simplex::FE_P_Bubbles<2,3>(2)::
-DEAL::Test support points for dim = 3 and spacedim = 3
-DEAL::approximation degree = 0
-DEAL::element tensor degree = 0
-DEAL:Simplex::FE_P_Bubbles<3>(0)::0.250000 0.250000 0.250000 : 
-DEAL:Simplex::FE_P_Bubbles<3>(0)::1.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 
-DEAL:Simplex::FE_P_Bubbles<3>(0)::
-DEAL::approximation degree = 1
-DEAL::element tensor degree = 1
-DEAL:Simplex::FE_P_Bubbles<3>(1)::0.00000 0.00000 0.00000 : 
-DEAL:Simplex::FE_P_Bubbles<3>(1)::1.00000 0.00000 0.00000 0.00000 -1.00000 -1.00000 -1.00000 1.00000 0.00000 0.00000 0.00000 1.00000 0.00000 0.00000 0.00000 1.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 
-DEAL:Simplex::FE_P_Bubbles<3>(1)::1.00000 0.00000 0.00000 : 
-DEAL:Simplex::FE_P_Bubbles<3>(1)::0.00000 1.00000 0.00000 0.00000 -1.00000 -1.00000 -1.00000 1.00000 0.00000 0.00000 0.00000 1.00000 0.00000 0.00000 0.00000 1.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 
-DEAL:Simplex::FE_P_Bubbles<3>(1)::0.00000 1.00000 0.00000 : 
-DEAL:Simplex::FE_P_Bubbles<3>(1)::0.00000 0.00000 1.00000 0.00000 -1.00000 -1.00000 -1.00000 1.00000 0.00000 0.00000 0.00000 1.00000 0.00000 0.00000 0.00000 1.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 
-DEAL:Simplex::FE_P_Bubbles<3>(1)::0.00000 0.00000 1.00000 : 
-DEAL:Simplex::FE_P_Bubbles<3>(1)::0.00000 0.00000 0.00000 1.00000 -1.00000 -1.00000 -1.00000 1.00000 0.00000 0.00000 0.00000 1.00000 0.00000 0.00000 0.00000 1.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 
-DEAL:Simplex::FE_P_Bubbles<3>(1)::
-DEAL::approximation degree = 2
-DEAL::element tensor degree = 3
-DEAL:Simplex::FE_P_Bubbles<3>(2)::0.00000 0.00000 0.00000 : 
-DEAL:Simplex::FE_P_Bubbles<3>(2)::1.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 -3.00000 -3.00000 -3.00000 -1.00000 0.00000 0.00000 0.00000 -1.00000 0.00000 0.00000 0.00000 -1.00000 4.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 4.00000 0.00000 0.00000 0.00000 4.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 4.00000 7.00000 7.00000 7.00000 4.00000 7.00000 7.00000 7.00000 4.00000 4.00000 3.00000 3.00000 3.00000 0.00000 0.00000 3.00000 0.00000 0.00000 0.00000 3.00000 0.00000 3.00000 4.00000 3.00000 0.00000 3.00000 0.00000 0.00000 0.00000 3.00000 0.00000 0.00000 3.00000 3.00000 3.00000 4.00000 -8.00000 -16.0000 -16.0000 -16.0000 0.00000 0.00000 -16.0000 0.00000 0.00000 0.00000 -8.00000 0.00000 -8.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 -16.0000 0.00000 -16.0000 -8.00000 -16.0000 0.00000 -16.0000 0.00000 0.00000 0.00000 -16.0000 0.00000 0.00000 -16.0000 -16.0000 -16.0000 -8.00000 0.00000 0.00000 -8.00000 0.00000 0.00000 0.00000 -8.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 -8.00000 0.00000 -8.00000 0.00000 0.00000 27.0000 0.00000 27.0000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 27.0000 0.00000 0.00000 0.00000 27.0000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 27.0000 0.00000 27.0000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 
-DEAL:Simplex::FE_P_Bubbles<3>(2)::1.00000 0.00000 0.00000 : 
-DEAL:Simplex::FE_P_Bubbles<3>(2)::0.00000 1.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 1.00000 1.00000 1.00000 3.00000 0.00000 0.00000 0.00000 -1.00000 0.00000 0.00000 0.00000 -1.00000 -4.00000 -4.00000 -4.00000 0.00000 4.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 4.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 4.00000 1.00000 1.00000 1.00000 -2.00000 -2.00000 1.00000 -2.00000 -2.00000 4.00000 -3.00000 -3.00000 -3.00000 -6.00000 -3.00000 -3.00000 -3.00000 -6.00000 0.00000 -3.00000 0.00000 -3.00000 -2.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 -3.00000 0.00000 0.00000 0.00000 -3.00000 0.00000 -2.00000 -8.00000 8.00000 8.00000 8.00000 24.0000 24.0000 8.00000 24.0000 24.0000 0.00000 16.0000 0.00000 16.0000 24.0000 0.00000 0.00000 0.00000 0.00000 0.00000 8.00000 0.00000 8.00000 16.0000 8.00000 0.00000 8.00000 0.00000 0.00000 0.00000 8.00000 0.00000 0.00000 8.00000 8.00000 8.00000 16.0000 0.00000 0.00000 16.0000 0.00000 0.00000 0.00000 16.0000 0.00000 24.0000 0.00000 0.00000 0.00000 0.00000 0.00000 -8.00000 0.00000 -8.00000 0.00000 0.00000 -27.0000 0.00000 -27.0000 -54.0000 -27.0000 0.00000 -27.0000 0.00000 0.00000 0.00000 -27.0000 0.00000 0.00000 -27.0000 -27.0000 -27.0000 -54.0000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 27.0000 0.00000 27.0000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 
-DEAL:Simplex::FE_P_Bubbles<3>(2)::0.00000 1.00000 0.00000 : 
-DEAL:Simplex::FE_P_Bubbles<3>(2)::0.00000 0.00000 1.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 1.00000 1.00000 1.00000 -1.00000 0.00000 0.00000 0.00000 3.00000 0.00000 0.00000 0.00000 -1.00000 0.00000 0.00000 0.00000 4.00000 0.00000 0.00000 -4.00000 -4.00000 -4.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 4.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 -2.00000 1.00000 -2.00000 1.00000 4.00000 1.00000 -2.00000 1.00000 -2.00000 -2.00000 -3.00000 0.00000 -3.00000 0.00000 0.00000 0.00000 0.00000 0.00000 -6.00000 -3.00000 -3.00000 -3.00000 4.00000 -3.00000 -3.00000 -3.00000 -6.00000 0.00000 0.00000 0.00000 0.00000 0.00000 -3.00000 0.00000 -3.00000 -2.00000 16.0000 8.00000 8.00000 8.00000 0.00000 0.00000 8.00000 0.00000 0.00000 24.0000 16.0000 0.00000 16.0000 0.00000 0.00000 0.00000 0.00000 0.00000 24.0000 8.00000 24.0000 8.00000 -8.00000 8.00000 24.0000 8.00000 24.0000 0.00000 0.00000 8.00000 0.00000 0.00000 8.00000 8.00000 8.00000 16.0000 0.00000 0.00000 -8.00000 0.00000 0.00000 0.00000 -8.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 16.0000 0.00000 16.0000 24.0000 -54.0000 -27.0000 -27.0000 -27.0000 0.00000 0.00000 -27.0000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 -27.0000 0.00000 0.00000 -27.0000 -27.0000 -27.0000 -54.0000 0.00000 0.00000 27.0000 0.00000 0.00000 0.00000 27.0000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 
-DEAL:Simplex::FE_P_Bubbles<3>(2)::0.00000 0.00000 1.00000 : 
-DEAL:Simplex::FE_P_Bubbles<3>(2)::0.00000 0.00000 0.00000 1.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 1.00000 1.00000 1.00000 -1.00000 0.00000 0.00000 0.00000 -1.00000 0.00000 0.00000 0.00000 3.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 -4.00000 -4.00000 -4.00000 4.00000 0.00000 0.00000 0.00000 4.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 -2.00000 -2.00000 1.00000 -2.00000 -2.00000 1.00000 1.00000 1.00000 4.00000 -2.00000 0.00000 -3.00000 0.00000 0.00000 0.00000 -3.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 -2.00000 -3.00000 0.00000 -3.00000 0.00000 -6.00000 -3.00000 -3.00000 -3.00000 -6.00000 -3.00000 -3.00000 -3.00000 4.00000 16.0000 8.00000 8.00000 8.00000 0.00000 0.00000 8.00000 0.00000 0.00000 0.00000 -8.00000 0.00000 -8.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 8.00000 0.00000 8.00000 16.0000 8.00000 0.00000 8.00000 0.00000 24.0000 24.0000 8.00000 24.0000 24.0000 8.00000 8.00000 8.00000 -8.00000 24.0000 0.00000 16.0000 0.00000 0.00000 0.00000 16.0000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 24.0000 16.0000 0.00000 16.0000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 -54.0000 -27.0000 -27.0000 -27.0000 0.00000 0.00000 -27.0000 0.00000 0.00000 0.00000 -27.0000 0.00000 -27.0000 -54.0000 -27.0000 0.00000 -27.0000 0.00000 0.00000 27.0000 0.00000 27.0000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 
-DEAL:Simplex::FE_P_Bubbles<3>(2)::0.500000 0.00000 0.00000 : 
-DEAL:Simplex::FE_P_Bubbles<3>(2)::0.00000 0.00000 0.00000 0.00000 1.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 -1.00000 -0.250000 -0.250000 1.00000 0.750000 0.750000 0.00000 -0.250000 0.00000 0.00000 0.00000 -0.250000 0.00000 -5.00000 -5.00000 0.00000 -1.00000 0.00000 0.00000 -1.00000 0.00000 0.00000 0.00000 -1.00000 0.00000 0.00000 -1.00000 0.00000 0.00000 0.00000 0.00000 6.75000 0.00000 0.00000 0.00000 6.75000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 4.00000 4.00000 4.00000 4.00000 1.00000 1.50000 4.00000 1.50000 1.00000 4.00000 0.00000 0.00000 0.00000 -3.00000 -2.50000 0.00000 -2.50000 -3.00000 0.00000 0.00000 0.00000 0.00000 1.00000 0.500000 0.00000 0.500000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.500000 0.00000 0.500000 1.00000 -8.00000 -4.00000 -4.00000 -4.00000 12.0000 20.0000 -4.00000 20.0000 12.0000 0.00000 4.00000 0.00000 4.00000 12.0000 8.00000 0.00000 8.00000 0.00000 0.00000 -4.00000 0.00000 -4.00000 4.00000 4.00000 0.00000 4.00000 0.00000 0.00000 0.00000 -4.00000 0.00000 0.00000 4.00000 -4.00000 4.00000 4.00000 0.00000 0.00000 4.00000 0.00000 0.00000 8.00000 4.00000 8.00000 12.0000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 -27.0000 -40.5000 0.00000 -40.5000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 -40.5000 0.00000 -40.5000 -27.0000 0.00000 0.00000 0.00000 0.00000 0.00000 -13.5000 0.00000 -13.5000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 -13.5000 0.00000 -13.5000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 64.0000 0.00000 64.0000 0.00000 
-DEAL:Simplex::FE_P_Bubbles<3>(2)::0.500000 0.500000 0.00000 : 
-DEAL:Simplex::FE_P_Bubbles<3>(2)::0.00000 0.00000 0.00000 0.00000 0.00000 1.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.250000 0.250000 0.250000 0.250000 -0.750000 0.00000 -0.750000 0.250000 0.00000 0.00000 0.00000 -0.250000 1.00000 1.00000 1.00000 5.00000 5.00000 0.00000 1.00000 1.00000 1.00000 0.00000 0.00000 -1.66533e-15 0.00000 0.00000 -1.00000 0.00000 0.00000 -1.00000 -6.75000 -6.75000 -6.75000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 6.75000 0.00000 0.00000 0.00000 1.00000 1.00000 0.500000 1.00000 1.00000 0.500000 0.500000 0.500000 8.88178e-15 1.00000 -3.00000 -0.500000 -3.00000 -3.00000 -0.500000 -0.500000 -0.500000 -1.00000 -3.00000 -3.00000 -0.500000 -3.00000 1.00000 -0.500000 -0.500000 -0.500000 -1.00000 0.00000 0.00000 -0.500000 0.00000 0.00000 -0.500000 -0.500000 -0.500000 0.00000 4.00000 8.00000 -1.24345e-14 8.00000 12.0000 4.00000 -1.24345e-14 4.00000 -4.00000 12.0000 16.0000 -8.00000 16.0000 12.0000 -8.00000 -8.00000 -8.00000 -16.0000 12.0000 8.00000 4.00000 8.00000 4.00000 -1.24345e-14 4.00000 -1.24345e-14 -4.00000 0.00000 0.00000 -1.24345e-14 0.00000 0.00000 -1.24345e-14 -1.24345e-14 -1.24345e-14 -1.77636e-14 0.00000 0.00000 -4.00000 0.00000 0.00000 -8.00000 -4.00000 -8.00000 -4.00000 0.00000 0.00000 -8.00000 0.00000 0.00000 -4.00000 -8.00000 -4.00000 -4.00000 -27.0000 -27.0000 13.5000 -27.0000 -27.0000 13.5000 13.5000 13.5000 54.0000 0.00000 0.00000 13.5000 0.00000 0.00000 13.5000 13.5000 13.5000 27.0000 0.00000 0.00000 13.5000 0.00000 0.00000 13.5000 13.5000 13.5000 27.0000 0.00000 0.00000 40.5000 0.00000 0.00000 40.5000 40.5000 40.5000 54.0000 0.00000 0.00000 -64.0000 0.00000 0.00000 -64.0000 -64.0000 -64.0000 -128.000 
-DEAL:Simplex::FE_P_Bubbles<3>(2)::0.00000 0.500000 0.00000 : 
-DEAL:Simplex::FE_P_Bubbles<3>(2)::0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 1.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 -0.250000 -1.00000 -0.250000 -0.250000 0.00000 0.00000 0.750000 1.00000 0.750000 0.00000 0.00000 -0.250000 -1.00000 0.00000 0.00000 -1.00000 0.00000 0.00000 -5.00000 0.00000 -5.00000 0.00000 0.00000 -1.00000 0.00000 0.00000 0.00000 0.00000 0.00000 -1.00000 6.75000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 6.75000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 1.00000 4.00000 1.50000 4.00000 4.00000 4.00000 1.50000 4.00000 1.00000 1.00000 0.00000 0.500000 0.00000 0.00000 0.00000 0.500000 0.00000 0.00000 -3.00000 0.00000 -2.50000 0.00000 4.00000 0.00000 -2.50000 0.00000 -3.00000 0.00000 0.00000 0.500000 0.00000 0.00000 0.00000 0.500000 0.00000 1.00000 4.00000 -4.00000 4.00000 -4.00000 0.00000 0.00000 4.00000 0.00000 0.00000 12.0000 4.00000 8.00000 4.00000 0.00000 0.00000 8.00000 0.00000 0.00000 12.0000 -4.00000 20.0000 -4.00000 -8.00000 -4.00000 20.0000 -4.00000 12.0000 0.00000 0.00000 4.00000 0.00000 0.00000 -4.00000 4.00000 -4.00000 4.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 8.00000 0.00000 0.00000 4.00000 8.00000 4.00000 12.0000 -27.0000 0.00000 -40.5000 0.00000 0.00000 0.00000 -40.5000 0.00000 0.00000 0.00000 0.00000 -13.5000 0.00000 0.00000 0.00000 -13.5000 0.00000 0.00000 0.00000 0.00000 -40.5000 0.00000 0.00000 0.00000 -40.5000 0.00000 -27.0000 0.00000 0.00000 -13.5000 0.00000 0.00000 0.00000 -13.5000 0.00000 0.00000 0.00000 0.00000 64.0000 0.00000 0.00000 0.00000 64.0000 0.00000 0.00000 
-DEAL:Simplex::FE_P_Bubbles<3>(2)::0.00000 0.00000 0.500000 : 
-DEAL:Simplex::FE_P_Bubbles<3>(2)::0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 1.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 -0.250000 -0.250000 -1.00000 -0.250000 0.00000 0.00000 0.00000 -0.250000 0.00000 0.750000 0.750000 1.00000 -1.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 -1.00000 0.00000 -5.00000 -5.00000 0.00000 -1.00000 0.00000 0.00000 0.00000 -1.00000 0.00000 0.00000 0.00000 0.00000 6.75000 0.00000 0.00000 0.00000 6.75000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 1.00000 1.50000 4.00000 1.50000 1.00000 4.00000 4.00000 4.00000 4.00000 1.00000 0.500000 0.00000 0.500000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.500000 0.00000 0.500000 1.00000 0.00000 0.00000 0.00000 0.00000 -3.00000 -2.50000 0.00000 -2.50000 -3.00000 0.00000 0.00000 0.00000 4.00000 4.00000 4.00000 -4.00000 4.00000 0.00000 0.00000 -4.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 4.00000 0.00000 4.00000 4.00000 -4.00000 0.00000 -4.00000 0.00000 12.0000 20.0000 -4.00000 20.0000 12.0000 -4.00000 -4.00000 -4.00000 -8.00000 12.0000 8.00000 4.00000 8.00000 0.00000 0.00000 4.00000 0.00000 0.00000 0.00000 8.00000 0.00000 8.00000 12.0000 4.00000 0.00000 4.00000 0.00000 0.00000 -13.5000 0.00000 -13.5000 0.00000 0.00000 0.00000 0.00000 0.00000 -27.0000 -40.5000 0.00000 -40.5000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 -40.5000 0.00000 -40.5000 -27.0000 0.00000 0.00000 0.00000 0.00000 0.00000 -13.5000 0.00000 -13.5000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 64.0000 0.00000 64.0000 0.00000 0.00000 0.00000 0.00000 0.00000 
-DEAL:Simplex::FE_P_Bubbles<3>(2)::0.500000 0.00000 0.500000 : 
-DEAL:Simplex::FE_P_Bubbles<3>(2)::0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 1.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.250000 0.250000 0.250000 0.250000 0.00000 -0.750000 0.00000 -0.250000 0.00000 -0.750000 0.00000 0.250000 1.00000 1.00000 1.00000 0.00000 -1.00000 0.00000 0.00000 -1.66533e-15 0.00000 1.00000 1.00000 1.00000 5.00000 0.00000 5.00000 0.00000 -1.00000 0.00000 0.00000 0.00000 0.00000 -6.75000 -6.75000 -6.75000 0.00000 0.00000 0.00000 0.00000 6.75000 0.00000 0.00000 0.00000 0.00000 1.00000 0.500000 1.00000 0.500000 8.88178e-15 0.500000 1.00000 0.500000 1.00000 1.00000 -0.500000 -3.00000 -0.500000 -1.00000 -0.500000 -3.00000 -0.500000 -3.00000 0.00000 -0.500000 0.00000 -0.500000 0.00000 -0.500000 0.00000 -0.500000 0.00000 -3.00000 -0.500000 -3.00000 -0.500000 -1.00000 -0.500000 -3.00000 -0.500000 1.00000 4.00000 -1.24345e-14 8.00000 -1.24345e-14 -4.00000 4.00000 8.00000 4.00000 12.0000 0.00000 -4.00000 0.00000 -4.00000 -4.00000 -8.00000 0.00000 -8.00000 0.00000 0.00000 -1.24345e-14 0.00000 -1.24345e-14 -1.77636e-14 -1.24345e-14 0.00000 -1.24345e-14 0.00000 12.0000 4.00000 8.00000 4.00000 -4.00000 -1.24345e-14 8.00000 -1.24345e-14 4.00000 12.0000 -8.00000 16.0000 -8.00000 -16.0000 -8.00000 16.0000 -8.00000 12.0000 0.00000 -8.00000 0.00000 -8.00000 -4.00000 -4.00000 0.00000 -4.00000 0.00000 0.00000 13.5000 0.00000 13.5000 27.0000 13.5000 0.00000 13.5000 0.00000 -27.0000 13.5000 -27.0000 13.5000 54.0000 13.5000 -27.0000 13.5000 -27.0000 0.00000 13.5000 0.00000 13.5000 27.0000 13.5000 0.00000 13.5000 0.00000 0.00000 40.5000 0.00000 40.5000 54.0000 40.5000 0.00000 40.5000 0.00000 0.00000 -64.0000 0.00000 -64.0000 -128.000 -64.0000 0.00000 -64.0000 0.00000 
-DEAL:Simplex::FE_P_Bubbles<3>(2)::0.00000 0.500000 0.500000 : 
-DEAL:Simplex::FE_P_Bubbles<3>(2)::0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 1.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.250000 0.250000 0.250000 -0.250000 0.00000 0.00000 0.00000 0.250000 -0.750000 0.00000 -0.750000 0.250000 -1.66533e-15 0.00000 0.00000 -1.00000 0.00000 0.00000 1.00000 1.00000 1.00000 1.00000 1.00000 1.00000 -1.00000 0.00000 0.00000 0.00000 5.00000 5.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 -6.75000 -6.75000 -6.75000 6.75000 0.00000 0.00000 0.00000 0.00000 0.00000 8.88178e-15 0.500000 0.500000 0.500000 1.00000 1.00000 0.500000 1.00000 1.00000 0.00000 -0.500000 -0.500000 -0.500000 0.00000 0.00000 -0.500000 0.00000 0.00000 -1.00000 -0.500000 -0.500000 -0.500000 1.00000 -3.00000 -0.500000 -3.00000 -3.00000 -1.00000 -0.500000 -0.500000 -0.500000 -3.00000 -3.00000 -0.500000 -3.00000 1.00000 -1.77636e-14 -1.24345e-14 -1.24345e-14 -1.24345e-14 0.00000 0.00000 -1.24345e-14 0.00000 0.00000 -4.00000 -4.00000 -8.00000 -4.00000 0.00000 0.00000 -8.00000 0.00000 0.00000 -4.00000 -1.24345e-14 4.00000 -1.24345e-14 4.00000 8.00000 4.00000 8.00000 12.0000 -4.00000 4.00000 -1.24345e-14 4.00000 12.0000 8.00000 -1.24345e-14 8.00000 4.00000 -4.00000 -8.00000 -4.00000 -8.00000 0.00000 0.00000 -4.00000 0.00000 0.00000 -16.0000 -8.00000 -8.00000 -8.00000 12.0000 16.0000 -8.00000 16.0000 12.0000 27.0000 13.5000 13.5000 13.5000 0.00000 0.00000 13.5000 0.00000 0.00000 27.0000 13.5000 13.5000 13.5000 0.00000 0.00000 13.5000 0.00000 0.00000 54.0000 13.5000 13.5000 13.5000 -27.0000 -27.0000 13.5000 -27.0000 -27.0000 54.0000 40.5000 40.5000 40.5000 0.00000 0.00000 40.5000 0.00000 0.00000 -128.000 -64.0000 -64.0000 -64.0000 0.00000 0.00000 -64.0000 0.00000 0.00000 
-DEAL:Simplex::FE_P_Bubbles<3>(2)::0.333333 0.333333 0.00000 : 
-DEAL:Simplex::FE_P_Bubbles<3>(2)::2.77556e-17 2.77556e-17 2.77556e-17 0.00000 -5.55112e-17 -1.11022e-16 -5.55112e-17 0.00000 0.00000 0.00000 1.00000 0.00000 0.00000 0.00000 0.00000 -0.333333 -0.333333 -0.148148 0.333333 5.55112e-17 0.185185 5.55112e-17 0.333333 0.185185 0.00000 0.00000 -0.148148 2.22045e-16 -1.33333 -0.148148 1.33333 1.33333 1.18519 -1.33333 2.22045e-16 -0.148148 0.00000 0.00000 -0.148148 0.00000 0.00000 -0.148148 0.00000 0.00000 -0.148148 4.44089e-16 4.44089e-16 -7.00000 0.00000 0.00000 -1.00000 0.00000 0.00000 -1.00000 0.00000 0.00000 -1.00000 0.00000 0.00000 9.48148 2.00000 3.00000 2.00000 3.00000 2.00000 2.00000 2.00000 2.00000 0.888889 2.00000 -1.00000 1.11022e-16 -1.00000 -2.00000 -1.00000 1.11022e-16 -1.00000 -1.11111 -2.00000 -1.00000 -1.00000 -1.00000 2.00000 1.11022e-16 -1.00000 1.11022e-16 -1.11111 0.00000 0.00000 1.11022e-16 0.00000 0.00000 1.11022e-16 1.11022e-16 1.11022e-16 0.888889 0.00000 -1.77636e-15 -2.66454e-15 -1.77636e-15 8.00000 8.00000 -2.66454e-15 8.00000 0.888889 8.00000 8.00000 8.88178e-16 8.00000 8.00000 8.88178e-16 8.88178e-16 8.88178e-16 -7.11111 8.00000 -1.77636e-15 8.00000 -1.77636e-15 0.00000 -2.66454e-15 8.00000 -2.66454e-15 0.888889 0.00000 0.00000 -2.66454e-15 0.00000 0.00000 -2.66454e-15 -2.66454e-15 -2.66454e-15 0.888889 0.00000 0.00000 0.00000 0.00000 0.00000 8.88178e-16 0.00000 8.88178e-16 0.888889 0.00000 0.00000 8.88178e-16 0.00000 0.00000 0.00000 8.88178e-16 0.00000 0.888889 -18.0000 -9.00000 -9.00000 -9.00000 -18.0000 -9.00000 -9.00000 -9.00000 24.0000 0.00000 0.00000 0.00000 0.00000 0.00000 -9.00000 0.00000 -9.00000 6.00000 0.00000 0.00000 -9.00000 0.00000 0.00000 0.00000 -9.00000 0.00000 6.00000 0.00000 0.00000 9.00000 0.00000 0.00000 9.00000 9.00000 9.00000 24.0000 0.00000 0.00000 7.10543e-15 0.00000 0.00000 7.10543e-15 7.10543e-15 7.10543e-15 -56.8889 
-DEAL:Simplex::FE_P_Bubbles<3>(2)::0.333333 0.00000 0.333333 : 
-DEAL:Simplex::FE_P_Bubbles<3>(2)::2.77556e-17 2.77556e-17 0.00000 2.77556e-17 -5.55112e-17 0.00000 0.00000 -5.55112e-17 -1.11022e-16 0.00000 0.00000 1.00000 0.00000 0.00000 0.00000 -0.333333 -0.148148 -0.333333 0.333333 0.185185 5.55112e-17 0.00000 -0.148148 0.00000 5.55112e-17 0.185185 0.333333 2.22045e-16 -0.148148 -1.33333 0.00000 -0.148148 0.00000 0.00000 -0.148148 0.00000 -1.33333 -0.148148 2.22045e-16 1.33333 1.18519 1.33333 0.00000 -0.148148 0.00000 0.00000 -1.00000 0.00000 4.44089e-16 -7.00000 4.44089e-16 0.00000 -1.00000 0.00000 0.00000 -1.00000 0.00000 0.00000 9.48148 0.00000 2.00000 2.00000 3.00000 2.00000 0.888889 2.00000 3.00000 2.00000 2.00000 2.00000 1.11022e-16 -1.00000 1.11022e-16 -1.11111 -1.00000 -1.00000 -1.00000 -2.00000 0.00000 1.11022e-16 0.00000 1.11022e-16 0.888889 1.11022e-16 0.00000 1.11022e-16 0.00000 -2.00000 -1.00000 -1.00000 -1.00000 -1.11111 1.11022e-16 -1.00000 1.11022e-16 2.00000 0.00000 -2.66454e-15 -1.77636e-15 -2.66454e-15 0.888889 8.00000 -1.77636e-15 8.00000 8.00000 0.00000 0.00000 0.00000 0.00000 0.888889 8.88178e-16 0.00000 8.88178e-16 0.00000 0.00000 -2.66454e-15 0.00000 -2.66454e-15 0.888889 -2.66454e-15 0.00000 -2.66454e-15 0.00000 8.00000 8.00000 -1.77636e-15 8.00000 0.888889 -2.66454e-15 -1.77636e-15 -2.66454e-15 0.00000 8.00000 8.88178e-16 8.00000 8.88178e-16 -7.11111 8.88178e-16 8.00000 8.88178e-16 8.00000 0.00000 8.88178e-16 0.00000 8.88178e-16 0.888889 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 6.00000 -9.00000 0.00000 -9.00000 0.00000 -18.0000 -9.00000 -9.00000 -9.00000 24.0000 -9.00000 -9.00000 -9.00000 -18.0000 0.00000 -9.00000 0.00000 -9.00000 6.00000 0.00000 0.00000 0.00000 0.00000 0.00000 9.00000 0.00000 9.00000 24.0000 9.00000 0.00000 9.00000 0.00000 0.00000 7.10543e-15 0.00000 7.10543e-15 -56.8889 7.10543e-15 0.00000 7.10543e-15 0.00000 
-DEAL:Simplex::FE_P_Bubbles<3>(2)::0.00000 0.333333 0.333333 : 
-DEAL:Simplex::FE_P_Bubbles<3>(2)::2.77556e-17 0.00000 2.77556e-17 2.77556e-17 0.00000 0.00000 -5.55112e-17 -5.55112e-17 0.00000 -1.11022e-16 0.00000 0.00000 1.00000 0.00000 0.00000 -0.148148 -0.333333 -0.333333 -0.148148 0.00000 0.00000 0.185185 0.333333 5.55112e-17 0.185185 5.55112e-17 0.333333 -0.148148 0.00000 0.00000 -0.148148 0.00000 0.00000 -0.148148 2.22045e-16 -1.33333 -0.148148 -1.33333 2.22045e-16 -0.148148 0.00000 0.00000 1.18519 1.33333 1.33333 -1.00000 0.00000 0.00000 -1.00000 0.00000 0.00000 -7.00000 4.44089e-16 4.44089e-16 -1.00000 0.00000 0.00000 9.48148 0.00000 0.00000 0.888889 2.00000 2.00000 2.00000 2.00000 3.00000 2.00000 3.00000 2.00000 0.888889 1.11022e-16 1.11022e-16 1.11022e-16 0.00000 0.00000 1.11022e-16 0.00000 0.00000 -1.11111 1.11022e-16 -1.00000 1.11022e-16 2.00000 -1.00000 -1.00000 -1.00000 -2.00000 -1.11111 -1.00000 1.11022e-16 -1.00000 -2.00000 -1.00000 1.11022e-16 -1.00000 2.00000 0.888889 -2.66454e-15 -2.66454e-15 -2.66454e-15 0.00000 0.00000 -2.66454e-15 0.00000 0.00000 0.888889 0.00000 8.88178e-16 0.00000 0.00000 0.00000 8.88178e-16 0.00000 0.00000 0.888889 -2.66454e-15 8.00000 -2.66454e-15 0.00000 -1.77636e-15 8.00000 -1.77636e-15 8.00000 0.888889 8.00000 -2.66454e-15 8.00000 8.00000 -1.77636e-15 -2.66454e-15 -1.77636e-15 0.00000 0.888889 8.88178e-16 0.00000 8.88178e-16 0.00000 0.00000 0.00000 0.00000 0.00000 -7.11111 8.88178e-16 8.88178e-16 8.88178e-16 8.00000 8.00000 8.88178e-16 8.00000 8.00000 6.00000 0.00000 -9.00000 0.00000 0.00000 0.00000 -9.00000 0.00000 0.00000 6.00000 -9.00000 0.00000 -9.00000 0.00000 0.00000 0.00000 0.00000 0.00000 24.0000 -9.00000 -9.00000 -9.00000 -18.0000 -9.00000 -9.00000 -9.00000 -18.0000 24.0000 9.00000 9.00000 9.00000 0.00000 0.00000 9.00000 0.00000 0.00000 -56.8889 7.10543e-15 7.10543e-15 7.10543e-15 0.00000 0.00000 7.10543e-15 0.00000 0.00000 
-DEAL:Simplex::FE_P_Bubbles<3>(2)::0.333333 0.333333 0.333333 : 
-DEAL:Simplex::FE_P_Bubbles<3>(2)::1.31582e-16 5.75671e-17 5.75671e-17 5.75671e-17 -2.63164e-16 -1.64477e-17 -2.63164e-16 -2.63164e-16 -1.64477e-17 -1.64477e-17 -1.11022e-16 -1.11022e-16 -1.11022e-16 1.00000 1.05266e-15 0.148148 0.148148 0.148148 0.148148 -0.185185 -0.185185 -0.185185 0.148148 -0.185185 -0.185185 -0.185185 0.148148 0.148148 0.148148 0.148148 0.148148 0.148148 -1.18519 0.148148 0.148148 0.148148 0.148148 0.148148 0.148148 0.148148 -1.18519 0.148148 -1.18519 0.148148 0.148148 1.00000 1.00000 1.00000 1.00000 1.00000 1.00000 1.00000 1.00000 1.00000 7.00000 7.00000 7.00000 -9.48148 -9.48148 -9.48148 0.888889 0.888889 0.888889 0.888889 0.888889 0.888889 0.888889 0.888889 0.888889 0.888889 -1.11111 -1.11111 -1.11111 -1.11111 -0.111111 -1.11111 -0.111111 -1.11111 -1.11111 -1.11111 -0.111111 -1.11111 0.888889 -1.11111 -0.111111 -1.11111 -1.11111 -1.11111 -0.111111 -1.11111 -0.111111 -1.11111 -1.11111 -1.11111 -1.11111 0.888889 0.888889 0.888889 0.888889 0.888889 0.888889 0.888889 0.888889 0.888889 0.888889 0.888889 0.888889 -7.11111 0.888889 0.888889 -7.11111 -7.11111 -7.11111 -7.11111 0.888889 0.888889 0.888889 0.888889 0.888889 0.888889 0.888889 0.888889 0.888889 0.888889 0.888889 0.888889 0.888889 0.888889 0.888889 0.888889 0.888889 0.888889 0.888889 -7.11111 0.888889 -7.11111 -7.11111 -7.11111 0.888889 -7.11111 0.888889 -7.11111 -7.11111 -7.11111 -7.11111 0.888889 0.888889 -7.11111 0.888889 0.888889 6.00000 6.00000 15.0000 6.00000 6.00000 15.0000 15.0000 15.0000 24.0000 6.00000 15.0000 6.00000 15.0000 24.0000 15.0000 6.00000 15.0000 6.00000 24.0000 15.0000 15.0000 15.0000 6.00000 6.00000 15.0000 6.00000 6.00000 24.0000 33.0000 33.0000 33.0000 24.0000 33.0000 33.0000 33.0000 24.0000 -56.8889 -56.8889 -56.8889 -56.8889 -56.8889 -56.8889 -56.8889 -56.8889 -56.8889 
-DEAL:Simplex::FE_P_Bubbles<3>(2)::0.250000 0.250000 0.250000 : 
-DEAL:Simplex::FE_P_Bubbles<3>(2)::0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 1.00000 -0.187500 -0.187500 -0.187500 0.187500 0.00000 0.00000 0.00000 0.187500 0.00000 0.00000 0.00000 0.187500 -4.44089e-16 -0.250000 -0.250000 0.250000 0.250000 0.00000 -0.250000 -4.44089e-16 -0.250000 -0.250000 -0.250000 -4.44089e-16 0.250000 0.00000 0.250000 0.00000 0.250000 0.250000 0.00000 0.00000 -1.68750 0.00000 -1.68750 0.00000 -1.68750 0.00000 0.00000 1.68750 1.68750 1.68750 0.00000 0.00000 0.00000 1.50000 2.00000 2.00000 2.00000 1.50000 2.00000 2.00000 2.00000 1.50000 1.50000 -0.500000 -0.500000 -0.500000 -1.00000 -0.500000 -0.500000 -0.500000 -1.00000 -1.00000 -0.500000 -0.500000 -0.500000 1.50000 -0.500000 -0.500000 -0.500000 -1.00000 -1.00000 -0.500000 -0.500000 -0.500000 -1.00000 -0.500000 -0.500000 -0.500000 1.50000 -3.55271e-15 -3.55271e-15 -3.55271e-15 -3.55271e-15 2.00000 4.00000 -3.55271e-15 4.00000 2.00000 2.00000 2.00000 -2.00000 2.00000 2.00000 -2.00000 -2.00000 -2.00000 -4.00000 2.00000 -3.55271e-15 4.00000 -3.55271e-15 -3.55271e-15 -3.10862e-15 4.00000 -3.10862e-15 2.00000 2.00000 4.00000 -3.55271e-15 4.00000 2.00000 -3.10862e-15 -3.55271e-15 -3.10862e-15 -3.55271e-15 2.00000 -2.00000 2.00000 -2.00000 -4.00000 -2.00000 2.00000 -2.00000 2.00000 -4.00000 -2.00000 -2.00000 -2.00000 2.00000 2.00000 -2.00000 2.00000 2.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 13.5000 0.00000 0.00000 0.00000 0.00000 13.5000 0.00000 0.00000 0.00000 0.00000 13.5000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 13.5000 13.5000 13.5000 13.5000 13.5000 13.5000 13.5000 13.5000 13.5000 -32.0000 -16.0000 -16.0000 -16.0000 -32.0000 -16.0000 -16.0000 -16.0000 -32.0000 
-DEAL:Simplex::FE_P_Bubbles<3>(2)::
diff --git a/tests/simplex/fe_p_bubbles_01.with_simplex_support=on.output b/tests/simplex/fe_p_bubbles_01.with_simplex_support=on.output
new file mode 100644
index 0000000000..7555cff88f
--- /dev/null
+++ b/tests/simplex/fe_p_bubbles_01.with_simplex_support=on.output
@@ -0,0 +1,181 @@
+
+DEAL::Test support points for dim = 1 and spacedim = 1
+DEAL::approximation degree = 0
+DEAL::element tensor degree = 0
+DEAL:FE_SimplexP_Bubbles<1>(0)::0.500000 : 
+DEAL:FE_SimplexP_Bubbles<1>(0)::1.00000 0.00000 0.00000 
+DEAL:FE_SimplexP_Bubbles<1>(0)::
+DEAL::approximation degree = 1
+DEAL::element tensor degree = 1
+DEAL:FE_SimplexP_Bubbles<1>(1)::0.00000 : 
+DEAL:FE_SimplexP_Bubbles<1>(1)::1.00000 0.00000 -1.00000 1.00000 0.00000 0.00000 
+DEAL:FE_SimplexP_Bubbles<1>(1)::1.00000 : 
+DEAL:FE_SimplexP_Bubbles<1>(1)::0.00000 1.00000 -1.00000 1.00000 0.00000 0.00000 
+DEAL:FE_SimplexP_Bubbles<1>(1)::
+DEAL::approximation degree = 2
+DEAL::element tensor degree = 2
+DEAL:FE_SimplexP_Bubbles<1>(2)::0.00000 : 
+DEAL:FE_SimplexP_Bubbles<1>(2)::1.00000 0.00000 0.00000 -3.00000 -1.00000 4.00000 4.00000 4.00000 -8.00000 
+DEAL:FE_SimplexP_Bubbles<1>(2)::1.00000 : 
+DEAL:FE_SimplexP_Bubbles<1>(2)::0.00000 1.00000 0.00000 1.00000 3.00000 -4.00000 4.00000 4.00000 -8.00000 
+DEAL:FE_SimplexP_Bubbles<1>(2)::0.500000 : 
+DEAL:FE_SimplexP_Bubbles<1>(2)::0.00000 0.00000 1.00000 -1.00000 1.00000 0.00000 4.00000 4.00000 -8.00000 
+DEAL:FE_SimplexP_Bubbles<1>(2)::
+DEAL::Test support points for dim = 1 and spacedim = 2
+DEAL::approximation degree = 0
+DEAL::element tensor degree = 0
+DEAL:FE_SimplexP_Bubbles<1,2>(0)::0.500000 : 
+DEAL:FE_SimplexP_Bubbles<1,2>(0)::1.00000 0.00000 0.00000 
+DEAL:FE_SimplexP_Bubbles<1,2>(0)::
+DEAL::approximation degree = 1
+DEAL::element tensor degree = 1
+DEAL:FE_SimplexP_Bubbles<1,2>(1)::0.00000 : 
+DEAL:FE_SimplexP_Bubbles<1,2>(1)::1.00000 0.00000 -1.00000 1.00000 0.00000 0.00000 
+DEAL:FE_SimplexP_Bubbles<1,2>(1)::1.00000 : 
+DEAL:FE_SimplexP_Bubbles<1,2>(1)::0.00000 1.00000 -1.00000 1.00000 0.00000 0.00000 
+DEAL:FE_SimplexP_Bubbles<1,2>(1)::
+DEAL::approximation degree = 2
+DEAL::element tensor degree = 2
+DEAL:FE_SimplexP_Bubbles<1,2>(2)::0.00000 : 
+DEAL:FE_SimplexP_Bubbles<1,2>(2)::1.00000 0.00000 0.00000 -3.00000 -1.00000 4.00000 4.00000 4.00000 -8.00000 
+DEAL:FE_SimplexP_Bubbles<1,2>(2)::1.00000 : 
+DEAL:FE_SimplexP_Bubbles<1,2>(2)::0.00000 1.00000 0.00000 1.00000 3.00000 -4.00000 4.00000 4.00000 -8.00000 
+DEAL:FE_SimplexP_Bubbles<1,2>(2)::0.500000 : 
+DEAL:FE_SimplexP_Bubbles<1,2>(2)::0.00000 0.00000 1.00000 -1.00000 1.00000 0.00000 4.00000 4.00000 -8.00000 
+DEAL:FE_SimplexP_Bubbles<1,2>(2)::
+DEAL::Test support points for dim = 1 and spacedim = 3
+DEAL::approximation degree = 0
+DEAL::element tensor degree = 0
+DEAL:FE_SimplexP_Bubbles<1,3>(0)::0.500000 : 
+DEAL:FE_SimplexP_Bubbles<1,3>(0)::1.00000 0.00000 0.00000 
+DEAL:FE_SimplexP_Bubbles<1,3>(0)::
+DEAL::approximation degree = 1
+DEAL::element tensor degree = 1
+DEAL:FE_SimplexP_Bubbles<1,3>(1)::0.00000 : 
+DEAL:FE_SimplexP_Bubbles<1,3>(1)::1.00000 0.00000 -1.00000 1.00000 0.00000 0.00000 
+DEAL:FE_SimplexP_Bubbles<1,3>(1)::1.00000 : 
+DEAL:FE_SimplexP_Bubbles<1,3>(1)::0.00000 1.00000 -1.00000 1.00000 0.00000 0.00000 
+DEAL:FE_SimplexP_Bubbles<1,3>(1)::
+DEAL::approximation degree = 2
+DEAL::element tensor degree = 2
+DEAL:FE_SimplexP_Bubbles<1,3>(2)::0.00000 : 
+DEAL:FE_SimplexP_Bubbles<1,3>(2)::1.00000 0.00000 0.00000 -3.00000 -1.00000 4.00000 4.00000 4.00000 -8.00000 
+DEAL:FE_SimplexP_Bubbles<1,3>(2)::1.00000 : 
+DEAL:FE_SimplexP_Bubbles<1,3>(2)::0.00000 1.00000 0.00000 1.00000 3.00000 -4.00000 4.00000 4.00000 -8.00000 
+DEAL:FE_SimplexP_Bubbles<1,3>(2)::0.500000 : 
+DEAL:FE_SimplexP_Bubbles<1,3>(2)::0.00000 0.00000 1.00000 -1.00000 1.00000 0.00000 4.00000 4.00000 -8.00000 
+DEAL:FE_SimplexP_Bubbles<1,3>(2)::
+DEAL::Test support points for dim = 2 and spacedim = 2
+DEAL::approximation degree = 0
+DEAL::element tensor degree = 0
+DEAL:FE_SimplexP_Bubbles<2>(0)::0.333333 0.333333 : 
+DEAL:FE_SimplexP_Bubbles<2>(0)::1.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 
+DEAL:FE_SimplexP_Bubbles<2>(0)::
+DEAL::approximation degree = 1
+DEAL::element tensor degree = 1
+DEAL:FE_SimplexP_Bubbles<2>(1)::0.00000 0.00000 : 
+DEAL:FE_SimplexP_Bubbles<2>(1)::1.00000 0.00000 0.00000 -1.00000 -1.00000 1.00000 0.00000 0.00000 1.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 
+DEAL:FE_SimplexP_Bubbles<2>(1)::1.00000 0.00000 : 
+DEAL:FE_SimplexP_Bubbles<2>(1)::0.00000 1.00000 0.00000 -1.00000 -1.00000 1.00000 0.00000 0.00000 1.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 
+DEAL:FE_SimplexP_Bubbles<2>(1)::0.00000 1.00000 : 
+DEAL:FE_SimplexP_Bubbles<2>(1)::0.00000 0.00000 1.00000 -1.00000 -1.00000 1.00000 0.00000 0.00000 1.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 
+DEAL:FE_SimplexP_Bubbles<2>(1)::
+DEAL::approximation degree = 2
+DEAL::element tensor degree = 3
+DEAL:FE_SimplexP_Bubbles<2>(2)::0.00000 0.00000 : 
+DEAL:FE_SimplexP_Bubbles<2>(2)::1.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 -3.00000 -3.00000 -1.00000 0.00000 0.00000 -1.00000 4.00000 0.00000 0.00000 0.00000 0.00000 4.00000 0.00000 0.00000 4.00000 7.00000 7.00000 4.00000 4.00000 3.00000 3.00000 0.00000 0.00000 3.00000 3.00000 4.00000 -8.00000 -16.0000 -16.0000 0.00000 0.00000 -8.00000 -8.00000 0.00000 0.00000 -16.0000 -16.0000 -8.00000 0.00000 27.0000 27.0000 0.00000 
+DEAL:FE_SimplexP_Bubbles<2>(2)::1.00000 0.00000 : 
+DEAL:FE_SimplexP_Bubbles<2>(2)::0.00000 1.00000 0.00000 0.00000 0.00000 0.00000 0.00000 1.00000 1.00000 3.00000 0.00000 0.00000 -1.00000 -4.00000 -4.00000 0.00000 4.00000 0.00000 0.00000 0.00000 0.00000 4.00000 1.00000 1.00000 -2.00000 4.00000 -3.00000 -3.00000 -6.00000 0.00000 -3.00000 -3.00000 -2.00000 -8.00000 8.00000 8.00000 24.0000 0.00000 16.0000 16.0000 24.0000 0.00000 8.00000 8.00000 16.0000 0.00000 -27.0000 -27.0000 -54.0000 
+DEAL:FE_SimplexP_Bubbles<2>(2)::0.00000 1.00000 : 
+DEAL:FE_SimplexP_Bubbles<2>(2)::0.00000 0.00000 1.00000 0.00000 0.00000 0.00000 0.00000 1.00000 1.00000 -1.00000 0.00000 0.00000 3.00000 0.00000 0.00000 4.00000 0.00000 -4.00000 -4.00000 0.00000 0.00000 -2.00000 1.00000 1.00000 4.00000 -2.00000 -3.00000 -3.00000 0.00000 -6.00000 -3.00000 -3.00000 4.00000 16.0000 8.00000 8.00000 0.00000 24.0000 16.0000 16.0000 0.00000 24.0000 8.00000 8.00000 -8.00000 -54.0000 -27.0000 -27.0000 0.00000 
+DEAL:FE_SimplexP_Bubbles<2>(2)::0.500000 0.00000 : 
+DEAL:FE_SimplexP_Bubbles<2>(2)::0.00000 0.00000 0.00000 1.00000 0.00000 0.00000 0.00000 -1.00000 -0.250000 1.00000 0.750000 0.00000 -0.250000 0.00000 -5.00000 0.00000 -1.00000 0.00000 -1.00000 0.00000 6.75000 4.00000 4.00000 4.00000 1.00000 4.00000 0.00000 0.00000 -3.00000 0.00000 0.00000 0.00000 1.00000 -8.00000 -4.00000 -4.00000 12.0000 0.00000 4.00000 4.00000 12.0000 0.00000 -4.00000 -4.00000 4.00000 0.00000 0.00000 0.00000 -27.0000 
+DEAL:FE_SimplexP_Bubbles<2>(2)::0.500000 0.500000 : 
+DEAL:FE_SimplexP_Bubbles<2>(2)::0.00000 0.00000 0.00000 0.00000 1.00000 0.00000 0.00000 0.250000 0.250000 0.250000 -0.750000 -0.750000 0.250000 1.00000 1.00000 5.00000 5.00000 1.00000 1.00000 -6.75000 -6.75000 1.00000 1.00000 1.00000 1.00000 1.00000 -3.00000 -3.00000 -3.00000 -3.00000 -3.00000 -3.00000 1.00000 4.00000 8.00000 8.00000 12.0000 12.0000 16.0000 16.0000 12.0000 12.0000 8.00000 8.00000 4.00000 -27.0000 -27.0000 -27.0000 -27.0000 
+DEAL:FE_SimplexP_Bubbles<2>(2)::0.00000 0.500000 : 
+DEAL:FE_SimplexP_Bubbles<2>(2)::0.00000 0.00000 0.00000 0.00000 0.00000 1.00000 0.00000 -0.250000 -1.00000 -0.250000 0.00000 0.750000 1.00000 -1.00000 0.00000 -1.00000 0.00000 -5.00000 0.00000 6.75000 0.00000 1.00000 4.00000 4.00000 4.00000 1.00000 0.00000 0.00000 0.00000 -3.00000 0.00000 0.00000 4.00000 4.00000 -4.00000 -4.00000 0.00000 12.0000 4.00000 4.00000 0.00000 12.0000 -4.00000 -4.00000 -8.00000 -27.0000 0.00000 0.00000 0.00000 
+DEAL:FE_SimplexP_Bubbles<2>(2)::0.333333 0.333333 : 
+DEAL:FE_SimplexP_Bubbles<2>(2)::0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 1.00000 -0.333333 -0.333333 0.333333 1.11022e-16 1.11022e-16 0.333333 2.22045e-16 -1.33333 1.33333 1.33333 -1.33333 2.22045e-16 4.44089e-16 4.44089e-16 2.00000 3.00000 3.00000 2.00000 2.00000 -1.00000 -1.00000 -2.00000 -2.00000 -1.00000 -1.00000 2.00000 0.00000 -8.88178e-16 -8.88178e-16 8.00000 8.00000 8.00000 8.00000 8.00000 8.00000 -8.88178e-16 -8.88178e-16 0.00000 -18.0000 -9.00000 -9.00000 -18.0000 
+DEAL:FE_SimplexP_Bubbles<2>(2)::
+DEAL::Test support points for dim = 2 and spacedim = 3
+DEAL::approximation degree = 0
+DEAL::element tensor degree = 0
+DEAL:FE_SimplexP_Bubbles<2,3>(0)::0.333333 0.333333 : 
+DEAL:FE_SimplexP_Bubbles<2,3>(0)::1.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 
+DEAL:FE_SimplexP_Bubbles<2,3>(0)::
+DEAL::approximation degree = 1
+DEAL::element tensor degree = 1
+DEAL:FE_SimplexP_Bubbles<2,3>(1)::0.00000 0.00000 : 
+DEAL:FE_SimplexP_Bubbles<2,3>(1)::1.00000 0.00000 0.00000 -1.00000 -1.00000 1.00000 0.00000 0.00000 1.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 
+DEAL:FE_SimplexP_Bubbles<2,3>(1)::1.00000 0.00000 : 
+DEAL:FE_SimplexP_Bubbles<2,3>(1)::0.00000 1.00000 0.00000 -1.00000 -1.00000 1.00000 0.00000 0.00000 1.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 
+DEAL:FE_SimplexP_Bubbles<2,3>(1)::0.00000 1.00000 : 
+DEAL:FE_SimplexP_Bubbles<2,3>(1)::0.00000 0.00000 1.00000 -1.00000 -1.00000 1.00000 0.00000 0.00000 1.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 
+DEAL:FE_SimplexP_Bubbles<2,3>(1)::
+DEAL::approximation degree = 2
+DEAL::element tensor degree = 3
+DEAL:FE_SimplexP_Bubbles<2,3>(2)::0.00000 0.00000 : 
+DEAL:FE_SimplexP_Bubbles<2,3>(2)::1.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 -3.00000 -3.00000 -1.00000 0.00000 0.00000 -1.00000 4.00000 0.00000 0.00000 0.00000 0.00000 4.00000 0.00000 0.00000 4.00000 7.00000 7.00000 4.00000 4.00000 3.00000 3.00000 0.00000 0.00000 3.00000 3.00000 4.00000 -8.00000 -16.0000 -16.0000 0.00000 0.00000 -8.00000 -8.00000 0.00000 0.00000 -16.0000 -16.0000 -8.00000 0.00000 27.0000 27.0000 0.00000 
+DEAL:FE_SimplexP_Bubbles<2,3>(2)::1.00000 0.00000 : 
+DEAL:FE_SimplexP_Bubbles<2,3>(2)::0.00000 1.00000 0.00000 0.00000 0.00000 0.00000 0.00000 1.00000 1.00000 3.00000 0.00000 0.00000 -1.00000 -4.00000 -4.00000 0.00000 4.00000 0.00000 0.00000 0.00000 0.00000 4.00000 1.00000 1.00000 -2.00000 4.00000 -3.00000 -3.00000 -6.00000 0.00000 -3.00000 -3.00000 -2.00000 -8.00000 8.00000 8.00000 24.0000 0.00000 16.0000 16.0000 24.0000 0.00000 8.00000 8.00000 16.0000 0.00000 -27.0000 -27.0000 -54.0000 
+DEAL:FE_SimplexP_Bubbles<2,3>(2)::0.00000 1.00000 : 
+DEAL:FE_SimplexP_Bubbles<2,3>(2)::0.00000 0.00000 1.00000 0.00000 0.00000 0.00000 0.00000 1.00000 1.00000 -1.00000 0.00000 0.00000 3.00000 0.00000 0.00000 4.00000 0.00000 -4.00000 -4.00000 0.00000 0.00000 -2.00000 1.00000 1.00000 4.00000 -2.00000 -3.00000 -3.00000 0.00000 -6.00000 -3.00000 -3.00000 4.00000 16.0000 8.00000 8.00000 0.00000 24.0000 16.0000 16.0000 0.00000 24.0000 8.00000 8.00000 -8.00000 -54.0000 -27.0000 -27.0000 0.00000 
+DEAL:FE_SimplexP_Bubbles<2,3>(2)::0.500000 0.00000 : 
+DEAL:FE_SimplexP_Bubbles<2,3>(2)::0.00000 0.00000 0.00000 1.00000 0.00000 0.00000 0.00000 -1.00000 -0.250000 1.00000 0.750000 0.00000 -0.250000 0.00000 -5.00000 0.00000 -1.00000 0.00000 -1.00000 0.00000 6.75000 4.00000 4.00000 4.00000 1.00000 4.00000 0.00000 0.00000 -3.00000 0.00000 0.00000 0.00000 1.00000 -8.00000 -4.00000 -4.00000 12.0000 0.00000 4.00000 4.00000 12.0000 0.00000 -4.00000 -4.00000 4.00000 0.00000 0.00000 0.00000 -27.0000 
+DEAL:FE_SimplexP_Bubbles<2,3>(2)::0.500000 0.500000 : 
+DEAL:FE_SimplexP_Bubbles<2,3>(2)::0.00000 0.00000 0.00000 0.00000 1.00000 0.00000 0.00000 0.250000 0.250000 0.250000 -0.750000 -0.750000 0.250000 1.00000 1.00000 5.00000 5.00000 1.00000 1.00000 -6.75000 -6.75000 1.00000 1.00000 1.00000 1.00000 1.00000 -3.00000 -3.00000 -3.00000 -3.00000 -3.00000 -3.00000 1.00000 4.00000 8.00000 8.00000 12.0000 12.0000 16.0000 16.0000 12.0000 12.0000 8.00000 8.00000 4.00000 -27.0000 -27.0000 -27.0000 -27.0000 
+DEAL:FE_SimplexP_Bubbles<2,3>(2)::0.00000 0.500000 : 
+DEAL:FE_SimplexP_Bubbles<2,3>(2)::0.00000 0.00000 0.00000 0.00000 0.00000 1.00000 0.00000 -0.250000 -1.00000 -0.250000 0.00000 0.750000 1.00000 -1.00000 0.00000 -1.00000 0.00000 -5.00000 0.00000 6.75000 0.00000 1.00000 4.00000 4.00000 4.00000 1.00000 0.00000 0.00000 0.00000 -3.00000 0.00000 0.00000 4.00000 4.00000 -4.00000 -4.00000 0.00000 12.0000 4.00000 4.00000 0.00000 12.0000 -4.00000 -4.00000 -8.00000 -27.0000 0.00000 0.00000 0.00000 
+DEAL:FE_SimplexP_Bubbles<2,3>(2)::0.333333 0.333333 : 
+DEAL:FE_SimplexP_Bubbles<2,3>(2)::0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 1.00000 -0.333333 -0.333333 0.333333 1.11022e-16 1.11022e-16 0.333333 2.22045e-16 -1.33333 1.33333 1.33333 -1.33333 2.22045e-16 4.44089e-16 4.44089e-16 2.00000 3.00000 3.00000 2.00000 2.00000 -1.00000 -1.00000 -2.00000 -2.00000 -1.00000 -1.00000 2.00000 0.00000 -8.88178e-16 -8.88178e-16 8.00000 8.00000 8.00000 8.00000 8.00000 8.00000 -8.88178e-16 -8.88178e-16 0.00000 -18.0000 -9.00000 -9.00000 -18.0000 
+DEAL:FE_SimplexP_Bubbles<2,3>(2)::
+DEAL::Test support points for dim = 3 and spacedim = 3
+DEAL::approximation degree = 0
+DEAL::element tensor degree = 0
+DEAL:FE_SimplexP_Bubbles<3>(0)::0.250000 0.250000 0.250000 : 
+DEAL:FE_SimplexP_Bubbles<3>(0)::1.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 
+DEAL:FE_SimplexP_Bubbles<3>(0)::
+DEAL::approximation degree = 1
+DEAL::element tensor degree = 1
+DEAL:FE_SimplexP_Bubbles<3>(1)::0.00000 0.00000 0.00000 : 
+DEAL:FE_SimplexP_Bubbles<3>(1)::1.00000 0.00000 0.00000 0.00000 -1.00000 -1.00000 -1.00000 1.00000 0.00000 0.00000 0.00000 1.00000 0.00000 0.00000 0.00000 1.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 
+DEAL:FE_SimplexP_Bubbles<3>(1)::1.00000 0.00000 0.00000 : 
+DEAL:FE_SimplexP_Bubbles<3>(1)::0.00000 1.00000 0.00000 0.00000 -1.00000 -1.00000 -1.00000 1.00000 0.00000 0.00000 0.00000 1.00000 0.00000 0.00000 0.00000 1.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 
+DEAL:FE_SimplexP_Bubbles<3>(1)::0.00000 1.00000 0.00000 : 
+DEAL:FE_SimplexP_Bubbles<3>(1)::0.00000 0.00000 1.00000 0.00000 -1.00000 -1.00000 -1.00000 1.00000 0.00000 0.00000 0.00000 1.00000 0.00000 0.00000 0.00000 1.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 
+DEAL:FE_SimplexP_Bubbles<3>(1)::0.00000 0.00000 1.00000 : 
+DEAL:FE_SimplexP_Bubbles<3>(1)::0.00000 0.00000 0.00000 1.00000 -1.00000 -1.00000 -1.00000 1.00000 0.00000 0.00000 0.00000 1.00000 0.00000 0.00000 0.00000 1.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 
+DEAL:FE_SimplexP_Bubbles<3>(1)::
+DEAL::approximation degree = 2
+DEAL::element tensor degree = 3
+DEAL:FE_SimplexP_Bubbles<3>(2)::0.00000 0.00000 0.00000 : 
+DEAL:FE_SimplexP_Bubbles<3>(2)::1.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 -3.00000 -3.00000 -3.00000 -1.00000 0.00000 0.00000 0.00000 -1.00000 0.00000 0.00000 0.00000 -1.00000 4.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 4.00000 0.00000 0.00000 0.00000 4.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 4.00000 7.00000 7.00000 7.00000 4.00000 7.00000 7.00000 7.00000 4.00000 4.00000 3.00000 3.00000 3.00000 0.00000 0.00000 3.00000 0.00000 0.00000 0.00000 3.00000 0.00000 3.00000 4.00000 3.00000 0.00000 3.00000 0.00000 0.00000 0.00000 3.00000 0.00000 0.00000 3.00000 3.00000 3.00000 4.00000 -8.00000 -16.0000 -16.0000 -16.0000 0.00000 0.00000 -16.0000 0.00000 0.00000 0.00000 -8.00000 0.00000 -8.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 -16.0000 0.00000 -16.0000 -8.00000 -16.0000 0.00000 -16.0000 0.00000 0.00000 0.00000 -16.0000 0.00000 0.00000 -16.0000 -16.0000 -16.0000 -8.00000 0.00000 0.00000 -8.00000 0.00000 0.00000 0.00000 -8.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 -8.00000 0.00000 -8.00000 0.00000 0.00000 27.0000 0.00000 27.0000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 27.0000 0.00000 0.00000 0.00000 27.0000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 27.0000 0.00000 27.0000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 
+DEAL:FE_SimplexP_Bubbles<3>(2)::1.00000 0.00000 0.00000 : 
+DEAL:FE_SimplexP_Bubbles<3>(2)::0.00000 1.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 1.00000 1.00000 1.00000 3.00000 0.00000 0.00000 0.00000 -1.00000 0.00000 0.00000 0.00000 -1.00000 -4.00000 -4.00000 -4.00000 0.00000 4.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 4.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 4.00000 1.00000 1.00000 1.00000 -2.00000 -2.00000 1.00000 -2.00000 -2.00000 4.00000 -3.00000 -3.00000 -3.00000 -6.00000 -3.00000 -3.00000 -3.00000 -6.00000 0.00000 -3.00000 0.00000 -3.00000 -2.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 -3.00000 0.00000 0.00000 0.00000 -3.00000 0.00000 -2.00000 -8.00000 8.00000 8.00000 8.00000 24.0000 24.0000 8.00000 24.0000 24.0000 0.00000 16.0000 0.00000 16.0000 24.0000 0.00000 0.00000 0.00000 0.00000 0.00000 8.00000 0.00000 8.00000 16.0000 8.00000 0.00000 8.00000 0.00000 0.00000 0.00000 8.00000 0.00000 0.00000 8.00000 8.00000 8.00000 16.0000 0.00000 0.00000 16.0000 0.00000 0.00000 0.00000 16.0000 0.00000 24.0000 0.00000 0.00000 0.00000 0.00000 0.00000 -8.00000 0.00000 -8.00000 0.00000 0.00000 -27.0000 0.00000 -27.0000 -54.0000 -27.0000 0.00000 -27.0000 0.00000 0.00000 0.00000 -27.0000 0.00000 0.00000 -27.0000 -27.0000 -27.0000 -54.0000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 27.0000 0.00000 27.0000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 
+DEAL:FE_SimplexP_Bubbles<3>(2)::0.00000 1.00000 0.00000 : 
+DEAL:FE_SimplexP_Bubbles<3>(2)::0.00000 0.00000 1.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 1.00000 1.00000 1.00000 -1.00000 0.00000 0.00000 0.00000 3.00000 0.00000 0.00000 0.00000 -1.00000 0.00000 0.00000 0.00000 4.00000 0.00000 0.00000 -4.00000 -4.00000 -4.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 4.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 -2.00000 1.00000 -2.00000 1.00000 4.00000 1.00000 -2.00000 1.00000 -2.00000 -2.00000 -3.00000 0.00000 -3.00000 0.00000 0.00000 0.00000 0.00000 0.00000 -6.00000 -3.00000 -3.00000 -3.00000 4.00000 -3.00000 -3.00000 -3.00000 -6.00000 0.00000 0.00000 0.00000 0.00000 0.00000 -3.00000 0.00000 -3.00000 -2.00000 16.0000 8.00000 8.00000 8.00000 0.00000 0.00000 8.00000 0.00000 0.00000 24.0000 16.0000 0.00000 16.0000 0.00000 0.00000 0.00000 0.00000 0.00000 24.0000 8.00000 24.0000 8.00000 -8.00000 8.00000 24.0000 8.00000 24.0000 0.00000 0.00000 8.00000 0.00000 0.00000 8.00000 8.00000 8.00000 16.0000 0.00000 0.00000 -8.00000 0.00000 0.00000 0.00000 -8.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 16.0000 0.00000 16.0000 24.0000 -54.0000 -27.0000 -27.0000 -27.0000 0.00000 0.00000 -27.0000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 -27.0000 0.00000 0.00000 -27.0000 -27.0000 -27.0000 -54.0000 0.00000 0.00000 27.0000 0.00000 0.00000 0.00000 27.0000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 
+DEAL:FE_SimplexP_Bubbles<3>(2)::0.00000 0.00000 1.00000 : 
+DEAL:FE_SimplexP_Bubbles<3>(2)::0.00000 0.00000 0.00000 1.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 1.00000 1.00000 1.00000 -1.00000 0.00000 0.00000 0.00000 -1.00000 0.00000 0.00000 0.00000 3.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 -4.00000 -4.00000 -4.00000 4.00000 0.00000 0.00000 0.00000 4.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 -2.00000 -2.00000 1.00000 -2.00000 -2.00000 1.00000 1.00000 1.00000 4.00000 -2.00000 0.00000 -3.00000 0.00000 0.00000 0.00000 -3.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 -2.00000 -3.00000 0.00000 -3.00000 0.00000 -6.00000 -3.00000 -3.00000 -3.00000 -6.00000 -3.00000 -3.00000 -3.00000 4.00000 16.0000 8.00000 8.00000 8.00000 0.00000 0.00000 8.00000 0.00000 0.00000 0.00000 -8.00000 0.00000 -8.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 8.00000 0.00000 8.00000 16.0000 8.00000 0.00000 8.00000 0.00000 24.0000 24.0000 8.00000 24.0000 24.0000 8.00000 8.00000 8.00000 -8.00000 24.0000 0.00000 16.0000 0.00000 0.00000 0.00000 16.0000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 24.0000 16.0000 0.00000 16.0000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 -54.0000 -27.0000 -27.0000 -27.0000 0.00000 0.00000 -27.0000 0.00000 0.00000 0.00000 -27.0000 0.00000 -27.0000 -54.0000 -27.0000 0.00000 -27.0000 0.00000 0.00000 27.0000 0.00000 27.0000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 
+DEAL:FE_SimplexP_Bubbles<3>(2)::0.500000 0.00000 0.00000 : 
+DEAL:FE_SimplexP_Bubbles<3>(2)::0.00000 0.00000 0.00000 0.00000 1.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 -1.00000 -0.250000 -0.250000 1.00000 0.750000 0.750000 0.00000 -0.250000 0.00000 0.00000 0.00000 -0.250000 0.00000 -5.00000 -5.00000 0.00000 -1.00000 0.00000 0.00000 -1.00000 0.00000 0.00000 0.00000 -1.00000 0.00000 0.00000 -1.00000 0.00000 0.00000 0.00000 0.00000 6.75000 0.00000 0.00000 0.00000 6.75000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 4.00000 4.00000 4.00000 4.00000 1.00000 1.50000 4.00000 1.50000 1.00000 4.00000 0.00000 0.00000 0.00000 -3.00000 -2.50000 0.00000 -2.50000 -3.00000 0.00000 0.00000 0.00000 0.00000 1.00000 0.500000 0.00000 0.500000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.500000 0.00000 0.500000 1.00000 -8.00000 -4.00000 -4.00000 -4.00000 12.0000 20.0000 -4.00000 20.0000 12.0000 0.00000 4.00000 0.00000 4.00000 12.0000 8.00000 0.00000 8.00000 0.00000 0.00000 -4.00000 0.00000 -4.00000 4.00000 4.00000 0.00000 4.00000 0.00000 0.00000 0.00000 -4.00000 0.00000 0.00000 4.00000 -4.00000 4.00000 4.00000 0.00000 0.00000 4.00000 0.00000 0.00000 8.00000 4.00000 8.00000 12.0000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 -27.0000 -40.5000 0.00000 -40.5000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 -40.5000 0.00000 -40.5000 -27.0000 0.00000 0.00000 0.00000 0.00000 0.00000 -13.5000 0.00000 -13.5000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 -13.5000 0.00000 -13.5000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 64.0000 0.00000 64.0000 0.00000 
+DEAL:FE_SimplexP_Bubbles<3>(2)::0.500000 0.500000 0.00000 : 
+DEAL:FE_SimplexP_Bubbles<3>(2)::0.00000 0.00000 0.00000 0.00000 0.00000 1.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.250000 0.250000 0.250000 0.250000 -0.750000 0.00000 -0.750000 0.250000 0.00000 0.00000 0.00000 -0.250000 1.00000 1.00000 1.00000 5.00000 5.00000 0.00000 1.00000 1.00000 1.00000 0.00000 0.00000 -1.66533e-15 0.00000 0.00000 -1.00000 0.00000 0.00000 -1.00000 -6.75000 -6.75000 -6.75000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 6.75000 0.00000 0.00000 0.00000 1.00000 1.00000 0.500000 1.00000 1.00000 0.500000 0.500000 0.500000 8.88178e-15 1.00000 -3.00000 -0.500000 -3.00000 -3.00000 -0.500000 -0.500000 -0.500000 -1.00000 -3.00000 -3.00000 -0.500000 -3.00000 1.00000 -0.500000 -0.500000 -0.500000 -1.00000 0.00000 0.00000 -0.500000 0.00000 0.00000 -0.500000 -0.500000 -0.500000 0.00000 4.00000 8.00000 -1.24345e-14 8.00000 12.0000 4.00000 -1.24345e-14 4.00000 -4.00000 12.0000 16.0000 -8.00000 16.0000 12.0000 -8.00000 -8.00000 -8.00000 -16.0000 12.0000 8.00000 4.00000 8.00000 4.00000 -1.24345e-14 4.00000 -1.24345e-14 -4.00000 0.00000 0.00000 -1.24345e-14 0.00000 0.00000 -1.24345e-14 -1.24345e-14 -1.24345e-14 -1.77636e-14 0.00000 0.00000 -4.00000 0.00000 0.00000 -8.00000 -4.00000 -8.00000 -4.00000 0.00000 0.00000 -8.00000 0.00000 0.00000 -4.00000 -8.00000 -4.00000 -4.00000 -27.0000 -27.0000 13.5000 -27.0000 -27.0000 13.5000 13.5000 13.5000 54.0000 0.00000 0.00000 13.5000 0.00000 0.00000 13.5000 13.5000 13.5000 27.0000 0.00000 0.00000 13.5000 0.00000 0.00000 13.5000 13.5000 13.5000 27.0000 0.00000 0.00000 40.5000 0.00000 0.00000 40.5000 40.5000 40.5000 54.0000 0.00000 0.00000 -64.0000 0.00000 0.00000 -64.0000 -64.0000 -64.0000 -128.000 
+DEAL:FE_SimplexP_Bubbles<3>(2)::0.00000 0.500000 0.00000 : 
+DEAL:FE_SimplexP_Bubbles<3>(2)::0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 1.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 -0.250000 -1.00000 -0.250000 -0.250000 0.00000 0.00000 0.750000 1.00000 0.750000 0.00000 0.00000 -0.250000 -1.00000 0.00000 0.00000 -1.00000 0.00000 0.00000 -5.00000 0.00000 -5.00000 0.00000 0.00000 -1.00000 0.00000 0.00000 0.00000 0.00000 0.00000 -1.00000 6.75000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 6.75000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 1.00000 4.00000 1.50000 4.00000 4.00000 4.00000 1.50000 4.00000 1.00000 1.00000 0.00000 0.500000 0.00000 0.00000 0.00000 0.500000 0.00000 0.00000 -3.00000 0.00000 -2.50000 0.00000 4.00000 0.00000 -2.50000 0.00000 -3.00000 0.00000 0.00000 0.500000 0.00000 0.00000 0.00000 0.500000 0.00000 1.00000 4.00000 -4.00000 4.00000 -4.00000 0.00000 0.00000 4.00000 0.00000 0.00000 12.0000 4.00000 8.00000 4.00000 0.00000 0.00000 8.00000 0.00000 0.00000 12.0000 -4.00000 20.0000 -4.00000 -8.00000 -4.00000 20.0000 -4.00000 12.0000 0.00000 0.00000 4.00000 0.00000 0.00000 -4.00000 4.00000 -4.00000 4.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 8.00000 0.00000 0.00000 4.00000 8.00000 4.00000 12.0000 -27.0000 0.00000 -40.5000 0.00000 0.00000 0.00000 -40.5000 0.00000 0.00000 0.00000 0.00000 -13.5000 0.00000 0.00000 0.00000 -13.5000 0.00000 0.00000 0.00000 0.00000 -40.5000 0.00000 0.00000 0.00000 -40.5000 0.00000 -27.0000 0.00000 0.00000 -13.5000 0.00000 0.00000 0.00000 -13.5000 0.00000 0.00000 0.00000 0.00000 64.0000 0.00000 0.00000 0.00000 64.0000 0.00000 0.00000 
+DEAL:FE_SimplexP_Bubbles<3>(2)::0.00000 0.00000 0.500000 : 
+DEAL:FE_SimplexP_Bubbles<3>(2)::0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 1.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 -0.250000 -0.250000 -1.00000 -0.250000 0.00000 0.00000 0.00000 -0.250000 0.00000 0.750000 0.750000 1.00000 -1.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 -1.00000 0.00000 -5.00000 -5.00000 0.00000 -1.00000 0.00000 0.00000 0.00000 -1.00000 0.00000 0.00000 0.00000 0.00000 6.75000 0.00000 0.00000 0.00000 6.75000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 1.00000 1.50000 4.00000 1.50000 1.00000 4.00000 4.00000 4.00000 4.00000 1.00000 0.500000 0.00000 0.500000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.500000 0.00000 0.500000 1.00000 0.00000 0.00000 0.00000 0.00000 -3.00000 -2.50000 0.00000 -2.50000 -3.00000 0.00000 0.00000 0.00000 4.00000 4.00000 4.00000 -4.00000 4.00000 0.00000 0.00000 -4.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 4.00000 0.00000 4.00000 4.00000 -4.00000 0.00000 -4.00000 0.00000 12.0000 20.0000 -4.00000 20.0000 12.0000 -4.00000 -4.00000 -4.00000 -8.00000 12.0000 8.00000 4.00000 8.00000 0.00000 0.00000 4.00000 0.00000 0.00000 0.00000 8.00000 0.00000 8.00000 12.0000 4.00000 0.00000 4.00000 0.00000 0.00000 -13.5000 0.00000 -13.5000 0.00000 0.00000 0.00000 0.00000 0.00000 -27.0000 -40.5000 0.00000 -40.5000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 -40.5000 0.00000 -40.5000 -27.0000 0.00000 0.00000 0.00000 0.00000 0.00000 -13.5000 0.00000 -13.5000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 64.0000 0.00000 64.0000 0.00000 0.00000 0.00000 0.00000 0.00000 
+DEAL:FE_SimplexP_Bubbles<3>(2)::0.500000 0.00000 0.500000 : 
+DEAL:FE_SimplexP_Bubbles<3>(2)::0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 1.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.250000 0.250000 0.250000 0.250000 0.00000 -0.750000 0.00000 -0.250000 0.00000 -0.750000 0.00000 0.250000 1.00000 1.00000 1.00000 0.00000 -1.00000 0.00000 0.00000 -1.66533e-15 0.00000 1.00000 1.00000 1.00000 5.00000 0.00000 5.00000 0.00000 -1.00000 0.00000 0.00000 0.00000 0.00000 -6.75000 -6.75000 -6.75000 0.00000 0.00000 0.00000 0.00000 6.75000 0.00000 0.00000 0.00000 0.00000 1.00000 0.500000 1.00000 0.500000 8.88178e-15 0.500000 1.00000 0.500000 1.00000 1.00000 -0.500000 -3.00000 -0.500000 -1.00000 -0.500000 -3.00000 -0.500000 -3.00000 0.00000 -0.500000 0.00000 -0.500000 0.00000 -0.500000 0.00000 -0.500000 0.00000 -3.00000 -0.500000 -3.00000 -0.500000 -1.00000 -0.500000 -3.00000 -0.500000 1.00000 4.00000 -1.24345e-14 8.00000 -1.24345e-14 -4.00000 4.00000 8.00000 4.00000 12.0000 0.00000 -4.00000 0.00000 -4.00000 -4.00000 -8.00000 0.00000 -8.00000 0.00000 0.00000 -1.24345e-14 0.00000 -1.24345e-14 -1.77636e-14 -1.24345e-14 0.00000 -1.24345e-14 0.00000 12.0000 4.00000 8.00000 4.00000 -4.00000 -1.24345e-14 8.00000 -1.24345e-14 4.00000 12.0000 -8.00000 16.0000 -8.00000 -16.0000 -8.00000 16.0000 -8.00000 12.0000 0.00000 -8.00000 0.00000 -8.00000 -4.00000 -4.00000 0.00000 -4.00000 0.00000 0.00000 13.5000 0.00000 13.5000 27.0000 13.5000 0.00000 13.5000 0.00000 -27.0000 13.5000 -27.0000 13.5000 54.0000 13.5000 -27.0000 13.5000 -27.0000 0.00000 13.5000 0.00000 13.5000 27.0000 13.5000 0.00000 13.5000 0.00000 0.00000 40.5000 0.00000 40.5000 54.0000 40.5000 0.00000 40.5000 0.00000 0.00000 -64.0000 0.00000 -64.0000 -128.000 -64.0000 0.00000 -64.0000 0.00000 
+DEAL:FE_SimplexP_Bubbles<3>(2)::0.00000 0.500000 0.500000 : 
+DEAL:FE_SimplexP_Bubbles<3>(2)::0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 1.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.250000 0.250000 0.250000 -0.250000 0.00000 0.00000 0.00000 0.250000 -0.750000 0.00000 -0.750000 0.250000 -1.66533e-15 0.00000 0.00000 -1.00000 0.00000 0.00000 1.00000 1.00000 1.00000 1.00000 1.00000 1.00000 -1.00000 0.00000 0.00000 0.00000 5.00000 5.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 -6.75000 -6.75000 -6.75000 6.75000 0.00000 0.00000 0.00000 0.00000 0.00000 8.88178e-15 0.500000 0.500000 0.500000 1.00000 1.00000 0.500000 1.00000 1.00000 0.00000 -0.500000 -0.500000 -0.500000 0.00000 0.00000 -0.500000 0.00000 0.00000 -1.00000 -0.500000 -0.500000 -0.500000 1.00000 -3.00000 -0.500000 -3.00000 -3.00000 -1.00000 -0.500000 -0.500000 -0.500000 -3.00000 -3.00000 -0.500000 -3.00000 1.00000 -1.77636e-14 -1.24345e-14 -1.24345e-14 -1.24345e-14 0.00000 0.00000 -1.24345e-14 0.00000 0.00000 -4.00000 -4.00000 -8.00000 -4.00000 0.00000 0.00000 -8.00000 0.00000 0.00000 -4.00000 -1.24345e-14 4.00000 -1.24345e-14 4.00000 8.00000 4.00000 8.00000 12.0000 -4.00000 4.00000 -1.24345e-14 4.00000 12.0000 8.00000 -1.24345e-14 8.00000 4.00000 -4.00000 -8.00000 -4.00000 -8.00000 0.00000 0.00000 -4.00000 0.00000 0.00000 -16.0000 -8.00000 -8.00000 -8.00000 12.0000 16.0000 -8.00000 16.0000 12.0000 27.0000 13.5000 13.5000 13.5000 0.00000 0.00000 13.5000 0.00000 0.00000 27.0000 13.5000 13.5000 13.5000 0.00000 0.00000 13.5000 0.00000 0.00000 54.0000 13.5000 13.5000 13.5000 -27.0000 -27.0000 13.5000 -27.0000 -27.0000 54.0000 40.5000 40.5000 40.5000 0.00000 0.00000 40.5000 0.00000 0.00000 -128.000 -64.0000 -64.0000 -64.0000 0.00000 0.00000 -64.0000 0.00000 0.00000 
+DEAL:FE_SimplexP_Bubbles<3>(2)::0.333333 0.333333 0.00000 : 
+DEAL:FE_SimplexP_Bubbles<3>(2)::2.77556e-17 2.77556e-17 2.77556e-17 0.00000 -5.55112e-17 -1.11022e-16 -5.55112e-17 0.00000 0.00000 0.00000 1.00000 0.00000 0.00000 0.00000 0.00000 -0.333333 -0.333333 -0.148148 0.333333 5.55112e-17 0.185185 5.55112e-17 0.333333 0.185185 0.00000 0.00000 -0.148148 2.22045e-16 -1.33333 -0.148148 1.33333 1.33333 1.18519 -1.33333 2.22045e-16 -0.148148 0.00000 0.00000 -0.148148 0.00000 0.00000 -0.148148 0.00000 0.00000 -0.148148 4.44089e-16 4.44089e-16 -7.00000 0.00000 0.00000 -1.00000 0.00000 0.00000 -1.00000 0.00000 0.00000 -1.00000 0.00000 0.00000 9.48148 2.00000 3.00000 2.00000 3.00000 2.00000 2.00000 2.00000 2.00000 0.888889 2.00000 -1.00000 1.11022e-16 -1.00000 -2.00000 -1.00000 1.11022e-16 -1.00000 -1.11111 -2.00000 -1.00000 -1.00000 -1.00000 2.00000 1.11022e-16 -1.00000 1.11022e-16 -1.11111 0.00000 0.00000 1.11022e-16 0.00000 0.00000 1.11022e-16 1.11022e-16 1.11022e-16 0.888889 0.00000 -1.77636e-15 -2.66454e-15 -1.77636e-15 8.00000 8.00000 -2.66454e-15 8.00000 0.888889 8.00000 8.00000 8.88178e-16 8.00000 8.00000 8.88178e-16 8.88178e-16 8.88178e-16 -7.11111 8.00000 -1.77636e-15 8.00000 -1.77636e-15 0.00000 -2.66454e-15 8.00000 -2.66454e-15 0.888889 0.00000 0.00000 -2.66454e-15 0.00000 0.00000 -2.66454e-15 -2.66454e-15 -2.66454e-15 0.888889 0.00000 0.00000 0.00000 0.00000 0.00000 8.88178e-16 0.00000 8.88178e-16 0.888889 0.00000 0.00000 8.88178e-16 0.00000 0.00000 0.00000 8.88178e-16 0.00000 0.888889 -18.0000 -9.00000 -9.00000 -9.00000 -18.0000 -9.00000 -9.00000 -9.00000 24.0000 0.00000 0.00000 0.00000 0.00000 0.00000 -9.00000 0.00000 -9.00000 6.00000 0.00000 0.00000 -9.00000 0.00000 0.00000 0.00000 -9.00000 0.00000 6.00000 0.00000 0.00000 9.00000 0.00000 0.00000 9.00000 9.00000 9.00000 24.0000 0.00000 0.00000 7.10543e-15 0.00000 0.00000 7.10543e-15 7.10543e-15 7.10543e-15 -56.8889 
+DEAL:FE_SimplexP_Bubbles<3>(2)::0.333333 0.00000 0.333333 : 
+DEAL:FE_SimplexP_Bubbles<3>(2)::2.77556e-17 2.77556e-17 0.00000 2.77556e-17 -5.55112e-17 0.00000 0.00000 -5.55112e-17 -1.11022e-16 0.00000 0.00000 1.00000 0.00000 0.00000 0.00000 -0.333333 -0.148148 -0.333333 0.333333 0.185185 5.55112e-17 0.00000 -0.148148 0.00000 5.55112e-17 0.185185 0.333333 2.22045e-16 -0.148148 -1.33333 0.00000 -0.148148 0.00000 0.00000 -0.148148 0.00000 -1.33333 -0.148148 2.22045e-16 1.33333 1.18519 1.33333 0.00000 -0.148148 0.00000 0.00000 -1.00000 0.00000 4.44089e-16 -7.00000 4.44089e-16 0.00000 -1.00000 0.00000 0.00000 -1.00000 0.00000 0.00000 9.48148 0.00000 2.00000 2.00000 3.00000 2.00000 0.888889 2.00000 3.00000 2.00000 2.00000 2.00000 1.11022e-16 -1.00000 1.11022e-16 -1.11111 -1.00000 -1.00000 -1.00000 -2.00000 0.00000 1.11022e-16 0.00000 1.11022e-16 0.888889 1.11022e-16 0.00000 1.11022e-16 0.00000 -2.00000 -1.00000 -1.00000 -1.00000 -1.11111 1.11022e-16 -1.00000 1.11022e-16 2.00000 0.00000 -2.66454e-15 -1.77636e-15 -2.66454e-15 0.888889 8.00000 -1.77636e-15 8.00000 8.00000 0.00000 0.00000 0.00000 0.00000 0.888889 8.88178e-16 0.00000 8.88178e-16 0.00000 0.00000 -2.66454e-15 0.00000 -2.66454e-15 0.888889 -2.66454e-15 0.00000 -2.66454e-15 0.00000 8.00000 8.00000 -1.77636e-15 8.00000 0.888889 -2.66454e-15 -1.77636e-15 -2.66454e-15 0.00000 8.00000 8.88178e-16 8.00000 8.88178e-16 -7.11111 8.88178e-16 8.00000 8.88178e-16 8.00000 0.00000 8.88178e-16 0.00000 8.88178e-16 0.888889 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 6.00000 -9.00000 0.00000 -9.00000 0.00000 -18.0000 -9.00000 -9.00000 -9.00000 24.0000 -9.00000 -9.00000 -9.00000 -18.0000 0.00000 -9.00000 0.00000 -9.00000 6.00000 0.00000 0.00000 0.00000 0.00000 0.00000 9.00000 0.00000 9.00000 24.0000 9.00000 0.00000 9.00000 0.00000 0.00000 7.10543e-15 0.00000 7.10543e-15 -56.8889 7.10543e-15 0.00000 7.10543e-15 0.00000 
+DEAL:FE_SimplexP_Bubbles<3>(2)::0.00000 0.333333 0.333333 : 
+DEAL:FE_SimplexP_Bubbles<3>(2)::2.77556e-17 0.00000 2.77556e-17 2.77556e-17 0.00000 0.00000 -5.55112e-17 -5.55112e-17 0.00000 -1.11022e-16 0.00000 0.00000 1.00000 0.00000 0.00000 -0.148148 -0.333333 -0.333333 -0.148148 0.00000 0.00000 0.185185 0.333333 5.55112e-17 0.185185 5.55112e-17 0.333333 -0.148148 0.00000 0.00000 -0.148148 0.00000 0.00000 -0.148148 2.22045e-16 -1.33333 -0.148148 -1.33333 2.22045e-16 -0.148148 0.00000 0.00000 1.18519 1.33333 1.33333 -1.00000 0.00000 0.00000 -1.00000 0.00000 0.00000 -7.00000 4.44089e-16 4.44089e-16 -1.00000 0.00000 0.00000 9.48148 0.00000 0.00000 0.888889 2.00000 2.00000 2.00000 2.00000 3.00000 2.00000 3.00000 2.00000 0.888889 1.11022e-16 1.11022e-16 1.11022e-16 0.00000 0.00000 1.11022e-16 0.00000 0.00000 -1.11111 1.11022e-16 -1.00000 1.11022e-16 2.00000 -1.00000 -1.00000 -1.00000 -2.00000 -1.11111 -1.00000 1.11022e-16 -1.00000 -2.00000 -1.00000 1.11022e-16 -1.00000 2.00000 0.888889 -2.66454e-15 -2.66454e-15 -2.66454e-15 0.00000 0.00000 -2.66454e-15 0.00000 0.00000 0.888889 0.00000 8.88178e-16 0.00000 0.00000 0.00000 8.88178e-16 0.00000 0.00000 0.888889 -2.66454e-15 8.00000 -2.66454e-15 0.00000 -1.77636e-15 8.00000 -1.77636e-15 8.00000 0.888889 8.00000 -2.66454e-15 8.00000 8.00000 -1.77636e-15 -2.66454e-15 -1.77636e-15 0.00000 0.888889 8.88178e-16 0.00000 8.88178e-16 0.00000 0.00000 0.00000 0.00000 0.00000 -7.11111 8.88178e-16 8.88178e-16 8.88178e-16 8.00000 8.00000 8.88178e-16 8.00000 8.00000 6.00000 0.00000 -9.00000 0.00000 0.00000 0.00000 -9.00000 0.00000 0.00000 6.00000 -9.00000 0.00000 -9.00000 0.00000 0.00000 0.00000 0.00000 0.00000 24.0000 -9.00000 -9.00000 -9.00000 -18.0000 -9.00000 -9.00000 -9.00000 -18.0000 24.0000 9.00000 9.00000 9.00000 0.00000 0.00000 9.00000 0.00000 0.00000 -56.8889 7.10543e-15 7.10543e-15 7.10543e-15 0.00000 0.00000 7.10543e-15 0.00000 0.00000 
+DEAL:FE_SimplexP_Bubbles<3>(2)::0.333333 0.333333 0.333333 : 
+DEAL:FE_SimplexP_Bubbles<3>(2)::1.31582e-16 5.75671e-17 5.75671e-17 5.75671e-17 -2.63164e-16 -1.64477e-17 -2.63164e-16 -2.63164e-16 -1.64477e-17 -1.64477e-17 -1.11022e-16 -1.11022e-16 -1.11022e-16 1.00000 1.05266e-15 0.148148 0.148148 0.148148 0.148148 -0.185185 -0.185185 -0.185185 0.148148 -0.185185 -0.185185 -0.185185 0.148148 0.148148 0.148148 0.148148 0.148148 0.148148 -1.18519 0.148148 0.148148 0.148148 0.148148 0.148148 0.148148 0.148148 -1.18519 0.148148 -1.18519 0.148148 0.148148 1.00000 1.00000 1.00000 1.00000 1.00000 1.00000 1.00000 1.00000 1.00000 7.00000 7.00000 7.00000 -9.48148 -9.48148 -9.48148 0.888889 0.888889 0.888889 0.888889 0.888889 0.888889 0.888889 0.888889 0.888889 0.888889 -1.11111 -1.11111 -1.11111 -1.11111 -0.111111 -1.11111 -0.111111 -1.11111 -1.11111 -1.11111 -0.111111 -1.11111 0.888889 -1.11111 -0.111111 -1.11111 -1.11111 -1.11111 -0.111111 -1.11111 -0.111111 -1.11111 -1.11111 -1.11111 -1.11111 0.888889 0.888889 0.888889 0.888889 0.888889 0.888889 0.888889 0.888889 0.888889 0.888889 0.888889 0.888889 -7.11111 0.888889 0.888889 -7.11111 -7.11111 -7.11111 -7.11111 0.888889 0.888889 0.888889 0.888889 0.888889 0.888889 0.888889 0.888889 0.888889 0.888889 0.888889 0.888889 0.888889 0.888889 0.888889 0.888889 0.888889 0.888889 0.888889 -7.11111 0.888889 -7.11111 -7.11111 -7.11111 0.888889 -7.11111 0.888889 -7.11111 -7.11111 -7.11111 -7.11111 0.888889 0.888889 -7.11111 0.888889 0.888889 6.00000 6.00000 15.0000 6.00000 6.00000 15.0000 15.0000 15.0000 24.0000 6.00000 15.0000 6.00000 15.0000 24.0000 15.0000 6.00000 15.0000 6.00000 24.0000 15.0000 15.0000 15.0000 6.00000 6.00000 15.0000 6.00000 6.00000 24.0000 33.0000 33.0000 33.0000 24.0000 33.0000 33.0000 33.0000 24.0000 -56.8889 -56.8889 -56.8889 -56.8889 -56.8889 -56.8889 -56.8889 -56.8889 -56.8889 
+DEAL:FE_SimplexP_Bubbles<3>(2)::0.250000 0.250000 0.250000 : 
+DEAL:FE_SimplexP_Bubbles<3>(2)::0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 1.00000 -0.187500 -0.187500 -0.187500 0.187500 0.00000 0.00000 0.00000 0.187500 0.00000 0.00000 0.00000 0.187500 -4.44089e-16 -0.250000 -0.250000 0.250000 0.250000 0.00000 -0.250000 -4.44089e-16 -0.250000 -0.250000 -0.250000 -4.44089e-16 0.250000 0.00000 0.250000 0.00000 0.250000 0.250000 0.00000 0.00000 -1.68750 0.00000 -1.68750 0.00000 -1.68750 0.00000 0.00000 1.68750 1.68750 1.68750 0.00000 0.00000 0.00000 1.50000 2.00000 2.00000 2.00000 1.50000 2.00000 2.00000 2.00000 1.50000 1.50000 -0.500000 -0.500000 -0.500000 -1.00000 -0.500000 -0.500000 -0.500000 -1.00000 -1.00000 -0.500000 -0.500000 -0.500000 1.50000 -0.500000 -0.500000 -0.500000 -1.00000 -1.00000 -0.500000 -0.500000 -0.500000 -1.00000 -0.500000 -0.500000 -0.500000 1.50000 -3.55271e-15 -3.55271e-15 -3.55271e-15 -3.55271e-15 2.00000 4.00000 -3.55271e-15 4.00000 2.00000 2.00000 2.00000 -2.00000 2.00000 2.00000 -2.00000 -2.00000 -2.00000 -4.00000 2.00000 -3.55271e-15 4.00000 -3.55271e-15 -3.55271e-15 -3.10862e-15 4.00000 -3.10862e-15 2.00000 2.00000 4.00000 -3.55271e-15 4.00000 2.00000 -3.10862e-15 -3.55271e-15 -3.10862e-15 -3.55271e-15 2.00000 -2.00000 2.00000 -2.00000 -4.00000 -2.00000 2.00000 -2.00000 2.00000 -4.00000 -2.00000 -2.00000 -2.00000 2.00000 2.00000 -2.00000 2.00000 2.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 13.5000 0.00000 0.00000 0.00000 0.00000 13.5000 0.00000 0.00000 0.00000 0.00000 13.5000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000 13.5000 13.5000 13.5000 13.5000 13.5000 13.5000 13.5000 13.5000 13.5000 -32.0000 -16.0000 -16.0000 -16.0000 -32.0000 -16.0000 -16.0000 -16.0000 -32.0000 
+DEAL:FE_SimplexP_Bubbles<3>(2)::
diff --git a/tests/simplex/fe_p_bubbles_02.cc b/tests/simplex/fe_p_bubbles_02.cc
index ca12e66851..4841b0fb2e 100644
--- a/tests/simplex/fe_p_bubbles_02.cc
+++ b/tests/simplex/fe_p_bubbles_02.cc
@@ -13,8 +13,8 @@
 //
 // ---------------------------------------------------------------------
 
-// Verify that FE_P_Bubbles can be used with a lumped mass matrix by computing a
-// convergence rate.
+// Verify that FE_SimplexP_Bubbles can be used with a lumped mass matrix by
+// computing a convergence rate.
 
 #include <deal.II/base/function_lib.h>
 #include <deal.II/base/quadrature_lib.h>
@@ -53,7 +53,7 @@ compute_nodal_quadrature(const FiniteElement<dim, spacedim> &fe)
   Triangulation<dim, spacedim> tria;
   GridGenerator::reference_cell(type, tria);
   const Mapping<dim, spacedim> &mapping =
-    get_default_linear_mapping<dim, spacedim>(type);
+    type.template get_default_linear_mapping<dim, spacedim>();
 
   auto                    cell = tria.begin_active();
   FEValues<dim, spacedim> fe_values(mapping,
@@ -110,7 +110,7 @@ test_interpolate()
           const Triangulation<dim, spacedim> &tria = trias[refinement_n];
           deallog << "number of cells = " << tria.n_active_cells() << std::endl;
 
-          Simplex::FE_P_Bubbles<dim, spacedim> fe(degree);
+          FE_SimplexP_Bubbles<dim, spacedim> fe(degree);
 
           const ReferenceCell       type = fe.reference_cell();
           DoFHandler<dim, spacedim> dh(tria);
@@ -118,13 +118,13 @@ test_interpolate()
           deallog << "number of dofs = " << dh.n_dofs() << std::endl;
 
           const Mapping<dim, spacedim> &map =
-            get_default_linear_mapping<dim, spacedim>(type);
+            type.template get_default_linear_mapping<dim, spacedim>();
 
           Vector<double> solution(dh.n_dofs());
           VectorTools::interpolate(map, dh, func, solution);
 
-          Simplex::QGauss<dim> error_quad(4);
-          Vector<double>       out_l2(tria.n_active_cells());
+          QGaussSimplex<dim> error_quad(4);
+          Vector<double>     out_l2(tria.n_active_cells());
           VectorTools::integrate_difference(
             map, dh, solution, func, out_l2, error_quad, VectorTools::L2_norm);
           const double new_error =
@@ -175,21 +175,21 @@ test_lumped_project()
           const Triangulation<dim, spacedim> &tria = trias[refinement_n];
           deallog << "number of cells = " << tria.n_active_cells() << std::endl;
 
-          Simplex::FE_P_Bubbles<dim, spacedim> fe(degree);
+          FE_SimplexP_Bubbles<dim, spacedim> fe(degree);
 
           const ReferenceCell       type = fe.reference_cell();
           DoFHandler<dim, spacedim> dh(tria);
           dh.distribute_dofs(fe);
           deallog << "number of dofs = " << dh.n_dofs() << std::endl;
           const Quadrature<dim> nodal_quad = compute_nodal_quadrature(fe);
-          const Quadrature<dim> cell_quad  = Simplex::QGauss<dim>(
+          const Quadrature<dim> cell_quad  = QGaussSimplex<dim>(
             std::max<unsigned int>(fe.tensor_degree() + 1, 2));
 
           Vector<double> lumped_mass(dh.n_dofs());
           Vector<double> consistent_rhs(dh.n_dofs());
 
           const Mapping<dim, spacedim> &map =
-            get_default_linear_mapping<dim, spacedim>(type);
+            type.template get_default_linear_mapping<dim, spacedim>();
 
           FEValues<dim> lumped_fev(map,
                                    fe,
@@ -232,8 +232,8 @@ test_lumped_project()
           for (std::size_t i = 0; i < solution.size(); ++i)
             solution[i] = consistent_rhs[i] / lumped_mass[i];
 
-          Simplex::QGauss<dim> error_quad(4);
-          Vector<double>       out_l2(tria.n_active_cells());
+          QGaussSimplex<dim> error_quad(4);
+          Vector<double>     out_l2(tria.n_active_cells());
           VectorTools::integrate_difference(
             map, dh, solution, func, out_l2, error_quad, VectorTools::L2_norm);
 
diff --git a/tests/simplex/fe_p_bubbles_02.with_simplex_support=on.out b/tests/simplex/fe_p_bubbles_02.with_simplex_support=on.output
similarity index 95%
rename from tests/simplex/fe_p_bubbles_02.with_simplex_support=on.out
rename to tests/simplex/fe_p_bubbles_02.with_simplex_support=on.output
index 85e5dbfdb3..41d0630803 100644
--- a/tests/simplex/fe_p_bubbles_02.with_simplex_support=on.out
+++ b/tests/simplex/fe_p_bubbles_02.with_simplex_support=on.output
@@ -41,15 +41,15 @@ DEAL::ratio = 3.77741
 DEAL::degree = 2
 DEAL::number of cells = 8
 DEAL::number of dofs = 33
-DEAL::error = 0.00424328
+DEAL::error = 0.00424076
 DEAL::number of cells = 32
 DEAL::number of dofs = 113
-DEAL::error = 0.000564602
-DEAL::ratio = 7.51554
+DEAL::error = 0.000564523
+DEAL::ratio = 7.51211
 DEAL::number of cells = 128
 DEAL::number of dofs = 417
-DEAL::error = 7.95939e-05
-DEAL::ratio = 7.09353
+DEAL::error = 7.95897e-05
+DEAL::ratio = 7.09292
 DEAL::
 DEAL::test interpolation
 DEAL::dim = 3
@@ -135,15 +135,15 @@ DEAL::ratio = 2.45946
 DEAL::degree = 2
 DEAL::number of cells = 8
 DEAL::number of dofs = 33
-DEAL::error = 0.0112526
+DEAL::error = 0.0112520
 DEAL::number of cells = 32
 DEAL::number of dofs = 113
-DEAL::error = 0.00294719
-DEAL::ratio = 3.81808
+DEAL::error = 0.00294718
+DEAL::ratio = 3.81787
 DEAL::number of cells = 128
 DEAL::number of dofs = 417
 DEAL::error = 0.000739778
-DEAL::ratio = 3.98389
+DEAL::ratio = 3.98388
 DEAL::number of cells = 512
 DEAL::number of dofs = 1601
 DEAL::error = 0.000195335
diff --git a/tests/simplex/get_projection_matrix_01.cc b/tests/simplex/get_projection_matrix_01.cc
index 327b17589d..a1e2235410 100644
--- a/tests/simplex/get_projection_matrix_01.cc
+++ b/tests/simplex/get_projection_matrix_01.cc
@@ -60,9 +60,9 @@ template <int dim, int spacedim = dim>
 void
 test()
 {
-  Simplex::FE_P<dim, spacedim> fe_coarse(1);
-  Simplex::FE_P<dim, spacedim> fe_fine(2);
-  MappingFE<dim>               mapping(Simplex::FE_P<dim>(1));
+  FE_SimplexP<dim, spacedim> fe_coarse(1);
+  FE_SimplexP<dim, spacedim> fe_fine(2);
+  MappingFE<dim>             mapping(FE_SimplexP<dim>(1));
 
   FullMatrix<double> matrix(fe_fine.n_dofs_per_cell(),
                             fe_coarse.n_dofs_per_cell());
diff --git a/tests/simplex/hanging_nodes_01.cc b/tests/simplex/hanging_nodes_01.cc
index cd10837641..4fbea6849c 100644
--- a/tests/simplex/hanging_nodes_01.cc
+++ b/tests/simplex/hanging_nodes_01.cc
@@ -63,11 +63,11 @@ main()
 
     test<dim>({1, 0},
               {0, 0},
-              hp::FECollection<dim>(Simplex::FE_P<dim>(1)),
+              hp::FECollection<dim>(FE_SimplexP<dim>(1)),
               subdivided_hyper_cube_with_simplices);
     test<dim>({1, 0},
               {0, 0},
-              hp::FECollection<dim>(Simplex::FE_P<dim>(2)),
+              hp::FECollection<dim>(FE_SimplexP<dim>(2)),
               subdivided_hyper_cube_with_simplices);
   }
   deallog.pop();
diff --git a/tests/simplex/hanging_nodes_02.cc b/tests/simplex/hanging_nodes_02.cc
index 3fce2d9bf6..87de202802 100644
--- a/tests/simplex/hanging_nodes_02.cc
+++ b/tests/simplex/hanging_nodes_02.cc
@@ -65,13 +65,11 @@ main()
 
     test<dim>({0, 0},
               {0, 1},
-              hp::FECollection<dim>(Simplex::FE_P<dim>(2),
-                                    Simplex::FE_P<dim>(1)),
+              hp::FECollection<dim>(FE_SimplexP<dim>(2), FE_SimplexP<dim>(1)),
               subdivided_hyper_cube_with_simplices);
     test<dim>({0, 0},
               {0, 1},
-              hp::FECollection<dim>(Simplex::FE_P<dim>(1),
-                                    Simplex::FE_P<dim>(2)),
+              hp::FECollection<dim>(FE_SimplexP<dim>(1), FE_SimplexP<dim>(2)),
               subdivided_hyper_cube_with_simplices);
   }
   deallog.pop();
diff --git a/tests/simplex/hanging_nodes_03.cc b/tests/simplex/hanging_nodes_03.cc
index 120aecb5a5..74246b8a16 100644
--- a/tests/simplex/hanging_nodes_03.cc
+++ b/tests/simplex/hanging_nodes_03.cc
@@ -65,13 +65,11 @@ main()
 
     test<dim>({1, 0},
               {0, 1},
-              hp::FECollection<dim>(Simplex::FE_P<dim>(1),
-                                    Simplex::FE_P<dim>(2)),
+              hp::FECollection<dim>(FE_SimplexP<dim>(1), FE_SimplexP<dim>(2)),
               subdivided_hyper_cube_with_simplices);
     test<dim>({1, 0},
               {0, 1},
-              hp::FECollection<dim>(Simplex::FE_P<dim>(2),
-                                    Simplex::FE_P<dim>(1)),
+              hp::FECollection<dim>(FE_SimplexP<dim>(2), FE_SimplexP<dim>(1)),
               subdivided_hyper_cube_with_simplices);
   }
   deallog.pop();
diff --git a/tests/simplex/hanging_nodes_hybrid_01.cc b/tests/simplex/hanging_nodes_hybrid_01.cc
index 27368b8f35..5e8db88010 100644
--- a/tests/simplex/hanging_nodes_hybrid_01.cc
+++ b/tests/simplex/hanging_nodes_hybrid_01.cc
@@ -65,19 +65,19 @@ main(int argc, char *argv[])
         deallog << "degree: " << d << std::endl;
         test<dim>({0, 1},
                   {0, 1},
-                  hp::FECollection<dim>(FE_Q<dim>(d), Simplex::FE_P<dim>(d)),
+                  hp::FECollection<dim>(FE_Q<dim>(d), FE_SimplexP<dim>(d)),
                   cube_and_pyramid);
         test<dim>({1, 0},
                   {0, 1},
-                  hp::FECollection<dim>(FE_Q<dim>(d), Simplex::FE_P<dim>(d)),
+                  hp::FECollection<dim>(FE_Q<dim>(d), FE_SimplexP<dim>(d)),
                   cube_and_pyramid);
         test<dim>({0, 1},
                   {1, 0},
-                  hp::FECollection<dim>(Simplex::FE_P<dim>(d), FE_Q<dim>(d)),
+                  hp::FECollection<dim>(FE_SimplexP<dim>(d), FE_Q<dim>(d)),
                   cube_and_pyramid);
         test<dim>({1, 0},
                   {1, 0},
-                  hp::FECollection<dim>(Simplex::FE_P<dim>(d), FE_Q<dim>(d)),
+                  hp::FECollection<dim>(FE_SimplexP<dim>(d), FE_Q<dim>(d)),
                   cube_and_pyramid);
       }
   }
diff --git a/tests/simplex/hanging_nodes_hybrid_02.cc b/tests/simplex/hanging_nodes_hybrid_02.cc
index 7e2bd1d6f1..7c4d33b5e2 100644
--- a/tests/simplex/hanging_nodes_hybrid_02.cc
+++ b/tests/simplex/hanging_nodes_hybrid_02.cc
@@ -69,11 +69,11 @@ main(int argc, char *argv[])
           deallog << "q_degree: " << q << ", p_degree: " << p << std::endl;
           test<dim>({0, 0},
                     {0, 1},
-                    hp::FECollection<dim>(FE_Q<dim>(q), Simplex::FE_P<dim>(p)),
+                    hp::FECollection<dim>(FE_Q<dim>(q), FE_SimplexP<dim>(p)),
                     cube_and_pyramid);
           test<dim>({0, 0},
                     {1, 0},
-                    hp::FECollection<dim>(Simplex::FE_P<dim>(p), FE_Q<dim>(q)),
+                    hp::FECollection<dim>(FE_SimplexP<dim>(p), FE_Q<dim>(q)),
                     cube_and_pyramid);
         }
   }
diff --git a/tests/simplex/hanging_nodes_hybrid_03.cc b/tests/simplex/hanging_nodes_hybrid_03.cc
index 4c56033805..b952c62028 100644
--- a/tests/simplex/hanging_nodes_hybrid_03.cc
+++ b/tests/simplex/hanging_nodes_hybrid_03.cc
@@ -56,19 +56,19 @@ main(int argc, char *argv[])
           deallog << "q_degree: " << q << ", p_degree: " << p << std::endl;
           test<dim>({0, 1},
                     {0, 1},
-                    hp::FECollection<dim>(FE_Q<dim>(q), Simplex::FE_P<dim>(p)),
+                    hp::FECollection<dim>(FE_Q<dim>(q), FE_SimplexP<dim>(p)),
                     cube_and_pyramid);
           test<dim>({1, 0},
                     {0, 1},
-                    hp::FECollection<dim>(FE_Q<dim>(q), Simplex::FE_P<dim>(p)),
+                    hp::FECollection<dim>(FE_Q<dim>(q), FE_SimplexP<dim>(p)),
                     cube_and_pyramid);
           test<dim>({0, 1},
                     {1, 0},
-                    hp::FECollection<dim>(Simplex::FE_P<dim>(p), FE_Q<dim>(q)),
+                    hp::FECollection<dim>(FE_SimplexP<dim>(p), FE_Q<dim>(q)),
                     cube_and_pyramid);
           test<dim>({1, 0},
                     {1, 0},
-                    hp::FECollection<dim>(Simplex::FE_P<dim>(p), FE_Q<dim>(q)),
+                    hp::FECollection<dim>(FE_SimplexP<dim>(p), FE_Q<dim>(q)),
                     cube_and_pyramid);
         }
   }
diff --git a/tests/simplex/mapping_fe_01.cc b/tests/simplex/mapping_fe_01.cc
index dc23a7bc0c..aaa3c74cec 100644
--- a/tests/simplex/mapping_fe_01.cc
+++ b/tests/simplex/mapping_fe_01.cc
@@ -14,7 +14,7 @@
 // ---------------------------------------------------------------------
 
 
-// Distribute Simplex::FE_Wedge on a DoFHandler.
+// Distribute FE_WedgeP on a DoFHandler.
 
 #include <deal.II/base/quadrature_lib.h>
 
@@ -48,12 +48,12 @@ test(const unsigned int mapping_degree)
     if (i != numbers::flat_manifold_id)
       tria.set_manifold(i, tria_temp.get_manifold(i));
 
-  Simplex::FE_P<dim> fe(2);
+  FE_SimplexP<dim> fe(2);
 
   DoFHandler<dim> dof_handler(tria);
   dof_handler.distribute_dofs(fe);
 
-  MappingFE<dim> mapping(Simplex::FE_P<dim>{mapping_degree});
+  MappingFE<dim> mapping(FE_SimplexP<dim>{mapping_degree});
 
   {
     DataOut<dim> data_out;
diff --git a/tests/simplex/mapping_fe_fields_01.cc b/tests/simplex/mapping_fe_fields_01.cc
index 4bc83fa77b..cec62f0240 100644
--- a/tests/simplex/mapping_fe_fields_01.cc
+++ b/tests/simplex/mapping_fe_fields_01.cc
@@ -48,8 +48,8 @@ test()
   Triangulation<dim> tria;
   GridGenerator::subdivided_hyper_cube_with_simplices(tria, 1);
 
-  Simplex::FE_P<dim> fe(1);
-  FESystem<dim>      euler_fe(fe, dim);
+  FE_SimplexP<dim> fe(1);
+  FESystem<dim>    euler_fe(fe, dim);
 
   DoFHandler<dim> dof_handler(tria);
   dof_handler.distribute_dofs(fe);
@@ -63,7 +63,7 @@ test()
 
   MappingFEField<dim> mapping(euler_dof_handler, euler_vector);
 
-  Simplex::QGauss<dim> quadrature_formula(1);
+  QGaussSimplex<dim> quadrature_formula(1);
 
   FEValues<dim> fe_values(mapping,
                           fe,
diff --git a/tests/simplex/mapping_fe_fields_02.cc b/tests/simplex/mapping_fe_fields_02.cc
index 3e9051d4d4..f9723eab6a 100644
--- a/tests/simplex/mapping_fe_fields_02.cc
+++ b/tests/simplex/mapping_fe_fields_02.cc
@@ -63,8 +63,8 @@ test(const unsigned int mapping_degree)
   Triangulation<dim> tria;
   GridGenerator::subdivided_hyper_cube_with_simplices(tria, 4);
 
-  Simplex::FE_P<dim> fe(mapping_degree);
-  FESystem<dim>      euler_fe(fe, dim);
+  FE_SimplexP<dim> fe(mapping_degree);
+  FESystem<dim>    euler_fe(fe, dim);
 
   DoFHandler<dim> dof_handler(tria);
   dof_handler.distribute_dofs(fe);
@@ -77,7 +77,7 @@ test(const unsigned int mapping_degree)
   // TODO: not working (missing mapping)
   // VectorTools::get_position_vector(euler_dof_handler, euler_vector);
 
-  MappingFE<dim> mapping_interpolation(Simplex::FE_P<dim>(1));
+  MappingFE<dim> mapping_interpolation(FE_SimplexP<dim>(1));
   VectorTools::interpolate(mapping_interpolation,
                            euler_dof_handler,
                            Solution<dim>(),
diff --git a/tests/simplex/mapping_transformations_01.cc b/tests/simplex/mapping_transformations_01.cc
index 970dce5548..7fc4ee9344 100644
--- a/tests/simplex/mapping_transformations_01.cc
+++ b/tests/simplex/mapping_transformations_01.cc
@@ -56,7 +56,7 @@ main()
   Triangulation<2> triangulation;
   make_grid(triangulation);
 
-  MappingFE<2> mapping(Simplex::FE_P<2>(1));
+  MappingFE<2> mapping(FE_SimplexP<2>(1));
 
   unsigned int n_points = 1;
 
diff --git a/tests/simplex/matrix_free_01.cc b/tests/simplex/matrix_free_01.cc
index 1e607dca78..cdc2029222 100644
--- a/tests/simplex/matrix_free_01.cc
+++ b/tests/simplex/matrix_free_01.cc
@@ -139,24 +139,24 @@ test(const unsigned int v, const unsigned int degree, const bool do_helmholtz)
     {
       GridGenerator::subdivided_hyper_cube_with_simplices(tria,
                                                           dim == 2 ? 16 : 8);
-      fe         = std::make_shared<Simplex::FE_P<dim>>(degree);
-      quad       = std::make_shared<Simplex::QGauss<dim>>(degree + 1);
-      fe_mapping = std::make_shared<Simplex::FE_P<dim>>(1);
+      fe         = std::make_shared<FE_SimplexP<dim>>(degree);
+      quad       = std::make_shared<QGaussSimplex<dim>>(degree + 1);
+      fe_mapping = std::make_shared<FE_SimplexP<dim>>(1);
     }
   else if (v == 1)
     {
       GridGenerator::subdivided_hyper_cube_with_wedges(tria, dim == 2 ? 16 : 8);
-      fe         = std::make_shared<Simplex::FE_WedgeP<dim>>(degree);
-      quad       = std::make_shared<Simplex::QGaussWedge<dim>>(degree + 1);
-      fe_mapping = std::make_shared<Simplex::FE_WedgeP<dim>>(1);
+      fe         = std::make_shared<FE_WedgeP<dim>>(degree);
+      quad       = std::make_shared<QGaussWedge<dim>>(degree + 1);
+      fe_mapping = std::make_shared<FE_WedgeP<dim>>(1);
     }
   else if (v == 2)
     {
       GridGenerator::subdivided_hyper_cube_with_pyramids(tria,
                                                          dim == 2 ? 16 : 8);
-      fe         = std::make_shared<Simplex::FE_PyramidP<dim>>(degree);
-      quad       = std::make_shared<Simplex::QGaussPyramid<dim>>(degree + 1);
-      fe_mapping = std::make_shared<Simplex::FE_PyramidP<dim>>(1);
+      fe         = std::make_shared<FE_PyramidP<dim>>(degree);
+      quad       = std::make_shared<QGaussPyramid<dim>>(degree + 1);
+      fe_mapping = std::make_shared<FE_PyramidP<dim>>(1);
     }
   else
     Assert(false, ExcNotImplemented());
diff --git a/tests/simplex/matrix_free_02.cc b/tests/simplex/matrix_free_02.cc
index d73069d0a0..4339fe26f5 100644
--- a/tests/simplex/matrix_free_02.cc
+++ b/tests/simplex/matrix_free_02.cc
@@ -144,15 +144,15 @@ test(const unsigned version, const unsigned int degree, const bool do_helmholtz)
   else if (version == 2)
     GridGenerator::subdivided_hyper_cube_with_simplices_mix(tria, subdivisions);
 
-  Simplex::FE_P<dim>    fe1(degree);
+  FE_SimplexP<dim>      fe1(degree);
   FE_Q<dim>             fe2(degree);
   hp::FECollection<dim> fes(fe1, fe2);
 
-  Simplex::QGauss<dim> quad1(degree + 1);
+  QGaussSimplex<dim>   quad1(degree + 1);
   QGauss<dim>          quad2(degree + 1);
   hp::QCollection<dim> quads(quad1, quad2);
 
-  MappingFE<dim>             mapping1(Simplex::FE_P<dim>(1));
+  MappingFE<dim>             mapping1(FE_SimplexP<dim>(1));
   MappingQ<dim>              mapping2(1);
   hp::MappingCollection<dim> mappings(mapping1, mapping2);
 
diff --git a/tests/simplex/matrix_free_03.cc b/tests/simplex/matrix_free_03.cc
index 5e9e00f137..0cf57e3f63 100644
--- a/tests/simplex/matrix_free_03.cc
+++ b/tests/simplex/matrix_free_03.cc
@@ -301,10 +301,10 @@ test(const unsigned int degree)
 
   GridGenerator::subdivided_hyper_cube_with_simplices(tria, n_subdivisions);
 
-  Simplex::FE_DGP<dim>     fe(degree);
-  Simplex::QGauss<dim>     quadrature(degree + 1);
-  Simplex::QGauss<dim - 1> face_quadrature(degree + 1);
-  MappingFE<dim>           mapping(Simplex::FE_P<dim>(1));
+  FE_SimplexDGP<dim>     fe(degree);
+  QGaussSimplex<dim>     quadrature(degree + 1);
+  QGaussSimplex<dim - 1> face_quadrature(degree + 1);
+  MappingFE<dim>         mapping(FE_SimplexP<dim>(1));
 #else
   GridGenerator::subdivided_hyper_cube(tria, dim == 2 ? 16 : 8);
 
diff --git a/tests/simplex/matrix_free_04.cc b/tests/simplex/matrix_free_04.cc
index 52e750f4ef..218887c221 100644
--- a/tests/simplex/matrix_free_04.cc
+++ b/tests/simplex/matrix_free_04.cc
@@ -247,15 +247,15 @@ test(const unsigned version, const unsigned int degree)
   else if (version == 2)
     GridGenerator::subdivided_hyper_cube_with_simplices_mix(tria, subdivisions);
 
-  Simplex::FE_DGP<dim>  fe1(degree);
+  FE_SimplexDGP<dim>    fe1(degree);
   FE_DGQ<dim>           fe2(degree);
   hp::FECollection<dim> fes(fe1, fe2);
 
-  Simplex::QGauss<dim> quad1(degree + 1);
+  QGaussSimplex<dim>   quad1(degree + 1);
   QGauss<dim>          quad2(degree + 1);
   hp::QCollection<dim> quads(quad1, quad2);
 
-  MappingFE<dim>             mapping1(Simplex::FE_P<dim>(1));
+  MappingFE<dim>             mapping1(FE_SimplexP<dim>(1));
   MappingQ<dim>              mapping2(1);
   hp::MappingCollection<dim> mappings(mapping1, mapping2);
 
diff --git a/tests/simplex/matrix_free_range_iteration_01.cc b/tests/simplex/matrix_free_range_iteration_01.cc
index 54479d8815..27bf5a4f1d 100644
--- a/tests/simplex/matrix_free_range_iteration_01.cc
+++ b/tests/simplex/matrix_free_range_iteration_01.cc
@@ -15,7 +15,7 @@
 
 
 
-// Test ShapeData for Simplex::FE_P and Simplex::QGauss
+// Test ShapeData for FE_SimplexP and QGaussSimplex
 
 #include <deal.II/dofs/dof_handler.h>
 
diff --git a/tests/simplex/matrix_free_shape_info_01.cc b/tests/simplex/matrix_free_shape_info_01.cc
index 126faf65d3..f7880e59df 100644
--- a/tests/simplex/matrix_free_shape_info_01.cc
+++ b/tests/simplex/matrix_free_shape_info_01.cc
@@ -15,7 +15,7 @@
 
 
 
-// Test ShapeData for Simplex::FE_P and Simplex::QGauss
+// Test ShapeData for FE_SimplexP and QGaussSimplex
 
 #include <deal.II/base/quadrature_lib.h>
 
@@ -124,9 +124,9 @@ test(const FiniteElement<dim, spacedim> &fe)
   DoFHandler<dim> dof_handler(tria);
   dof_handler.distribute_dofs(fe);
 
-  MappingFE<dim> mapping(Simplex::FE_P<dim>(1));
+  MappingFE<dim> mapping(FE_SimplexP<dim>(1));
 
-  Simplex::QGauss<dim> quadrature(1);
+  QGaussSimplex<dim> quadrature(1);
 
   internal::MatrixFreeFunctions::ShapeInfo<Number> shape_info(quadrature, fe);
 
@@ -193,5 +193,5 @@ main()
 {
   initlog();
 
-  test<2>(Simplex::FE_P<2>(2));
+  test<2>(FE_SimplexP<2>(2));
 }
diff --git a/tests/simplex/poisson_01.cc b/tests/simplex/poisson_01.cc
index 2828aa1882..d69b4f01c1 100644
--- a/tests/simplex/poisson_01.cc
+++ b/tests/simplex/poisson_01.cc
@@ -336,7 +336,7 @@ test_tet(const MPI_Comm &comm, const Parameters<dim> &params)
   // ... create triangulation
   if (params.use_grid_generator)
     {
-      // ...via Simplex::GridGenerator
+      // ...via GridGenerator
       GridGenerator::subdivided_hyper_rectangle_with_simplices(
         *tria, params.repetitions, params.p1, params.p2, false);
     }
@@ -373,15 +373,14 @@ test_tet(const MPI_Comm &comm, const Parameters<dim> &params)
   grid_out.write_vtk(*tria, out);
 
   // 3) Select components
-  Simplex::FE_P<dim> fe(params.degree);
+  FE_SimplexP<dim> fe(params.degree);
 
-  Simplex::QGauss<dim> quad(params.degree + 1);
+  QGaussSimplex<dim> quad(params.degree + 1);
 
-  hp::QCollection<dim - 1> face_quad{
-    Simplex::QGauss<dim - 1>(params.degree + 1)};
+  hp::QCollection<dim - 1> face_quad{QGaussSimplex<dim - 1>(params.degree + 1)};
 
-  Simplex::FE_P<dim> fe_mapping(1);
-  MappingFE<dim>     mapping(fe_mapping);
+  FE_SimplexP<dim> fe_mapping(1);
+  MappingFE<dim>   mapping(fe_mapping);
 
   // 4) Perform test (independent of mesh type)
   test(*tria, fe, quad, face_quad, mapping, params.p2[0]);
@@ -466,7 +465,7 @@ test_wedge(const MPI_Comm &comm, const Parameters<dim> &params)
   // ... create triangulation
   if (params.use_grid_generator)
     {
-      // ...via Simplex::GridGenerator
+      // ...via GridGenerator
       GridGenerator::subdivided_hyper_rectangle_with_wedges(
         *tria, params.repetitions, params.p1, params.p2, false);
     }
@@ -503,19 +502,18 @@ test_wedge(const MPI_Comm &comm, const Parameters<dim> &params)
   grid_out.write_vtk(*tria, out);
 
   // 3) Select components
-  Simplex::FE_WedgeP<dim> fe(params.degree);
+  FE_WedgeP<dim> fe(params.degree);
 
-  Simplex::QGaussWedge<dim> quad(params.degree + 1);
+  QGaussWedge<dim> quad(params.degree + 1);
 
-  hp::QCollection<dim - 1> face_quad{
-    Simplex::QGauss<dim - 1>(params.degree + 1),
-    Simplex::QGauss<dim - 1>(params.degree + 1),
-    QGauss<dim - 1>(params.degree + 1),
-    QGauss<dim - 1>(params.degree + 1),
-    QGauss<dim - 1>(params.degree + 1)};
+  hp::QCollection<dim - 1> face_quad{QGaussSimplex<dim - 1>(params.degree + 1),
+                                     QGaussSimplex<dim - 1>(params.degree + 1),
+                                     QGauss<dim - 1>(params.degree + 1),
+                                     QGauss<dim - 1>(params.degree + 1),
+                                     QGauss<dim - 1>(params.degree + 1)};
 
-  Simplex::FE_WedgeP<dim> fe_mapping(1);
-  MappingFE<dim>          mapping(fe_mapping);
+  FE_WedgeP<dim> fe_mapping(1);
+  MappingFE<dim> mapping(fe_mapping);
 
   // 4) Perform test (independent of mesh type)
   test(*tria, fe, quad, face_quad, mapping, params.p2[0], true);
@@ -558,7 +556,7 @@ test_pyramid(const MPI_Comm &comm, const Parameters<dim> &params)
   // ... create triangulation
   if (params.use_grid_generator)
     {
-      // ...via Simplex::GridGenerator
+      // ...via GridGenerator
       GridGenerator::subdivided_hyper_rectangle_with_pyramids(
         *tria, params.repetitions, params.p1, params.p2, false);
     }
@@ -595,19 +593,18 @@ test_pyramid(const MPI_Comm &comm, const Parameters<dim> &params)
   grid_out.write_vtk(*tria, out);
 
   // 3) Select components
-  Simplex::FE_PyramidP<dim> fe(params.degree);
+  FE_PyramidP<dim> fe(params.degree);
 
-  Simplex::QGaussPyramid<dim> quad(params.degree + 1);
+  QGaussPyramid<dim> quad(params.degree + 1);
 
-  hp::QCollection<dim - 1> face_quad{
-    QGauss<dim - 1>(params.degree + 1),
-    Simplex::QGauss<dim - 1>(params.degree + 1),
-    Simplex::QGauss<dim - 1>(params.degree + 1),
-    Simplex::QGauss<dim - 1>(params.degree + 1),
-    Simplex::QGauss<dim - 1>(params.degree + 1)};
+  hp::QCollection<dim - 1> face_quad{QGauss<dim - 1>(params.degree + 1),
+                                     QGaussSimplex<dim - 1>(params.degree + 1),
+                                     QGaussSimplex<dim - 1>(params.degree + 1),
+                                     QGaussSimplex<dim - 1>(params.degree + 1),
+                                     QGaussSimplex<dim - 1>(params.degree + 1)};
 
-  Simplex::FE_PyramidP<dim> fe_mapping(1);
-  MappingFE<dim>            mapping(fe_mapping);
+  FE_PyramidP<dim> fe_mapping(1);
+  MappingFE<dim>   mapping(fe_mapping);
 
   // 4) Perform test (independent of mesh type)
   test(*tria, fe, quad, face_quad, mapping, params.p2[0], true);
diff --git a/tests/simplex/poisson_02.cc b/tests/simplex/poisson_02.cc
index f2906722bd..cec0e7f0db 100644
--- a/tests/simplex/poisson_02.cc
+++ b/tests/simplex/poisson_02.cc
@@ -185,14 +185,14 @@ public:
       unsigned int initial_refinement,
       unsigned int number_refinement)
   {
-    return std::make_unique<DGHeat<dim>>(
-      false,
-      new Simplex::FE_DGP<dim>(degree),
-      new MappingFE<dim>(Simplex::FE_P<dim>(1)),
-      new Simplex::QGauss<dim>(degree + 1),
-      new Simplex::QGauss<dim - 1>(degree + 1),
-      initial_refinement,
-      number_refinement);
+    return std::make_unique<DGHeat<dim>>(false,
+                                         new FE_SimplexDGP<dim>(degree),
+                                         new MappingFE<dim>(
+                                           FE_SimplexP<dim>(1)),
+                                         new QGaussSimplex<dim>(degree + 1),
+                                         new QGaussSimplex<dim - 1>(degree + 1),
+                                         initial_refinement,
+                                         number_refinement);
   }
 
 
diff --git a/tests/simplex/polynomials_01.cc b/tests/simplex/polynomials_01.cc
index 96ffeb06c0..1aac04708e 100644
--- a/tests/simplex/polynomials_01.cc
+++ b/tests/simplex/polynomials_01.cc
@@ -14,7 +14,7 @@
 // ---------------------------------------------------------------------
 
 
-// Test Simplex::BarycentricPolynomials on an the points of an arbitrary
+// Test BarycentricPolynomials on an the points of an arbitrary
 // quadrature rule.
 
 
@@ -29,8 +29,7 @@ template <int dim>
 void
 test(const unsigned int degree)
 {
-  const auto poly =
-    Simplex::BarycentricPolynomials<dim>::get_fe_p_basis(degree);
+  const auto    poly = BarycentricPolynomials<dim>::get_fe_p_basis(degree);
   QSimplex<dim> quad(QGauss<dim>(degree + 1));
 
   std::vector<double>         values(poly.n());
diff --git a/tests/simplex/q_projection_01.cc b/tests/simplex/q_projection_01.cc
index 60f4cf89a5..26aa20cc5b 100644
--- a/tests/simplex/q_projection_01.cc
+++ b/tests/simplex/q_projection_01.cc
@@ -14,7 +14,7 @@
 // ---------------------------------------------------------------------
 
 
-// Test QProjection for Simplex::QGauss.
+// Test QProjection for QGaussSimplex.
 
 
 #include <deal.II/base/qprojector.h>
@@ -37,7 +37,7 @@ test<2>(const unsigned int n_points)
 {
   const int dim = 2;
 
-  Simplex::QGauss<dim - 1> quad_ref(n_points);
+  QGaussSimplex<dim - 1> quad_ref(n_points);
 
   const auto quad =
     QProjector<dim>::project_to_all_faces(ReferenceCells::Triangle, quad_ref);
@@ -79,7 +79,7 @@ test<3>(const unsigned int n_points)
 {
   const int dim = 3;
 
-  Simplex::QGauss<dim - 1> quad_ref(n_points);
+  QGaussSimplex<dim - 1> quad_ref(n_points);
 
   const auto quad =
     QProjector<dim>::project_to_all_faces(ReferenceCells::Tetrahedron,
diff --git a/tests/simplex/q_witherden_vincent_01.cc b/tests/simplex/q_witherden_vincent_01.cc
index b521142c98..d060b3fb98 100644
--- a/tests/simplex/q_witherden_vincent_01.cc
+++ b/tests/simplex/q_witherden_vincent_01.cc
@@ -23,7 +23,7 @@ void
 print(const unsigned int n_points_1D)
 {
   deallog << "n_points_1D = " << n_points_1D << std::endl;
-  const Simplex::QWitherdenVincent<dim> quad(n_points_1D);
+  const QWitherdenVincent<dim> quad(n_points_1D);
 
   deallog << "quad size = " << quad.size() << std::endl;
   for (unsigned int q = 0; q < quad.size(); ++q)
@@ -52,8 +52,8 @@ check_accuracy_1D(const unsigned int n_points_1D)
   // component
   monomial_powers[dim - 1] += accuracy - sum;
 
-  const Functions::Monomial<dim>        func(monomial_powers);
-  const Simplex::QWitherdenVincent<dim> quad(n_points_1D);
+  const Functions::Monomial<dim> func(monomial_powers);
+  const QWitherdenVincent<dim>   quad(n_points_1D);
 
   deallog << "Monomial powers = " << monomial_powers << std::endl;
   double integrand = 0.0;
diff --git a/tests/simplex/quadrature_lib_01.cc b/tests/simplex/quadrature_lib_01.cc
index a3e417b5a7..eddd1b9746 100644
--- a/tests/simplex/quadrature_lib_01.cc
+++ b/tests/simplex/quadrature_lib_01.cc
@@ -14,7 +14,7 @@
 // ---------------------------------------------------------------------
 
 
-// Test Simplex::QGauss: output its quadrature points and weights.
+// Test QGaussSimplex: output its quadrature points and weights.
 
 
 #include <deal.II/base/quadrature_lib.h>
@@ -27,7 +27,7 @@ template <int dim>
 void
 test(const unsigned int n_points)
 {
-  Simplex::QGauss<dim> quad(n_points);
+  QGaussSimplex<dim> quad(n_points);
 
   for (unsigned int q = 0; q < quad.size(); ++q)
     {
diff --git a/tests/simplex/step-02.cc b/tests/simplex/step-02.cc
index 7798f2e45c..9118828a25 100644
--- a/tests/simplex/step-02.cc
+++ b/tests/simplex/step-02.cc
@@ -62,7 +62,7 @@ void make_grid(Triangulation<2> &triangulation)
 
 void distribute_dofs(DoFHandler<2> &dof_handler)
 {
-  const Simplex::FE_P<2> finite_element(1);
+  const FE_SimplexP<2> finite_element(1);
   dof_handler.distribute_dofs(finite_element);
 
   DynamicSparsityPattern dynamic_sparsity_pattern(dof_handler.n_dofs(),
diff --git a/tests/simplex/step-03.cc b/tests/simplex/step-03.cc
index 6924433f29..16c09b29bb 100644
--- a/tests/simplex/step-03.cc
+++ b/tests/simplex/step-03.cc
@@ -16,8 +16,8 @@
 
 // Step-03 on a simplex mesh. Following incompatible modifications had to be
 // made:
-//  - Change the FE_Q to Simplex::FE_P.
-//  - Change QGauss to Simplex::QGauss.
+//  - Change the FE_Q to FE_SimplexP.
+//  - Change QGauss to QGaussSimplex.
 //  - Use MappingFE (Do not use default mapping).
 //  - Convert triangulation to a triangulation based on simplices.
 
@@ -84,8 +84,8 @@ private:
 
   Triangulation<dim, dim> triangulation;
   unsigned int            fe_degree;
-  Simplex::FE_P<dim>      fe;
-  Simplex::QGauss<dim>    quadrature_formula;
+  FE_SimplexP<dim>        fe;
+  QGaussSimplex<dim>      quadrature_formula;
 
   DoFHandler<dim> dof_handler;
   MappingFE<dim>  mapping;
@@ -103,7 +103,7 @@ Step3<dim>::Step3()
   , fe(fe_degree)
   , quadrature_formula(fe_degree + 1)
   , dof_handler(triangulation)
-  , mapping(Simplex::FE_P<dim>(1))
+  , mapping(FE_SimplexP<dim>(1))
 {}
 
 template <int dim>
diff --git a/tests/simplex/step-04.cc b/tests/simplex/step-04.cc
index 60d0b14681..f3f6d982ff 100644
--- a/tests/simplex/step-04.cc
+++ b/tests/simplex/step-04.cc
@@ -20,10 +20,10 @@
 
 // Step-04 on a simplex mesh. Following incompatible modifications had to be
 // made:
-//  - Change the FE_Q to Simplex::FE_P
+//  - Change the FE_Q to FE_SimplexP
 //  - Put the MappingFE as a class member and use as an argument instead of
 //  default mapping
-//  - Change QGauss to Simplex::QGauss
+//  - Change QGauss to QGaussSimplex
 //  - Convert triangulation to a triangulation based on simplices
 
 
@@ -88,7 +88,7 @@ private:
   output_results() const;
 
   Triangulation<dim> triangulation;
-  Simplex::FE_P<dim> fe;
+  FE_SimplexP<dim>   fe;
   DoFHandler<dim>    dof_handler;
 
   MappingFE<dim> mapping;
@@ -190,7 +190,7 @@ template <int dim>
 void
 Step4<dim>::assemble_system()
 {
-  Simplex::QGauss<dim> quadrature_formula(fe.degree + 1);
+  QGaussSimplex<dim> quadrature_formula(fe.degree + 1);
 
   RightHandSide<dim> right_hand_side;
 
diff --git a/tests/simplex/step-06.cc b/tests/simplex/step-06.cc
index d13a24d4d9..7766127460 100644
--- a/tests/simplex/step-06.cc
+++ b/tests/simplex/step-06.cc
@@ -101,7 +101,7 @@ private:
   output_results(const unsigned int cycle) const;
 
 #ifdef USE_SIMPLEX
-  Simplex::FE_P<dim> fe;
+  FE_SimplexP<dim> fe;
 #else
   FE_Q<dim>         fe;
 #endif
@@ -173,7 +173,7 @@ void
 Step6<dim>::assemble_system()
 {
 #ifdef USE_SIMPLEX
-  const Simplex::QGauss<dim> quadrature_formula(fe.degree + 1);
+  const QGaussSimplex<dim> quadrature_formula(fe.degree + 1);
 #else
   const QGauss<dim> quadrature_formula(fe.degree + 1);
 #endif
@@ -252,7 +252,7 @@ Step6<dim>::refine_grid()
 #  ifdef USE_SIMPLEX
   KellyErrorEstimator<dim>::estimate(MappingFE<dim>(fe),
                                      dof_handler,
-                                     Simplex::QGauss<dim - 1>(fe.degree + 1),
+                                     QGaussSimplex<dim - 1>(fe.degree + 1),
                                      {},
                                      solution,
                                      estimated_error_per_cell);
diff --git a/tests/simplex/step-07.cc b/tests/simplex/step-07.cc
index 2ffa48a28c..89b68d7b8f 100644
--- a/tests/simplex/step-07.cc
+++ b/tests/simplex/step-07.cc
@@ -262,8 +262,8 @@ namespace Step7
   HelmholtzProblem<dim>::assemble_system()
   {
 #ifdef USE_SIMPLEX
-    Simplex::QGauss<dim>     quadrature_formula(fe->degree + 1);
-    Simplex::QGauss<dim - 1> face_quadrature_formula(fe->degree + 1);
+    QGaussSimplex<dim>     quadrature_formula(fe->degree + 1);
+    QGaussSimplex<dim - 1> face_quadrature_formula(fe->degree + 1);
 #else
     QGauss<dim>     quadrature_formula(fe->degree + 1);
     QGauss<dim - 1> face_quadrature_formula(fe->degree + 1);
@@ -280,7 +280,7 @@ namespace Step7
     std::vector<types::global_dof_index> local_dof_indices(dofs_per_cell);
 
 #ifdef USE_SIMPLEX
-    MappingFE<dim> mapping(Simplex::FE_P<dim>(1));
+    MappingFE<dim> mapping(FE_SimplexP<dim>(1));
 #else
     MappingFE<dim>  mapping(FE_Q<dim>(1));
 #endif
@@ -440,7 +440,7 @@ namespace Step7
     Vector<float> difference_per_cell(triangulation.n_active_cells());
 
 #ifdef USE_SIMPLEX
-    MappingFE<dim> mapping(Simplex::FE_P<dim>(1));
+    MappingFE<dim> mapping(FE_SimplexP<dim>(1));
 #else
     MappingFE<dim>  mapping(FE_Q<dim>(1));
 #endif
@@ -574,7 +574,7 @@ namespace Step7
     data_out.add_data_vector(solution, "solution");
 
 #ifdef USE_SIMPLEX
-    MappingFE<dim> mapping(Simplex::FE_P<dim>(1));
+    MappingFE<dim> mapping(FE_SimplexP<dim>(1));
 #else
     MappingFE<dim> mapping(FE_Q<dim>(1));
 #endif
@@ -705,7 +705,7 @@ main()
                 << std::endl;
 
 #ifdef USE_SIMPLEX
-        Simplex::FE_P<dim> fe(1);
+        FE_SimplexP<dim> fe(1);
 #else
         FE_Q<dim> fe(1);
 #endif
@@ -726,7 +726,7 @@ main()
                 << std::endl;
 
 #ifdef USE_SIMPLEX
-        Simplex::FE_P<dim> fe(1);
+        FE_SimplexP<dim> fe(1);
 #else
         FE_Q<dim> fe(1);
 #endif
@@ -744,7 +744,7 @@ main()
                 << std::endl;
 
 #ifdef USE_SIMPLEX
-        Simplex::FE_P<dim> fe(2);
+        FE_SimplexP<dim> fe(2);
 #else
         FE_Q<dim> fe(2);
 #endif
@@ -761,7 +761,7 @@ main()
                 << std::endl;
 
 #ifdef USE_SIMPLEX
-        Simplex::FE_P<dim> fe(2);
+        FE_SimplexP<dim> fe(2);
 #else
         FE_Q<dim> fe(2);
 #endif
diff --git a/tests/simplex/step-08.cc b/tests/simplex/step-08.cc
index 483a891611..c224815ecb 100644
--- a/tests/simplex/step-08.cc
+++ b/tests/simplex/step-08.cc
@@ -16,8 +16,8 @@
 
 // Step-08 on a simplex mesh. Following incompatible modifications had to be
 // made:
-//  - Change the FE_Q to Simplex::FE_P.
-//  - Change QGauss to Simplex::QGauss.
+//  - Change the FE_Q to FE_SimplexP.
+//  - Change QGauss to QGaussSimplex.
 //  - Use MappingFE (Do not use default mapping).
 //  - Convert triangulation to a triangulation based on simplices.
 //  - Use refine_global() instead of execute_coarsening_and_refinement().
@@ -135,8 +135,8 @@ namespace Step8
   template <int dim>
   ElasticProblem<dim>::ElasticProblem()
     : dof_handler(triangulation)
-    , mapping(Simplex::FE_P<dim>(1))
-    , fe(Simplex::FE_P<dim>(1), dim)
+    , mapping(FE_SimplexP<dim>(1))
+    , fe(FE_SimplexP<dim>(1), dim)
   {}
 
   template <int dim>
@@ -164,8 +164,8 @@ namespace Step8
   void
   ElasticProblem<dim>::assemble_system()
   {
-    Simplex::QGauss<dim> quadrature_formula(fe.degree + 1);
-    FEValues<dim>        fe_values(mapping,
+    QGaussSimplex<dim> quadrature_formula(fe.degree + 1);
+    FEValues<dim>      fe_values(mapping,
                             fe,
                             quadrature_formula,
                             update_values | update_gradients |
@@ -267,7 +267,7 @@ namespace Step8
   {
     Vector<float> estimated_error_per_cell(triangulation.n_active_cells());
 
-    Simplex::QGauss<dim - 1> quadrature(fe.degree + 1);
+    QGaussSimplex<dim - 1> quadrature(fe.degree + 1);
     KellyErrorEstimator<dim>::estimate(
       mapping, dof_handler, quadrature, {}, solution, estimated_error_per_cell);
 
diff --git a/tests/simplex/step-12.cc b/tests/simplex/step-12.cc
index 5e8936a356..13e535b579 100644
--- a/tests/simplex/step-12.cc
+++ b/tests/simplex/step-12.cc
@@ -205,11 +205,11 @@ namespace Step12
     Triangulation<dim>   triangulation;
     const MappingFE<dim> mapping;
 
-    const Simplex::FE_DGP<dim> fe;
-    DoFHandler<dim>            dof_handler;
+    const FE_SimplexDGP<dim> fe;
+    DoFHandler<dim>          dof_handler;
 
-    const Simplex::QGauss<dim>     quadrature;
-    const Simplex::QGauss<dim - 1> quadrature_face;
+    const QGaussSimplex<dim>     quadrature;
+    const QGaussSimplex<dim - 1> quadrature_face;
 
     SparsityPattern      sparsity_pattern;
     SparseMatrix<double> system_matrix;
@@ -221,7 +221,7 @@ namespace Step12
 
   template <int dim>
   AdvectionProblem<dim>::AdvectionProblem()
-    : mapping(Simplex::FE_P<dim>(1))
+    : mapping(FE_SimplexP<dim>(1))
     , fe(1)
     , dof_handler(triangulation)
     , quadrature(fe.tensor_degree() + 1)
diff --git a/tests/simplex/step-12a.cc b/tests/simplex/step-12a.cc
index 40df59beef..b0c7cee7b9 100644
--- a/tests/simplex/step-12a.cc
+++ b/tests/simplex/step-12a.cc
@@ -211,7 +211,7 @@ namespace Step12
 #ifdef HEX
     const MappingQ1<dim> mapping;
 #else
-    Simplex::FE_P<dim>   fe_mapping;
+    FE_SimplexP<dim>     fe_mapping;
     const MappingFE<dim> mapping;
 #endif
 
@@ -219,7 +219,7 @@ namespace Step12
 #ifdef HEX
     FE_DGQ<dim> fe;
 #else
-    Simplex::FE_DGP<dim> fe;
+    FE_SimplexDGP<dim>   fe;
 #endif
     DoFHandler<dim> dof_handler;
 
@@ -395,9 +395,9 @@ namespace Step12
 
     QGauss<dim - 1> face_quad(degree + 1);
 #else
-    Simplex::QGauss<dim> quad(degree + 1);
+    QGaussSimplex<dim> quad(degree + 1);
 
-    Simplex::QGauss<dim - 1> face_quad(degree + 1);
+    QGaussSimplex<dim - 1> face_quad(degree + 1);
 #endif
 
     ScratchData<dim> scratch_data(mapping, fe, quad, face_quad);
diff --git a/tests/simplex/step-18.cc b/tests/simplex/step-18.cc
index 25cd897699..abb4376ed4 100644
--- a/tests/simplex/step-18.cc
+++ b/tests/simplex/step-18.cc
@@ -421,10 +421,10 @@ namespace Step18
   template <int dim>
   TopLevel<dim>::TopLevel()
     : triangulation()
-    , fe(Simplex::FE_P<dim>(degree), dim)
+    , fe(FE_SimplexP<dim>(degree), dim)
     , dof_handler(triangulation)
-    , quadrature_formula(Simplex::QGauss<dim>(fe.degree + 1))
-    , mapping(Simplex::FE_P<dim>(1))
+    , quadrature_formula(QGaussSimplex<dim>(fe.degree + 1))
+    , mapping(FE_SimplexP<dim>(1))
     , present_time(0.0)
     , present_timestep(1.0)
     , end_time(10.0)
diff --git a/tests/simplex/step-20.cc b/tests/simplex/step-20.cc
index c16551e69f..08499c9c6f 100644
--- a/tests/simplex/step-20.cc
+++ b/tests/simplex/step-20.cc
@@ -16,11 +16,11 @@
 
 // Step-20 on a simplex mesh. Following modifications had to be made:
 //  - Create a hypercube with simplices
-//  - Change the FE_RT elements to Simplex::FE_P (2nd degree) and FE_DGQ to
-//  Simplex::FE_DGP (1st degree)
+//  - Change the FE_RT elements to FE_SimplexP (2nd degree) and FE_DGQ to
+//  FE_SimplexDGP (1st degree)
 //    These spaces are an alternative to solve the mixed Laplacian
 //    (https://link.springer.com/article/10.1007/s10092-009-0009-6)
-//  - Change QGauss to Simplex::QGauss and use MappingFE instead of default
+//  - Change QGauss to QGaussSimplex and use MappingFE instead of default
 //  mapping.
 
 
@@ -215,9 +215,9 @@ namespace Step20
   template <int dim>
   MixedLaplaceProblem<dim>::MixedLaplaceProblem(const unsigned int degree)
     : degree(degree)
-    , fe(FESystem<dim>(Simplex::FE_P<dim>(degree), dim),
+    , fe(FESystem<dim>(FE_SimplexP<dim>(degree), dim),
          1,
-         Simplex::FE_DGP<dim>(degree - 1),
+         FE_SimplexDGP<dim>(degree - 1),
          1)
     , dof_handler(triangulation)
   {}
@@ -273,9 +273,9 @@ namespace Step20
   void
   MixedLaplaceProblem<dim>::assemble_system()
   {
-    Simplex::QGauss<dim>     quadrature_formula(degree + 1);
-    Simplex::QGauss<dim - 1> face_quadrature_formula(degree + 1);
-    MappingFE<dim>           mapping(Simplex::FE_DGP<dim>(1));
+    QGaussSimplex<dim>     quadrature_formula(degree + 1);
+    QGaussSimplex<dim - 1> face_quadrature_formula(degree + 1);
+    MappingFE<dim>         mapping(FE_SimplexDGP<dim>(1));
 
     FEValues<dim>     fe_values(mapping,
                             fe,
@@ -436,7 +436,7 @@ namespace Step20
 
     QTrapezoid<1>  q_trapez;
     QIterated<dim> quadrature(q_trapez, degree + 2);
-    MappingFE<dim> mapping(Simplex::FE_DGP<dim>(1));
+    MappingFE<dim> mapping(FE_SimplexDGP<dim>(1));
 
     VectorTools::integrate_difference(mapping,
                                       dof_handler,
@@ -472,7 +472,7 @@ namespace Step20
   void
   MixedLaplaceProblem<dim>::output_results() const
   {
-    MappingFE<dim>           mapping(Simplex::FE_DGP<dim>(1));
+    MappingFE<dim>           mapping(FE_SimplexDGP<dim>(1));
     std::vector<std::string> solution_names(dim, "u");
     solution_names.emplace_back("p");
     std::vector<DataComponentInterpretation::DataComponentInterpretation>
diff --git a/tests/simplex/step-23.cc b/tests/simplex/step-23.cc
index 52af8814de..e0b7168f7d 100644
--- a/tests/simplex/step-23.cc
+++ b/tests/simplex/step-23.cc
@@ -16,7 +16,7 @@
 
 // Step-23 with tetrahedron mesh. Following incompatible modifications had to be
 // made:
-// - Change FE_Q and QGauss to Simplex::FE_P and Simplex::QGauss.
+// - Change FE_Q and QGauss to FE_SimplexP and QGaussSimplex.
 // - Explicit use of MappingFE instead of the default mapping.
 // - Grid generation by subdivided_hyper_cube_with_simplices instead of
 // hyper_cube, because global refinement is not allowed.
@@ -92,9 +92,9 @@ namespace Step23
     FE_Q<dim>                 fe;
     QGauss<dim>               quadrature;
 #else
-    MappingFE<dim, dim>  mapping;
-    Simplex::FE_P<dim>   fe;
-    Simplex::QGauss<dim> quadrature;
+    MappingFE<dim, dim> mapping;
+    FE_SimplexP<dim>    fe;
+    QGaussSimplex<dim>  quadrature;
 #endif
     DoFHandler<dim> dof_handler;
 
@@ -207,7 +207,7 @@ namespace Step23
 #ifdef HEX
     : mapping(1)
 #else
-    : mapping(Simplex::FE_P<dim>(1))
+    : mapping(FE_SimplexP<dim>(1))
 #endif
     , fe(1)
     , quadrature(fe.degree + 1)
diff --git a/tests/simplex/step-38.cc b/tests/simplex/step-38.cc
index e47803bce1..d93810cafb 100644
--- a/tests/simplex/step-38.cc
+++ b/tests/simplex/step-38.cc
@@ -90,8 +90,8 @@ namespace Step38
     DoFHandler<dim, spacedim>    dof_handler;
 
 #ifdef USE_SIMPLEX
-    Simplex::FE_P<dim, spacedim> fe;
-    MappingFE<dim, spacedim>     mapping;
+    FE_SimplexP<dim, spacedim> fe;
+    MappingFE<dim, spacedim>   mapping;
 #else
     FE_Q<dim, spacedim>     fe;
     MappingQ<dim, spacedim> mapping;
@@ -214,7 +214,7 @@ namespace Step38
     , fe(degree)
 #ifdef USE_SIMPLEX
     // Quadratic mapping for simplex is still not implemented.
-    , mapping(Simplex::FE_P<dim, spacedim>(degree))
+    , mapping(FE_SimplexP<dim, spacedim>(degree))
 #else
     , mapping(degree)
 #endif
@@ -279,7 +279,7 @@ namespace Step38
     system_matrix = 0;
     system_rhs    = 0;
 #ifdef USE_SIMPLEX
-    const Simplex::QGauss<dim> quadrature_formula(fe.degree + 1);
+    const QGaussSimplex<dim> quadrature_formula(fe.degree + 1);
 #else
     const QGauss<dim> quadrature_formula(2 * fe.degree);
 #endif
@@ -384,7 +384,7 @@ namespace Step38
                                       Solution<spacedim>(),
                                       difference_per_cell,
 #ifdef USE_SIMPLEX
-                                      Simplex::QGauss<dim>(fe.degree + 1),
+                                      QGaussSimplex<dim>(fe.degree + 1),
 #else
                                       QGauss<dim>(2 * fe.degree +
                                                   1), // This also works on
diff --git a/tests/simplex/step-55.cc b/tests/simplex/step-55.cc
index c657613c0c..53c0d0e32c 100644
--- a/tests/simplex/step-55.cc
+++ b/tests/simplex/step-55.cc
@@ -368,12 +368,12 @@ namespace Step55
                       Triangulation<dim>::smoothing_on_refinement |
                       Triangulation<dim>::smoothing_on_coarsening))
 #else
-    , fe(Simplex::FE_P<dim>(velocity_degree),
+    , fe(FE_SimplexP<dim>(velocity_degree),
          dim,
-         Simplex::FE_P<dim>(velocity_degree - 1),
+         FE_SimplexP<dim>(velocity_degree - 1),
          1)
     , triangulation(mpi_communicator)
-    , mapping(Simplex::FE_P<dim>(1))
+    , mapping(FE_SimplexP<dim>(1))
 #endif
     , dof_handler(triangulation)
     , pcout(std::cout,
@@ -571,7 +571,7 @@ namespace Step55
 #ifdef HEX
     const QGauss<dim> quadrature_formula(velocity_degree + 1);
 #else
-    const Simplex::QGauss<dim> quadrature_formula(velocity_degree + 1);
+    const QGaussSimplex<dim> quadrature_formula(velocity_degree + 1);
 #endif
 
     FEValues<dim> fe_values(mapping,
@@ -734,8 +734,8 @@ namespace Step55
 #ifdef HEX
                                       QGauss<dim>(velocity_degree + 2),
 #else
-                                      Simplex::QGauss<dim>(velocity_degree +
-                                                           1),    // TODO: +2
+                                      QGaussSimplex<dim>(velocity_degree +
+                                                         1),    // TODO: +2
 #endif
                                       locally_relevant_solution,
                                       dim);
@@ -774,7 +774,7 @@ namespace Step55
 #ifdef HEX
       const QGauss<dim> quadrature(velocity_degree + 2);
 #else
-      const Simplex::QGauss<dim> quadrature(velocity_degree + 1); // TODO: +2
+      const QGaussSimplex<dim> quadrature(velocity_degree + 1); // TODO: +2
 #endif
 
       VectorTools::integrate_difference(mapping,
diff --git a/tests/simplex/step-68.cc b/tests/simplex/step-68.cc
index 861b224e97..f51181f93c 100644
--- a/tests/simplex/step-68.cc
+++ b/tests/simplex/step-68.cc
@@ -171,8 +171,8 @@ namespace Step68
     : mpi_communicator(MPI_COMM_WORLD)
     , background_triangulation(mpi_communicator)
     , fluid_dh(background_triangulation)
-    , fluid_fe(Simplex::FE_P<dim>(velocity_degree), dim)
-    , mapping(Simplex::FE_P<dim>(velocity_degree))
+    , fluid_fe(FE_SimplexP<dim>(velocity_degree), dim)
+    , mapping(FE_SimplexP<dim>(velocity_degree))
   {}
 
   // @sect4{Particles generation}
@@ -272,7 +272,7 @@ namespace Step68
     // We generate the particles at the position of a single
     // point quadrature. Consequently, one particle will be generated
     // at the centroid of each cell.
-    Simplex::QGauss<dim> quadrature_formula(1);
+    QGaussSimplex<dim> quadrature_formula(1);
 
     Particles::Generators::quadrature_points(particle_triangulation,
                                              quadrature_formula,
diff --git a/tests/simplex/step-74.cc b/tests/simplex/step-74.cc
index 340cd3c42a..ac2f573c80 100644
--- a/tests/simplex/step-74.cc
+++ b/tests/simplex/step-74.cc
@@ -274,12 +274,12 @@ namespace Step74
     const unsigned     degree;
 
 #ifdef USE_SIMPLEX
-    const Simplex::QGauss<dim>     quadrature;
-    const Simplex::QGauss<dim - 1> face_quadrature;
-    const Simplex::QGauss<dim>     quadrature_2;
-    const Simplex::QGauss<dim - 1> face_quadrature_2;
-    const MappingFE<dim>           mapping;
-    const Simplex::FE_DGP<dim>     fe;
+    const QGaussSimplex<dim>     quadrature;
+    const QGaussSimplex<dim - 1> face_quadrature;
+    const QGaussSimplex<dim>     quadrature_2;
+    const QGaussSimplex<dim - 1> face_quadrature_2;
+    const MappingFE<dim>         mapping;
+    const FE_SimplexDGP<dim>     fe;
 #else
     const QGauss<dim>     quadrature;
     const QGauss<dim - 1> face_quadrature;
@@ -319,7 +319,7 @@ namespace Step74
     , quadrature_2(degree + 1)
     , face_quadrature_2(degree + 1)
 #ifdef USE_SIMPLEX
-    , mapping(Simplex::FE_P<dim>(1))
+    , mapping(FE_SimplexP<dim>(1))
 #else
     , mapping()
 #endif
diff --git a/tests/simplex/variable_face_quadratures_03.cc b/tests/simplex/variable_face_quadratures_03.cc
index 6560f1515a..af8e946633 100644
--- a/tests/simplex/variable_face_quadratures_03.cc
+++ b/tests/simplex/variable_face_quadratures_03.cc
@@ -72,12 +72,12 @@ test<2>()
 
   // test FEFaceValues for FE_System(FE_P)
   {
-    const hp::QCollection<dim - 1> quad_ref(Simplex::QGauss<dim - 1>(1),
-                                            Simplex::QGauss<dim - 1>(2),
-                                            Simplex::QGauss<dim - 1>(3));
+    const hp::QCollection<dim - 1> quad_ref(QGaussSimplex<dim - 1>(1),
+                                            QGaussSimplex<dim - 1>(2),
+                                            QGaussSimplex<dim - 1>(3));
 
-    MappingFE<dim> mapping(Simplex::FE_P<dim>(1));
-    FESystem<dim>  fe(Simplex::FE_P<dim>{2}, dim);
+    MappingFE<dim> mapping(FE_SimplexP<dim>(1));
+    FESystem<dim>  fe(FE_SimplexP<dim>{2}, dim);
 
     const UpdateFlags flags = mapping.requires_update_flags(
       update_values | update_quadrature_points | update_JxW_values);
@@ -125,13 +125,13 @@ test<3>()
 
   // test FEFaceValues for FE_System(FE_P)
   {
-    const hp::QCollection<dim - 1> quad_ref(Simplex::QGauss<dim - 1>(1),
-                                            Simplex::QGauss<dim - 1>(2),
-                                            Simplex::QGauss<dim - 1>(3),
-                                            Simplex::QGauss<dim - 1>(1));
+    const hp::QCollection<dim - 1> quad_ref(QGaussSimplex<dim - 1>(1),
+                                            QGaussSimplex<dim - 1>(2),
+                                            QGaussSimplex<dim - 1>(3),
+                                            QGaussSimplex<dim - 1>(1));
 
-    MappingFE<dim> mapping(Simplex::FE_P<dim>(1));
-    FESystem<dim>  fe(Simplex::FE_P<dim>{2}, dim);
+    MappingFE<dim> mapping(FE_SimplexP<dim>(1));
+    FESystem<dim>  fe(FE_SimplexP<dim>{2}, dim);
 
     const UpdateFlags flags = mapping.requires_update_flags(
       update_values | update_quadrature_points | update_JxW_values);
diff --git a/tests/simplex/wedge_01.cc b/tests/simplex/wedge_01.cc
index 62ecb8ddfb..5c32f161a3 100644
--- a/tests/simplex/wedge_01.cc
+++ b/tests/simplex/wedge_01.cc
@@ -14,7 +14,7 @@
 // ---------------------------------------------------------------------
 
 
-// Distribute Simplex::FE_Wedge on a DoFHandler.
+// Distribute FE_WedgeP on a DoFHandler.
 
 #include <deal.II/dofs/dof_handler.h>
 
@@ -81,7 +81,7 @@ test_3()
   std::ofstream out("mesh.vtk");
   grid_out.write_vtk(tria, out);
 
-  Simplex::FE_WedgeP<dim, spacedim> fe(2);
+  FE_WedgeP<dim, spacedim> fe(2);
 
   DoFHandler<dim, spacedim> dof_handler(tria);
   dof_handler.distribute_dofs(fe);