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)
-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)
-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)
-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)
+++ /dev/null
-New: The new class Simplex::ScalarPolynomial provides polynomials defined on
-simplices.
-<br>
-(Peter Munch, 2020/07/02)
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
*
* @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
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
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);
+};
/*@}*/
*
* @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;
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
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
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
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
* 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>
* 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.
/**
* 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
if (*this ==
ReferenceCells::Triangle) // see also
- // Simplex::ScalarPolynomial::compute_value
+ // BarycentricPolynomials<2>::compute_value
{
switch (i)
{
if (*this ==
ReferenceCells::Tetrahedron) // see also
- // Simplex::ScalarPolynomial::compute_value
+ // BarycentricPolynomials<3>::compute_value
{
switch (i)
{
}
}
- 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)],
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;
if (*this ==
ReferenceCells::Triangle) // see also
- // Simplex::ScalarPolynomial::compute_grad
+ // BarycentricPolynomials<2>::compute_grad
{
switch (i)
{
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();
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)
#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
{
#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
{
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());
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,
}
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,
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,
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,
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());
}
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());
}
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
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
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
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)
{
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)
{
// 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;
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)}));
-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);
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);
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);
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!"));
+}
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
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;
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"
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
}
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;
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;
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;
// 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
// 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
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
// 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
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"
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
}
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"
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
}
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"
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
}
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());
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
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());
#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>
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);
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,
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);
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
{
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
{
//
// ---------------------------------------------------------------------
-// Test Simplex::BarycentricPolynomial and Simplex::BarycentricPolynomials.
+// Test BarycentricPolynomial and BarycentricPolynomials.
#include <deal.II/base/point.h>
#include <deal.II/base/polynomials_barycentric.h>
{
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;
{
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;
{
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));
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;
{
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());
{
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());
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());
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);
// ---------------------------------------------------------------------
-// Test Simplex::FE_Poly::get_prolongation_matrix()
+// Test FE_SimplexPoly::get_prolongation_matrix()
// (and indirectly FETools::compute_embedding_matrices() for simplices).
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;
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,
{
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);
}
}
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,
{
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);
}
}
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();
VectorTools::project(mapping,
dof_handler,
dummy,
- Simplex::QGauss<dim>(fe.tensor_degree() + 1),
+ QGaussSimplex<dim>(fe.tensor_degree() + 1),
RightHandSideFunction<dim>(n_components),
solution);
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);
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);
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;
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);
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,
{
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);
}
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;
// ---------------------------------------------------------------------
-// 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>
{
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));
}
-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
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
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
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
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
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
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
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
// ---------------------------------------------------------------------
-// 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>
{
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));
}
-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)::
// ---------------------------------------------------------------------
-// Evaluate Simplex::FE_P_Bubbles.
+// Evaluate FE_SimplexP_Bubbles.
#include <deal.II/base/quadrature_lib.h>
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);
+++ /dev/null
-
-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)::
--- /dev/null
+
+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)::
//
// ---------------------------------------------------------------------
-// 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>
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,
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);
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 =
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,
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);
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
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
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());
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();
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();
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();
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);
}
}
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);
}
}
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);
}
}
// ---------------------------------------------------------------------
-// Distribute Simplex::FE_Wedge on a DoFHandler.
+// Distribute FE_WedgeP on a DoFHandler.
#include <deal.II/base/quadrature_lib.h>
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;
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);
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,
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);
// 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>(),
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;
{
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());
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);
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);
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);
-// Test ShapeData for Simplex::FE_P and Simplex::QGauss
+// Test ShapeData for FE_SimplexP and QGaussSimplex
#include <deal.II/dofs/dof_handler.h>
-// Test ShapeData for Simplex::FE_P and Simplex::QGauss
+// Test ShapeData for FE_SimplexP and QGaussSimplex
#include <deal.II/base/quadrature_lib.h>
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);
{
initlog();
- test<2>(Simplex::FE_P<2>(2));
+ test<2>(FE_SimplexP<2>(2));
}
// ... 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);
}
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]);
// ... 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);
}
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);
// ... 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);
}
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);
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);
}
// ---------------------------------------------------------------------
-// Test Simplex::BarycentricPolynomials on an the points of an arbitrary
+// Test BarycentricPolynomials on an the points of an arbitrary
// quadrature rule.
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());
// ---------------------------------------------------------------------
-// Test QProjection for Simplex::QGauss.
+// Test QProjection for QGaussSimplex.
#include <deal.II/base/qprojector.h>
{
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);
{
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,
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)
// 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;
// ---------------------------------------------------------------------
-// Test Simplex::QGauss: output its quadrature points and weights.
+// Test QGaussSimplex: output its quadrature points and weights.
#include <deal.II/base/quadrature_lib.h>
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)
{
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(),
// 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.
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;
, 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>
// 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
output_results() const;
Triangulation<dim> triangulation;
- Simplex::FE_P<dim> fe;
+ FE_SimplexP<dim> fe;
DoFHandler<dim> dof_handler;
MappingFE<dim> mapping;
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;
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
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
# 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);
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);
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
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
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
<< std::endl;
#ifdef USE_SIMPLEX
- Simplex::FE_P<dim> fe(1);
+ FE_SimplexP<dim> fe(1);
#else
FE_Q<dim> fe(1);
#endif
<< std::endl;
#ifdef USE_SIMPLEX
- Simplex::FE_P<dim> fe(1);
+ FE_SimplexP<dim> fe(1);
#else
FE_Q<dim> fe(1);
#endif
<< std::endl;
#ifdef USE_SIMPLEX
- Simplex::FE_P<dim> fe(2);
+ FE_SimplexP<dim> fe(2);
#else
FE_Q<dim> fe(2);
#endif
<< std::endl;
#ifdef USE_SIMPLEX
- Simplex::FE_P<dim> fe(2);
+ FE_SimplexP<dim> fe(2);
#else
FE_Q<dim> fe(2);
#endif
// 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().
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>
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 |
{
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);
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;
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)
#ifdef HEX
const MappingQ1<dim> mapping;
#else
- Simplex::FE_P<dim> fe_mapping;
+ FE_SimplexP<dim> fe_mapping;
const MappingFE<dim> mapping;
#endif
#ifdef HEX
FE_DGQ<dim> fe;
#else
- Simplex::FE_DGP<dim> fe;
+ FE_SimplexDGP<dim> fe;
#endif
DoFHandler<dim> dof_handler;
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);
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)
// 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.
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)
{}
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,
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,
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>
// 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.
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;
#ifdef HEX
: mapping(1)
#else
- : mapping(Simplex::FE_P<dim>(1))
+ : mapping(FE_SimplexP<dim>(1))
#endif
, fe(1)
, quadrature(fe.degree + 1)
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;
, 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
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
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
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,
#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,
#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);
#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,
: 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}
// 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,
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;
, 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
// 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);
// 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);
// ---------------------------------------------------------------------
-// Distribute Simplex::FE_Wedge on a DoFHandler.
+// Distribute FE_WedgeP on a DoFHandler.
#include <deal.II/dofs/dof_handler.h>
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);
projects / dealii.git / commitdiff