]> https://gitweb.dealii.org/ - dealii-svn.git/commitdiff
Correct documentation in a number of places.
authorbangerth <bangerth@0785d39b-7218-0410-832d-ea1e28bc413d>
Wed, 16 Jan 2013 23:50:34 +0000 (23:50 +0000)
committerbangerth <bangerth@0785d39b-7218-0410-832d-ea1e28bc413d>
Wed, 16 Jan 2013 23:50:34 +0000 (23:50 +0000)
git-svn-id: https://svn.dealii.org/trunk@28093 0785d39b-7218-0410-832d-ea1e28bc413d

deal.II/include/deal.II/fe/fe.h
deal.II/include/deal.II/fe/fe_dgp.h
deal.II/include/deal.II/fe/fe_dgp_monomial.h
deal.II/include/deal.II/fe/fe_dgp_nonparametric.h
deal.II/include/deal.II/fe/fe_dgq.h
deal.II/include/deal.II/fe/fe_nedelec.h
deal.II/include/deal.II/fe/fe_q.h
deal.II/include/deal.II/fe/fe_q_dg0.h
deal.II/include/deal.II/fe/fe_q_hierarchical.h
deal.II/include/deal.II/fe/fe_system.h

index 15c34dcd3ec92cb8e37dc969721bc50e390c0e07..8b260a3b5ec732134cbeb56f90d60d4abfd36c71 100644 (file)
@@ -1092,60 +1092,42 @@ public:
 
 
   /**
-   * If, on a vertex, several
-   * finite elements are active,
-   * the hp code first assigns the
-   * degrees of freedom of each of
-   * these FEs different global
-   * indices. It then calls this
-   * function to find out which of
-   * them should get identical
-   * values, and consequently can
-   * receive the same global DoF
-   * index. This function therefore
-   * returns a list of identities
-   * between DoFs of the present
-   * finite element object with the
-   * DoFs of @p fe_other, which is
-   * a reference to a finite
-   * element object representing
-   * one of the other finite
-   * elements active on this
-   * particular vertex. The
-   * function computes which of the
-   * degrees of freedom of the two
-   * finite element objects are
-   * equivalent, and returns a list
-   * of pairs of global dof indices
-   * in @p identities. The first
-   * index of each pair denotes one
-   * of the vertex dofs of the
-   * present element, whereas the
-   * second is the corresponding
-   * index of the other finite
-   * element.
+   * @name Functions to support hp
+   * @{
+   */
+
+  /**
+   * If, on a vertex, several finite elements are active, the hp code
+   * first assigns the degrees of freedom of each of these FEs
+   * different global indices. It then calls this function to find out
+   * which of them should get identical values, and consequently can
+   * receive the same global DoF index. This function therefore
+   * returns a list of identities between DoFs of the present finite
+   * element object with the DoFs of @p fe_other, which is a reference
+   * to a finite element object representing one of the other finite
+   * elements active on this particular vertex. The function computes
+   * which of the degrees of freedom of the two finite element objects
+   * are equivalent, both numbered between zero and the corresponding
+   * value of dofs_per_vertex of the two finite elements. The first
+   * index of each pair denotes one of the vertex dofs of the present
+   * element, whereas the second is the corresponding index of the
+   * other finite element.
    */
   virtual
   std::vector<std::pair<unsigned int, unsigned int> >
   hp_vertex_dof_identities (const FiniteElement<dim,spacedim> &fe_other) const;
 
   /**
-   * Same as
-   * hp_vertex_dof_indices(),
-   * except that the function
-   * treats degrees of freedom on
-   * lines.
+   * Same as hp_vertex_dof_indices(), except that the function treats
+   * degrees of freedom on lines.
    */
   virtual
   std::vector<std::pair<unsigned int, unsigned int> >
   hp_line_dof_identities (const FiniteElement<dim,spacedim> &fe_other) const;
 
   /**
-   * Same as
-   * hp_vertex_dof_indices(),
-   * except that the function
-   * treats degrees of freedom on
-   * quads.
+   * Same as hp_vertex_dof_indices(), except that the function treats
+   * degrees of freedom on quads.
    */
   virtual
   std::vector<std::pair<unsigned int, unsigned int> >
index 81b52aa7b3f221e0ab6f4a8806ed32f171429eab..7b3bcdbbc1b8f8e2272df5d77271c3b159c6b911 100644 (file)
@@ -1,7 +1,7 @@
 //---------------------------------------------------------------------------
 //    $Id$
 //
-//    Copyright (C) 2002, 2003, 2004, 2005, 2006, 2010, 2012 by the deal.II authors
+//    Copyright (C) 2002, 2003, 2004, 2005, 2006, 2010, 2012, 2013 by the deal.II authors
 //
 //    This file is subject to QPL and may not be  distributed
 //    without copyright and license information. Please refer
@@ -131,57 +131,35 @@ public:
    */
 
   /**
-   * If, on a vertex, several
-   * finite elements are active,
-   * the hp code first assigns the
-   * degrees of freedom of each of
-   * these FEs different global
-   * indices. It then calls this
-   * function to find out which of
-   * them should get identical
-   * values, and consequently can
-   * receive the same global DoF
-   * index. This function therefore
-   * returns a list of identities
-   * between DoFs of the present
-   * finite element object with the
-   * DoFs of @p fe_other, which is
-   * a reference to a finite
-   * element object representing
-   * one of the other finite
-   * elements active on this
-   * particular vertex. The
-   * function computes which of the
-   * degrees of freedom of the two
-   * finite element objects are
-   * equivalent, and returns a list
-   * of pairs of global dof indices
-   * in @p identities. The first
-   * index of each pair denotes one
-   * of the vertex dofs of the
-   * present element, whereas the
-   * second is the corresponding
-   * index of the other finite
-   * element.
+   * If, on a vertex, several finite elements are active, the hp code
+   * first assigns the degrees of freedom of each of these FEs
+   * different global indices. It then calls this function to find out
+   * which of them should get identical values, and consequently can
+   * receive the same global DoF index. This function therefore
+   * returns a list of identities between DoFs of the present finite
+   * element object with the DoFs of @p fe_other, which is a reference
+   * to a finite element object representing one of the other finite
+   * elements active on this particular vertex. The function computes
+   * which of the degrees of freedom of the two finite element objects
+   * are equivalent, both numbered between zero and the corresponding
+   * value of dofs_per_vertex of the two finite elements. The first
+   * index of each pair denotes one of the vertex dofs of the present
+   * element, whereas the second is the corresponding index of the
+   * other finite element.
    *
-   * This being a discontinuous element,
-   * the set of such constraints is of
-   * course empty.
+   * This being a discontinuous element, the set of such constraints
+   * is of course empty.
    */
   virtual
   std::vector<std::pair<unsigned int, unsigned int> >
   hp_vertex_dof_identities (const FiniteElement<dim,spacedim> &fe_other) const;
 
   /**
-   * Same as
-   * hp_vertex_dof_indices(),
-   * except that the function
-   * treats degrees of freedom on
-   * lines.
+   * Same as hp_vertex_dof_indices(), except that the function treats
+   * degrees of freedom on lines.
    *
-   * This being a discontinuous element,
-   * the set of such constraints is of
-   * course empty.
+   * This being a discontinuous element, the set of such constraints
+   * is of course empty.
    */
   virtual
   std::vector<std::pair<unsigned int, unsigned int> >
index b1b6c940f91b250fea2cfffec4ac482089d94244..53d833400647ddd5763875171cbf862e27ae77f0 100644 (file)
@@ -1,7 +1,7 @@
 //---------------------------------------------------------------------------
 //    $Id$
 //
-//    Copyright (C) 2004, 2005, 2006, 2010, 2012 by the deal.II authors
+//    Copyright (C) 2004, 2005, 2006, 2010, 2012, 2013 by the deal.II authors
 //
 //    This file is subject to QPL and may not be  distributed
 //    without copyright and license information. Please refer
@@ -110,57 +110,35 @@ public:
    */
 
   /**
-   * If, on a vertex, several
-   * finite elements are active,
-   * the hp code first assigns the
-   * degrees of freedom of each of
-   * these FEs different global
-   * indices. It then calls this
-   * function to find out which of
-   * them should get identical
-   * values, and consequently can
-   * receive the same global DoF
-   * index. This function therefore
-   * returns a list of identities
-   * between DoFs of the present
-   * finite element object with the
-   * DoFs of @p fe_other, which is
-   * a reference to a finite
-   * element object representing
-   * one of the other finite
-   * elements active on this
-   * particular vertex. The
-   * function computes which of the
-   * degrees of freedom of the two
-   * finite element objects are
-   * equivalent, and returns a list
-   * of pairs of global dof indices
-   * in @p identities. The first
-   * index of each pair denotes one
-   * of the vertex dofs of the
-   * present element, whereas the
-   * second is the corresponding
-   * index of the other finite
-   * element.
+   * If, on a vertex, several finite elements are active, the hp code
+   * first assigns the degrees of freedom of each of these FEs
+   * different global indices. It then calls this function to find out
+   * which of them should get identical values, and consequently can
+   * receive the same global DoF index. This function therefore
+   * returns a list of identities between DoFs of the present finite
+   * element object with the DoFs of @p fe_other, which is a reference
+   * to a finite element object representing one of the other finite
+   * elements active on this particular vertex. The function computes
+   * which of the degrees of freedom of the two finite element objects
+   * are equivalent, both numbered between zero and the corresponding
+   * value of dofs_per_vertex of the two finite elements. The first
+   * index of each pair denotes one of the vertex dofs of the present
+   * element, whereas the second is the corresponding index of the
+   * other finite element.
    *
-   * This being a discontinuous element,
-   * the set of such constraints is of
-   * course empty.
+   * This being a discontinuous element, the set of such constraints
+   * is of course empty.
    */
   virtual
   std::vector<std::pair<unsigned int, unsigned int> >
   hp_vertex_dof_identities (const FiniteElement<dim> &fe_other) const;
 
   /**
-   * Same as
-   * hp_vertex_dof_indices(),
-   * except that the function
-   * treats degrees of freedom on
-   * lines.
+   * Same as hp_vertex_dof_indices(), except that the function treats
+   * degrees of freedom on lines.
    *
-   * This being a discontinuous element,
-   * the set of such constraints is of
-   * course empty.
+   * This being a discontinuous element, the set of such constraints
+   * is of course empty.
    */
   virtual
   std::vector<std::pair<unsigned int, unsigned int> >
index d57116d39c4fd5e135584439a6417f6df55f57de..87a68a53e8cb86ef330450e7ba62fc5b03f9c1d9 100644 (file)
@@ -1,7 +1,7 @@
 //---------------------------------------------------------------------------
 //    $Id$
 //
-//    Copyright (C) 2002, 2003, 2004, 2005, 2006, 2010, 2011, 2012 by the deal.II authors
+//    Copyright (C) 2002, 2003, 2004, 2005, 2006, 2010, 2011, 2012, 2013 by the deal.II authors
 //
 //    This file is subject to QPL and may not be  distributed
 //    without copyright and license information. Please refer
@@ -238,72 +238,46 @@ public:
    */
 
   /**
-   * If, on a vertex, several
-   * finite elements are active,
-   * the hp code first assigns the
-   * degrees of freedom of each of
-   * these FEs different global
-   * indices. It then calls this
-   * function to find out which of
-   * them should get identical
-   * values, and consequently can
-   * receive the same global DoF
-   * index. This function therefore
-   * returns a list of identities
-   * between DoFs of the present
-   * finite element object with the
-   * DoFs of @p fe_other, which is
-   * a reference to a finite
-   * element object representing
-   * one of the other finite
-   * elements active on this
-   * particular vertex. The
-   * function computes which of the
-   * degrees of freedom of the two
-   * finite element objects are
-   * equivalent, and returns a list
-   * of pairs of global dof indices
-   * in @p identities. The first
-   * index of each pair denotes one
-   * of the vertex dofs of the
-   * present element, whereas the
-   * second is the corresponding
-   * index of the other finite
-   * element.
+   * If, on a vertex, several finite elements are active, the hp code
+   * first assigns the degrees of freedom of each of these FEs
+   * different global indices. It then calls this function to find out
+   * which of them should get identical values, and consequently can
+   * receive the same global DoF index. This function therefore
+   * returns a list of identities between DoFs of the present finite
+   * element object with the DoFs of @p fe_other, which is a reference
+   * to a finite element object representing one of the other finite
+   * elements active on this particular vertex. The function computes
+   * which of the degrees of freedom of the two finite element objects
+   * are equivalent, both numbered between zero and the corresponding
+   * value of dofs_per_vertex of the two finite elements. The first
+   * index of each pair denotes one of the vertex dofs of the present
+   * element, whereas the second is the corresponding index of the
+   * other finite element.
    *
-   * This being a discontinuous element,
-   * the set of such constraints is of
-   * course empty.
+   * This being a discontinuous element, the set of such constraints
+   * is of course empty.
    */
   virtual
   std::vector<std::pair<unsigned int, unsigned int> >
   hp_vertex_dof_identities (const FiniteElement<dim,spacedim> &fe_other) const;
 
   /**
-   * Same as
-   * hp_vertex_dof_indices(),
-   * except that the function
-   * treats degrees of freedom on
-   * lines.
+   * Same as hp_vertex_dof_indices(), except that the function treats
+   * degrees of freedom on lines.
    *
-   * This being a discontinuous element,
-   * the set of such constraints is of
-   * course empty.
+   * This being a discontinuous element, the set of such constraints
+   * is of course empty.
    */
   virtual
   std::vector<std::pair<unsigned int, unsigned int> >
   hp_line_dof_identities (const FiniteElement<dim,spacedim> &fe_other) const;
 
   /**
-   * Same as
-   * hp_vertex_dof_indices(),
-   * except that the function
-   * treats degrees of freedom on
-   * quads.
+   * Same as hp_vertex_dof_indices(), except that the function treats
+   * degrees of freedom on quads.
    *
-   * This being a discontinuous element,
-   * the set of such constraints is of
-   * course empty.
+   * This being a discontinuous element, the set of such constraints
+   * is of course empty.
    */
   virtual
   std::vector<std::pair<unsigned int, unsigned int> >
index 085c89b6c60e6ddb8737fdd3a1e0f851c938e3fb..e2c1190b881f74f5057cadb8f362e205318ee130 100644 (file)
@@ -1,7 +1,7 @@
 //---------------------------------------------------------------------------
 //    $Id$
 //
-//    Copyright (C) 2001, 2002, 2003, 2004, 2005, 2006, 2009, 2010, 2011, 2012 by the deal.II authors
+//    Copyright (C) 2001, 2002, 2003, 2004, 2005, 2006, 2009, 2010, 2011, 2012, 2013 by the deal.II authors
 //
 //    This file is subject to QPL and may not be  distributed
 //    without copyright and license information. Please refer
@@ -180,72 +180,46 @@ public:
    */
 
   /**
-   * If, on a vertex, several
-   * finite elements are active,
-   * the hp code first assigns the
-   * degrees of freedom of each of
-   * these FEs different global
-   * indices. It then calls this
-   * function to find out which of
-   * them should get identical
-   * values, and consequently can
-   * receive the same global DoF
-   * index. This function therefore
-   * returns a list of identities
-   * between DoFs of the present
-   * finite element object with the
-   * DoFs of @p fe_other, which is
-   * a reference to a finite
-   * element object representing
-   * one of the other finite
-   * elements active on this
-   * particular vertex. The
-   * function computes which of the
-   * degrees of freedom of the two
-   * finite element objects are
-   * equivalent, and returns a list
-   * of pairs of global dof indices
-   * in @p identities. The first
-   * index of each pair denotes one
-   * of the vertex dofs of the
-   * present element, whereas the
-   * second is the corresponding
-   * index of the other finite
-   * element.
+   * If, on a vertex, several finite elements are active, the hp code
+   * first assigns the degrees of freedom of each of these FEs
+   * different global indices. It then calls this function to find out
+   * which of them should get identical values, and consequently can
+   * receive the same global DoF index. This function therefore
+   * returns a list of identities between DoFs of the present finite
+   * element object with the DoFs of @p fe_other, which is a reference
+   * to a finite element object representing one of the other finite
+   * elements active on this particular vertex. The function computes
+   * which of the degrees of freedom of the two finite element objects
+   * are equivalent, both numbered between zero and the corresponding
+   * value of dofs_per_vertex of the two finite elements. The first
+   * index of each pair denotes one of the vertex dofs of the present
+   * element, whereas the second is the corresponding index of the
+   * other finite element.
    *
-   * This being a discontinuous element,
-   * the set of such constraints is of
-   * course empty.
+   * This being a discontinuous element, the set of such constraints
+   * is of course empty.
    */
   virtual
   std::vector<std::pair<unsigned int, unsigned int> >
   hp_vertex_dof_identities (const FiniteElement<dim, spacedim> &fe_other) const;
 
   /**
-   * Same as
-   * hp_vertex_dof_indices(),
-   * except that the function
-   * treats degrees of freedom on
-   * lines.
+   * Same as hp_vertex_dof_indices(), except that the function treats
+   * degrees of freedom on lines.
    *
-   * This being a discontinuous element,
-   * the set of such constraints is of
-   * course empty.
+   * This being a discontinuous element, the set of such constraints
+   * is of course empty.
    */
   virtual
   std::vector<std::pair<unsigned int, unsigned int> >
   hp_line_dof_identities (const FiniteElement<dim, spacedim> &fe_other) const;
 
   /**
-   * Same as
-   * hp_vertex_dof_indices(),
-   * except that the function
-   * treats degrees of freedom on
-   * quads.
+   * Same as hp_vertex_dof_indices(), except that the function treats
+   * degrees of freedom on quads.
    *
-   * This being a discontinuous element,
-   * the set of such constraints is of
-   * course empty.
+   * This being a discontinuous element, the set of such constraints
+   * is of course empty.
    */
   virtual
   std::vector<std::pair<unsigned int, unsigned int> >
index 8bed672e20d83389852c72b8fe9f137cf65bf3b4..ad9ed880a81644bf1921a7c12420baadaf37001e 100644 (file)
@@ -1,7 +1,7 @@
 //---------------------------------------------------------------------------
 //    $Id$
 //
-//    Copyright (C) 2002, 2003, 2004, 2005, 2006, 2010, 2011, 2012 by the deal.II authors
+//    Copyright (C) 2002, 2003, 2004, 2005, 2006, 2010, 2011, 2012, 2013 by the deal.II authors
 //
 //    This file is subject to QPL and may not be  distributed
 //    without copyright and license information. Please refer
@@ -197,26 +197,23 @@ public:
    */
   virtual FiniteElementDomination::Domination
   compare_for_face_domination (const FiniteElement<dim> &fe_other) const;
+
   /**
-   * If, on a vertex, several finite elements are
-   * active, the hp code first assigns the degrees
-   * of freedom of each of these FEs different global
-   * indices. It then calls this function to find
-   * out which of them should get identical values,
-   * and consequently can receive the same global DoF
-   * index. This function therefore returns a list
-   * of identities between DoFs of the present finite
-   * element object with the DoFs of fe_other, which
-   * is a reference to a finite element object representing
-   * one of the other finite elements active on this
-   * particular vertex. The function computes which
-   * of the degrees of freedom of the two finite
-   * element objects are equivalent, and returns a
-   * list of pairs of global dof indices in identities.
-   * The first index of each pair denotes one of the
-   * vertex dofs of the present element, whereas the
-   * second is the corresponding index of the other
-   * finite element.
+   * If, on a vertex, several finite elements are active, the hp code
+   * first assigns the degrees of freedom of each of these FEs
+   * different global indices. It then calls this function to find out
+   * which of them should get identical values, and consequently can
+   * receive the same global DoF index. This function therefore
+   * returns a list of identities between DoFs of the present finite
+   * element object with the DoFs of @p fe_other, which is a reference
+   * to a finite element object representing one of the other finite
+   * elements active on this particular vertex. The function computes
+   * which of the degrees of freedom of the two finite element objects
+   * are equivalent, both numbered between zero and the corresponding
+   * value of dofs_per_vertex of the two finite elements. The first
+   * index of each pair denotes one of the vertex dofs of the present
+   * element, whereas the second is the corresponding index of the
+   * other finite element.
    */
   virtual std::vector<std::pair<unsigned int, unsigned int> >
   hp_vertex_dof_identities (const FiniteElement<dim> &fe_other) const;
index c20c02b8ecf9637db346cad279f272f01894adec..d5e4717f20a7b18d4fe6f00c8934728647cdd6c3 100644 (file)
@@ -1,7 +1,7 @@
 //---------------------------------------------------------------------------
 //    $Id$
 //
-//    Copyright (C) 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011, 2012 by the deal.II authors
+//    Copyright (C) 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011, 2012, 2013 by the deal.II authors
 //
 //    This file is subject to QPL and may not be  distributed
 //    without copyright and license information. Please refer
@@ -371,60 +371,37 @@ public:
   virtual bool hp_constraints_are_implemented () const;
 
   /**
-   * If, on a vertex, several
-   * finite elements are active,
-   * the hp code first assigns the
-   * degrees of freedom of each of
-   * these FEs different global
-   * indices. It then calls this
-   * function to find out which of
-   * them should get identical
-   * values, and consequently can
-   * receive the same global DoF
-   * index. This function therefore
-   * returns a list of identities
-   * between DoFs of the present
-   * finite element object with the
-   * DoFs of @p fe_other, which is
-   * a reference to a finite
-   * element object representing
-   * one of the other finite
-   * elements active on this
-   * particular vertex. The
-   * function computes which of the
-   * degrees of freedom of the two
-   * finite element objects are
-   * equivalent, and returns a list
-   * of pairs of global dof indices
-   * in @p identities. The first
-   * index of each pair denotes one
-   * of the vertex dofs of the
-   * present element, whereas the
-   * second is the corresponding
-   * index of the other finite
-   * element.
+   * If, on a vertex, several finite elements are active, the hp code
+   * first assigns the degrees of freedom of each of these FEs
+   * different global indices. It then calls this function to find out
+   * which of them should get identical values, and consequently can
+   * receive the same global DoF index. This function therefore
+   * returns a list of identities between DoFs of the present finite
+   * element object with the DoFs of @p fe_other, which is a reference
+   * to a finite element object representing one of the other finite
+   * elements active on this particular vertex. The function computes
+   * which of the degrees of freedom of the two finite element objects
+   * are equivalent, both numbered between zero and the corresponding
+   * value of dofs_per_vertex of the two finite elements. The first
+   * index of each pair denotes one of the vertex dofs of the present
+   * element, whereas the second is the corresponding index of the
+   * other finite element.
    */
   virtual
   std::vector<std::pair<unsigned int, unsigned int> >
   hp_vertex_dof_identities (const FiniteElement<dim,spacedim> &fe_other) const;
 
   /**
-   * Same as
-   * hp_vertex_dof_indices(),
-   * except that the function
-   * treats degrees of freedom on
-   * lines.
+   * Same as hp_vertex_dof_indices(), except that the function treats
+   * degrees of freedom on lines.
    */
   virtual
   std::vector<std::pair<unsigned int, unsigned int> >
   hp_line_dof_identities (const FiniteElement<dim,spacedim> &fe_other) const;
 
   /**
-   * Same as
-   * hp_vertex_dof_indices(),
-   * except that the function
-   * treats degrees of freedom on
-   * quads.
+   * Same as hp_vertex_dof_indices(), except that the function treats
+   * degrees of freedom on quads.
    */
   virtual
   std::vector<std::pair<unsigned int, unsigned int> >
index 4260c7c92fcca69cef04b00450ac3656aeeb2a1e..abca28a15fe7d9c23871a41adeb6b09fbad8612a 100644 (file)
@@ -277,7 +277,7 @@ public:
   virtual void interpolate(std::vector<double>                &local_dofs,
                            const std::vector<Vector<double> > &values,
                            unsigned int offset = 0) const;
-                                                    
+
   /**
    * Interpolate a set of vector
    * values, computed in the
@@ -393,38 +393,21 @@ public:
   virtual bool hp_constraints_are_implemented () const;
 
   /**
-   * If, on a vertex, several
-   * finite elements are active,
-   * the hp code first assigns the
-   * degrees of freedom of each of
-   * these FEs different global
-   * indices. It then calls this
-   * function to find out which of
-   * them should get identical
-   * values, and consequently can
-   * receive the same global DoF
-   * index. This function therefore
-   * returns a list of identities
-   * between DoFs of the present
-   * finite element object with the
-   * DoFs of @p fe_other, which is
-   * a reference to a finite
-   * element object representing
-   * one of the other finite
-   * elements active on this
-   * particular vertex. The
-   * function computes which of the
-   * degrees of freedom of the two
-   * finite element objects are
-   * equivalent, and returns a list
-   * of pairs of global dof indices
-   * in @p identities. The first
-   * index of each pair denotes one
-   * of the vertex dofs of the
-   * present element, whereas the
-   * second is the corresponding
-   * index of the other finite
-   * element.
+   * If, on a vertex, several finite elements are active, the hp code
+   * first assigns the degrees of freedom of each of these FEs
+   * different global indices. It then calls this function to find out
+   * which of them should get identical values, and consequently can
+   * receive the same global DoF index. This function therefore
+   * returns a list of identities between DoFs of the present finite
+   * element object with the DoFs of @p fe_other, which is a reference
+   * to a finite element object representing one of the other finite
+   * elements active on this particular vertex. The function computes
+   * which of the degrees of freedom of the two finite element objects
+   * are equivalent, both numbered between zero and the corresponding
+   * value of dofs_per_vertex of the two finite elements. The first
+   * index of each pair denotes one of the vertex dofs of the present
+   * element, whereas the second is the corresponding index of the
+   * other finite element.
    */
   virtual
   std::vector<std::pair<unsigned int, unsigned int> >
index c0920765d65e133fe3e6f3c4bac707d38fed1ae0..e53f5dab32585fca5396b42575fbc44434d093c0 100644 (file)
@@ -1,7 +1,7 @@
 //---------------------------------------------------------------------------
 //    $Id$
 //
-//    Copyright (C) 2002, 2003, 2004, 2005, 2006, 2010, 2011, 2012 by the deal.II authors
+//    Copyright (C) 2002, 2003, 2004, 2005, 2006, 2010, 2011, 2012, 2013 by the deal.II authors
 //
 //    This file is subject to QPL and may not be  distributed
 //    without copyright and license information. Please refer
@@ -285,38 +285,21 @@ public:
   virtual bool hp_constraints_are_implemented () const;
 
   /**
-   * If, on a vertex, several
-   * finite elements are active,
-   * the hp code first assigns the
-   * degrees of freedom of each of
-   * these FEs different global
-   * indices. It then calls this
-   * function to find out which of
-   * them should get identical
-   * values, and consequently can
-   * receive the same global DoF
-   * index. This function therefore
-   * returns a list of identities
-   * between DoFs of the present
-   * finite element object with the
-   * DoFs of @p fe_other, which is
-   * a reference to a finite
-   * element object representing
-   * one of the other finite
-   * elements active on this
-   * particular vertex. The
-   * function computes which of the
-   * degrees of freedom of the two
-   * finite element objects are
-   * equivalent, and returns a list
-   * of pairs of global dof indices
-   * in @p identities. The first
-   * index of each pair denotes one
-   * of the vertex dofs of the
-   * present element, whereas the
-   * second is the corresponding
-   * index of the other finite
-   * element.
+   * If, on a vertex, several finite elements are active, the hp code
+   * first assigns the degrees of freedom of each of these FEs
+   * different global indices. It then calls this function to find out
+   * which of them should get identical values, and consequently can
+   * receive the same global DoF index. This function therefore
+   * returns a list of identities between DoFs of the present finite
+   * element object with the DoFs of @p fe_other, which is a reference
+   * to a finite element object representing one of the other finite
+   * elements active on this particular vertex. The function computes
+   * which of the degrees of freedom of the two finite element objects
+   * are equivalent, both numbered between zero and the corresponding
+   * value of dofs_per_vertex of the two finite elements. The first
+   * index of each pair denotes one of the vertex dofs of the present
+   * element, whereas the second is the corresponding index of the
+   * other finite element.
    */
   virtual
   std::vector<std::pair<unsigned int, unsigned int> >
index c6c85789853a141062ecdb6f168a0cb657feabdc..e5f408b544d6ef8617b35509df17d9053170faf1 100644 (file)
@@ -1,7 +1,7 @@
 //---------------------------------------------------------------------------
 //    $Id$
 //
-//    Copyright (C) 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011, 2012 by the deal.II authors
+//    Copyright (C) 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011, 2012, 2013 by the deal.II authors
 //
 //    This file is subject to QPL and may not be  distributed
 //    without copyright and license information. Please refer
@@ -563,60 +563,37 @@ public:
                                     FullMatrix<double>       &matrix) const;
 
   /**
-   * If, on a vertex, several
-   * finite elements are active,
-   * the hp code first assigns the
-   * degrees of freedom of each of
-   * these FEs different global
-   * indices. It then calls this
-   * function to find out which of
-   * them should get identical
-   * values, and consequently can
-   * receive the same global DoF
-   * index. This function therefore
-   * returns a list of identities
-   * between DoFs of the present
-   * finite element object with the
-   * DoFs of @p fe_other, which is
-   * a reference to a finite
-   * element object representing
-   * one of the other finite
-   * elements active on this
-   * particular vertex. The
-   * function computes which of the
-   * degrees of freedom of the two
-   * finite element objects are
-   * equivalent, and returns a list
-   * of pairs of global dof indices
-   * in @p identities. The first
-   * index of each pair denotes one
-   * of the vertex dofs of the
-   * present element, whereas the
-   * second is the corresponding
-   * index of the other finite
-   * element.
+   * If, on a vertex, several finite elements are active, the hp code
+   * first assigns the degrees of freedom of each of these FEs
+   * different global indices. It then calls this function to find out
+   * which of them should get identical values, and consequently can
+   * receive the same global DoF index. This function therefore
+   * returns a list of identities between DoFs of the present finite
+   * element object with the DoFs of @p fe_other, which is a reference
+   * to a finite element object representing one of the other finite
+   * elements active on this particular vertex. The function computes
+   * which of the degrees of freedom of the two finite element objects
+   * are equivalent, both numbered between zero and the corresponding
+   * value of dofs_per_vertex of the two finite elements. The first
+   * index of each pair denotes one of the vertex dofs of the present
+   * element, whereas the second is the corresponding index of the
+   * other finite element.
    */
   virtual
   std::vector<std::pair<unsigned int, unsigned int> >
   hp_vertex_dof_identities (const FiniteElement<dim,spacedim> &fe_other) const;
 
   /**
-   * Same as
-   * hp_vertex_dof_indices(),
-   * except that the function
-   * treats degrees of freedom on
-   * lines.
+   * Same as hp_vertex_dof_indices(), except that the function treats
+   * degrees of freedom on lines.
    */
   virtual
   std::vector<std::pair<unsigned int, unsigned int> >
   hp_line_dof_identities (const FiniteElement<dim,spacedim> &fe_other) const;
 
   /**
-   * Same as
-   * hp_vertex_dof_indices(),
-   * except that the function
-   * treats degrees of freedom on
-   * quads.
+   * Same as hp_vertex_dof_indices(), except that the function treats
+   * degrees of freedom on quads.
    */
   virtual
   std::vector<std::pair<unsigned int, unsigned int> >

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.