]> https://gitweb.dealii.org/ - dealii.git/commitdiff
Introduced 'compare_for_domination()' functions. Deprecated 'compare_for_face_dominat... 7337/head
authorMarc Fehling <marc.fehling@gmx.net>
Thu, 11 Oct 2018 01:26:39 +0000 (19:26 -0600)
committerMarc Fehling <marc.fehling@gmx.net>
Mon, 29 Oct 2018 00:15:16 +0000 (18:15 -0600)
51 files changed:
doc/news/changes/incompatibilities/20181011Fehling [new file with mode: 0644]
doc/news/changes/major/20181011Fehling [new file with mode: 0644]
include/deal.II/fe/fe.h
include/deal.II/fe/fe_base.h
include/deal.II/fe/fe_bernstein.h
include/deal.II/fe/fe_dgp.h
include/deal.II/fe/fe_dgp_monomial.h
include/deal.II/fe/fe_dgp_nonparametric.h
include/deal.II/fe/fe_dgq.h
include/deal.II/fe/fe_enriched.h
include/deal.II/fe/fe_face.h
include/deal.II/fe/fe_nedelec.h
include/deal.II/fe/fe_nothing.h
include/deal.II/fe/fe_q.h
include/deal.II/fe/fe_q_base.h
include/deal.II/fe/fe_q_bubbles.h
include/deal.II/fe/fe_q_dg0.h
include/deal.II/fe/fe_q_hierarchical.h
include/deal.II/fe/fe_q_iso_q1.h
include/deal.II/fe/fe_raviart_thomas.h
include/deal.II/fe/fe_system.h
include/deal.II/fe/fe_trace.h
include/deal.II/hp/fe_collection.h
source/distributed/active_fe_indices_transfer.cc
source/distributed/cell_weights.cc
source/distributed/solution_transfer.cc
source/dofs/dof_handler_policy.cc
source/dofs/dof_tools_constraints.cc
source/fe/fe.cc
source/fe/fe_bernstein.cc
source/fe/fe_dgp.cc
source/fe/fe_dgp_monomial.cc
source/fe/fe_dgp_nonparametric.cc
source/fe/fe_dgq.cc
source/fe/fe_enriched.cc
source/fe/fe_face.cc
source/fe/fe_nedelec.cc
source/fe/fe_nothing.cc
source/fe/fe_q.cc
source/fe/fe_q_base.cc
source/fe/fe_q_bubbles.cc
source/fe/fe_q_dg0.cc
source/fe/fe_q_hierarchical.cc
source/fe/fe_q_iso_q1.cc
source/fe/fe_raviart_thomas_nodal.cc
source/fe/fe_system.cc
source/fe/fe_trace.cc
source/hp/fe_collection.cc
tests/fe/fe_enriched_color_08.cc
tests/fe/fe_enriched_color_08.with_mpi=true.with_trilinos=true.with_trilinos_with_zoltan=true.output
tests/hp/fe_collection_05.cc

diff --git a/doc/news/changes/incompatibilities/20181011Fehling b/doc/news/changes/incompatibilities/20181011Fehling
new file mode 100644 (file)
index 0000000..4c8eb01
--- /dev/null
@@ -0,0 +1,5 @@
+Deprecated: FiniteElement::compare_for_face_domination() has been
+deprecated and will be replaced by the more versatile function
+FiniteElement::compare_for_domination().
+<br>
+(Marc Fehling, 2018/10/11)
diff --git a/doc/news/changes/major/20181011Fehling b/doc/news/changes/major/20181011Fehling
new file mode 100644 (file)
index 0000000..8ab781a
--- /dev/null
@@ -0,0 +1,5 @@
+New: Function FiniteElement::compare_for_domination() inspects two
+FiniteElement objects upon FiniteElementDomination, and uses a codim
+parameter that determines in which subspace we actually compare them.
+<br>
+(Marc Fehling, 2018/10/11)
index bcb5fda482a2ec3c881ded96d6d88e0ded180db3..01b4b05546ba2fb41c22ad6c5af7c9604e7b6fd9 100644 (file)
@@ -1356,10 +1356,31 @@ public:
    * For a definition of domination, see FiniteElementDomination::Domination
    * and in particular the
    * @ref hp_paper "hp paper".
+   *
+   * @deprecated Use compare_for_domination() with `codim=1` instead.
    */
-  virtual FiniteElementDomination::Domination
+  DEAL_II_DEPRECATED virtual FiniteElementDomination::Domination
   compare_for_face_domination(
-    const FiniteElement<dim, spacedim> &fe_other) const;
+    const FiniteElement<dim, spacedim> &fe_other) const final;
+
+  /**
+   * Return whether this element dominates another one given as argument
+   * @p fe_other, whether it is the other way around, whether neither dominates,
+   * or if either could dominate. The @p codim parameter describes the codimension
+   * of the investigated subspace and specifies that it is subject to this
+   * comparison. For example, if `codim==0` then this function compares which
+   * element dominates at the cell level. If `codim==1`, then the elements are
+   * compared at faces, i.e., the comparison happens between the function spaces
+   * of the two finite elements as restricted to a face. Larger values of
+   * `codim` work correspondingly.
+   *
+   * For a definition of domination, see FiniteElementDomination::Domination
+   * and in particular the
+   * @ref hp_paper "hp paper".
+   */
+  virtual FiniteElementDomination::Domination
+  compare_for_domination(const FiniteElement<dim, spacedim> &fe_other,
+                         const unsigned int                  codim = 0) const;
 
   //@}
 
index c5e4fb312d1490cf3dacb8cd5a373a4866f8f202..95deafb58e5ae66c7e978c896b40f3c57d0c8668 100644 (file)
@@ -39,13 +39,13 @@ namespace FiniteElementDomination
    * strictly larger than that of the dominating element. For example, in 2-d
    * Q(2) elements dominate Q(4) elements, because the traces of Q(4) elements
    * are quartic polynomials which is a space strictly larger than the
-   * quadratic polynomials (the restriction of the Q(2) element). In general,
-   * Q(k) dominates Q(k') if $k\le k'$.
+   * quadratic polynomials (the restriction of the Q(2) element). Similar
+   * reasonings apply for vertices and cells as well. In general, Q(k) dominates
+   * Q(k') if $k\le k'$.
    *
-   * This enum is used in the FiniteElement::compare_for_face_domination()
-   * function that is used in the context of hp finite element methods when
-   * determining what to do at faces where two different finite elements meet
-   * (see the
+   * This enum is used in the FiniteElement::compare_for_domination() function
+   * that is used in the context of hp finite element methods when determining
+   * what to do at faces where two different finite elements meet (see the
    * @ref hp_paper "hp paper"
    * for a more detailed description of the following). In that case, the
    * degrees of freedom of one side need to be constrained to those on the
@@ -53,11 +53,6 @@ namespace FiniteElementDomination
    * of a comparison for mutual domination: the dominated side is constrained
    * to the dominating one.
    *
-   * A similar situation happens in 3d, where we have to consider different
-   * elements meeting at only an edge, not an entire face. Such comparisons
-   * are then implemented in the FiniteElement::compare_for_line_domination()
-   * function.
-   *
    * Note that there are situations where neither side dominates. The
    * @ref hp_paper "hp paper"
    * lists two case, with the simpler one being that a $Q_2\times Q_1$ vector-
index 3d02720b23362a18932a0b5b29ccf8d4b6483eb7..f3dde795008c9812b1aa27811c90334019c4a65d 100644 (file)
@@ -180,18 +180,11 @@ public:
     const FiniteElement<dim, spacedim> &fe_other) const override;
 
   /**
-   * Return whether this element dominates the one given as argument when they
-   * meet at a common face, whether it is the other way around, whether
-   * neither dominates, or if either could dominate.
-   *
-   * For a definition of domination, see FiniteElementDomination::Domination
-   * and in particular the
-   * @ref hp_paper "hp paper".
+   * @copydoc FiniteElement::compare_for_domination()
    */
   virtual FiniteElementDomination::Domination
-  compare_for_face_domination(
-    const FiniteElement<dim, spacedim> &fe_other) const override;
-
+  compare_for_domination(const FiniteElement<dim, spacedim> &fe_other,
+                         const unsigned int codim = 0) const override final;
 
   /**
    * Return a string that uniquely identifies a finite element. This class
index 5016822b7a06e1589339f7b4fa8f575b78eee2a9..355252111ad12d0d89cdeb721bc07fcebcd5fe2a 100644 (file)
@@ -385,17 +385,11 @@ public:
   hp_constraints_are_implemented() const override;
 
   /**
-   * Return whether this element dominates the one given as argument when they
-   * meet at a common face, whether it is the other way around, whether
-   * neither dominates, or if either could dominate.
-   *
-   * For a definition of domination, see FiniteElementDomination::Domination
-   * and in particular the
-   * @ref hp_paper "hp paper".
+   * @copydoc FiniteElement::compare_for_domination()
    */
   virtual FiniteElementDomination::Domination
-  compare_for_face_domination(
-    const FiniteElement<dim, spacedim> &fe_other) const override;
+  compare_for_domination(const FiniteElement<dim, spacedim> &fe_other,
+                         const unsigned int codim = 0) const override final;
 
   /**
    * @}
index 11be38054dbdcc2912803c9ea7bb99f29403d647..16dffa8ed892c86a868715e119d8d892a45f3492 100644 (file)
@@ -357,17 +357,11 @@ public:
   hp_constraints_are_implemented() const override;
 
   /**
-   * Return whether this element dominates the one given as argument when they
-   * meet at a common face, whether it is the other way around, whether
-   * neither dominates, or if either could dominate.
-   *
-   * For a definition of domination, see FiniteElementDomination::Domination
-   * and in particular the
-   * @ref hp_paper "hp paper".
+   * @copydoc FiniteElement::compare_for_domination()
    */
   virtual FiniteElementDomination::Domination
-  compare_for_face_domination(
-    const FiniteElement<dim> &fe_other) const override;
+  compare_for_domination(const FiniteElement<dim> &fe_other,
+                         const unsigned int codim = 0) const override final;
 
   /**
    * @}
index c6c1b534fbbc8b5e78f38efc2da4f000654eee55..80a565427150689b827181602cee18218263a697 100644 (file)
@@ -474,17 +474,11 @@ public:
   hp_constraints_are_implemented() const override;
 
   /**
-   * Return whether this element dominates the one given as argument when they
-   * meet at a common face, whether it is the other way around, whether
-   * neither dominates, or if either could dominate.
-   *
-   * For a definition of domination, see FiniteElementDomination::Domination
-   * and in particular the
-   * @ref hp_paper "hp paper".
+   * @copydoc FiniteElement::compare_for_domination()
    */
   virtual FiniteElementDomination::Domination
-  compare_for_face_domination(
-    const FiniteElement<dim, spacedim> &fe_other) const override;
+  compare_for_domination(const FiniteElement<dim, spacedim> &fe_other,
+                         const unsigned int codim = 0) const override final;
 
   /**
    * @}
index 32d50c3c3c57c880be825646cf157a1e4c7c9824..de3c6975099b9e8c836039049e9d0d8ec0a9767d 100644 (file)
@@ -280,17 +280,11 @@ public:
   hp_constraints_are_implemented() const override;
 
   /**
-   * Return whether this element dominates the one given as argument when they
-   * meet at a common face, whether it is the other way around, whether
-   * neither dominates, or if either could dominate.
-   *
-   * For a definition of domination, see FiniteElementDomination::Domination
-   * and in particular the
-   * @ref hp_paper "hp paper".
+   * @copydoc FiniteElement::compare_for_domination()
    */
   virtual FiniteElementDomination::Domination
-  compare_for_face_domination(
-    const FiniteElement<dim, spacedim> &fe_other) const override;
+  compare_for_domination(const FiniteElement<dim, spacedim> &fe_other,
+                         const unsigned int codim = 0) const override final;
 
   /**
    * @}
index b123f9772df8fbc9742b82ece59674d52dec3454..b09de46b916ecf32fa7582fd6c9755a95c3b26f6 100644 (file)
@@ -454,17 +454,12 @@ public:
     const FiniteElement<dim, spacedim> &fe_other) const override;
 
   /**
-   * Return whether this element dominates the one given as argument when they
-   * meet at a common face, whether it is the other way around, whether
-   * neither dominates, or if either could dominate.
-   *
-   * For a definition of domination, see FiniteElementBase::Domination and in
-   * particular the
-   * @ref hp_paper "hp paper".
+   * @copydoc FiniteElement::compare_for_domination()
    */
   virtual FiniteElementDomination::Domination
-  compare_for_face_domination(
-    const FiniteElement<dim, spacedim> &fe_other) const override;
+  compare_for_domination(const FiniteElement<dim, spacedim> &fe_other,
+                         const unsigned int codim = 0) const override final;
+
   //@}
 
 
index 91aa2a07ebc6e86e44171562bec6e8053a4f0453..c0238f6deb7a321fe04a074cf6110a53889ef61a 100644 (file)
@@ -175,17 +175,12 @@ public:
   hp_constraints_are_implemented() const override;
 
   /**
-   * Return whether this element dominates the one given as argument when they
-   * meet at a common face, whether it is the other way around, whether
-   * neither dominates, or if either could dominate.
-   *
-   * For a definition of domination, see FiniteElementDomination::Domination
-   * and in particular the
-   * @ref hp_paper "hp paper".
+   * @copydoc FiniteElement::compare_for_domination()
    */
   virtual FiniteElementDomination::Domination
-  compare_for_face_domination(
-    const FiniteElement<dim, spacedim> &fe_other) const override;
+  compare_for_domination(const FiniteElement<dim, spacedim> &fe_other,
+                         const unsigned int codim = 0) const override final;
+
   /**
    * @}
    */
@@ -324,19 +319,6 @@ public:
   hp_quad_dof_identities(
     const FiniteElement<1, spacedim> &fe_other) const override;
 
-  /**
-   * Return whether this element dominates the one given as argument when they
-   * meet at a common face, whether it is the other way around, whether
-   * neither dominates, or if either could dominate.
-   *
-   * For a definition of domination, see FiniteElementDomination::Domination
-   * and in particular the
-   * @ref hp_paper "hp paper".
-   */
-  virtual FiniteElementDomination::Domination
-  compare_for_face_domination(
-    const FiniteElement<1, spacedim> &fe_other) const override;
-
   /**
    * Return a list of constant modes of the element. For this element, it
    * simply returns one row with all entries set to true.
@@ -548,17 +530,11 @@ public:
   hp_constraints_are_implemented() const override;
 
   /**
-   * Return whether this element dominates the one given as argument when they
-   * meet at a common face, whether it is the other way around, whether
-   * neither dominates, or if either could dominate.
-   *
-   * For a definition of domination, see FiniteElementDomination::Domination
-   * and in particular the
-   * @ref hp_paper "hp paper".
+   * @copydoc FiniteElement::compare_for_domination()
    */
   virtual FiniteElementDomination::Domination
-  compare_for_face_domination(
-    const FiniteElement<dim, spacedim> &fe_other) const override;
+  compare_for_domination(const FiniteElement<dim, spacedim> &fe_other,
+                         const unsigned int codim = 0) const override final;
 
   /**
    * Return a list of constant modes of the element. For this element, the
index 25acab28d2324bf37bc2f1bdd741f0ac4d26fd27..0256343594eb6a2e57587209ec819821073ea387 100644 (file)
@@ -150,12 +150,11 @@ public:
   hp_constraints_are_implemented() const override;
 
   /**
-   * Return whether this element dominates the one, which is given as
-   * argument.
+   * @copydoc FiniteElement::compare_for_domination()
    */
   virtual FiniteElementDomination::Domination
-  compare_for_face_domination(
-    const FiniteElement<dim> &fe_other) const override;
+  compare_for_domination(const FiniteElement<dim> &fe_other,
+                         const unsigned int codim = 0) const override final;
 
   /**
    * If, on a vertex, several finite elements are active, the hp code first
@@ -219,6 +218,7 @@ public:
   get_subface_interpolation_matrix(const FiniteElement<dim> &source,
                                    const unsigned int        subface,
                                    FullMatrix<double> &matrix) const override;
+
   /**
    * Projection from a fine grid space onto a coarse grid space. If this
    * projection operator is associated with a matrix @p P, then the
index 384ad5f6b5d2d8bf16ff00d76c86b0966c7df13c..fd3b8270e6c056df36453c1580bc3d30030de494 100644 (file)
@@ -86,11 +86,11 @@ public:
    * finite element (default = 1).
    *
    * Second argument decides whether FE_Nothing will dominate any other FE in
-   * compare_for_face_domination() (default = false). Therefore at interfaces
-   * where, for example, a Q1 meets an FE_Nothing, we will force the traces of
-   * the two functions to be the same. Because the FE_Nothing encodes a space
-   * that is zero everywhere, this means that the Q1 field will be forced to
-   * become zero at this interface.
+   * compare_for_domination() (default = false). Therefore at interfaces where,
+   * for example, a Q1 meets an FE_Nothing, we will force the traces of the two
+   * functions to be the same. Because the FE_Nothing encodes a space that is
+   * zero everywhere, this means that the Q1 field will be forced to become zero
+   * at this interface.
    */
   FE_Nothing(const unsigned int n_components = 1, const bool dominate = false);
 
@@ -184,13 +184,7 @@ public:
       &output_data) const override;
 
   /**
-   * Return whether this element dominates the one given as argument when they
-   * meet at a common face, whether it is the other way around, whether
-   * neither dominates, or if either could dominate.
-   *
-   * For a definition of domination, see FiniteElementDomination::Domination
-   * and in particular the
-   * @ref hp_paper "hp paper".
+   * @copydoc FiniteElement::compare_for_domination()
    *
    * In the current case, this element is assumed to dominate if the second
    * argument in the constructor @p dominate is true. When this argument is
@@ -198,8 +192,8 @@ public:
    * dominate. Otherwise there are no_requirements.
    */
   virtual FiniteElementDomination::Domination
-  compare_for_face_domination(
-    const FiniteElement<dim, spacedim> &fe_other) const override;
+  compare_for_domination(const FiniteElement<dim, spacedim> &fe_other,
+                         const unsigned int codim = 0) const override final;
 
 
 
@@ -277,7 +271,9 @@ public:
 private:
   /**
    * If true, this element will dominate any other apart from itself in
-   * compare_for_face_domination();
+   * compare_for_domination(). This is because a space that only contains the
+   * zero function is definitely smaller (and consequently dominant) when
+   * compared to any other finite element space.
    */
   const bool dominate;
 };
index 0487ac76557ac11636b1acd36c86dd0ba68026f9..e5ba575fea008c47ed5304d058ad51742c109b11 100644 (file)
@@ -595,6 +595,13 @@ public:
   convert_generalized_support_point_values_to_dof_values(
     const std::vector<Vector<double>> &support_point_values,
     std::vector<double> &              nodal_values) const override;
+
+  /**
+   * @copydoc FiniteElement::compare_for_domination()
+   */
+  virtual FiniteElementDomination::Domination
+  compare_for_domination(const FiniteElement<dim, spacedim> &fe_other,
+                         const unsigned int codim = 0) const override final;
 };
 
 
index aa89ec321ad5f8d35aad052dae8ffabb020f9533..39e9c3282d1a60dae93650e0c7c371399979ad48 100644 (file)
@@ -263,18 +263,6 @@ public:
   hp_quad_dof_identities(
     const FiniteElement<dim, spacedim> &fe_other) const override;
 
-  /**
-   * Return whether this element dominates the one given as argument when they
-   * meet at a common face, whether it is the other way around, whether
-   * neither dominates, or if either could dominate.
-   *
-   * For a definition of domination, see FiniteElementDomination::Domination
-   * and in particular the
-   * @ref hp_paper "hp paper".
-   */
-  virtual FiniteElementDomination::Domination
-  compare_for_face_domination(
-    const FiniteElement<dim, spacedim> &fe_other) const override;
   //@}
 
   /**
index f906065ebf0307a82e311abaec6ddd39bb1d3c8e..05651de719e0b7bfd2e2cd2fac9ba9ec4393e541 100644 (file)
@@ -152,6 +152,13 @@ public:
   virtual std::unique_ptr<FiniteElement<dim, spacedim>>
   clone() const override;
 
+  /**
+   * @copydoc FiniteElement::compare_for_domination()
+   */
+  virtual FiniteElementDomination::Domination
+  compare_for_domination(const FiniteElement<dim, spacedim> &fe_other,
+                         const unsigned int codim = 0) const override final;
+
 private:
   /**
    * Return the restriction_is_additive flags. Only the last components for
index e23a841e24d0d4094f027968f83a060326f39eb9..fd6f8c4e9bd253da527f78a8d24a41a5ac148350 100644 (file)
@@ -302,6 +302,13 @@ public:
   virtual std::unique_ptr<FiniteElement<dim, spacedim>>
   clone() const override;
 
+  /**
+   * @copydoc FiniteElement::compare_for_domination()
+   */
+  virtual FiniteElementDomination::Domination
+  compare_for_domination(const FiniteElement<dim, spacedim> &fe_other,
+                         const unsigned int codim = 0) const override final;
+
 private:
   /**
    * Return the restriction_is_additive flags. Only the last component is
index 85c4a7533f05543851d68f0cbc81361fc6eb7bd9..7b25ab08b816da7809b17c65a587c47111d51667 100644 (file)
@@ -630,6 +630,13 @@ public:
   virtual std::vector<std::pair<unsigned int, unsigned int>>
   hp_quad_dof_identities(const FiniteElement<dim> &fe_other) const override;
 
+  /**
+   * @copydoc FiniteElement::compare_for_domination()
+   */
+  virtual FiniteElementDomination::Domination
+  compare_for_domination(const FiniteElement<dim> &fe_other,
+                         const unsigned int codim = 0) const override final;
+
   /*@}*/
 
   /**
@@ -663,19 +670,6 @@ public:
                                    const unsigned int        subface,
                                    FullMatrix<double> &matrix) const override;
 
-  /**
-   * Return whether this element dominates the one given as argument when they
-   * meet at a common face, whether it is the other way around, whether
-   * neither dominates, or if either could dominate.
-   *
-   * For a definition of domination, see FiniteElementDomination::Domination
-   * and in particular the
-   * @ref hp_paper "hp paper".
-   */
-  virtual FiniteElementDomination::Domination
-  compare_for_face_domination(
-    const FiniteElement<dim> &fe_other) const override;
-
   /**
    * Determine an estimate for the memory consumption (in bytes) of this
    * object.
index ca10e762d7394da8f7d7b9281bb71de14961fb2e..6231dc67c21cb1a00d5a07d48ba7c00c13e8a8b0 100644 (file)
@@ -153,17 +153,12 @@ public:
    */
 
   /**
-   * Return whether this element dominates the one given as argument when they
-   * meet at a common face, whether it is the other way around, whether
-   * neither dominates, or if either could dominate.
-   *
-   * For a definition of domination, see FiniteElementDomination::Domination
-   * and in particular the
-   * @ref hp_paper "hp paper".
+   * @copydoc FiniteElement::compare_for_domination()
    */
   virtual FiniteElementDomination::Domination
-  compare_for_face_domination(
-    const FiniteElement<dim, spacedim> &fe_other) const override;
+  compare_for_domination(const FiniteElement<dim, spacedim> &fe_other,
+                         const unsigned int codim = 0) const override final;
+
   //@}
 };
 
index 73d93cc98a7f29ab5cc6778f9571efc8cface14e..af43eafd1641efdaf865393ea3666cd007f770c9 100644 (file)
@@ -292,9 +292,12 @@ public:
   virtual std::vector<std::pair<unsigned int, unsigned int>>
   hp_quad_dof_identities(const FiniteElement<dim> &fe_other) const override;
 
+  /**
+   * @copydoc FiniteElement::compare_for_domination()
+   */
   virtual FiniteElementDomination::Domination
-  compare_for_face_domination(
-    const FiniteElement<dim> &fe_other) const override;
+  compare_for_domination(const FiniteElement<dim> &fe_other,
+                         const unsigned int codim = 0) const override final;
 
 private:
   /**
index bc269b5bab15f0334bdb674fb829b66726bb72cd..06c3cc1f5cbe589ff2e34fe6f159d08770351815 100644 (file)
@@ -957,17 +957,12 @@ public:
     const FiniteElement<dim, spacedim> &fe_other) const override;
 
   /**
-   * Return whether this element dominates the one given as argument when they
-   * meet at a common face, whether it is the other way around, whether
-   * neither dominates, or if either could dominate.
-   *
-   * For a definition of domination, see FiniteElementDomination::Domination
-   * and in particular the
-   * @ref hp_paper "hp paper".
+   * @copydoc FiniteElement::compare_for_domination()
    */
   virtual FiniteElementDomination::Domination
-  compare_for_face_domination(
-    const FiniteElement<dim, spacedim> &fe_other) const override;
+  compare_for_domination(const FiniteElement<dim, spacedim> &fe_other,
+                         const unsigned int codim = 0) const override final;
+
   //@}
 
   /**
index 7551f93656f187d2b7908a969d5bb1f9d31c2dcf..86205542c8920f307def523eccb09f0934a523fb 100644 (file)
@@ -125,17 +125,11 @@ public:
                                    FullMatrix<double> &matrix) const override;
 
   /**
-   * Return whether this element dominates the one given as argument when they
-   * meet at a common face, whether it is the other way around, whether
-   * neither dominates, or if either could dominate.
-   *
-   * For a definition of domination, see FiniteElementDomination::Domination
-   * and in particular the
-   * @ref hp_paper "hp paper".
+   * @copydoc FiniteElement::compare_for_domination()
    */
   virtual FiniteElementDomination::Domination
-  compare_for_face_domination(
-    const FiniteElement<dim, spacedim> &fe_other) const override;
+  compare_for_domination(const FiniteElement<dim, spacedim> &fe_other,
+                         const unsigned int codim = 0) const override final;
 
 private:
   /**
index 10e09287e7326bfb458651488cad9b1faf2bb30f..c078660001cb6bf6f11646421fa461bb647dcda3 100644 (file)
@@ -252,17 +252,15 @@ namespace hp
      * within that set of dominating elements, we find the <i>least</i>
      * dominant one.
      *
-     * For example, if
-     * an FECollection consists of `{FE_Q(1),FE_Q(2),FE_Q(3),FE_Q(4)}` elements
+     * For example, if an FECollection consists of
+     * `{FE_Q(1),FE_Q(2),FE_Q(3),FE_Q(4)}` elements
      * and the argument @p fes equals `{2,3}`, then the set of dominating
      * elements consists of `{0,1,2}`, of which `2` (i.e., the `FE_Q(3)`) is the
      * least dominant one, and then that's what the function returns.
      *
-     * On the other hand, if the
-     * FECollection consists of
-     * `{FE_Q(1)xFE_Q(1),FE_Q(2)xFE_Q(2),FE_Q(2)xFE_Q(3), FE_Q(3)xFE_Q(2)}`
-     * elements and the argument is again
-     * @p fes equal to `{2,3}`, then the set of dominating
+     * On the other hand, if the FECollection consists of
+     * `{FE_Q(1)xFE_Q(1),FE_Q(2)xFE_Q(2),FE_Q(2)xFE_Q(3),FE_Q(3)xFE_Q(2)}`
+     * elements and the argument is again @p fes equal to `{2,3}`, then the set of dominating
      * elements consists of `{0,1}` because now neither of the last two
      * elements dominates the other, of which `1` (i.e., the `FE_Q(2)xFE_Q(2)`)
      * is the least dominant one -- so that's what the function returns in
@@ -276,30 +274,70 @@ namespace hp
      * a single element `{3}`, then the function returns 3.
      *
      * If the function is not able to find a finite element that satisfies
-     * the description above, the function
-     * returns numbers::invalid_unsigned_int. An example would go like this:
-     * If the FECollection consists of `{FE_Nothing
-     * x FE_Nothing, FE_Q(1)xFE_Q(2), FE_Q(2)xFE_Q(1)}` with @p fes as `{1}`,
+     * the description above, the function returns
+     * numbers::invalid_unsigned_int. An example would go like this:
+     * If the FECollection consists of `{FE_Nothing x FE_Nothing, FE_Q(1)xFE_Q(2), FE_Q(2)xFE_Q(1)}` with @p fes as `{1}`,
      * the function will not find a most dominating element as the default
      * behavior of FE_Nothing is to return
      * FiniteElementDomination::no_requirements when comparing for face
-     * domination with any other element. In other words, the set of
-     * dominating elements is empty, and we can not find a least dominant
-     * one among it. The return value is therefore
-     * numbers::invalid_unsigned_int.
+     * domination with any other element. In other words, the set of dominating
+     * elements is empty, and we can not find a least dominant one among it. The
+     * return value is therefore numbers::invalid_unsigned_int.
+     *
+     * @deprecated Use
+     * hp::FECollection::find_least_face_dominating_fe_in_collection(fes, 1)
+     * instead.
      */
-    unsigned int
-    find_least_face_dominating_fe_in_collection(
-      const std::set<unsigned int> &fes) const;
+    DEAL_II_DEPRECATED unsigned int
+    find_least_face_dominating_fe(const std::set<unsigned int> &fes) const;
 
     /**
-     * @copydoc FECollection::find_least_face_dominating_fe_in_collection()
+     * Try to find a least dominant finite element inside this FECollection
+     * which dominates all of those finite elements in the current collection
+     * indexed by the numbers provided through @p fes . In other words, we
+     * first form the set of elements in this collection that dominate
+     * all of the ones that are indexed by the argument @p fes, and then
+     * within that set of dominating elements, we find the <i>least</i>
+     * dominant one.
+     *
+     * For example, if an FECollection consists of
+     * `{FE_Q(1),FE_Q(2),FE_Q(3),FE_Q(4)}` elements
+     * and the argument @p fes equals `{2,3}`, then the set of dominating
+     * elements consists of `{0,1,2}`, of which `2` (i.e., the `FE_Q(3)`) is the
+     * least dominant one, and then that's what the function returns.
+     *
+     * On the other hand, if the FECollection consists of
+     * `{FE_Q(1)xFE_Q(1),FE_Q(2)xFE_Q(2),FE_Q(2)xFE_Q(3),FE_Q(3)xFE_Q(2)}`
+     * elements and the argument is again @p fes equal to `{2,3}`, then the set of dominating
+     * elements consists of `{0,1}` because now neither of the last two
+     * elements dominates the other, of which `1` (i.e., the `FE_Q(2)xFE_Q(2)`)
+     * is the least dominant one -- so that's what the function returns in
+     * this case.
+     *
+     * For the purpose of this function by domination we consider either
+     * FiniteElementDomination::Domination::this_element_dominates or
+     * FiniteElementDomination::Domination::either_element_can_dominate;
+     * therefore the element can dominate itself. Thus, if an FECollection
+     * contains `{FE_Q(1),FE_Q(2),FE_Q(3),FE_Q(4)}` and @p fes only has
+     * a single element `{3}`, then the function returns 3.
      *
-     * @deprecated This function has been renamed. Use
-     * hp::FECollection::find_least_face_dominating_fe_in_collection() instead.
+     * If the function is not able to find a finite element that satisfies
+     * the description above, the function returns
+     * numbers::invalid_unsigned_int. An example would go like this:
+     * If the FECollection consists of `{FE_Nothing x FE_Nothing, FE_Q(1)xFE_Q(2), FE_Q(2)xFE_Q(1)}` with @p fes as `{1}`,
+     * the function will not find a most dominating element as the default
+     * behavior of FE_Nothing is to return
+     * FiniteElementDomination::no_requirements when comparing for face
+     * domination with any other element. In other words, the set of dominating
+     * elements is empty, and we can not find a least dominant one among it. The
+     * return value is therefore numbers::invalid_unsigned_int.
+     *
+     * The @p codim parameter describes the codimension of of the investigated
+     * subspace and specifies that it is subject to this comparison.
      */
-    DEAL_II_DEPRECATED unsigned int
-    find_least_face_dominating_fe(const std::set<unsigned int> &fes) const;
+    unsigned int
+    find_least_dominating_fe_in_collection(const std::set<unsigned int> &fes,
+                                           const unsigned int codim = 0) const;
 
     /**
      * Try to find a most face dominating finite element inside the subset of
@@ -310,8 +348,9 @@ namespace hp
      * answer is FE_Q(3) and therefore this function will return its index in
      * the FECollection, namely `2`.
      *
-     * This function differs from find_least_face_dominating_fe() in such a way
-     * that it looks for the most dominating finite element within the given
+     * This function differs from find_least_dominating_fe_in_collection() in
+     * such a way that it looks for the most dominating finite element within
+     * the given
      * subset @p fes, instead of finding a finite element in the whole
      * FECollection that dominates all elements of the subset @p fes.
      *
@@ -324,9 +363,13 @@ namespace hp
      *
      * If the function is not able to find a finite element, the function
      * returns numbers::invalid_unsigned_int.
+     *
+     * The @p codim parameter describes the codimension of of the investigated
+     * subspace and specifies that it is subject to this comparison.
      */
     unsigned int
-    find_face_dominating_fe_in_subset(const std::set<unsigned int> &fes) const;
+    find_dominating_fe_in_subset(const std::set<unsigned int> &fes,
+                                 const unsigned int            codim = 0) const;
 
     /**
      * Return a component mask with as many elements as this object has vector
index e956c7f6bb570460c8f7283bcf7e44bc9ecafccd..60ea718f17ca207f557b430951a8326fc67ab80f 100644 (file)
@@ -138,9 +138,10 @@ namespace parallel
                   fe_indices_children.insert(child->active_fe_index());
                 }
 
-              fe_index = dof_handler->get_fe()
-                           .find_least_face_dominating_fe_in_collection(
-                             fe_indices_children);
+              fe_index =
+                dof_handler->get_fe_collection()
+                  .find_least_dominating_fe_in_collection(fe_indices_children,
+                                                          /*codim=*/0);
 
               Assert(fe_index != numbers::invalid_unsigned_int,
                      ExcMessage(
index c031c4654303f459927a7f7253a877ab7ad04324..365c86051f8c5d2b37503faa2f038c9bd162628e 100644 (file)
@@ -150,8 +150,9 @@ namespace parallel
                 cell->child(child_index)->active_fe_index());
 
             fe_index =
-              dof_handler->get_fe().find_least_face_dominating_fe_in_collection(
-                fe_indices_children);
+              dof_handler->get_fe_collection()
+                .find_least_dominating_fe_in_collection(fe_indices_children,
+                                                        /*codim=*/0);
 
             Assert(fe_index != numbers::invalid_unsigned_int,
                    ExcMessage(
index e1b57c8da48a729f9802e56f0c98b7626a51f9da..4c4f5d9f26f18cad37d4dff60df7d4dac01df989 100644 (file)
@@ -253,8 +253,8 @@ namespace parallel
                       cell->child(child_index)->active_fe_index());
 
                   fe_index = dof_handler->get_fe_collection()
-                               .find_least_face_dominating_fe_in_collection(
-                                 fe_indices_children);
+                               .find_least_dominating_fe_in_collection(
+                                 fe_indices_children, /*codim=*/0);
 
                   Assert(
                     fe_index != numbers::invalid_unsigned_int,
index 7297b431634460d384b933a6c10febf4fccc9bad..613746b074a8ffd85d80221df6a42adffa9b730b 100644 (file)
@@ -968,7 +968,8 @@ namespace internal
                       // the ones that are used on this line
                       const unsigned int most_dominating_fe_index =
                         dof_handler.get_fe_collection()
-                          .find_face_dominating_fe_in_subset(fe_indices);
+                          .find_dominating_fe_in_subset(fe_indices,
+                                                        /*codim=*/dim - 1);
 
                       // if we found the most dominating element, then use this
                       // to eliminate some of the degrees of freedom by
@@ -1127,7 +1128,8 @@ namespace internal
                   // element of the ones that are used on this quad
                   const unsigned int most_dominating_fe_index =
                     dof_handler.get_fe_collection()
-                      .find_face_dominating_fe_in_subset(fe_indices);
+                      .find_dominating_fe_in_subset(fe_indices,
+                                                    /*codim=*/dim - 2);
 
                   // if we found the most dominating element, then use
                   // this to eliminate some of the degrees of freedom
@@ -1681,7 +1683,8 @@ namespace internal
                       // the ones that are used on this line
                       const unsigned int most_dominating_fe_index =
                         dof_handler.get_fe_collection()
-                          .find_face_dominating_fe_in_subset(fe_indices);
+                          .find_dominating_fe_in_subset(fe_indices,
+                                                        /*codim=*/dim - 1);
 
                       // if we found the most dominating element, then use this
                       // to eliminate some of the degrees of freedom by
@@ -1823,7 +1826,8 @@ namespace internal
                   // element of the ones that are used on this quad
                   const unsigned int most_dominating_fe_index =
                     dof_handler.get_fe_collection()
-                      .find_face_dominating_fe_in_subset(fe_indices);
+                      .find_dominating_fe_in_subset(fe_indices,
+                                                    /*codim=*/dim - 2);
 
                   // if we found the most dominating element, then use
                   // this to eliminate some of the degrees of freedom
index c0ecfcdefae6a9cc518538005bd775cdf65393bd..86348638f98702b0fe488dcf504406f2bcdeeb1e 100644 (file)
@@ -1145,8 +1145,8 @@ namespace DoFTools
                         {
                           mother_face_dominates =
                             mother_face_dominates &
-                            (cell->get_fe().compare_for_face_domination(
-                              subcell->get_fe()));
+                            (cell->get_fe().compare_for_domination(
+                              subcell->get_fe(), /*codim=*/1));
                           fe_ind_face_subface.insert(
                             subcell->active_fe_index());
                         }
@@ -1199,8 +1199,9 @@ namespace DoFTools
                             // subface between FE_Q(1) and FE_Nothing, there are
                             // no constraints that we need to take care of. in
                             // that case, just continue
-                            if (cell->get_fe().compare_for_face_domination(
-                                  subface->get_fe(subface_fe_index)) ==
+                            if (cell->get_fe().compare_for_domination(
+                                  subface->get_fe(subface_fe_index),
+                                  /*codim=*/1) ==
                                 FiniteElementDomination::no_requirements)
                               continue;
 
@@ -1284,21 +1285,20 @@ namespace DoFTools
                         // 2) there is no dominating FE among sub faces (e.g.
                         // Q1xQ2 vs Q2xQ1), but subfaces still dominate mother
                         // face (e.g. Q2xQ2). To cover this case we would have
-                        // to use find_least_face_dominating_fe_in_collection()
+                        // to use find_least_dominating_fe_in_collection()
                         // of FECollection with fe_indices of sub faces. 3)
                         // Finally, it could happen that we got here because
                         // neither_element_dominates (e.g. Q1xQ1xQ2 and Q1xQ2xQ1
                         // for subfaces and Q2xQ1xQ1 for mother face). This
                         // requires usage of
-                        // find_least_face_dominating_fe_in_collection() with
+                        // find_least_dominating_fe_in_collection() with
                         // fe_indices of sub-faces and the mother face.
                         // Note that the last solution covers the first two
                         // scenarios, thus we stick with it assuming that we
                         // won't lose much time/efficiency.
                         const unsigned int dominating_fe_index =
-                          fe_collection
-                            .find_least_face_dominating_fe_in_collection(
-                              fe_ind_face_subface);
+                          fe_collection.find_least_dominating_fe_in_collection(
+                            fe_ind_face_subface, /*codim=*/1);
                         AssertThrow(
                           dominating_fe_index != numbers::invalid_unsigned_int,
                           ExcMessage(
@@ -1494,8 +1494,9 @@ namespace DoFTools
                       neighbor = cell->neighbor(face);
 
                     // see which side of the face we have to constrain
-                    switch (cell->get_fe().compare_for_face_domination(
-                      neighbor->get_fe()))
+                    switch (
+                      cell->get_fe().compare_for_domination(neighbor->get_fe(),
+                                                            /*codim=*/1))
                       {
                         case FiniteElementDomination::this_element_dominates:
                           {
@@ -1597,8 +1598,8 @@ namespace DoFTools
                               &fe_collection = dof_handler.get_fe_collection();
                             const unsigned int dominating_fe_index =
                               fe_collection
-                                .find_least_face_dominating_fe_in_collection(
-                                  fes);
+                                .find_least_dominating_fe_in_collection(
+                                  fes, /*codim=*/1);
 
                             AssertThrow(
                               dominating_fe_index !=
index b35ab09ab7c339ff10d7b959b492d61a7011e7e2..74e768387c82e0507dfbb88cbc477128a58405e2 100644 (file)
@@ -962,7 +962,18 @@ FiniteElement<dim, spacedim>::hp_quad_dof_identities(
 template <int dim, int spacedim>
 FiniteElementDomination::Domination
 FiniteElement<dim, spacedim>::compare_for_face_domination(
-  const FiniteElement<dim, spacedim> &) const
+  const FiniteElement<dim, spacedim> &fe_other) const
+{
+  return this->compare_for_domination(fe_other, 1);
+}
+
+
+
+template <int dim, int spacedim>
+FiniteElementDomination::Domination
+FiniteElement<dim, spacedim>::compare_for_domination(
+  const FiniteElement<dim, spacedim> &,
+  const unsigned int) const
 {
   Assert(false, ExcNotImplemented());
   return FiniteElementDomination::neither_element_dominates;
index 394ba22f6cdd789ec262d77fc640e749b8d4fd5b..99294631a2eeac5d7290dffc59eefefffdb0f5c3 100644 (file)
@@ -21,6 +21,7 @@
 #include <deal.II/base/std_cxx14/memory.h>
 
 #include <deal.II/fe/fe_bernstein.h>
+#include <deal.II/fe/fe_dgq.h>
 #include <deal.II/fe/fe_nothing.h>
 #include <deal.II/fe/fe_q.h>
 #include <deal.II/fe/fe_tools.h>
@@ -278,9 +279,24 @@ FE_Bernstein<dim, spacedim>::hp_quad_dof_identities(
 
 template <int dim, int spacedim>
 FiniteElementDomination::Domination
-FE_Bernstein<dim, spacedim>::compare_for_face_domination(
-  const FiniteElement<dim, spacedim> &fe_other) const
+FE_Bernstein<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_DGQ)
+  // ------------------------------------
+  if (codim > 0)
+    if (dynamic_cast<const FE_DGQ<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_DGQ)
+  // & cell domination
+  // ----------------------------------------
   if (const FE_Bernstein<dim, spacedim> *fe_b_other =
         dynamic_cast<const FE_Bernstein<dim, spacedim> *>(&fe_other))
     {
@@ -291,20 +307,16 @@ FE_Bernstein<dim, spacedim>::compare_for_face_domination(
       else
         return FiniteElementDomination::other_element_dominates;
     }
-  else if (const FE_Nothing<dim> *fe_nothing =
-             dynamic_cast<const FE_Nothing<dim> *>(&fe_other))
+  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;
-        }
+        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;
-        }
+        // 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());
index 0fa056545a978573fdb94e0c3afde840e7562f56..9b43acf48e56236adc7ac6710d3362e984ddce70 100644 (file)
@@ -17,6 +17,7 @@
 #include <deal.II/base/std_cxx14/memory.h>
 
 #include <deal.II/fe/fe_dgp.h>
+#include <deal.II/fe/fe_nothing.h>
 #include <deal.II/fe/fe_tools.h>
 
 #include <sstream>
@@ -213,14 +214,44 @@ FE_DGP<dim, spacedim>::hp_quad_dof_identities(
 
 template <int dim, int spacedim>
 FiniteElementDomination::Domination
-FE_DGP<dim, spacedim>::compare_for_face_domination(
-  const FiniteElement<dim, spacedim> &fe_other) const
+FE_DGP<dim, spacedim>::compare_for_domination(
+  const FiniteElement<dim, spacedim> &fe_other,
+  const unsigned int                  codim) const
 {
-  // check whether both are discontinuous elements, see the description of
-  // FiniteElementDomination::Domination
-  if (dynamic_cast<const FE_DGP<dim, spacedim> *>(&fe_other) != nullptr)
+  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_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;
 }
index 759c2d9f838ce58124c85de9f9b28e282a2ed6c5..3e1176bfaec3842d3c91bf628532c7c3e9753777 100644 (file)
@@ -17,6 +17,7 @@
 #include <deal.II/base/std_cxx14/memory.h>
 
 #include <deal.II/fe/fe_dgp_monomial.h>
+#include <deal.II/fe/fe_nothing.h>
 #include <deal.II/fe/fe_tools.h>
 
 #include <sstream>
@@ -390,16 +391,43 @@ FE_DGPMonomial<dim>::hp_quad_dof_identities(
 
 template <int dim>
 FiniteElementDomination::Domination
-FE_DGPMonomial<dim>::compare_for_face_domination(
-  const FiniteElement<dim> &fe_other) const
+FE_DGPMonomial<dim>::compare_for_domination(const FiniteElement<dim> &fe_other,
+                                            const unsigned int codim) const
 {
-  // check whether both are discontinuous
-  // elements, see
-  // the description of
-  // FiniteElementDomination::Domination
-  if (dynamic_cast<const FE_DGPMonomial<dim> *>(&fe_other) != nullptr)
+  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_DGPMonomial<dim> *fe_monomial_other =
+        dynamic_cast<const FE_DGPMonomial<dim> *>(&fe_other))
+    {
+      if (this->degree < fe_monomial_other->degree)
+        return FiniteElementDomination::this_element_dominates;
+      else if (this->degree == fe_monomial_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;
 }
index 99c94c4aba3a8fcfdb5837f08998d447c721b3be..140a11c52432620917b923e82d70212b359a8553 100644 (file)
@@ -21,6 +21,7 @@
 
 #include <deal.II/fe/fe.h>
 #include <deal.II/fe/fe_dgp_nonparametric.h>
+#include <deal.II/fe/fe_nothing.h>
 #include <deal.II/fe/fe_values.h>
 #include <deal.II/fe/mapping.h>
 
@@ -590,16 +591,44 @@ FE_DGPNonparametric<dim, spacedim>::hp_quad_dof_identities(
 
 template <int dim, int spacedim>
 FiniteElementDomination::Domination
-FE_DGPNonparametric<dim, spacedim>::compare_for_face_domination(
-  const FiniteElement<dim, spacedim> &fe_other) const
+FE_DGPNonparametric<dim, spacedim>::compare_for_domination(
+  const FiniteElement<dim, spacedim> &fe_other,
+  const unsigned int                  codim) const
 {
-  // check whether both are discontinuous
-  // elements, see the description of
-  // FiniteElementDomination::Domination
-  if (dynamic_cast<const FE_DGPNonparametric<dim, spacedim> *>(&fe_other) !=
-      nullptr)
+  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_DGPNonparametric<dim, spacedim> *fe_nonparametric_other =
+        dynamic_cast<const FE_DGPNonparametric<dim, spacedim> *>(&fe_other))
+    {
+      if (this->degree < fe_nonparametric_other->degree)
+        return FiniteElementDomination::this_element_dominates;
+      else if (this->degree == fe_nonparametric_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;
 }
index 439fb5d7b5a783aa3c7de0f1bdbfa736b7e0056b..07ff80d9a3d28336c828d65cefdf6f8ffafdfdb0 100644 (file)
 #include <deal.II/base/std_cxx14/memory.h>
 
 #include <deal.II/fe/fe.h>
+#include <deal.II/fe/fe_bernstein.h>
 #include <deal.II/fe/fe_dgq.h>
+#include <deal.II/fe/fe_nothing.h>
+#include <deal.II/fe/fe_q.h>
+#include <deal.II/fe/fe_q_bubbles.h>
+#include <deal.II/fe/fe_q_dg0.h>
+#include <deal.II/fe/fe_q_hierarchical.h>
+#include <deal.II/fe/fe_q_iso_q1.h>
 #include <deal.II/fe/fe_tools.h>
 
 #include <deal.II/lac/vector.h>
@@ -600,13 +607,109 @@ FE_DGQ<dim, spacedim>::hp_quad_dof_identities(
 
 template <int dim, int spacedim>
 FiniteElementDomination::Domination
-FE_DGQ<dim, spacedim>::compare_for_face_domination(
-  const FiniteElement<dim, spacedim> & /*fe_other*/) const
+FE_DGQ<dim, spacedim>::compare_for_domination(
+  const FiniteElement<dim, spacedim> &fe_other,
+  const unsigned int                  codim) const
 {
-  // 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;
+  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
+  // ---------------
+  // The following block of conditionals is rather ugly, but there is currently
+  // no other way how to deal with a robust comparison of FE_DGQ elements with
+  // relevant others in the current implementation.
+  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_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_Bernstein<dim, spacedim> *fe_bernstein_other =
+             dynamic_cast<const FE_Bernstein<dim, spacedim> *>(&fe_other))
+    {
+      if (this->degree < fe_bernstein_other->degree)
+        return FiniteElementDomination::this_element_dominates;
+      else if (this->degree == fe_bernstein_other->degree)
+        return FiniteElementDomination::either_element_can_dominate;
+      else
+        return FiniteElementDomination::other_element_dominates;
+    }
+  else if (const FE_Q_Bubbles<dim, spacedim> *fe_bubbles_other =
+             dynamic_cast<const FE_Q_Bubbles<dim, spacedim> *>(&fe_other))
+    {
+      if (this->degree < fe_bubbles_other->degree)
+        return FiniteElementDomination::this_element_dominates;
+      else if (this->degree == fe_bubbles_other->degree)
+        return FiniteElementDomination::either_element_can_dominate;
+      else
+        return FiniteElementDomination::other_element_dominates;
+    }
+  else if (const FE_Q_DG0<dim, spacedim> *fe_dg0_other =
+             dynamic_cast<const FE_Q_DG0<dim, spacedim> *>(&fe_other))
+    {
+      if (this->degree < fe_dg0_other->degree)
+        return FiniteElementDomination::this_element_dominates;
+      else if (this->degree == fe_dg0_other->degree)
+        return FiniteElementDomination::either_element_can_dominate;
+      else
+        return FiniteElementDomination::other_element_dominates;
+    }
+  else if (const FE_Q_iso_Q1<dim, spacedim> *fe_q_iso_q1_other =
+             dynamic_cast<const FE_Q_iso_Q1<dim, spacedim> *>(&fe_other))
+    {
+      if (this->degree < fe_q_iso_q1_other->degree)
+        return FiniteElementDomination::this_element_dominates;
+      else if (this->degree == fe_q_iso_q1_other->degree)
+        return FiniteElementDomination::either_element_can_dominate;
+      else
+        return FiniteElementDomination::other_element_dominates;
+    }
+  else if (const FE_Q_Hierarchical<dim> *fe_hierarchical_other =
+             dynamic_cast<const FE_Q_Hierarchical<dim> *>(&fe_other))
+    {
+      if (this->degree < fe_hierarchical_other->degree)
+        return FiniteElementDomination::this_element_dominates;
+      else if (this->degree == fe_hierarchical_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;
 }
 
 
index e6aaa777056f10a93b31854e40972437c378a58f..fc0b24487bdd59250bd2d690cd3d93cffefd9721 100644 (file)
@@ -975,9 +975,14 @@ FE_Enriched<dim, spacedim>::hp_quad_dof_identities(
 
 template <int dim, int spacedim>
 FiniteElementDomination::Domination
-FE_Enriched<dim, spacedim>::compare_for_face_domination(
-  const FiniteElement<dim, spacedim> &fe_other) const
+FE_Enriched<dim, spacedim>::compare_for_domination(
+  const FiniteElement<dim, spacedim> &fe_other,
+  const unsigned int                  codim) const
 {
+  Assert(codim <= dim, ExcImpossibleInDim(dim));
+
+  // vertex/line/face/cell domination
+  // --------------------------------
   // need to decide which element constrain another.
   // for example Q(2) dominate Q(4) and thus some DoFs of Q(4) will be
   // constrained. If we have Q(2) and Q(4)+POU, then it's clear that Q(2)
@@ -985,14 +990,14 @@ FE_Enriched<dim, spacedim>::compare_for_face_domination(
   // However, we need to check for situations like Q(4) vs Q(2)+POU.
   // In that case the domination for the underlying FEs should be the other way,
   // but this implies that we can't constrain POU dofs to make the field
-  // continuous. In that case, through an error
+  // continuous. In that case, throw an error
 
   // if it's also enriched, do domination based on each one's FESystem
   if (const FE_Enriched<dim, spacedim> *fe_enr_other =
         dynamic_cast<const FE_Enriched<dim, spacedim> *>(&fe_other))
     {
-      return fe_system->compare_for_face_domination(
-        fe_enr_other->get_fe_system());
+      return fe_system->compare_for_domination(fe_enr_other->get_fe_system(),
+                                               codim);
     }
   else
     {
@@ -1001,6 +1006,7 @@ FE_Enriched<dim, spacedim>::compare_for_face_domination(
     }
 }
 
+
 template <int dim, int spacedim>
 const FullMatrix<double> &
 FE_Enriched<dim, spacedim>::get_prolongation_matrix(
@@ -1258,8 +1264,7 @@ namespace ColorEnriched
        * Each time we build constraints at the
        * interface between two different FE_Enriched, we look for the least
        * dominating FE via
-       * hp::FECollection<dim,
-       * spacedim>::find_least_face_dominating_fe_in_collection(). If we don't
+       * hp::FECollection::find_least_dominating_fe_in_collection(). If we don't
        * take further actions, we may find a dominating FE that is too
        * restrictive, i.e. enriched FE consisting of only FE_Nothing. New
        * elements needs to be added to FECollection object to help find the
@@ -1275,7 +1280,7 @@ namespace ColorEnriched
        * on adjacent cells, an enriched FE [0 0 1] should exist and is
        * found as the least dominating finite element for the two cells by
        * DoFTools::make_hanging_node_constraints using a call to the function
-       * hp::FECollection::find_least_face_dominating_fe_in_collection.
+       * hp::FECollection::find_least_dominating_fe_in_collection().
        * Denoting the fe set in adjacent cells as {1,3} and {2,3}, this
        * implies that an fe set {3} needs to be added! Based on the
        * predicate configuration, this may not be automatically done without
index 62505a05ae846f4a911dd07349490ac9cc83e551..02db2fb446dbb67993a32ef8956e80e36baf3b5e 100644 (file)
@@ -436,15 +436,21 @@ FE_FaceQ<dim, spacedim>::hp_quad_dof_identities(
 
 template <int dim, int spacedim>
 FiniteElementDomination::Domination
-FE_FaceQ<dim, spacedim>::compare_for_face_domination(
-  const FiniteElement<dim, spacedim> &fe_other) const
+FE_FaceQ<dim, spacedim>::compare_for_domination(
+  const FiniteElement<dim, spacedim> &fe_other,
+  const unsigned int                  codim) const
 {
-  if (const FE_FaceQ<dim, spacedim> *fe_q_other =
+  Assert(codim <= dim, ExcImpossibleInDim(dim));
+  (void)codim;
+
+  // vertex/line/face/cell domination
+  // --------------------------------
+  if (const FE_FaceQ<dim, spacedim> *fe_faceq_other =
         dynamic_cast<const FE_FaceQ<dim, spacedim> *>(&fe_other))
     {
-      if (this->degree < fe_q_other->degree)
+      if (this->degree < fe_faceq_other->degree)
         return FiniteElementDomination::this_element_dominates;
-      else if (this->degree == fe_q_other->degree)
+      else if (this->degree == fe_faceq_other->degree)
         return FiniteElementDomination::either_element_can_dominate;
       else
         return FiniteElementDomination::other_element_dominates;
@@ -453,24 +459,18 @@ FE_FaceQ<dim, spacedim>::compare_for_face_domination(
              dynamic_cast<const FE_Nothing<dim> *>(&fe_other))
     {
       if (fe_nothing->is_dominating())
-        {
-          return FiniteElementDomination::other_element_dominates;
-        }
+        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;
-        }
+        // 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::pair<Table<2, bool>, std::vector<unsigned int>>
 FE_FaceQ<dim, spacedim>::get_constant_modes() const
@@ -643,16 +643,6 @@ FE_FaceQ<1, spacedim>::hp_quad_dof_identities(
 
 
 
-template <int spacedim>
-FiniteElementDomination::Domination
-FE_FaceQ<1, spacedim>::compare_for_face_domination(
-  const FiniteElement<1, spacedim> & /*fe_other*/) const
-{
-  return FiniteElementDomination::no_requirements;
-}
-
-
-
 template <int spacedim>
 std::pair<Table<2, bool>, std::vector<unsigned int>>
 FE_FaceQ<1, spacedim>::get_constant_modes() const
@@ -830,15 +820,21 @@ FE_FaceP<dim, spacedim>::hp_constraints_are_implemented() const
 
 template <int dim, int spacedim>
 FiniteElementDomination::Domination
-FE_FaceP<dim, spacedim>::compare_for_face_domination(
-  const FiniteElement<dim, spacedim> &fe_other) const
+FE_FaceP<dim, spacedim>::compare_for_domination(
+  const FiniteElement<dim, spacedim> &fe_other,
+  const unsigned int                  codim) const
 {
-  if (const FE_FaceP<dim, spacedim> *fe_q_other =
+  Assert(codim <= dim, ExcImpossibleInDim(dim));
+  (void)codim;
+
+  // vertex/line/face/cell domination
+  // --------------------------------
+  if (const FE_FaceP<dim, spacedim> *fe_facep_other =
         dynamic_cast<const FE_FaceP<dim, spacedim> *>(&fe_other))
     {
-      if (this->degree < fe_q_other->degree)
+      if (this->degree < fe_facep_other->degree)
         return FiniteElementDomination::this_element_dominates;
-      else if (this->degree == fe_q_other->degree)
+      else if (this->degree == fe_facep_other->degree)
         return FiniteElementDomination::either_element_can_dominate;
       else
         return FiniteElementDomination::other_element_dominates;
@@ -847,16 +843,12 @@ FE_FaceP<dim, spacedim>::compare_for_face_domination(
              dynamic_cast<const FE_Nothing<dim> *>(&fe_other))
     {
       if (fe_nothing->is_dominating())
-        {
-          return FiniteElementDomination::other_element_dominates;
-        }
+        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;
-        }
+        // 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());
index 51f5fe7515b7f0484f2117821d73c78218fffa51..c37e8111ff99780ceca7f24e1339930aee703c80 100644 (file)
@@ -2274,9 +2274,14 @@ FE_Nedelec<dim>::has_support_on_face(const unsigned int shape_index,
 
 template <int dim>
 FiniteElementDomination::Domination
-FE_Nedelec<dim>::compare_for_face_domination(
-  const FiniteElement<dim> &fe_other) const
+FE_Nedelec<dim>::compare_for_domination(const FiniteElement<dim> &fe_other,
+                                        const unsigned int        codim) const
 {
+  Assert(codim <= dim, ExcImpossibleInDim(dim));
+  (void)codim;
+
+  // vertex/line/face/cell domination
+  // --------------------------------
   if (const FE_Nedelec<dim> *fe_nedelec_other =
         dynamic_cast<const FE_Nedelec<dim> *>(&fe_other))
     {
@@ -2290,29 +2295,13 @@ FE_Nedelec<dim>::compare_for_face_domination(
   else if (const FE_Nothing<dim> *fe_nothing =
              dynamic_cast<const FE_Nothing<dim> *>(&fe_other))
     {
-      // TODO: ???
-      // the FE_Nothing has no
-      // degrees of
-      // freedom. nevertheless, we
-      // say that the FE_Q element
-      // dominates so that we don't
-      // have to force the FE_Q side
-      // to become a zero function
-      // and rather allow the
-      // function to be discontinuous
-      // along the interface
-      //      return FiniteElementDomination::other_element_dominates;
       if (fe_nothing->is_dominating())
-        {
-          return FiniteElementDomination::other_element_dominates;
-        }
+        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;
-        }
+        // 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());
index ba1df8393f3ca5f51cc7cf53e21f598d1fb85a45..1777528ed6ef382fd19347626cd6e603717775cc 100644 (file)
@@ -206,24 +206,22 @@ operator==(const FiniteElement<dim, spacedim> &f) const
 
 template <int dim, int spacedim>
 FiniteElementDomination::Domination
-FE_Nothing<dim, spacedim>::compare_for_face_domination(
-  const FiniteElement<dim, spacedim> &fe) const
+FE_Nothing<dim, spacedim>::compare_for_domination(
+  const FiniteElement<dim, spacedim> &fe,
+  const unsigned int                  codim) const
 {
-  // if FE_Nothing does not dominate, there are no requirements
+  Assert(codim <= dim, ExcImpossibleInDim(dim));
+  (void)codim;
+
   if (!dominate)
-    {
-      return FiniteElementDomination::no_requirements;
-    }
-  // if it does and the other is FE_Nothing, either can dominate
+    // if FE_Nothing does not dominate, there are no requirements
+    return FiniteElementDomination::no_requirements;
   else if (dynamic_cast<const FE_Nothing<dim> *>(&fe) != nullptr)
-    {
-      return FiniteElementDomination::either_element_can_dominate;
-    }
-  // otherwise we dominate whatever fe is provided
+    // if it does and the other is FE_Nothing, either can dominate
+    return FiniteElementDomination::either_element_can_dominate;
   else
-    {
-      return FiniteElementDomination::this_element_dominates;
-    }
+    // otherwise we dominate whatever fe is provided
+    return FiniteElementDomination::this_element_dominates;
 }
 
 
index e959cd16650ef7e74d95c323e23ac55f7d71ca84..2b5f2ee150ce486a6d6fe4d4f096187fedfceecb 100644 (file)
@@ -17,6 +17,8 @@
 #include <deal.II/base/quadrature_lib.h>
 #include <deal.II/base/std_cxx14/memory.h>
 
+#include <deal.II/fe/fe_dgq.h>
+#include <deal.II/fe/fe_nothing.h>
 #include <deal.II/fe/fe_q.h>
 
 #include <deal.II/lac/vector.h>
@@ -171,6 +173,54 @@ FE_Q<dim, spacedim>::clone() const
 }
 
 
+
+template <int dim, int spacedim>
+FiniteElementDomination::Domination
+FE_Q<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_DGQ)
+  // ------------------------------------
+  if (codim > 0)
+    if (dynamic_cast<const FE_DGQ<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_DGQ)
+  // & cell domination
+  // ----------------------------------------
+  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;
+}
+
+
 // explicit instantiations
 #include "fe_q.inst"
 
index fd4f429c2293f5f9beb6006e1c53567e456a54d4..6d96202b1a8766af9f281064ab28097b1f2f72f4 100644 (file)
@@ -887,51 +887,6 @@ FE_Q_Base<PolynomialType, dim, spacedim>::hp_quad_dof_identities(
 
 
 
-template <class PolynomialType, int dim, int spacedim>
-FiniteElementDomination::Domination
-FE_Q_Base<PolynomialType, dim, spacedim>::compare_for_face_domination(
-  const FiniteElement<dim, spacedim> &fe_other) const
-{
-  if (const FE_Q_Base<PolynomialType, dim, spacedim> *fe_q_other =
-        dynamic_cast<const FE_Q_Base<PolynomialType, 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;
-        }
-    }
-  else if ((dynamic_cast<const FE_DGQ<dim, spacedim> *>(&fe_other) !=
-            nullptr) ||
-           (dynamic_cast<const FE_DGP<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;
-}
-
-
 //---------------------------------------------------------------------------
 // Auxiliary functions
 //---------------------------------------------------------------------------
index ce0ff54ef8d687db739d3c0391df50e67f0f0090..ba8c36efa952d6e7ec535ed3ff515ad426ca6d0a 100644 (file)
@@ -23,6 +23,7 @@
 #include <deal.II/dofs/dof_accessor.h>
 #include <deal.II/dofs/dof_handler.h>
 
+#include <deal.II/fe/fe_dgq.h>
 #include <deal.II/fe/fe_nothing.h>
 #include <deal.II/fe/fe_q_bubbles.h>
 #include <deal.II/fe/fe_tools.h>
@@ -505,6 +506,55 @@ FE_Q_Bubbles<dim, spacedim>::get_restriction_matrix(
   return this->restriction[refinement_case - 1][child];
 }
 
+
+
+template <int dim, int spacedim>
+FiniteElementDomination::Domination
+FE_Q_Bubbles<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_DGQ)
+  // ------------------------------------
+  if (codim > 0)
+    if (dynamic_cast<const FE_DGQ<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_DGQ)
+  // & cell domination
+  // ----------------------------------------
+  if (const FE_Q_Bubbles<dim, spacedim> *fe_bubbles_other =
+        dynamic_cast<const FE_Q_Bubbles<dim, spacedim> *>(&fe_other))
+    {
+      if (this->degree < fe_bubbles_other->degree)
+        return FiniteElementDomination::this_element_dominates;
+      else if (this->degree == fe_bubbles_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;
+}
+
+
 // explicit instantiations
 #include "fe_q_bubbles.inst"
 
index f582f5dfe7b054c7aada4023951ed6df745d3d7e..6cbc96a7cfeaa205885dfcb13b06d3238c95307b 100644 (file)
@@ -22,6 +22,7 @@
 
 #include <deal.II/dofs/dof_accessor.h>
 
+#include <deal.II/fe/fe_dgq.h>
 #include <deal.II/fe/fe_nothing.h>
 #include <deal.II/fe/fe_q_dg0.h>
 
@@ -291,6 +292,53 @@ FE_Q_DG0<dim, spacedim>::get_constant_modes() const
 
 
 
+template <int dim, int spacedim>
+FiniteElementDomination::Domination
+FE_Q_DG0<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_DGQ)
+  // ------------------------------------
+  if (codim > 0)
+    if (dynamic_cast<const FE_DGQ<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_DGQ)
+  // & cell domination
+  // ----------------------------------------
+  if (const FE_Q_DG0<dim, spacedim> *fe_dg0_other =
+        dynamic_cast<const FE_Q_DG0<dim, spacedim> *>(&fe_other))
+    {
+      if (this->degree < fe_dg0_other->degree)
+        return FiniteElementDomination::this_element_dominates;
+      else if (this->degree == fe_dg0_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;
+}
+
+
 // explicit instantiations
 #include "fe_q_dg0.inst"
 
index 06294e3aa21fb00aa7db71e29a0df21319354e82..a46b0106b204292e57e4b4f19f934d90a14b10e2 100644 (file)
@@ -16,6 +16,7 @@
 
 #include <deal.II/base/std_cxx14/memory.h>
 
+#include <deal.II/fe/fe_dgq.h>
 #include <deal.II/fe/fe_nothing.h>
 #include <deal.II/fe/fe_q_hierarchical.h>
 
@@ -333,17 +334,30 @@ FE_Q_Hierarchical<dim>::hp_quad_dof_identities(
 
 template <int dim>
 FiniteElementDomination::Domination
-FE_Q_Hierarchical<dim>::compare_for_face_domination(
-  const FiniteElement<dim> &fe_other) const
+FE_Q_Hierarchical<dim>::compare_for_domination(
+  const FiniteElement<dim> &fe_other,
+  const unsigned int        codim) const
 {
-  if (const FE_Q_Hierarchical<dim> *fe_q_other =
+  Assert(codim <= dim, ExcImpossibleInDim(dim));
+
+  // vertex/line/face domination
+  // (if fe_other is derived from FE_DGQ)
+  // ------------------------------------
+  if (codim > 0)
+    if (dynamic_cast<const FE_DGQ<dim> *>(&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_DGQ)
+  // & cell domination
+  // ----------------------------------------
+  if (const FE_Q_Hierarchical<dim> *fe_hierarchical_other =
         dynamic_cast<const FE_Q_Hierarchical<dim> *>(&fe_other))
     {
-      // the element with lowest polynomial degree
-      // dominates the other.
-      if (this->degree < fe_q_other->degree)
+      if (this->degree < fe_hierarchical_other->degree)
         return FiniteElementDomination::this_element_dominates;
-      else if (this->degree == fe_q_other->degree)
+      else if (this->degree == fe_hierarchical_other->degree)
         return FiniteElementDomination::either_element_can_dominate;
       else
         return FiniteElementDomination::other_element_dominates;
@@ -352,16 +366,12 @@ FE_Q_Hierarchical<dim>::compare_for_face_domination(
              dynamic_cast<const FE_Nothing<dim> *>(&fe_other))
     {
       if (fe_nothing->is_dominating())
-        {
-          return FiniteElementDomination::other_element_dominates;
-        }
+        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;
-        }
+        // 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());
index 0e1214febef8758ac97e1595fcbba439312d4703..69aed15a54454734ab249e02ad241be01ab3bbde 100644 (file)
@@ -17,6 +17,7 @@
 #include <deal.II/base/quadrature_lib.h>
 #include <deal.II/base/std_cxx14/memory.h>
 
+#include <deal.II/fe/fe_dgq.h>
 #include <deal.II/fe/fe_nothing.h>
 #include <deal.II/fe/fe_q_iso_q1.h>
 
@@ -106,9 +107,25 @@ FE_Q_iso_Q1<dim, spacedim>::clone() const
 
 template <int dim, int spacedim>
 FiniteElementDomination::Domination
-FE_Q_iso_Q1<dim, spacedim>::compare_for_face_domination(
-  const FiniteElement<dim, spacedim> &fe_other) const
+FE_Q_iso_Q1<dim, spacedim>::compare_for_domination(
+  const FiniteElement<dim, spacedim> &fe_other,
+  const unsigned int                  codim) const
 {
+  Assert(codim <= dim, ExcImpossibleInDim(dim));
+  (void)codim;
+
+  // vertex/line/face domination
+  // (if fe_other is derived from FE_DGQ)
+  // ------------------------------------
+  if (codim > 0)
+    if (dynamic_cast<const FE_DGQ<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_DGQ)
+  // & cell domination
+  // ----------------------------------------
   if (const FE_Q_iso_Q1<dim, spacedim> *fe_q_iso_q1_other =
         dynamic_cast<const FE_Q_iso_Q1<dim, spacedim> *>(&fe_other))
     {
@@ -130,16 +147,12 @@ FE_Q_iso_Q1<dim, spacedim>::compare_for_face_domination(
              dynamic_cast<const FE_Nothing<dim> *>(&fe_other))
     {
       if (fe_nothing->is_dominating())
-        {
-          return FiniteElementDomination::other_element_dominates;
-        }
+        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;
-        }
+        // 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());
index 038a2556595ef67653eda12e0d79e3f2d595186a..736815808003ef610cf0db05753d7939ab844091 100644 (file)
@@ -505,33 +505,35 @@ FE_RaviartThomasNodal<dim>::hp_quad_dof_identities(
 
 template <int dim>
 FiniteElementDomination::Domination
-FE_RaviartThomasNodal<dim>::compare_for_face_domination(
-  const FiniteElement<dim> &fe_other) const
+FE_RaviartThomasNodal<dim>::compare_for_domination(
+  const FiniteElement<dim> &fe_other,
+  const unsigned int        codim) const
 {
-  if (const FE_RaviartThomasNodal<dim> *fe_q_other =
+  Assert(codim <= dim, ExcImpossibleInDim(dim));
+  (void)codim;
+
+  // vertex/line/face/cell domination
+  // --------------------------------
+  if (const FE_RaviartThomasNodal<dim> *fe_rt_nodal_other =
         dynamic_cast<const FE_RaviartThomasNodal<dim> *>(&fe_other))
     {
-      if (this->degree < fe_q_other->degree)
+      if (this->degree < fe_rt_nodal_other->degree)
         return FiniteElementDomination::this_element_dominates;
-      else if (this->degree == fe_q_other->degree)
+      else if (this->degree == fe_rt_nodal_other->degree)
         return FiniteElementDomination::either_element_can_dominate;
       else
         return FiniteElementDomination::other_element_dominates;
     }
-  else if (const FE_Nothing<dim> *fe_q_other =
+  else if (const FE_Nothing<dim> *fe_nothing =
              dynamic_cast<const FE_Nothing<dim> *>(&fe_other))
     {
-      if (fe_q_other->is_dominating())
-        {
-          return FiniteElementDomination::other_element_dominates;
-        }
+      if (fe_nothing->is_dominating())
+        return FiniteElementDomination::other_element_dominates;
       else
-        {
-          // FE_Nothing has no degrees of freedom and is typically
-          // used in a context where there are no continuity
-          // requirements along the interface
-          return FiniteElementDomination::no_requirements;
-        }
+        // 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());
index 89f88c634fa55463f410f1f920554d02e8c29e38..55a9f52c3e887475edb33f76ee56ed1eae1dd70c 100644 (file)
@@ -2245,9 +2245,14 @@ FESystem<dim, spacedim>::hp_quad_dof_identities(
 
 template <int dim, int spacedim>
 FiniteElementDomination::Domination
-FESystem<dim, spacedim>::compare_for_face_domination(
-  const FiniteElement<dim, spacedim> &fe_other) const
+FESystem<dim, spacedim>::compare_for_domination(
+  const FiniteElement<dim, spacedim> &fe_other,
+  const unsigned int                  codim) const
 {
+  Assert(codim <= dim, ExcImpossibleInDim(dim));
+
+  // vertex/line/face/cell domination
+  // --------------------------------
   // at present all we can do is to compare with other FESystems that have the
   // same number of components and bases
   if (const FESystem<dim, spacedim> *fe_sys_other =
@@ -2274,8 +2279,8 @@ FESystem<dim, spacedim>::compare_for_face_domination(
           // for this pair of base elements, check who dominates and combine
           // with previous result
           const FiniteElementDomination::Domination base_domination =
-            (this->base_element(b).compare_for_face_domination(
-              fe_sys_other->base_element(b)));
+            (this->base_element(b).compare_for_domination(
+              fe_sys_other->base_element(b), codim));
           domination = domination & base_domination;
         }
 
index 083260b6b9e028d284e0a88c2f44b884c4140c77..9761c8b1f146d5fccd928bdd07149180bab4f48a 100644 (file)
@@ -177,15 +177,21 @@ FE_TraceQ<dim, spacedim>::hp_constraints_are_implemented() const
 
 template <int dim, int spacedim>
 FiniteElementDomination::Domination
-FE_TraceQ<dim, spacedim>::compare_for_face_domination(
-  const FiniteElement<dim, spacedim> &fe_other) const
+FE_TraceQ<dim, spacedim>::compare_for_domination(
+  const FiniteElement<dim, spacedim> &fe_other,
+  const unsigned int                  codim) const
 {
-  if (const FE_TraceQ<dim, spacedim> *fe_q_other =
+  Assert(codim <= dim, ExcImpossibleInDim(dim));
+  (void)codim;
+
+  // vertex/line/face/cell domination
+  // --------------------------------
+  if (const FE_TraceQ<dim, spacedim> *fe_traceq_other =
         dynamic_cast<const FE_TraceQ<dim, spacedim> *>(&fe_other))
     {
-      if (this->degree < fe_q_other->degree)
+      if (this->degree < fe_traceq_other->degree)
         return FiniteElementDomination::this_element_dominates;
-      else if (this->degree == fe_q_other->degree)
+      else if (this->degree == fe_traceq_other->degree)
         return FiniteElementDomination::either_element_can_dominate;
       else
         return FiniteElementDomination::other_element_dominates;
@@ -194,16 +200,12 @@ FE_TraceQ<dim, spacedim>::compare_for_face_domination(
              dynamic_cast<const FE_Nothing<dim> *>(&fe_other))
     {
       if (fe_nothing->is_dominating())
-        {
-          return FiniteElementDomination::other_element_dominates;
-        }
+        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;
-        }
+        // 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());
index 4677a30efbee43d75eaaee2cb25c4b14d9230d08..ce980da3b656286e7a63652048b7e25f72865b12 100644 (file)
@@ -24,9 +24,22 @@ namespace hp
 {
   template <int dim, int spacedim>
   unsigned int
-  FECollection<dim, spacedim>::find_least_face_dominating_fe_in_collection(
+  FECollection<dim, spacedim>::find_least_face_dominating_fe(
     const std::set<unsigned int> &fes) const
   {
+    return find_least_dominating_fe_in_collection(fes, /*codim*/ 1);
+  }
+
+
+
+  template <int dim, int spacedim>
+  unsigned int
+  FECollection<dim, spacedim>::find_least_dominating_fe_in_collection(
+    const std::set<unsigned int> &fes,
+    const unsigned int            codim) const
+  {
+    Assert(codim <= dim, ExcImpossibleInDim(dim));
+
     for (auto it = fes.cbegin(); it != fes.cend(); ++it)
       AssertIndexRange(*it, finite_elements.size());
 
@@ -52,8 +65,8 @@ namespace hp
         // check if cur_fe can dominate all FEs in @p fes:
         for (const auto &other_fe : fes)
           domination =
-            domination & finite_elements[cur_fe]->compare_for_face_domination(
-                           *finite_elements[other_fe]);
+            domination & finite_elements[cur_fe]->compare_for_domination(
+                           *finite_elements[other_fe], codim);
 
         // if we found dominating element, keep them in a set.
         if (
@@ -76,10 +89,9 @@ namespace hp
 
           for (const auto &other_fe : candidate_fes)
             if (current_fe != other_fe)
-              domination =
-                domination &
-                finite_elements[current_fe]->compare_for_face_domination(
-                  *finite_elements[other_fe]);
+              domination = domination &
+                           finite_elements[current_fe]->compare_for_domination(
+                             *finite_elements[other_fe], codim);
 
           if ((domination ==
                FiniteElementDomination::other_element_dominates) ||
@@ -96,19 +108,12 @@ namespace hp
 
   template <int dim, int spacedim>
   unsigned int
-  FECollection<dim, spacedim>::find_least_face_dominating_fe(
-    const std::set<unsigned int> &fes) const
+  FECollection<dim, spacedim>::find_dominating_fe_in_subset(
+    const std::set<unsigned int> &fes,
+    const unsigned int            codim) const
   {
-    return find_least_face_dominating_fe_in_collection(fes);
-  }
-
-
+    Assert(codim <= dim, ExcImpossibleInDim(dim));
 
-  template <int dim, int spacedim>
-  unsigned int
-  FECollection<dim, spacedim>::find_face_dominating_fe_in_subset(
-    const std::set<unsigned int> &fes) const
-  {
     for (auto it = fes.cbegin(); it != fes.cend(); ++it)
       AssertIndexRange(*it, finite_elements.size());
 
@@ -131,9 +136,8 @@ namespace hp
         for (const auto &other_fe : fes)
           if (other_fe != current_fe)
             domination =
-              domination &
-              finite_elements[current_fe]->compare_for_face_domination(
-                *finite_elements[other_fe]);
+              domination & finite_elements[current_fe]->compare_for_domination(
+                             *finite_elements[other_fe], codim);
 
         // see if this element is able to dominate all the other
         // ones, and if so take it
index 8e5f849c07ee739c040fb44a2381d7bb6d051835..f3640f39af621f3b090b9bb7287c0074cffe81cf 100644 (file)
@@ -268,8 +268,9 @@ main(int argc, char **argv)
               << std::endl;
     }
 
-  deallog << "Dominating set for 1 and 2: "
-          << fe_collection.find_least_face_dominating_fe_in_collection({1, 2})
+  deallog << "Face dominating set for 1 and 2: "
+          << fe_collection.find_least_dominating_fe_in_collection({1, 2},
+                                                                  /*codim=*/1)
           << std::endl;
 
   dof_handler.distribute_dofs(fe_collection);
index 675f3567bbdfbefb7c0a856ed06f703ead46c062..270629affe8c6792060ff66b87b596521e5525e4 100644 (file)
@@ -16,7 +16,7 @@ DEAL:0::name:FE_Enriched<2>[FE_Q<2>(2)-FE_Nothing<2>(dominating)-FE_Nothing<2>(d
 DEAL:0::n_blocks:4
 DEAL:0::n_comp:1
 DEAL:0::n_dofs:13
-DEAL:0::Dominating set for 1 and 2: 3
+DEAL:0::Face dominating set for 1 and 2: 3
     9 = 0
     10 = 0
     12 = 0
index 5ad07d1344514b52c505e427b6284f552c1c7eb2..52853340873d937c56428fc52eba79d4693c7541 100644 (file)
@@ -15,7 +15,8 @@
 
 
 /* clang-format off */
-// test the results of FECollection::find_least_face_dominating_fe_in_collection(), namely for:
+// test the results of FECollection::find_least_dominating_fe_in_collection()
+// for faces (codim=1), namely for:
 //   {Q1, Q2, Q3, Q4}             with {2,3} => Q3          2
 //   {Q1xQ1, Q2xQ2, Q3xQ4, Q4xQ3} with {2,3} => Q2xQ2       1
 //   {Q1xQ1, Q3xQ4, Q4xQ3}        with {1,2} => Q1xQ1       0
@@ -53,7 +54,8 @@ test()
     fe_collection.push_back(FE_Q<dim>(2));
     fe_collection.push_back(FE_Q<dim>(3));
     fe_collection.push_back(FE_Q<dim>(4));
-    deallog << fe_collection.find_least_face_dominating_fe_in_collection(fes)
+    deallog << fe_collection.find_least_dominating_fe_in_collection(fes,
+                                                                    /*codim=*/1)
             << std::endl;
   }
 
@@ -64,7 +66,8 @@ test()
     fe_collection.push_back(FESystem<dim>(FE_Q<dim>(2), 1, FE_Q<dim>(2), 1));
     fe_collection.push_back(FESystem<dim>(FE_Q<dim>(3), 1, FE_Q<dim>(4), 1));
     fe_collection.push_back(FESystem<dim>(FE_Q<dim>(4), 1, FE_Q<dim>(3), 1));
-    deallog << fe_collection.find_least_face_dominating_fe_in_collection(fes)
+    deallog << fe_collection.find_least_dominating_fe_in_collection(fes,
+                                                                    /*codim=*/1)
             << std::endl;
   }
 
@@ -77,7 +80,8 @@ test()
     std::set<unsigned int> fes;
     fes.insert(1);
     fes.insert(2);
-    deallog << fe_collection.find_least_face_dominating_fe_in_collection(fes)
+    deallog << fe_collection.find_least_dominating_fe_in_collection(fes,
+                                                                    /*codim=*/1)
             << std::endl;
   }
 
@@ -93,7 +97,7 @@ test()
     fe_collection.push_back(
       FESystem<dim>(FE_Nothing<dim>(), 1, FE_Q<dim>(1), 1));
     const unsigned int ind =
-      fe_collection.find_least_face_dominating_fe_in_collection(fes);
+      fe_collection.find_least_dominating_fe_in_collection(fes, /*codim=*/1);
     if (ind == numbers::invalid_unsigned_int)
       deallog << "numbers::invalid_unsigned_int" << std::endl;
     else
@@ -112,7 +116,8 @@ test()
       FESystem<dim>(FE_Q<dim>(1), 1, FE_Nothing<dim>(1, true), 1));
     fe_collection.push_back(
       FESystem<dim>(FE_Nothing<dim>(1, true), 1, FE_Q<dim>(1), 1));
-    deallog << fe_collection.find_least_face_dominating_fe_in_collection(fes)
+    deallog << fe_collection.find_least_dominating_fe_in_collection(fes,
+                                                                    /*codim=*/1)
             << std::endl;
   }
 
@@ -124,7 +129,8 @@ test()
     fe_collection.push_back(FESystem<dim>(FE_Q<dim>(1), 1, FE_Q<dim>(1), 1));
     fe_collection.push_back(FESystem<dim>(FE_Q<dim>(2), 1, FE_Q<dim>(1), 1));
     fe_collection.push_back(FESystem<dim>(FE_Q<dim>(1), 1, FE_Q<dim>(2), 1));
-    deallog << fe_collection.find_least_face_dominating_fe_in_collection(fes)
+    deallog << fe_collection.find_least_dominating_fe_in_collection(fes,
+                                                                    /*codim=*/1)
             << std::endl;
   }
 
@@ -136,7 +142,7 @@ test()
     fe_collection.push_back(FESystem<dim>(FE_Q<dim>(3), 1, FE_Q<dim>(4), 1));
     fe_collection.push_back(FESystem<dim>(FE_Q<dim>(4), 1, FE_Q<dim>(3), 1));
     const unsigned int ind =
-      fe_collection.find_least_face_dominating_fe_in_collection(fes);
+      fe_collection.find_least_dominating_fe_in_collection(fes, /*codim=*/1);
     if (ind == numbers::invalid_unsigned_int)
       deallog << "numbers::invalid_unsigned_int" << std::endl;
     else
@@ -152,7 +158,8 @@ test()
     fe_collection.push_back(FE_Q<dim>(3));
     std::set<unsigned int> fes;
     fes.insert(3);
-    deallog << fe_collection.find_least_face_dominating_fe_in_collection(fes)
+    deallog << fe_collection.find_least_dominating_fe_in_collection(fes,
+                                                                    /*codim=*/1)
             << std::endl;
   }
 
@@ -163,7 +170,8 @@ test()
     fe_collection.push_back(FE_Q<dim>(4));
     fe_collection.push_back(FE_Q<dim>(1));
     fe_collection.push_back(FE_Q<dim>(1));
-    deallog << fe_collection.find_least_face_dominating_fe_in_collection(fes)
+    deallog << fe_collection.find_least_dominating_fe_in_collection(fes,
+                                                                    /*codim=*/1)
             << std::endl;
   }
 }

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

Douglas Adams


Typeset in Trocchi and Trocchi Bold Sans Serif.