]> https://gitweb.dealii.org/ - dealii-svn.git/commitdiff
add structure to documentation
authorkanschat <kanschat@0785d39b-7218-0410-832d-ea1e28bc413d>
Fri, 9 Sep 2011 20:28:11 +0000 (20:28 +0000)
committerkanschat <kanschat@0785d39b-7218-0410-832d-ea1e28bc413d>
Fri, 9 Sep 2011 20:28:11 +0000 (20:28 +0000)
git-svn-id: https://svn.dealii.org/trunk@24298 0785d39b-7218-0410-832d-ea1e28bc413d

deal.II/include/deal.II/dofs/dof_tools.h

index 61e71f093c1232e897dd75b7fa536a36c1a853f0..fbdb26a2931c6c98e3c600bb4e6ee47bad9774f4 100644 (file)
@@ -1155,6 +1155,10 @@ namespace DoFTools
                             std::vector<bool>              &selected_dofs);
                                   //@}
 
+                                  /**
+                                   * @name Parallelization and domain decomposition
+                                   * @{
+                                   */
                                   /**
                                    * Flag all those degrees of
                                    * freedom which are on cells
@@ -1251,77 +1255,6 @@ namespace DoFTools
   extract_locally_relevant_dofs (const DH & dof_handler,
                                 IndexSet & dof_set);
 
-                                  /**
-                                   * Extract a vector that represents the
-                                   * constant modes of the DoFHandler for
-                                   * the components chosen by
-                                   * <tt>component_select</tt>.  The
-                                   * constant modes on a discretization are
-                                   * the null space of a Laplace operator
-                                   * on the selected components with
-                                   * Neumann boundary conditions
-                                   * applied. The null space is a necessary
-                                   * ingredient for obtaining a good AMG
-                                   * preconditioner when using the class
-                                   * TrilinosWrappers::PreconditionAMG.
-                                   * Since the ML AMG package only works on
-                                   * algebraic properties of the respective
-                                   * matrix, it has no chance to detect
-                                   * whether the matrix comes from a scalar
-                                   * or a vector valued problem. However, a
-                                   * near null space supplies exactly the
-                                   * needed information about these
-                                   * components.  The null space will
-                                   * consist of as many vectors as there
-                                   * are true arguments in
-                                   * <tt>component_select</tt>, each of
-                                   * which will be one in one vector component and
-                                   * zero in all others. We store this
-                                   * object in a vector of vectors, where
-                                   * the outer vector is of the size of the
-                                   * number of selected components, and
-                                   * each inner vector has as many
-                                   * components as there are (locally owned) degrees of
-                                   * freedom in the selected
-                                   * components. Note that any matrix
-                                   * associated with this null space must
-                                   * have been constructed using the same
-                                   * <tt>component_select</tt> argument,
-                                   * since the numbering of DoFs is done
-                                   * relative to the selected dofs, not to
-                                   * all dofs.
-                                   *
-                                   * The main reason for this
-                                   * program is the use of the
-                                   * null space with the
-                                   * AMG preconditioner.
-                                   */
-  template <class DH>
-  void
-  extract_constant_modes (const DH                        &dof_handler,
-                         const std::vector<bool>         &component_select,
-                         std::vector<std::vector<bool> > &constant_modes);
-
-                                  /**
-                                   * For each active cell of a DoFHandler
-                                   * or hp::DoFHandler, extract the active
-                                   * finite element index and fill the
-                                   * vector given as second argument. This
-                                   * vector is assumed to have as many
-                                   * entries as there are active cells.
-                                   *
-                                   * For non-hp DoFHandler objects given as
-                                   * first argument, the returned vector
-                                   * will consist of only zeros, indicating
-                                   * that all cells use the same finite
-                                   * element. For a hp::DoFHandler, the
-                                   * values may be different, though.
-                                   */
-  template <class DH>
-  void
-  get_active_fe_indices (const DH                  &dof_handler,
-                        std::vector<unsigned int> &active_fe_indices);
-
                                   /**
                                    * For each DoF, return in the output
                                    * array to which subdomain (as given by
@@ -1503,6 +1436,79 @@ namespace DoFTools
   dof_indices_with_subdomain_association (const DH           &dof_handler,
                                          const types::subdomain_id_t subdomain);
 
+                                  // @}
+
+                                  /**
+                                   * Extract a vector that represents the
+                                   * constant modes of the DoFHandler for
+                                   * the components chosen by
+                                   * <tt>component_select</tt>.  The
+                                   * constant modes on a discretization are
+                                   * the null space of a Laplace operator
+                                   * on the selected components with
+                                   * Neumann boundary conditions
+                                   * applied. The null space is a necessary
+                                   * ingredient for obtaining a good AMG
+                                   * preconditioner when using the class
+                                   * TrilinosWrappers::PreconditionAMG.
+                                   * Since the ML AMG package only works on
+                                   * algebraic properties of the respective
+                                   * matrix, it has no chance to detect
+                                   * whether the matrix comes from a scalar
+                                   * or a vector valued problem. However, a
+                                   * near null space supplies exactly the
+                                   * needed information about these
+                                   * components.  The null space will
+                                   * consist of as many vectors as there
+                                   * are true arguments in
+                                   * <tt>component_select</tt>, each of
+                                   * which will be one in one vector component and
+                                   * zero in all others. We store this
+                                   * object in a vector of vectors, where
+                                   * the outer vector is of the size of the
+                                   * number of selected components, and
+                                   * each inner vector has as many
+                                   * components as there are (locally owned) degrees of
+                                   * freedom in the selected
+                                   * components. Note that any matrix
+                                   * associated with this null space must
+                                   * have been constructed using the same
+                                   * <tt>component_select</tt> argument,
+                                   * since the numbering of DoFs is done
+                                   * relative to the selected dofs, not to
+                                   * all dofs.
+                                   *
+                                   * The main reason for this
+                                   * program is the use of the
+                                   * null space with the
+                                   * AMG preconditioner.
+                                   */
+  template <class DH>
+  void
+  extract_constant_modes (const DH                        &dof_handler,
+                         const std::vector<bool>         &component_select,
+                         std::vector<std::vector<bool> > &constant_modes);
+
+                                  /**
+                                   * For each active cell of a DoFHandler
+                                   * or hp::DoFHandler, extract the active
+                                   * finite element index and fill the
+                                   * vector given as second argument. This
+                                   * vector is assumed to have as many
+                                   * entries as there are active cells.
+                                   *
+                                   * For non-hp DoFHandler objects given as
+                                   * first argument, the returned vector
+                                   * will consist of only zeros, indicating
+                                   * that all cells use the same finite
+                                   * element. For a hp::DoFHandler, the
+                                   * values may be different, though.
+                                   */
+  template <class DH>
+  void
+  get_active_fe_indices (const DH                  &dof_handler,
+                        std::vector<unsigned int> &active_fe_indices);
+
                                   /**
                                    * Count how many degrees of
                                    * freedom out of the total

In the beginning the Universe was created. This has made a lot of people very angry and has been widely regarded as a bad move.

Douglas Adams


Typeset in Trocchi and Trocchi Bold Sans Serif.