From 3d7ea856c322cad44c6685201e61faa002e38bde Mon Sep 17 00:00:00 2001 From: bangerth Date: Wed, 16 Jan 2013 23:50:34 +0000 Subject: [PATCH] Correct documentation in a number of places. git-svn-id: https://svn.dealii.org/trunk@28093 0785d39b-7218-0410-832d-ea1e28bc413d --- deal.II/include/deal.II/fe/fe.h | 66 ++++++---------- deal.II/include/deal.II/fe/fe_dgp.h | 66 ++++++---------- deal.II/include/deal.II/fe/fe_dgp_monomial.h | 66 ++++++---------- .../include/deal.II/fe/fe_dgp_nonparametric.h | 78 +++++++------------ deal.II/include/deal.II/fe/fe_dgq.h | 78 +++++++------------ deal.II/include/deal.II/fe/fe_nedelec.h | 37 ++++----- deal.II/include/deal.II/fe/fe_q.h | 63 +++++---------- deal.II/include/deal.II/fe/fe_q_dg0.h | 49 ++++-------- .../include/deal.II/fe/fe_q_hierarchical.h | 49 ++++-------- deal.II/include/deal.II/fe/fe_system.h | 63 +++++---------- 10 files changed, 209 insertions(+), 406 deletions(-) diff --git a/deal.II/include/deal.II/fe/fe.h b/deal.II/include/deal.II/fe/fe.h index 15c34dcd3e..8b260a3b5e 100644 --- a/deal.II/include/deal.II/fe/fe.h +++ b/deal.II/include/deal.II/fe/fe.h @@ -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 > hp_vertex_dof_identities (const FiniteElement &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 > hp_line_dof_identities (const FiniteElement &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 > diff --git a/deal.II/include/deal.II/fe/fe_dgp.h b/deal.II/include/deal.II/fe/fe_dgp.h index 81b52aa7b3..7b3bcdbbc1 100644 --- a/deal.II/include/deal.II/fe/fe_dgp.h +++ b/deal.II/include/deal.II/fe/fe_dgp.h @@ -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 > hp_vertex_dof_identities (const FiniteElement &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 > diff --git a/deal.II/include/deal.II/fe/fe_dgp_monomial.h b/deal.II/include/deal.II/fe/fe_dgp_monomial.h index b1b6c940f9..53d8334006 100644 --- a/deal.II/include/deal.II/fe/fe_dgp_monomial.h +++ b/deal.II/include/deal.II/fe/fe_dgp_monomial.h @@ -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 > hp_vertex_dof_identities (const FiniteElement &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 > diff --git a/deal.II/include/deal.II/fe/fe_dgp_nonparametric.h b/deal.II/include/deal.II/fe/fe_dgp_nonparametric.h index d57116d39c..87a68a53e8 100644 --- a/deal.II/include/deal.II/fe/fe_dgp_nonparametric.h +++ b/deal.II/include/deal.II/fe/fe_dgp_nonparametric.h @@ -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 > hp_vertex_dof_identities (const FiniteElement &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 > hp_line_dof_identities (const FiniteElement &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 > diff --git a/deal.II/include/deal.II/fe/fe_dgq.h b/deal.II/include/deal.II/fe/fe_dgq.h index 085c89b6c6..e2c1190b88 100644 --- a/deal.II/include/deal.II/fe/fe_dgq.h +++ b/deal.II/include/deal.II/fe/fe_dgq.h @@ -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 > hp_vertex_dof_identities (const FiniteElement &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 > hp_line_dof_identities (const FiniteElement &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 > diff --git a/deal.II/include/deal.II/fe/fe_nedelec.h b/deal.II/include/deal.II/fe/fe_nedelec.h index 8bed672e20..ad9ed880a8 100644 --- a/deal.II/include/deal.II/fe/fe_nedelec.h +++ b/deal.II/include/deal.II/fe/fe_nedelec.h @@ -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 &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 > hp_vertex_dof_identities (const FiniteElement &fe_other) const; diff --git a/deal.II/include/deal.II/fe/fe_q.h b/deal.II/include/deal.II/fe/fe_q.h index c20c02b8ec..d5e4717f20 100644 --- a/deal.II/include/deal.II/fe/fe_q.h +++ b/deal.II/include/deal.II/fe/fe_q.h @@ -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 > hp_vertex_dof_identities (const FiniteElement &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 > hp_line_dof_identities (const FiniteElement &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 > diff --git a/deal.II/include/deal.II/fe/fe_q_dg0.h b/deal.II/include/deal.II/fe/fe_q_dg0.h index 4260c7c92f..abca28a15f 100644 --- a/deal.II/include/deal.II/fe/fe_q_dg0.h +++ b/deal.II/include/deal.II/fe/fe_q_dg0.h @@ -277,7 +277,7 @@ public: virtual void interpolate(std::vector &local_dofs, const std::vector > &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 > diff --git a/deal.II/include/deal.II/fe/fe_q_hierarchical.h b/deal.II/include/deal.II/fe/fe_q_hierarchical.h index c0920765d6..e53f5dab32 100644 --- a/deal.II/include/deal.II/fe/fe_q_hierarchical.h +++ b/deal.II/include/deal.II/fe/fe_q_hierarchical.h @@ -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 > diff --git a/deal.II/include/deal.II/fe/fe_system.h b/deal.II/include/deal.II/fe/fe_system.h index c6c8578985..e5f408b544 100644 --- a/deal.II/include/deal.II/fe/fe_system.h +++ b/deal.II/include/deal.II/fe/fe_system.h @@ -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 &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 > hp_vertex_dof_identities (const FiniteElement &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 > hp_line_dof_identities (const FiniteElement &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 > -- 2.39.5