]> https://gitweb.dealii.org/ - dealii.git/commitdiff
Remove Simplex namespace 11809/head
authorPeter Munch <peterrmuench@gmail.com>
Thu, 25 Feb 2021 08:40:25 +0000 (09:40 +0100)
committerPeter Munch <peterrmuench@gmail.com>
Thu, 25 Feb 2021 08:40:25 +0000 (09:40 +0100)
98 files changed:
doc/news/changes/incompatibilities/20201212Munch
doc/news/changes/major/20210126DavidWells
doc/news/changes/major/20210126DavidWells-2
doc/news/changes/major/20210208DavidWells
doc/news/changes/minor/20200704Munch [deleted file]
include/deal.II/base/polynomials_barycentric.h
include/deal.II/base/polynomials_pyramid.h
include/deal.II/base/polynomials_wedge.h
include/deal.II/base/quadrature_lib.h
include/deal.II/fe/fe_poly.h
include/deal.II/fe/fe_pyramid_p.h
include/deal.II/fe/fe_simplex_p.h
include/deal.II/fe/fe_simplex_p_bubbles.h
include/deal.II/fe/fe_wedge_p.h
include/deal.II/grid/reference_cell.h
include/deal.II/matrix_free/matrix_free.templates.h
include/deal.II/matrix_free/shape_info.templates.h
include/deal.II/matrix_free/util.h
include/deal.II/numerics/data_out_dof_data.templates.h
source/base/polynomials_barycentric.cc
source/base/polynomials_pyramid.cc
source/base/polynomials_wedge.cc
source/base/qprojector.cc
source/base/quadrature_lib.cc
source/fe/fe_dgq.cc
source/fe/fe_pyramid_p.cc
source/fe/fe_pyramid_p.inst.in
source/fe/fe_q.cc
source/fe/fe_q_base.cc
source/fe/fe_simplex_p.cc
source/fe/fe_simplex_p.inst.in
source/fe/fe_simplex_p_bubbles.cc
source/fe/fe_simplex_p_bubbles.inst.in
source/fe/fe_wedge_p.cc
source/fe/fe_wedge_p.inst.in
source/grid/reference_cell.cc
tests/matrix_free/compute_diagonal_05.cc
tests/multigrid-global-coarsening/multigrid_a_01.cc
tests/multigrid-global-coarsening/multigrid_p_01.cc
tests/simplex/barycentric_01.cc
tests/simplex/cell_measure_01.cc
tests/simplex/compute_point_locations_01.cc
tests/simplex/compute_projection_matrices_01.cc
tests/simplex/data_out_write_hdf5_01.cc
tests/simplex/data_out_write_hdf5_02.cc
tests/simplex/data_out_write_vtk_01.cc
tests/simplex/data_out_write_vtk_02.cc
tests/simplex/data_out_write_vtu_01.cc
tests/simplex/extract_boundary_dofs.cc
tests/simplex/fe_lib_01.cc
tests/simplex/fe_lib_01.output
tests/simplex/fe_lib_02.cc
tests/simplex/fe_lib_02.output
tests/simplex/fe_p_bubbles_01.cc
tests/simplex/fe_p_bubbles_01.with_simplex_support=on.out [deleted file]
tests/simplex/fe_p_bubbles_01.with_simplex_support=on.output [new file with mode: 0644]
tests/simplex/fe_p_bubbles_02.cc
tests/simplex/fe_p_bubbles_02.with_simplex_support=on.output [moved from tests/simplex/fe_p_bubbles_02.with_simplex_support=on.out with 95% similarity]
tests/simplex/get_projection_matrix_01.cc
tests/simplex/hanging_nodes_01.cc
tests/simplex/hanging_nodes_02.cc
tests/simplex/hanging_nodes_03.cc
tests/simplex/hanging_nodes_hybrid_01.cc
tests/simplex/hanging_nodes_hybrid_02.cc
tests/simplex/hanging_nodes_hybrid_03.cc
tests/simplex/mapping_fe_01.cc
tests/simplex/mapping_fe_fields_01.cc
tests/simplex/mapping_fe_fields_02.cc
tests/simplex/mapping_transformations_01.cc
tests/simplex/matrix_free_01.cc
tests/simplex/matrix_free_02.cc
tests/simplex/matrix_free_03.cc
tests/simplex/matrix_free_04.cc
tests/simplex/matrix_free_range_iteration_01.cc
tests/simplex/matrix_free_shape_info_01.cc
tests/simplex/poisson_01.cc
tests/simplex/poisson_02.cc
tests/simplex/polynomials_01.cc
tests/simplex/q_projection_01.cc
tests/simplex/q_witherden_vincent_01.cc
tests/simplex/quadrature_lib_01.cc
tests/simplex/step-02.cc
tests/simplex/step-03.cc
tests/simplex/step-04.cc
tests/simplex/step-06.cc
tests/simplex/step-07.cc
tests/simplex/step-08.cc
tests/simplex/step-12.cc
tests/simplex/step-12a.cc
tests/simplex/step-18.cc
tests/simplex/step-20.cc
tests/simplex/step-23.cc
tests/simplex/step-38.cc
tests/simplex/step-55.cc
tests/simplex/step-68.cc
tests/simplex/step-74.cc
tests/simplex/variable_face_quadratures_03.cc
tests/simplex/wedge_01.cc

index 4ecd10bb7d4b3287d2dc20f965037497b2d04d6e..4c5dfd21c51c68b75cc05f0aacbcd9f3ac980a45 100644 (file)
@@ -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)
index 52af3ceaf3110277971135deeb46db59e3f9b324..bc1b33844a5c115baab61f7185045375452f61d6 100644 (file)
@@ -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)
index 0011dbe6fe446bfc3043e333d21194663b6818c4..9c9322fc094763234021e0328554e7a662c427ca 100644 (file)
@@ -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)
index c6b3fb39ef57b20793f8b3bffdd640750a23f408..4ed24ddb9413fd598a04ef7400db781203ba8e4c 100644 (file)
@@ -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 (file)
index 858dbcb..0000000
+++ /dev/null
@@ -1,4 +0,0 @@
-New: The new class Simplex::ScalarPolynomial provides polynomials defined on 
-simplices.
-<br>
-(Peter Munch, 2020/07/02)
index 8596ef0744a90502d1a7b025bae1e507f2dccc98..14c8349537d8e21c31170833ece5a15b97873c26 100644 (file)
 
 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
 
index 31421e95f71087375a658f0f314bd8c4b8230c3a..b75d9ee082b247b6ff0c51815dcb81ccb7367146 100644 (file)
@@ -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
 
index 880660f27dad2dc369eaf6de128b88422d43437d..296c80616337997534f32a9755d6cc9ccb65ab1d 100644 (file)
 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
 
index 890440acd47a1ed989daa1f65e2cd16d4597bf68..a82e7373af0d50c59aec6a22282df912f5d73eab 100644 (file)
@@ -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);
+};
 
 /*@}*/
 
index 50d6a5652a2e649659e36cb028c88747a23ec153..199e077321678f6d023216c755c2a9f4c7a83d99 100644 (file)
@@ -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;
index 0079600da6fa0499da4bf86efbf72b85bb9462bc..2e22b4b5801aedf4ae24fcefcf61be6fa9027b28 100644 (file)
 
 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
 
index 8105d2237601127452a9ec8aabd7e60f29ea0fef..43fb6b08a3009edcc6084a6d52599e24b6891564 100644 (file)
 
 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
 
index d6cdb8abe8093b8bff53709fd8f4a6c8d2f0dcd6..387928fa5e55884df0979be450481f3d63a61d4b 100644 (file)
 
 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
 
index 3a01b2e7c3b39c537beaddb16a353ec9fbe72298..46b7c8ce6057f6b46870b862063621a0d907d160 100644 (file)
 
 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
 
index 99569b072af826129de6c6f5d879e9d6a076f00f..564c9db7baf0e12a6000a4e213f0ec62db323f6e 100644 (file)
@@ -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)
         {
index 1e0d715dd4cf68c29ca7e632454fd79e792e7ecd..1d1429a6bf99506ddebd2545a1fb7edb5eaf8fb9 100644 (file)
@@ -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();
index 6cf1cb2125e950cd2e9d920d33202c82a63ddd8f..c3293a0f12dc0721b4c17c1ec8b075ddc091652a 100644 (file)
@@ -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
index dec9542a16e9bf243385c0683f5efa76806a564a..c1f6dce66a21ec76112227126c82a5068855698c 100644 (file)
@@ -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,
index 4222b7f11218fc87ed76b66c8f03b4cf6d15a861..e97e2a2dd2cdcb44af6d839689127a231819de1b 100644 (file)
@@ -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());
             }
index d916f9e9441a0426b7f6cf5cb63fd68eed9324d9..67616cf6c3c890b8562f3da08e3eb7c3793c3f53 100644 (file)
 
 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
index 9321dfb3a96e0e254c53ed6db411fb168946b9c4..dbab75b527b03124d245ed0b44238266d43bb313 100644 (file)
 
 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
index 8ac20bb9ded4e9ff3a4bd1bcf8b67045bd417302..6517e624430c8c8debb75b96fb621b1885cb31c9 100644 (file)
 
 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
index f64d67cc5a3f60689475cf21089d1360a9784e43..e311e648505dfb99761a91851f58be99b1dd747b 100644 (file)
@@ -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)}));
index f84f13fb6cd0f0081c959af46b38cdff12aa52b7..d2a21598e6a914a06626693f030fe1964c243892 100644 (file)
@@ -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
index 73acc4e8d59537c5a3fcc4dbc4c0da86adff742b..f131faba73bedeae61dd8db3f44563108f298e58 100644 (file)
@@ -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;
index fe286a52edfe15cccd62853b2cd5a8c46ddad20d..97e450c0f008885b525a0efe8d66d0eb2f674a03 100644 (file)
 
 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"
index cce82dcff2be484d81adbe8d713466e2885229ac..5c0a0ecaab34803bd75d602d5f80e968665a512e 100644 (file)
 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
   }
index 39db78bb5ceb94c09ad7c91b14a0697f5b6cc353..5d0226c94aadd93ce6074d4cb78a06ab0bfbc8ad 100644 (file)
@@ -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;
index c663f75efe469539a5994f05dfbc10b58d8638ff..924e5b4cbddd6a4541846fe97f57d877d0652838 100644 (file)
@@ -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
 
index 9adbe33f9e320ccd54d01c915fe192a481651602..9f32a2f2933f3929e2760d8b60c84f6e7ab2fa1c 100644 (file)
 
 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"
index 0f29f676d1957b033b34456da9d360e49d04b65c..32befcab593a6c9491fcdd9a34fd84f114ff180c 100644 (file)
@@ -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
   }
index 8c2ee43f53c3f7a75ff93aa76e9e6304981be14a..50da7e1241e9772476353865f8dba46c59e3130d 100644 (file)
 
 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"
index ca82953a4650084889356d6c2b59111f6c2f7df2..d428c679c121b07bab78f635acafe4e2bd6218a4 100644 (file)
@@ -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
   }
index 1a1d1fd0cab3f5a40de60c1db3ae9d9634069d65..4f4d4cf995e2234c15811a5e2ca25b46a5c1bf51 100644 (file)
 
 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"
index 9b6ee61535deea645db2922902ab3e7b902658fb..1aaddea0455bd250c5dfb37903221c476ac5aad9 100644 (file)
 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
   }
index a9bc30f535abd4009acdd1ced876a36d563bb1b6..9bafdb90a2fe3e40d2f62f6db86b86a6b052d8ca 100644 (file)
@@ -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());
 
index 5daa7c3d059db5b67b1cf82aac6912b3647cd830..b504d144f303d6fcad696310b044f21221f0369b 100644 (file)
@@ -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);
index f461708bfe32073ef3fbaf3bb16e3467491c7663..42f5eec640085f5de7d21ea4afc38162353d68a6 100644 (file)
@@ -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
         {
index bcd3e39ba19c4421ff1c45d9c10049a1aa258142..945ded48087e924398a8f605b3bbf97507b8a4e0 100644 (file)
@@ -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
         {
index 277d7220be0cf42d7ef261d0505514ca15a059b1..3b1c726d9fbab4fc3f6f123d69997ad2394d95fa 100644 (file)
@@ -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());
index 12488df21f48a61b54252d59ffcacd9b213719ad..1bd815328fc1881b2d4cac78493369b1547af8d2 100644 (file)
@@ -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());
 
index 7f01defc34718f9f9f842dcc5489fceff7debcf5..ca8a2017486279c9b716fdd602a629913eaebdbe 100644 (file)
@@ -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);
index 0eb96bc768582a392117bc2a3c9642ec78f159c4..663d92862fb7305aba1b3ea649cf615379382184 100644 (file)
@@ -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;
 
index bcae95fde259650c8d32f924af4513876559c278..eb79d2c4d3b26ee990809619cb709901e5a2abad 100644 (file)
@@ -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);
   }
 }
index 038c15220bb609fb4250fe1214f31416f0145bdb..98746efe1503fc9fe2893ceff44444b65ad2d5aa 100644 (file)
@@ -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);
   }
 }
index b2d6b364804c7875f13315b491466a01150bbd54..c90accdb7909a46f3c94dfd72cae580da576116b 100644 (file)
@@ -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);
index d88279770dcb43a7a4a4b8372cdf05b98c70d839..e76a757062ec180aa35cdad3230c42aad0e7b164 100644 (file)
@@ -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);
index a58cbf23072bf3b780b3db225edf5d253a21aba6..b84e31460a2bf2b1d4e9de1afb049c05998e88e0 100644 (file)
@@ -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);
   }
index 9329aca91da7c62b900946e8add0849252d26552..2de79fa1b0162e137e26bbf269a9a441d6d41b6d 100644 (file)
@@ -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;
index 50460a2f09f75e4ffccbe3e7bfbc74c11bec0d80..7ea90033fe086f4ef2de478a5ff9789b84fa470c 100644 (file)
@@ -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));
 }
index ec3b0b86fdee1ff680b21fb3e59a94e7e0166658..ccea093a59a10aa80995fc2583ea6338c56f686e 100644 (file)
@@ -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 
index bb96eef5f3110c29f7f1c7b339f022d2c3eb98e8..a4cda1f0f80217b2c98f484cca20bc4183de14c4 100644 (file)
@@ -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));
 }
index 0d6e3ad17f8627b6d9e653947866378f721b8f9f..cceed5719b6849670eb9a9719ff7a0d2f6752083 100644 (file)
 
-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)::
index c79de2e615557642af3846a00dd7fdd8d2c6de6d..db2fb66e2146fc919c0ba22863d4b6785cffb98e 100644 (file)
@@ -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 (file)
index 858f6dd..0000000
+++ /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 (file)
index 0000000..7555cff
--- /dev/null
@@ -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)::
index ca12e668510580d3439b34e6befb4f4653388bc9..4841b0fb2ebc70d43a19c81b26d782f3faf46086 100644 (file)
@@ -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);
 
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 85e5dbfdb3eafd3f4ba479747007e79385e2a32a..41d0630803db059b8ee08387bceb73b68cf7b047 100644 (file)
@@ -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
index 327b17589dc43dc05bbb785d940a2b61449d6e37..a1e22354103206dcb0aef04df5f21dc028695c82 100644 (file)
@@ -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());
index cd10837641837ec054bfe23677713aba4b5e521a..4fbea6849cfdeb8f5613932d59d8a454b771a8f9 100644 (file)
@@ -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();
index 3fce2d9bf69c8815fbdbd9914079af543520b0b9..87de2028023da26515746f53aa4ff6f2571b4b09 100644 (file)
@@ -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();
index 120aecb5a56776b7a37782b6387030e2a82819fe..74246b8a16cc6e860672523fb2927614a108f945 100644 (file)
@@ -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();
index 27368b8f356fb32ceedd415fb353bac182378643..5e8db880102d3b6ab7c46a2e4974c4ce1ba2b31f 100644 (file)
@@ -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);
       }
   }
index 7e2bd1d6f10adc390aea9724ec12d51395dc4010..7c4d33b5e27dc162660ced2738d8e1a86c74039a 100644 (file)
@@ -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);
         }
   }
index 4c56033805bdbfad85089162d7553be93dd04746..b952c62028990576c28eee9784773869e328a8eb 100644 (file)
@@ -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);
         }
   }
index dc23a7bc0cd9fecb3c3d8ff2de2c01603858e0c6..aaa3c74ceca42401cc0c5359a46aa91408d6aa8a 100644 (file)
@@ -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;
index 4bc83fa77b192e0d10e5c96b3fb0e344b1d47a9e..cec62f024098ac114d4cdbcfc90cc0c0b860e5ba 100644 (file)
@@ -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,
index 3e9051d4d4d10890dc03f627bd4a5553155cd94e..f9723eab6a58c86294ae73e5c4ca46389f1910ab 100644 (file)
@@ -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>(),
index 970dce5548c43ef096aca3b8235e389aa85c5e28..7fc4ee934495381a94222fdcfbecc394b2261add 100644 (file)
@@ -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;
 
index 1e607dca78c67ee3d8b1e4e061c404e729028759..cdc20292223bd88634f2b24b5a7a498d1bedacc6 100644 (file)
@@ -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());
index d73069d0a0e419a4e0dcf2d047fb377470738635..4339fe26f59d4ca4883532b1339ef453fc697a1e 100644 (file)
@@ -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);
 
index 5e9e00f13718063304f2c6c3e31101de443a0881..0cf57e3f635b14cc8523ec854eedf3a51ab30add 100644 (file)
@@ -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);
 
index 52e750f4efe8e3bf71ad0773734bc1e516839ffb..218887c221061eeb49b9a745936f4d88feb97883 100644 (file)
@@ -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);
 
index 54479d88158902e08899a24e0811d57d8976ee00..27bf5a4f1deec358655df5b903fec1c9c6307c36 100644 (file)
@@ -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>
 
index 126faf65d39af1f08fc7ca37c9971ee586adbc7a..f7880e59dfbad4bd104d20da0dc5e01ef5bd6369 100644 (file)
@@ -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));
 }
index 2828aa18827fbbea8266f410d2935c81fcf67361..d69b4f01c1f7e81530210b8e851bd1c25e924997 100644 (file)
@@ -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);
index f2906722bd4a377b508bca321b3ff082d3c34446..cec0e7f0db08f656d441b49f01fa7e5e0b9511ef 100644 (file)
@@ -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);
   }
 
 
index 96ffeb06c0d050a53ff650ef9e95d055405bb249..1aac04708e132dfc5ebf80c153bd415972405c5e 100644 (file)
@@ -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());
index 60f4cf89a5fb7552131a9ff07389db9e3a0f3ca7..26aa20cc5b23d472da0ac1ddaa546752e5bf2c49 100644 (file)
@@ -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,
index b521142c98cec87c146aac6e58a4529900c59f41..d060b3fb9854595a3dfb7f1d640af9487ab93afd 100644 (file)
@@ -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;
index a3e417b5a7eabf5cab896e9ad1a3900e97e47337..eddd1b97469d37f5223ded62833ff837edbda734 100644 (file)
@@ -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)
     {
index 7798f2e45c6373d454d8dcd7e3465fa099a680d8..9118828a2549fa55d06367ad5bc18c23a09aa809 100644 (file)
@@ -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(),
index 6924433f29ae1cb787633da9adf96ae4c24ace38..16c09b29bbae5d4ac7bc93ba78f29c16e09b5357 100644 (file)
@@ -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>
index 60d0b14681bf2b599584eb09e79de571725d7b80..f3f6d982ff22599f71e0b820c3534bb04f6fe918 100644 (file)
 
 // 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;
 
index d13a24d4d919ca7bb4234a296cf03b38fe1e8357..7766127460d389ae8de30c6cb74360eb714ff675 100644 (file)
@@ -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);
index 2ffa48a28c60911fb35b325e6143e1485319cb04..89b68d7b8f6e93347d140c3cd227fe38c6308987 100644 (file)
@@ -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
index 483a891611cd357cc97bf42d05f8ba9f8f483d02..c224815ecb4083e1f6ef9dbb1707c5bd6a5e932a 100644 (file)
@@ -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);
 
index 5e8936a356ad0dc67758154634e924255a3ee8fd..13e535b579aeaff05aa4bd635b873d91995b1baa 100644 (file)
@@ -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)
index 40df59beefbee64df79f1d35a6f8e0053a7d178a..b0c7cee7b968b69299d81269df97b2d3be14667a 100644 (file)
@@ -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);
index 25cd89769981298bd428876b557e3487554cbbde..abb4376ed4663fbdf56ab3f887820de9c76f155a 100644 (file)
@@ -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)
index c16551e69fa9892cc1b93f24294336a09a5d747d..08499c9c6fa613b9af340fddf140f06177bdaf5f 100644 (file)
 
 // 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>
index 52af8814de587e0a89463f2f2bda12d64c61a9ef..e0b7168f7d6664819cae95766d3b6f2bcb2e8eeb 100644 (file)
@@ -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)
index e47803bce1c2034ac0beff760b50d2d9f8781fc9..d93810cafb179e0e118a43ce80184559231158dd 100644 (file)
@@ -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
index c657613c0cafac517ec04dd5395497b0b1b0707d..53c0d0e32c0004ebda70343ade156193a1624af1 100644 (file)
@@ -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,
index 861b224e97c3f32c0015bc629dac0e8e2cf731ff..f51181f93cf03e7344b3fd81cc4a452b15d65a34 100644 (file)
@@ -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,
index 340cd3c42a0a9aa52699fbbfce5d50f81e563e80..ac2f573c8087a357ed20dce50573fe7dd7111620 100644 (file)
@@ -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
index 6560f1515a428880f4eb766994d41f4050582662..af8e946633e5feaff3f52c3e70495209b7bbb24b 100644 (file)
@@ -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);
index 62ecb8ddfb6565fc913b915ac464f8b0ca7b5a3b..5c32f161a3bb896f026a1cd283b2189090db4ec1 100644 (file)
@@ -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);

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

Douglas Adams


Typeset in Trocchi and Trocchi Bold Sans Serif.