/**
- * 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> >
//---------------------------------------------------------------------------
// $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
*/
/**
- * 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> >
//---------------------------------------------------------------------------
// $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
*/
/**
- * 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> >
//---------------------------------------------------------------------------
// $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
*/
/**
- * 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> >
//---------------------------------------------------------------------------
// $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
*/
/**
- * 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> >
//---------------------------------------------------------------------------
// $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
*/
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;
//---------------------------------------------------------------------------
// $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
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> >
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
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> >
//---------------------------------------------------------------------------
// $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
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> >
//---------------------------------------------------------------------------
// $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
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> >