typedef typename ActiveSelector::cell_iterator cell_iterator;
/**
- * Alias the @p FunctionMap type
- * declared elsewhere.
- */
+ * Alias the @p FunctionMap type
+ * declared elsewhere.
+ */
typedef typename dealii::FunctionMap<spacedim>::type FunctionMap;
/**
- * Make the dimension available
- * in function templates.
- */
+ * Make the dimension available
+ * in function templates.
+ */
static const unsigned int dimension = dim;
/**
- * Make the space dimension available
- * in function templates.
- */
+ * Make the space dimension available
+ * in function templates.
+ */
static const unsigned int space_dimension = spacedim;
/**
- * When the arrays holding the
- * DoF indices are set up, but
- * before they are filled with
- * actual values, they are set to
- * an invalid value, in order to
- * monitor possible
- * problems. This invalid value
- * is the constant defined here.
- *
- * Please note that you should
- * not rely on it having a
- * certain value, but rather take
- * its symbolic name.
- */
+ * When the arrays holding the
+ * DoF indices are set up, but
+ * before they are filled with
+ * actual values, they are set to
+ * an invalid value, in order to
+ * monitor possible
+ * problems. This invalid value
+ * is the constant defined here.
+ *
+ * Please note that you should
+ * not rely on it having a
+ * certain value, but rather take
+ * its symbolic name.
+ */
static const unsigned int invalid_dof_index = numbers::invalid_unsigned_int;
/**
- * The default index of the
- * finite element to be used on a
- * given cell. Since the present
- * class only supports the same
- * finite element to be used on
- * all cells, the index of the
- * finite element needs to be the
- * same on all cells anyway, and
- * by convention we pick zero for
- * this value. The situation is
- * different for hp objects
- * (i.e. the hp::DoFHandler
- * class) where different finite
- * element indices may be used on
- * different cells, and the
- * default index there
- * corresponds to an invalid
- * value.
- */
+ * The default index of the
+ * finite element to be used on a
+ * given cell. Since the present
+ * class only supports the same
+ * finite element to be used on
+ * all cells, the index of the
+ * finite element needs to be the
+ * same on all cells anyway, and
+ * by convention we pick zero for
+ * this value. The situation is
+ * different for hp objects
+ * (i.e. the hp::DoFHandler
+ * class) where different finite
+ * element indices may be used on
+ * different cells, and the
+ * default index there
+ * corresponds to an invalid
+ * value.
+ */
static const unsigned int default_fe_index = 0;
/**
- * Standard constructor, not
- * initializing any data. After
- * constructing an object with
- * this constructor, use
- * initialize() to make a valid
- * DoFHandler.
- */
+ * Standard constructor, not
+ * initializing any data. After
+ * constructing an object with
+ * this constructor, use
+ * initialize() to make a valid
+ * DoFHandler.
+ */
DoFHandler ();
/**
- * Constructor. Take @p tria as the
- * triangulation to work on.
- */
+ * Constructor. Take @p tria as the
+ * triangulation to work on.
+ */
DoFHandler ( const Triangulation<dim,spacedim> &tria);
/**
- * Destructor.
- */
+ * Destructor.
+ */
virtual ~DoFHandler ();
/**
- * Assign a Triangulation and a
- * FiniteElement to the
- * DoFHandler and compute the
- * distribution of degrees of
- * freedom over the mesh.
- */
+ * Assign a Triangulation and a
+ * FiniteElement to the
+ * DoFHandler and compute the
+ * distribution of degrees of
+ * freedom over the mesh.
+ */
void initialize(const Triangulation<dim,spacedim> &tria,
const FiniteElement<dim,spacedim> &fe);
/**
- * Go through the triangulation and
- * distribute the degrees of freedoms
- * needed for the given finite element
- * according to the given distribution
- * method. The purpose of this function
- * is first discussed in the introduction
- * to the step-2 tutorial program.
- *
- * A pointer of the transferred
- * finite element is
- * stored. Therefore, the
- * lifetime of the finite element
- * object shall be longer than
- * that of this object. If you
- * don't want this behaviour, you
- * may want to call the @p clear
- * member function which also
- * releases the lock of this
- * object to the finite element.
- */
+ * Go through the triangulation and
+ * distribute the degrees of freedoms
+ * needed for the given finite element
+ * according to the given distribution
+ * method. The purpose of this function
+ * is first discussed in the introduction
+ * to the step-2 tutorial program.
+ *
+ * A pointer of the transferred
+ * finite element is
+ * stored. Therefore, the
+ * lifetime of the finite element
+ * object shall be longer than
+ * that of this object. If you
+ * don't want this behaviour, you
+ * may want to call the @p clear
+ * member function which also
+ * releases the lock of this
+ * object to the finite element.
+ */
virtual void distribute_dofs (const FiniteElement<dim,spacedim> &fe);
virtual void distribute_mg_dofs (const FiniteElement<dim, spacedim> &fe);
*/
bool has_active_dofs() const;
/**
- * After distribute_dofs() with
- * an FESystem element, the block
- * structure of global and level
- * vectors is stored in a
- * BlockInfo object accessible
- * with block_info(). This
- * function initializes the local
- * block structure on each cell
- * in the same object.
- */
+ * After distribute_dofs() with
+ * an FESystem element, the block
+ * structure of global and level
+ * vectors is stored in a
+ * BlockInfo object accessible
+ * with block_info(). This
+ * function initializes the local
+ * block structure on each cell
+ * in the same object.
+ */
void initialize_local_block_info();
/**
- * Clear all data of this object and
- * especially delete the lock this object
- * has to the finite element used the last
- * time when @p distribute_dofs was called.
- */
+ * Clear all data of this object and
+ * especially delete the lock this object
+ * has to the finite element used the last
+ * time when @p distribute_dofs was called.
+ */
virtual void clear ();
/**
- * Renumber degrees of freedom based on
- * a list of new dof numbers for all the
- * dofs.
- *
- * This function is called by
- * the functions in
- * DoFRenumbering function
- * after computing the ordering
- * of the degrees of freedom.
- * This function is called, for
- * example, by the functions in
- * the DoFRenumbering
- * namespace, but it can of
- * course also be called from
- * user code.
- *
- * @arg new_number This array
- * must have a size equal to
- * the number of degrees of
- * freedom owned by the current
- * processor, i.e. the size
- * must be equal to what
- * n_locally_owned_dofs()
- * returns. If only one
- * processor participates in
- * storing the current mesh,
- * then this equals the total
- * number of degrees of
- * freedom, i.e. the result of
- * n_dofs(). The contents of
- * this array are the new
- * global indices for each
- * freedom listed in the
- * IndexSet returned by
- * locally_owned_dofs(). In the
- * case of a sequential mesh
- * this means that the array is
- * a list of new indices for
- * each of the degrees of
- * freedom on the current
- * mesh. In the case that we
- * have a
- * parallel::distributed::Triangulation
- * underlying this DoFHandler
- * object, the array is a list
- * of new indices for all the
- * locally owned degrees of
- * freedom, enumerated in the
- * same order as the currently
- * locally owned DoFs. In other
- * words, assume that degree of
- * freedom <code>i</code> is
- * currently locally owned,
- * then
- * <code>new_numbers[locally_owned_dofs().index_within_set(i)]</code>
- * returns the new global DoF
- * index of
- * <code>i</code>. Since the
- * IndexSet of
- * locally_owned_dofs() is
- * complete in the sequential
- * case, the latter convention
- * for the content of the array
- * reduces to the former in the
- * case that only one processor
- * participates in the mesh.
- */
+ * Renumber degrees of freedom based on
+ * a list of new dof numbers for all the
+ * dofs.
+ *
+ * This function is called by
+ * the functions in
+ * DoFRenumbering function
+ * after computing the ordering
+ * of the degrees of freedom.
+ * This function is called, for
+ * example, by the functions in
+ * the DoFRenumbering
+ * namespace, but it can of
+ * course also be called from
+ * user code.
+ *
+ * @arg new_number This array
+ * must have a size equal to
+ * the number of degrees of
+ * freedom owned by the current
+ * processor, i.e. the size
+ * must be equal to what
+ * n_locally_owned_dofs()
+ * returns. If only one
+ * processor participates in
+ * storing the current mesh,
+ * then this equals the total
+ * number of degrees of
+ * freedom, i.e. the result of
+ * n_dofs(). The contents of
+ * this array are the new
+ * global indices for each
+ * freedom listed in the
+ * IndexSet returned by
+ * locally_owned_dofs(). In the
+ * case of a sequential mesh
+ * this means that the array is
+ * a list of new indices for
+ * each of the degrees of
+ * freedom on the current
+ * mesh. In the case that we
+ * have a
+ * parallel::distributed::Triangulation
+ * underlying this DoFHandler
+ * object, the array is a list
+ * of new indices for all the
+ * locally owned degrees of
+ * freedom, enumerated in the
+ * same order as the currently
+ * locally owned DoFs. In other
+ * words, assume that degree of
+ * freedom <code>i</code> is
+ * currently locally owned,
+ * then
+ * <code>new_numbers[locally_owned_dofs().index_within_set(i)]</code>
+ * returns the new global DoF
+ * index of
+ * <code>i</code>. Since the
+ * IndexSet of
+ * locally_owned_dofs() is
+ * complete in the sequential
+ * case, the latter convention
+ * for the content of the array
+ * reduces to the former in the
+ * case that only one processor
+ * participates in the mesh.
+ */
void renumber_dofs (const std::vector<unsigned int> &new_numbers);
/**
const std::vector<unsigned int> &new_numbers);
/**
- * @deprecated Use
- * CompressedSparsityPattern instead of
- * initializing SparsityPattern with this
- * value, see the discussion in step-2
- * and the @ref Sparsity module.
- *
- * Return the maximum number of
- * degrees of freedom a degree of freedom
- * in the given triangulation with the
- * given finite element may couple with.
- * This is the maximum number of entries
- * per line in the system matrix; this
- * information can therefore be used upon
- * construction of the SparsityPattern
- * object.
- *
- * The returned number is not really the
- * maximum number but an estimate based
- * on the finite element and the maximum
- * number of cells meeting at a vertex.
- * The number holds for the constrained
- * matrix as well.
- *
- * The determination of the number of
- * couplings can be done by simple
- * picture drawing. An example can be
- * found in the implementation of this
- * function.
- *
- * Note that this function is most often
- * used to determine the maximal row
- * length for sparsity
- * patterns. Unfortunately, while the
- * estimates returned by this function
- * are rather accurate in 1d and 2d, they
- * are often significantly too high in
- * 3d, leading the SparsityPattern class
- * to allocate much too much memory in
- * some cases. Unless someone comes
- * around to improving the present
- * function for 3d, there is not very
- * much one can do about these cases. The
- * typical way to work around this
- * problem is to use an intermediate
- * compressed sparsity pattern that only
- * allocates memory on demand. Refer to
- * the step-2 and step-11 example
- * programs on how to do this. The problem
- * is also discussed in the documentation
- * of the module on @ref Sparsity.
- */
+ * @deprecated Use
+ * CompressedSparsityPattern instead of
+ * initializing SparsityPattern with this
+ * value, see the discussion in step-2
+ * and the @ref Sparsity module.
+ *
+ * Return the maximum number of
+ * degrees of freedom a degree of freedom
+ * in the given triangulation with the
+ * given finite element may couple with.
+ * This is the maximum number of entries
+ * per line in the system matrix; this
+ * information can therefore be used upon
+ * construction of the SparsityPattern
+ * object.
+ *
+ * The returned number is not really the
+ * maximum number but an estimate based
+ * on the finite element and the maximum
+ * number of cells meeting at a vertex.
+ * The number holds for the constrained
+ * matrix as well.
+ *
+ * The determination of the number of
+ * couplings can be done by simple
+ * picture drawing. An example can be
+ * found in the implementation of this
+ * function.
+ *
+ * Note that this function is most often
+ * used to determine the maximal row
+ * length for sparsity
+ * patterns. Unfortunately, while the
+ * estimates returned by this function
+ * are rather accurate in 1d and 2d, they
+ * are often significantly too high in
+ * 3d, leading the SparsityPattern class
+ * to allocate much too much memory in
+ * some cases. Unless someone comes
+ * around to improving the present
+ * function for 3d, there is not very
+ * much one can do about these cases. The
+ * typical way to work around this
+ * problem is to use an intermediate
+ * compressed sparsity pattern that only
+ * allocates memory on demand. Refer to
+ * the step-2 and step-11 example
+ * programs on how to do this. The problem
+ * is also discussed in the documentation
+ * of the module on @ref Sparsity.
+ */
unsigned int max_couplings_between_dofs () const;
/**
- * @deprecated Use
- * CompressedSparsityPattern
- * instead of initializing
- * SparsityPattern with this
- * value.
- *
- * Return the number of degrees of freedom
- * located on the boundary another dof on
- * the boundary can couple with.
- *
- * The number is the same as for
- * max_couplings_between_dofs() in one
- * dimension less.
- */
+ * @deprecated Use
+ * CompressedSparsityPattern
+ * instead of initializing
+ * SparsityPattern with this
+ * value.
+ *
+ * Return the number of degrees of freedom
+ * located on the boundary another dof on
+ * the boundary can couple with.
+ *
+ * The number is the same as for
+ * max_couplings_between_dofs() in one
+ * dimension less.
+ */
unsigned int max_couplings_between_boundary_dofs () const;
/*--------------------------------------*/
* Iterator to the first used
* cell on level @p level.
*/
- cell_iterator begin (const unsigned int level = 0) const;
+ cell_iterator begin (const unsigned int level = 0) const;
/**
* Iterator to the first active
/*---------------------------------------*/
+
/**
- * Return the global number of
- * degrees of freedom. If the
- * current object handles all
- * degrees of freedom itself
- * (even if you may intend to
- * solve your linear system in
- * parallel, such as in step-17
- * or step-18), then this number
- * equals the number of locally
- * owned degrees of freedom since
- * this object doesn't know
- * anything about what you want
- * to do with it and believes
- * that it owns every degree of
- * freedom it knows about.
- *
- * On the other hand, if this
- * object operates on a
- * parallel::distributed::Triangulation
- * object, then this function
- * returns the global number of
- * degrees of freedom,
- * accumulated over all
- * processors.
- *
- * In either case, included in
- * the returned number are those
- * DoFs which are constrained by
- * hanging nodes, see @ref constraints.
- */
+ * Return the global number of
+ * degrees of freedom. If the
+ * current object handles all
+ * degrees of freedom itself
+ * (even if you may intend to
+ * solve your linear system in
+ * parallel, such as in step-17
+ * or step-18), then this number
+ * equals the number of locally
+ * owned degrees of freedom since
+ * this object doesn't know
+ * anything about what you want
+ * to do with it and believes
+ * that it owns every degree of
+ * freedom it knows about.
+ *
+ * On the other hand, if this
+ * object operates on a
+ * parallel::distributed::Triangulation
+ * object, then this function
+ * returns the global number of
+ * degrees of freedom,
+ * accumulated over all
+ * processors.
+ *
+ * In either case, included in
+ * the returned number are those
+ * DoFs which are constrained by
+ * hanging nodes, see @ref constraints.
+ */
unsigned int n_dofs () const;
/**
- * The (global) number of multilevel
- * degrees of freedom on a
- * given level.
- *
- * If no level degrees of
- * freedom have been assigned
- * to this level, returns
- * numbers::invalid_unsigned_int. Else
- * returns the number of
- * degrees of freedom on this level.
- */
+ * The (global) number of multilevel
+ * degrees of freedom on a
+ * given level.
+ *
+ * If no level degrees of
+ * freedom have been assigned
+ * to this level, returns
+ * numbers::invalid_unsigned_int. Else
+ * returns the number of
+ * degrees of freedom on this level.
+ */
unsigned int n_dofs (const unsigned int level) const;
/**
- * Return the number of degrees of freedom
- * located on the boundary.
- */
+ * Return the number of degrees of freedom
+ * located on the boundary.
+ */
unsigned int n_boundary_dofs () const;
/**
- * Return the number of degrees
- * of freedom located on those
- * parts of the boundary which
- * have a boundary indicator
- * listed in the given set. The
- * reason that a @p map rather
- * than a @p set is used is the
- * same as described in the
- * section on the
- * @p make_boundary_sparsity_pattern
- * function.
- */
+ * Return the number of degrees
+ * of freedom located on those
+ * parts of the boundary which
+ * have a boundary indicator
+ * listed in the given set. The
+ * reason that a @p map rather
+ * than a @p set is used is the
+ * same as described in the
+ * section on the
+ * @p make_boundary_sparsity_pattern
+ * function.
+ */
unsigned int
n_boundary_dofs (const FunctionMap &boundary_indicators) const;
n_boundary_dofs (const std::set<types::boundary_id> &boundary_indicators) const;
/**
- * Access to an object informing
- * of the block structure of the
- * dof handler.
- *
- * If an FESystem is used in
- * distribute_dofs(), degrees of
- * freedom naturally split into
- * several @ref GlossBlock
- * "blocks". For each base element
- * as many blocks appear as its
- * multiplicity.
- *
- * At the end of
- * distribute_dofs(), the number
- * of degrees of freedom in each
- * block is counted, and stored
- * in a BlockInfo object, which
- * can be accessed here. In an
- * MGDoFHandler, the same is done
- * on each level. Additionally,
- * the block structure on each
- * cell can be generated in this
- * object by calling
- * initialize_local_block_info().
- */
+ * Access to an object informing
+ * of the block structure of the
+ * dof handler.
+ *
+ * If an FESystem is used in
+ * distribute_dofs(), degrees of
+ * freedom naturally split into
+ * several @ref GlossBlock
+ * "blocks". For each base element
+ * as many blocks appear as its
+ * multiplicity.
+ *
+ * At the end of
+ * distribute_dofs(), the number
+ * of degrees of freedom in each
+ * block is counted, and stored
+ * in a BlockInfo object, which
+ * can be accessed here. In an
+ * MGDoFHandler, the same is done
+ * on each level. Additionally,
+ * the block structure on each
+ * cell can be generated in this
+ * object by calling
+ * initialize_local_block_info().
+ */
const BlockInfo &block_info() const;
/**
- * Return the number of
- * degrees of freedom that
- * belong to this
- * process.
- *
- * If this is a sequential job,
- * then the result equals that
- * produced by n_dofs(). On the
- * other hand, if we are
- * operating on a
- * parallel::distributed::Triangulation,
- * then it includes only the
- * degrees of freedom that the
- * current processor owns. Note
- * that in this case this does
- * not include all degrees of
- * freedom that have been
- * distributed on the current
- * processor's image of the mesh:
- * in particular, some of the
- * degrees of freedom on the
- * interface between the cells
- * owned by this processor and
- * cells owned by other
- * processors may be theirs, and
- * degrees of freedom on ghost
- * cells are also not necessarily
- * included.
- */
+ * Return the number of
+ * degrees of freedom that
+ * belong to this
+ * process.
+ *
+ * If this is a sequential job,
+ * then the result equals that
+ * produced by n_dofs(). On the
+ * other hand, if we are
+ * operating on a
+ * parallel::distributed::Triangulation,
+ * then it includes only the
+ * degrees of freedom that the
+ * current processor owns. Note
+ * that in this case this does
+ * not include all degrees of
+ * freedom that have been
+ * distributed on the current
+ * processor's image of the mesh:
+ * in particular, some of the
+ * degrees of freedom on the
+ * interface between the cells
+ * owned by this processor and
+ * cells owned by other
+ * processors may be theirs, and
+ * degrees of freedom on ghost
+ * cells are also not necessarily
+ * included.
+ */
unsigned int n_locally_owned_dofs() const;
/**
- * Return an IndexSet describing
- * the set of locally owned DoFs
- * as a subset of
- * 0..n_dofs(). The number of
- * elements of this set equals
- * n_locally_owned_dofs().
- */
+ * Return an IndexSet describing
+ * the set of locally owned DoFs
+ * as a subset of
+ * 0..n_dofs(). The number of
+ * elements of this set equals
+ * n_locally_owned_dofs().
+ */
const IndexSet &locally_owned_dofs() const;
+
+ /**
+ * Returns an IndexSet describing the set of locally
+ * owned DoFs used for the given multigrid level as
+ * a subset of 0..n_dofs(level).
const IndexSet &locally_owned_mg_dofs(const unsigned int level) const;
locally_owned_mg_dofs_per_processor (const unsigned int level) const;
/**
- * Return a vector that
- * stores the number of
- * degrees of freedom each
- * processor that
- * participates in this
- * triangulation owns
- * locally. The sum of all
- * these numbers equals the
- * number of degrees of
- * freedom that exist
- * globally, i.e. what
- * n_dofs() returns.
- *
- * Each element of the vector
- * returned by this function
- * equals the number of
- * elements of the
- * corresponding sets
- * returned by
- * global_dof_indices().
- *
- * If this is a sequential job,
- * then the vector has a single
- * element equal to n_dofs().
- */
+ * Return a vector that
+ * stores the number of
+ * degrees of freedom each
+ * processor that
+ * participates in this
+ * triangulation owns
+ * locally. The sum of all
+ * these numbers equals the
+ * number of degrees of
+ * freedom that exist
+ * globally, i.e. what
+ * n_dofs() returns.
+ *
+ * Each element of the vector
+ * returned by this function
+ * equals the number of
+ * elements of the
+ * corresponding sets
+ * returned by
+ * global_dof_indices().
+ *
+ * If this is a sequential job,
+ * then the vector has a single
+ * element equal to n_dofs().
+ */
const std::vector<unsigned int> &
n_locally_owned_dofs_per_processor () const;
/**
- * Return a constant reference to
- * the selected finite element
- * object.
- */
+ * Return a constant reference to
+ * the selected finite element
+ * object.
+ */
const FiniteElement<dim,spacedim> &get_fe () const;
/**
- * Return a constant reference to
- * the triangulation underlying
- * this object.
- */
+ * Return a constant reference to
+ * the triangulation underlying
+ * this object.
+ */
const Triangulation<dim,spacedim> &get_tria () const;
/**
- * Determine an estimate for the
- * memory consumption (in bytes)
- * of this object.
- *
- * This function is made virtual,
- * since a dof handler object
- * might be accessed through a
- * pointers to this base class,
- * although the actual object
- * might be a derived class.
- */
+ * Determine an estimate for the
+ * memory consumption (in bytes)
+ * of this object.
+ *
+ * This function is made virtual,
+ * since a dof handler object
+ * might be accessed through a
+ * pointers to this base class,
+ * although the actual object
+ * might be a derived class.
+ */
virtual std::size_t memory_consumption () const;
/**
- * Write the data of this object to a
- * stream for the purpose of
- * serialization.
- */
+ * Write the data of this object to a
+ * stream for the purpose of
+ * serialization.
+ */
template <class Archive>
void save (Archive &ar, const unsigned int version) const;
/**
- * Read the data of this object from a
- * stream for the purpose of
- * serialization.
- */
+ * Read the data of this object from a
+ * stream for the purpose of
+ * serialization.
+ */
template <class Archive>
void load (Archive &ar, const unsigned int version);
BOOST_SERIALIZATION_SPLIT_MEMBER()
/**
- * We are trying to renumber the
- * degrees of freedom, but
- * somehow did not count
- * correctly.
- *
- * @ingroup Exceptions
- */
+ * We are trying to renumber the
+ * degrees of freedom, but
+ * somehow did not count
+ * correctly.
+ *
+ * @ingroup Exceptions
+ */
DeclException0 (ExcRenumberingIncomplete);
/**
- * Exception
- * @ingroup Exceptions
- */
+ * Exception
+ * @ingroup Exceptions
+ */
DeclException0 (ExcGridsDoNotMatch);
/**
- * Exception
- * @ingroup Exceptions
- */
+ * Exception
+ * @ingroup Exceptions
+ */
DeclException0 (ExcInvalidBoundaryIndicator);
/**
- * Exception
- * @ingroup Exceptions
- */
+ * Exception
+ * @ingroup Exceptions
+ */
DeclException1 (ExcNewNumbersNotConsecutive,
int,
<< "The given list of new dof indices is not consecutive: "
<< "the index " << arg1 << " does not exist.");
/**
- * Exception
- * @ingroup Exceptions
- */
+ * Exception
+ * @ingroup Exceptions
+ */
DeclException1 (ExcInvalidLevel,
int,
<< "The given level " << arg1
<< " is not in the valid range!");
/**
- * Exception
- * @ingroup Exceptions
- */
+ * Exception
+ * @ingroup Exceptions
+ */
DeclException0 (ExcFacesHaveNoLevel);
/**
- * The triangulation level you
- * accessed is empty.
- * @ingroup Exceptions
- */
+ * The triangulation level you
+ * accessed is empty.
+ * @ingroup Exceptions
+ */
DeclException1 (ExcEmptyLevel,
int,
<< "You tried to do something on level " << arg1
protected:
/**
- * The object containing
- * information on the block structure.
- */
+ * The object containing
+ * information on the block structure.
+ */
BlockInfo block_info_object;
/**
- * Array to store the indices for
- * degrees of freedom located at
- * vertices.
- */
+ * Array to store the indices for
+ * degrees of freedom located at
+ * vertices.
+ */
std::vector<unsigned int> vertex_dofs;
/**
- * Address of the triangulation to
- * work on.
- */
+ * Address of the triangulation to
+ * work on.
+ */
SmartPointer<const Triangulation<dim,spacedim>,DoFHandler<dim,spacedim> >
tria;
/**
- * Store a pointer to the finite element
- * given latest for the distribution of
- * dofs. In order to avoid destruction of
- * the object before the lifetime of
- * the DoF handler, we subscribe to
- * the finite element object. To unlock
- * the FE before the end of the lifetime
- * of this DoF handler, use the <tt>clear()</tt>
- * function (this clears all data of
- * this object as well, though).
- */
+ * Store a pointer to the finite element
+ * given latest for the distribution of
+ * dofs. In order to avoid destruction of
+ * the object before the lifetime of
+ * the DoF handler, we subscribe to
+ * the finite element object. To unlock
+ * the FE before the end of the lifetime
+ * of this DoF handler, use the <tt>clear()</tt>
+ * function (this clears all data of
+ * this object as well, though).
+ */
SmartPointer<const FiniteElement<dim,spacedim>,DoFHandler<dim,spacedim> >
selected_fe;
/**
- * An object that describes how degrees
- * of freedom should be distributed and
- * renumbered.
- */
+ * An object that describes how degrees
+ * of freedom should be distributed and
+ * renumbered.
+ */
std_cxx1x::shared_ptr<dealii::internal::DoFHandler::Policy::PolicyBase<dim,spacedim> > policy;
/**
- * A structure that contains all
- * sorts of numbers that
- * characterize the degrees of
- * freedom this object works on.
- *
- * For most members of this
- * structure, there is an
- * accessor function in this
- * class that returns its value.
- */
+ * A structure that contains all
+ * sorts of numbers that
+ * characterize the degrees of
+ * freedom this object works on.
+ *
+ * For most members of this
+ * structure, there is an
+ * accessor function in this
+ * class that returns its value.
+ */
dealii::internal::DoFHandler::NumberCache number_cache;
/**
private:
/**
- * Copy constructor. I can see no reason
- * why someone might want to use it, so
- * I don't provide it. Since this class
- * has pointer members, making it private
- * prevents the compiler to provide it's
- * own, incorrect one if anyone chose to
- * copy such an object.
- */
+ * Copy constructor. I can see no reason
+ * why someone might want to use it, so
+ * I don't provide it. Since this class
+ * has pointer members, making it private
+ * prevents the compiler to provide it's
+ * own, incorrect one if anyone chose to
+ * copy such an object.
+ */
DoFHandler (const DoFHandler &);
/**
- * Copy operator. I can see no reason
- * why someone might want to use it, so
- * I don't provide it. Since this class
- * has pointer members, making it private
- * prevents the compiler to provide it's
- * own, incorrect one if anyone chose to
- * copy such an object.
- */
+ * Copy operator. I can see no reason
+ * why someone might want to use it, so
+ * I don't provide it. Since this class
+ * has pointer members, making it private
+ * prevents the compiler to provide it's
+ * own, incorrect one if anyone chose to
+ * copy such an object.
+ */
DoFHandler &operator = (const DoFHandler &);
class MGVertexDoFs
void clear_mg_space ();
/**
- * Free all used memory.
- */
+ * Free all used memory.
+ */
void clear_space ();
void reserve_space ();
void set_dof_index (const unsigned int obj_level, const unsigned int obj_index, const unsigned int fe_index, const unsigned int local_index, const unsigned int global_index) const;
/**
- * Space to store the DoF numbers
- * for the different
- * levels. Analogous to the
- * <tt>levels[]</tt> tree of the
- * Triangulation objects.
- */
+ * Space to store the DoF numbers
+ * for the different
+ * levels. Analogous to the
+ * <tt>levels[]</tt> tree of the
+ * Triangulation objects.
+ */
std::vector<dealii::internal::DoFHandler::DoFLevel<dim>*> levels;
std::vector<dealii::internal::DoFHandler::DoFLevel<dim>*> mg_levels;
/**
- * Space to store DoF numbers of
- * faces. They are not stored in
- * <tt>levels</tt> since faces
- * are not organized
- * hierarchically, but in a flat
- * array.
- */
+ * Space to store DoF numbers of
+ * faces. They are not stored in
+ * <tt>levels</tt> since faces
+ * are not organized
+ * hierarchically, but in a flat
+ * array.
+ */
dealii::internal::DoFHandler::DoFFaces<dim> *faces;
dealii::internal::DoFHandler::DoFFaces<dim> *mg_faces;
std::vector<MGVertexDoFs> mg_vertex_dofs;
/**
- * Make accessor objects friends.
- */
- template <int, class, bool> friend class DoFAccessor;
- template <class, bool> friend class DoFCellAccessor;
+ * Make accessor objects friends.
+ */
+ template <int, class> friend class DoFAccessor;
+ template <class> friend class DoFCellAccessor;
friend struct dealii::internal::DoFAccessor::Implementation;
friend struct dealii::internal::DoFCellAccessor::Implementation;
projects / dealii-svn.git / commitdiff