]> https://gitweb.dealii.org/ - dealii-svn.git/commitdiff
Rename FE::compare_for_domination to FE::compare_for_face_domination
authorbangerth <bangerth@0785d39b-7218-0410-832d-ea1e28bc413d>
Sun, 10 Sep 2006 16:51:11 +0000 (16:51 +0000)
committerbangerth <bangerth@0785d39b-7218-0410-832d-ea1e28bc413d>
Sun, 10 Sep 2006 16:51:11 +0000 (16:51 +0000)
git-svn-id: https://svn.dealii.org/trunk@13889 0785d39b-7218-0410-832d-ea1e28bc413d

15 files changed:
deal.II/deal.II/include/fe/fe.h
deal.II/deal.II/include/fe/fe_base.h
deal.II/deal.II/include/fe/fe_dgp.h
deal.II/deal.II/include/fe/fe_dgp_monomial.h
deal.II/deal.II/include/fe/fe_dgp_nonparametric.h
deal.II/deal.II/include/fe/fe_dgq.h
deal.II/deal.II/include/fe/fe_q.h
deal.II/deal.II/include/fe/fe_system.h
deal.II/deal.II/source/fe/fe.cc
deal.II/deal.II/source/fe/fe_dgp.cc
deal.II/deal.II/source/fe/fe_dgp_monomial.cc
deal.II/deal.II/source/fe/fe_dgp_nonparametric.cc
deal.II/deal.II/source/fe/fe_dgq.cc
deal.II/deal.II/source/fe/fe_q.cc
deal.II/deal.II/source/fe/fe_system.cc

index 399646cac7a41e8455b5e888ad937fe4810dd1d3..cdb37a4239f973319b176f138de75203701e9e67 100644 (file)
@@ -1062,10 +1062,11 @@ class FiniteElement : public Subscriptor,
 
                                     /**
                                      * Return whether this element dominates
-                                     * the one given as argument, whether it
-                                     * is the other way around, whether
-                                     * neither dominates, or if either could
-                                     * dominate.
+                                     * 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
@@ -1073,7 +1074,7 @@ class FiniteElement : public Subscriptor,
                                      */
     virtual
     FiniteElementDomination::Domination
-    compare_for_domination (const FiniteElement<dim> &fe_other) const;
+    compare_for_face_domination (const FiniteElement<dim> &fe_other) const;
     
                                     //@}
     
index d0bd90cc777249d6c976208041648744b9b7b7cf..9da08925419dfade2c057b449514e2ef7aa451db 100644 (file)
@@ -55,7 +55,7 @@ namespace FiniteElementDomination
                                    * dominates Q(k') if $k\le k'$.
                                    *
                                    * This enum is used in the
-                                   * FiniteElement::compare_fe_for_domination()
+                                   * 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
@@ -70,6 +70,14 @@ namespace FiniteElementDomination
                                    * 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 hp paper
                                    * lists two case, with the simpler one
index 1e9385d3ec7a20a45f33ef171b5b619fd4ad6f25..874010a29bf5670cd21a93156bad2323d30f9dde 100644 (file)
@@ -194,10 +194,11 @@ class FE_DGP : public FE_Poly<PolynomialSpace<dim>,dim>
 
                                     /**
                                      * Return whether this element dominates
-                                     * the one given as argument, whether it
-                                     * is the other way around, whether
-                                     * neither dominates, or if either could
-                                     * dominate.
+                                     * 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
@@ -205,7 +206,7 @@ class FE_DGP : public FE_Poly<PolynomialSpace<dim>,dim>
                                      */
     virtual
     FiniteElementDomination::Domination
-    compare_for_domination (const FiniteElement<dim> &fe_other) const;
+    compare_for_face_domination (const FiniteElement<dim> &fe_other) const;
     
                                     /**
                                      * @}
index cabf430e631fa7cf255e2bbd31f9b218ea8fcecd..df79182e7e3f401c0b4174aaf4d146f39ab2c2e7 100644 (file)
@@ -195,10 +195,11 @@ class FE_DGPMonomial : public FE_Poly<PolynomialsP<dim>,dim>
 
                                     /**
                                      * Return whether this element dominates
-                                     * the one given as argument, whether it
-                                     * is the other way around, whether
-                                     * neither dominates, or if either could
-                                     * dominate.
+                                     * 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
@@ -206,7 +207,7 @@ class FE_DGPMonomial : public FE_Poly<PolynomialsP<dim>,dim>
                                      */
     virtual
     FiniteElementDomination::Domination
-    compare_for_domination (const FiniteElement<dim> &fe_other) const;
+    compare_for_face_domination (const FiniteElement<dim> &fe_other) const;
 
                                     /**
                                      * @}
index 260ebc4bea55e25cb8bc05cc24b144f820c7227e..1f043d1844a8fb964fd0741e24581e7f1bda7db9 100644 (file)
@@ -350,10 +350,11 @@ class FE_DGPNonparametric : public FiniteElement<dim>
 
                                     /**
                                      * Return whether this element dominates
-                                     * the one given as argument, whether it
-                                     * is the other way around, whether
-                                     * neither dominates, or if either could
-                                     * dominate.
+                                     * 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
@@ -361,7 +362,7 @@ class FE_DGPNonparametric : public FiniteElement<dim>
                                      */
     virtual
     FiniteElementDomination::Domination
-    compare_for_domination (const FiniteElement<dim> &fe_other) const;
+    compare_for_face_domination (const FiniteElement<dim> &fe_other) const;
 
                                     /**
                                      * @}
index 112dc39c825baf64da8565f3a62d3c234bbfcfba..b73f97ba45624dea5c75097a393896061ad74c02 100644 (file)
@@ -266,10 +266,11 @@ class FE_DGQ : public FE_Poly<TensorProductPolynomials<dim>,dim>
 
                                     /**
                                      * Return whether this element dominates
-                                     * the one given as argument, whether it
-                                     * is the other way around, whether
-                                     * neither dominates, or if either could
-                                     * dominate.
+                                     * 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
@@ -277,7 +278,7 @@ class FE_DGQ : public FE_Poly<TensorProductPolynomials<dim>,dim>
                                      */
     virtual
     FiniteElementDomination::Domination
-    compare_for_domination (const FiniteElement<dim> &fe_other) const;
+    compare_for_face_domination (const FiniteElement<dim> &fe_other) const;
 
                                     /**
                                      * @}
index dd7f60e28fcca7d9c6955fcc049473dcbac40e48..31733b0a537ba11a4401fa6b6564b6f0d171f265 100644 (file)
@@ -423,10 +423,11 @@ class FE_Q : public FE_Poly<TensorProductPolynomials<dim>,dim>
     
                                     /**
                                      * Return whether this element dominates
-                                     * the one given as argument, whether it
-                                     * is the other way around, whether
-                                     * neither dominates, or if either could
-                                     * dominate.
+                                     * 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
@@ -434,7 +435,7 @@ class FE_Q : public FE_Poly<TensorProductPolynomials<dim>,dim>
                                      */
     virtual
     FiniteElementDomination::Domination
-    compare_for_domination (const FiniteElement<dim> &fe_other) const;
+    compare_for_face_domination (const FiniteElement<dim> &fe_other) const;
                                     //@}
 
                                     /**
index e807507044f912a39188f5d37a62faceb155b476..b9e764201b3cbbf9633767ab52e30c638ea4baf8 100644 (file)
@@ -525,10 +525,11 @@ class FESystem : public FiniteElement<dim>
     
                                     /**
                                      * Return whether this element dominates
-                                     * the one given as argument, whether it
-                                     * is the other way around, whether
-                                     * neither dominates, or if either could
-                                     * dominate.
+                                     * 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
@@ -536,7 +537,7 @@ class FESystem : public FiniteElement<dim>
                                      */
     virtual
     FiniteElementDomination::Domination
-    compare_for_domination (const FiniteElement<dim> &fe_other) const;
+    compare_for_face_domination (const FiniteElement<dim> &fe_other) const;
                                     //@}
     
                                     /**
index 3ca65daf1956caa9fd8b048c9e23418f34546db1..51a512399a97accc1e40a500104582da15823f1e 100644 (file)
@@ -521,7 +521,7 @@ hp_quad_dof_identities (const FiniteElement<dim> &) const
 template <int dim>
 FiniteElementDomination::Domination
 FiniteElement<dim>::
-compare_for_domination (const FiniteElement<dim> &) const
+compare_for_face_domination (const FiniteElement<dim> &) const
 {
   Assert (false, ExcNotImplemented());
   return FiniteElementDomination::neither_element_dominates;
index bc3945796e35548c91211a631404b67341615f8a..88e9491620ec825a619316c0989480e416457efa 100644 (file)
@@ -214,7 +214,7 @@ hp_quad_dof_identities (const FiniteElement<dim>        &fe_other) const
 
 template <int dim>
 FiniteElementDomination::Domination
-FE_DGP<dim>::compare_for_domination (const FiniteElement<dim> &fe_other) const
+FE_DGP<dim>::compare_for_face_domination (const FiniteElement<dim> &fe_other) const
 {
                                   // check whether both are discontinuous
                                   // elements and both could dominate, see
index c5950e0e163fe64f8f58f8cb3925c856107bf7d2..9495615b87e708b3e3da6d7a52ed121ca648bf23 100644 (file)
@@ -376,7 +376,7 @@ hp_quad_dof_identities (const FiniteElement<dim>        &fe_other) const
 template <int dim>
 FiniteElementDomination::Domination
 FE_DGPMonomial<dim>::
-compare_for_domination (const FiniteElement<dim> &fe_other) const
+compare_for_face_domination (const FiniteElement<dim> &fe_other) const
 {
                                   // check whether both are discontinuous
                                   // elements and both could dominate, see
index 4050ac8d2611aef2fcebab55616e4ce7954a290f..3934f5f75f65eabf8f6eaf3418e796b27450f83f 100644 (file)
@@ -545,7 +545,7 @@ hp_quad_dof_identities (const FiniteElement<dim>        &fe_other) const
 template <int dim>
 FiniteElementDomination::Domination
 FE_DGPNonparametric<dim>::
-compare_for_domination (const FiniteElement<dim> &fe_other) const
+compare_for_face_domination (const FiniteElement<dim> &fe_other) const
 {
                                   // check whether both are discontinuous
                                   // elements and both could dominate, see
index 42b433651c32a16d428bb9cd3143cf8b87ca0eb8..ac8a77a31cf0a6570193940999efc27cd792d105 100644 (file)
@@ -551,7 +551,7 @@ hp_quad_dof_identities (const FiniteElement<dim>        &fe_other) const
 
 template <int dim>
 FiniteElementDomination::Domination
-FE_DGQ<dim>::compare_for_domination (const FiniteElement<dim> &fe_other) const
+FE_DGQ<dim>::compare_for_face_domination (const FiniteElement<dim> &fe_other) const
 {
                                   // check whether both are discontinuous
                                   // elements and both could dominate, see
index d55875a7587cc2ee9adda0bd8beb8eb0028606da..0f4d12c95e36cd2bebd47eaea0d37c188c7d1421 100644 (file)
@@ -681,7 +681,7 @@ hp_quad_dof_identities (const FiniteElement<dim>        &fe_other) const
 template <int dim>
 FiniteElementDomination::Domination
 FE_Q<dim>::
-compare_for_domination (const FiniteElement<dim> &fe_other) const
+compare_for_face_domination (const FiniteElement<dim> &fe_other) const
 {
   if (const FE_Q<dim> *fe_q_other
       = dynamic_cast<const FE_Q<dim>*>(&fe_other))
index 866a6eb36176587895e0d95d38c8e9ee6a26926d..126de218c70ca0d9d09b79c88736ba2e44d4cb9b 100644 (file)
@@ -2274,7 +2274,7 @@ FESystem<dim>::hp_quad_dof_identities (const FiniteElement<dim> &fe_other) const
 template <int dim>
 FiniteElementDomination::Domination
 FESystem<dim>::
-compare_for_domination (const FiniteElement<dim> &fe_other) const
+compare_for_face_domination (const FiniteElement<dim> &fe_other) const
 {
                                   // at present all we can do is to compare
                                   // with other FESystems that have the same
@@ -2305,7 +2305,7 @@ compare_for_domination (const FiniteElement<dim> &fe_other) const
                                           // check who dominates and combine
                                           // with previous result
          domination = domination & (this->base_element(b)
-                                    .compare_for_domination (fe_sys_other->base_element(b)));
+                                    .compare_for_face_domination (fe_sys_other->base_element(b)));
        }
 
                                       // if we've gotten here, then we've

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.