]> https://gitweb.dealii.org/ - dealii.git/commitdiff
wrapcomments 443/head
authorTimo Heister <timo.heister@gmail.com>
Wed, 14 Jan 2015 18:18:25 +0000 (13:18 -0500)
committerTimo Heister <timo.heister@gmail.com>
Wed, 14 Jan 2015 18:18:25 +0000 (13:18 -0500)
15 files changed:
include/deal.II/dofs/dof_handler.h
include/deal.II/dofs/dof_objects.h
include/deal.II/dofs/dof_renumbering.h
include/deal.II/grid/grid_tools.h
include/deal.II/grid/intergrid_map.h
include/deal.II/grid/tria_iterator.h
include/deal.II/lac/parallel_vector.h
include/deal.II/lac/petsc_parallel_sparse_matrix.h
include/deal.II/lac/relaxation_block.h
include/deal.II/lac/solver_control.h
include/deal.II/lac/trilinos_sparse_matrix.h
include/deal.II/meshworker/dof_info.h
include/deal.II/multigrid/mg_smoother.h
include/deal.II/numerics/data_postprocessor.h
include/deal.II/numerics/fe_field_function.h

index 2f1b392e26deb750f429c5a14dfef08fa982c37b..f9dafbee2f252a0733297659c92df2a5972062dc 100644 (file)
@@ -725,10 +725,10 @@ public:
    *
    * 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. If you have previously called distribute_mg_dofs(),
-   * the same is done on each level of the multigrid hierarchy. Additionally,
-   * the block structure on each cell can be generated in this object by
-   * calling initialize_local_block_info().
+   * here. If you have previously called distribute_mg_dofs(), the same is
+   * done on each level of the multigrid hierarchy. Additionally, the block
+   * structure on each cell can be generated in this object by calling
+   * initialize_local_block_info().
    */
   const BlockInfo &block_info() const;
 
index 7fd4b1420c3ab4196992c45ba6ba0e251fd02a2a..0ca9e6600dd94312b7088d9e2d6e57dac16753c8 100644 (file)
@@ -142,8 +142,8 @@ namespace internal
                      const unsigned int version);
 
       /**
-       * Declare the classes that store levels and faces of DoFs
-       * friends so that they can resize arrays.
+       * Declare the classes that store levels and faces of DoFs friends so
+       * that they can resize arrays.
        */
       template <int> friend class DoFLevel;
       template <int> friend class DoFFaces;
index c7c1836b0f6882998b66de47986438a3233599f4..2a8b0c87912ef0d1315ac7131af9416f87a151e2 100644 (file)
@@ -925,8 +925,8 @@ namespace DoFRenumbering
   /**
    * This function computes the renumbering vector on each level needed by the
    * sort_selected_dofs_back() function. Does not perform the renumbering on
-   * the DoFHandler dofs but only computes the renumbering and returns
-   * the renumbering vector.
+   * the DoFHandler dofs but only computes the renumbering and returns the
+   * renumbering vector.
    *
    * @pre The @p selected_dofs array must have as many elements as the @p
    * dof_handler has degrees of freedom on the given level.
index 5946c65fedb421a38d2157880b7024c58dad801e..6c458a0401c26db201f5d67a5fb649e48be3a416 100644 (file)
@@ -707,11 +707,11 @@ namespace GridTools
 
   /**
    * Given two mesh containers (i.e. objects of type Triangulation,
-   * DoFHandler, or hp::DoFHandler) that are based on the same
-   * coarse mesh, this function figures out a set of cells that are matched
-   * between the two meshes and where at most one of the meshes is more
-   * refined on this cell. In other words, it finds the smallest cells that
-   * are common to both meshes, and that together completely cover the domain.
+   * DoFHandler, or hp::DoFHandler) that are based on the same coarse mesh,
+   * this function figures out a set of cells that are matched between the two
+   * meshes and where at most one of the meshes is more refined on this cell.
+   * In other words, it finds the smallest cells that are common to both
+   * meshes, and that together completely cover the domain.
    *
    * This function is useful, for example, in time-dependent or nonlinear
    * application, where one has to integrate a solution defined on one mesh
@@ -756,8 +756,8 @@ namespace GridTools
 
   /**
    * The same function as above, but working on arguments of type DoFHandler,
-   * or hp::DoFHandler. This function is provided to allow
-   * calling have_same_coarse_mesh for all types of containers representing
+   * or hp::DoFHandler. This function is provided to allow calling
+   * have_same_coarse_mesh for all types of containers representing
    * triangulations or the classes built on triangulations.
    *
    * @tparam Container A type that satisfies the requirements of a mesh
@@ -1152,20 +1152,19 @@ namespace GridTools
   /*@{*/
 
   /**
-   * Copy boundary ids to manifold ids. The default manifold_id for
-   * new Triangulation objects is numbers::invalid_manifold_id. This
-   * function copies the boundary_ids of the boundary faces to the
-   * manifold_ids of the same faces, allowing the user to change the
-   * boundary_ids and use them for boundary conditions regardless of
-   * the geometry, which will use manifold_ids to create new
-   * points. Only active cells will be iterated over. This is a
-   * function you'd typically call when there is only one active level
-   * on your Triangulation.
-   *
-   * The optional parameter @p reset_boundary_ids, indicates wether
-   * this function should reset the boundary_ids of the Triangulation
-   * to its default value 0 after copying its value to the
-   * manifold_id. By default, boundary_ids are left untouched.
+   * Copy boundary ids to manifold ids. The default manifold_id for new
+   * Triangulation objects is numbers::invalid_manifold_id. This function
+   * copies the boundary_ids of the boundary faces to the manifold_ids of the
+   * same faces, allowing the user to change the boundary_ids and use them for
+   * boundary conditions regardless of the geometry, which will use
+   * manifold_ids to create new points. Only active cells will be iterated
+   * over. This is a function you'd typically call when there is only one
+   * active level on your Triangulation.
+   *
+   * The optional parameter @p reset_boundary_ids, indicates wether this
+   * function should reset the boundary_ids of the Triangulation to its
+   * default value 0 after copying its value to the manifold_id. By default,
+   * boundary_ids are left untouched.
    *
    * @ingroup manifold
    * @ingroup boundary
@@ -1177,33 +1176,31 @@ namespace GridTools
                                     const bool reset_boundary_ids=false);
 
   /**
-   * Copy material ids to manifold ids. The default manifold_id for
-   * new Triangulation objects is numbers::invalid_manifold_id. When
-   * refinements occurs, the Triangulation asks where to locate new
-   * points to the underlying manifold.
-   *
-   * When reading a Triangulation from a supported input format,
-   * typical informations that can be stored in a file are boundary
-   * conditions for boundary faces (which we store in the boundary_id
-   * of the faces), material types for cells (which we store in the
-   * material_id of the cells) and in some cases subdomain ids for
-   * cells (which we store in the subdomain_id of the cell).
-   *
-   * If you read one of these grids into a Triangulation, you might
-   * still want to use the material_id specified in the input file as
-   * a manifold_id description. In this case you can associate a
-   * Manifold object to internal cells, and this object will be used
-   * by the Triangulation to query Manifold objects for new
-   * points. This function iterates over active cells and copies the
-   * material_ids to the manifold_ids.
+   * Copy material ids to manifold ids. The default manifold_id for new
+   * Triangulation objects is numbers::invalid_manifold_id. When refinements
+   * occurs, the Triangulation asks where to locate new points to the
+   * underlying manifold.
+   *
+   * When reading a Triangulation from a supported input format, typical
+   * informations that can be stored in a file are boundary conditions for
+   * boundary faces (which we store in the boundary_id of the faces), material
+   * types for cells (which we store in the material_id of the cells) and in
+   * some cases subdomain ids for cells (which we store in the subdomain_id of
+   * the cell).
+   *
+   * If you read one of these grids into a Triangulation, you might still want
+   * to use the material_id specified in the input file as a manifold_id
+   * description. In this case you can associate a Manifold object to internal
+   * cells, and this object will be used by the Triangulation to query
+   * Manifold objects for new points. This function iterates over active cells
+   * and copies the material_ids to the manifold_ids.
    *
    * The optional parameter @p compute_face_ids, indicates wether this
-   * function should also set the manifold_ids of the faces (both for
-   * internal faces and for faces on the boundary). If set to true,
-   * then each face will get a manifold_id equal to the minimum of the
-   * surrounding manifold_ids, ensuring that a unique manifold id is
-   * selected for each face of the Triangulation. By default, face
-   * manifold_ids are not computed.
+   * function should also set the manifold_ids of the faces (both for internal
+   * faces and for faces on the boundary). If set to true, then each face will
+   * get a manifold_id equal to the minimum of the surrounding manifold_ids,
+   * ensuring that a unique manifold id is selected for each face of the
+   * Triangulation. By default, face manifold_ids are not computed.
    *
    * @ingroup manifold
    *
index 948487c8852398dcc0e849c799687571dd0692e5..76986ecebfc50948597134867355e4a1cb5e0868 100644 (file)
@@ -68,14 +68,13 @@ DEAL_II_NAMESPACE_OPEN
  *
  * The implementation of this class is such that not only cell iterators into
  * triangulations can be mapped, but also iterators into objects of type
- * DoFHandler or hp::DoFHandler. The extension to other classes
- * offering iterator functions and some minor additional requirements is
- * simple.
+ * DoFHandler or hp::DoFHandler. The extension to other classes offering
+ * iterator functions and some minor additional requirements is simple.
  *
  * Note that this class could in principle be based on the C++
- * <tt>std::map<Key,Value></tt> data type. Instead, it uses another data format
- * which is more effective both in terms of computing time for access as well
- * as with regard to memory consumpion.
+ * <tt>std::map<Key,Value></tt> data type. Instead, it uses another data
+ * format which is more effective both in terms of computing time for access
+ * as well as with regard to memory consumpion.
  *
  *
  * <h3>Usage</h3>
index c8fae28017eb3dc1b6b1358b14f4c5246873141d..4036909527f49652f248577aaa7dabdc5b666c74 100644 (file)
@@ -161,8 +161,8 @@ template <typename> class TriaActiveIterator;
  * but you may write your own version (non-virtual, since we use templates) to
  * add functionality.
  *
- * The accessors provided by the library consists of two groups,
- * determined by whether they access the data of Triangulation objects or
+ * The accessors provided by the library consists of two groups, determined by
+ * whether they access the data of Triangulation objects or
  * DoFHandler/hp::DoFHandler objects. They are derived from TriaAccessor and
  * DoFAccessor, respectively. Each group also has specialized accessors for
  * cells (as opposed to faces and lines) that offer more functionality such as
index 1d9c472316e4a4a7a40f9e5ef786530f4780464e..a657fa6e5f81eb5fe8901d08e5084bc3deda969b 100644 (file)
@@ -73,47 +73,45 @@ namespace parallel
      * The vector is designed for the following scheme of parallel
      * partitioning:
      * <ul>
-     * <li> The indices held by individual processes
-     * (locally owned part) in the MPI parallelization form a contiguous range
+     * <li> The indices held by individual processes (locally owned part) in
+     * the MPI parallelization form a contiguous range
      * <code>[my_first_index,my_last_index)</code>.
-     * <li> Ghost indices
-     * residing on arbitrary positions of other processors are allowed. It is
-     * in general more efficient if ghost indices are clustered, since they
-     * are stored as a set of intervals. The communication pattern of the
-     * ghost indices is determined when calling the function <code>reinit
-     * (locally_owned, ghost_indices, communicator)</code>, and retained until
-     * the partitioning is changed. This allows for efficient parallel
-     * communication of indices. In particular, it stores the communication
-     * pattern, rather than having to compute it again for every
-     * communication. For more information on ghost vectors, see also the
+     * <li> Ghost indices residing on arbitrary positions of other processors
+     * are allowed. It is in general more efficient if ghost indices are
+     * clustered, since they are stored as a set of intervals. The
+     * communication pattern of the ghost indices is determined when calling
+     * the function <code>reinit (locally_owned, ghost_indices,
+     * communicator)</code>, and retained until the partitioning is changed.
+     * This allows for efficient parallel communication of indices. In
+     * particular, it stores the communication pattern, rather than having to
+     * compute it again for every communication. For more information on ghost
+     * vectors, see also the
      * @ref GlossGhostedVector "glossary entry on vectors with ghost elements".
-     * <li> Besides the usual global access operator() it is also
-     * possible to access vector entries in the local index space with the
-     * function @p local_element(). Locally owned indices are placed first,
-     * [0, local_size()), and then all ghost indices follow after them
+     * <li> Besides the usual global access operator() it is also possible to
+     * access vector entries in the local index space with the function @p
+     * local_element(). Locally owned indices are placed first, [0,
+     * local_size()), and then all ghost indices follow after them
      * contiguously, [local_size(), local_size()+n_ghost_entries()).
      * </ul>
      *
      * Functions related to parallel functionality:
      * <ul>
-     * <li> The function
-     * <code>compress()</code> goes through the data associated with ghost
-     * indices and communicates it to the owner process, which can then add it
-     * to the correct position. This can be used e.g. after having run an
-     * assembly routine involving ghosts that fill this vector. Note that the
-     * @p insert mode of @p compress() does not set the elements included in
-     * ghost entries but simply discards them, assuming that the owning
-     * processor has set them to the desired value already (See also the
+     * <li> The function <code>compress()</code> goes through the data
+     * associated with ghost indices and communicates it to the owner process,
+     * which can then add it to the correct position. This can be used e.g.
+     * after having run an assembly routine involving ghosts that fill this
+     * vector. Note that the @p insert mode of @p compress() does not set the
+     * elements included in ghost entries but simply discards them, assuming
+     * that the owning processor has set them to the desired value already
+     * (See also the
      * @ref GlossCompress "glossary entry on compress").
-     * <li> The
-     * <code>update_ghost_values()</code> function imports the data from the
-     * owning processor to the ghost indices in order to provide read access
-     * to the data associated with ghosts.
-     * <li> It is possible to split the
-     * above functions into two phases, where the first initiates the
-     * communication and the second one finishes it. These functions can be
-     * used to overlap communication with computations in other parts of the
-     * code.
+     * <li> The <code>update_ghost_values()</code> function imports the data
+     * from the owning processor to the ghost indices in order to provide read
+     * access to the data associated with ghosts.
+     * <li> It is possible to split the above functions into two phases, where
+     * the first initiates the communication and the second one finishes it.
+     * These functions can be used to overlap communication with computations
+     * in other parts of the code.
      * <li> Of course, reduction operations (like norms) make use of
      * collective all-to-all MPI communications.
      * </ul>
@@ -121,9 +119,9 @@ namespace parallel
      * This vector can take two different states with respect to ghost
      * elements:
      * <ul>
-     * <li> After creation and whenever zero_out_ghosts() is
-     * called (or <code>operator= (0.)</code>), the vector does only allow
-     * writing into ghost elements but not reading from ghost elements.
+     * <li> After creation and whenever zero_out_ghosts() is called (or
+     * <code>operator= (0.)</code>), the vector does only allow writing into
+     * ghost elements but not reading from ghost elements.
      * <li> After a call to update_ghost_values(), the vector does not allow
      * writing into ghost elements but only reading from them. This is to
      * avoid undesired ghost data artifacts when calling compress() after
index 8830fc83380fc11e57f72c6f1cdf21378b463656..c7a14049d5760885d640d6d37425656b2b4316cc 100644 (file)
@@ -326,8 +326,9 @@ namespace PETScWrappers
                    const MPI_Comm                  &communicator);
 
       /**
-       * Initialize this matrix to have the same structure as @p other. This will not copy
-       * the values of the other matrix, but you can use copy_from() for this.
+       * Initialize this matrix to have the same structure as @p other. This
+       * will not copy the values of the other matrix, but you can use
+       * copy_from() for this.
        */
       void reinit (const SparseMatrix &other);
 
index 939fb09bb08d229688a2cbddb52c1fa51550bac8..b2a2c071f6fcdb1b1231720fc25bcde2b9f19401 100644 (file)
@@ -220,10 +220,10 @@ protected:
  *
  * This class implements the step() and Tstep() functions expected by
  * SolverRelaxation and MGSmootherRelaxation. They perform an additive Schwarz
- * method on the blocks provided in the block list of AdditionalData. Differing
- * from PreconditionBlockJacobi, these blocks may be of varying size, non-
- * contiguous, and overlapping. On the other hand, this class does not
- * implement the preconditioner interface expected by Solver objects.
+ * method on the blocks provided in the block list of AdditionalData.
+ * Differing from PreconditionBlockJacobi, these blocks may be of varying
+ * size, non- contiguous, and overlapping. On the other hand, this class does
+ * not implement the preconditioner interface expected by Solver objects.
  *
  * @ingroup Preconditioners
  * @author Guido Kanschat
@@ -383,9 +383,9 @@ public:
  *
  * This class implements the step() and Tstep() functions expected by
  * SolverRelaxation and MGSmootherRelaxation. They perform a multiplicative
- * Schwarz method on the blocks provided in the block list of AdditionalData in
- * symmetric fashion. Differing from PreconditionBlockSSOR, these blocks may
- * be of varying size, non-contiguous, and overlapping. On the other hand,
+ * Schwarz method on the blocks provided in the block list of AdditionalData
+ * in symmetric fashion. Differing from PreconditionBlockSSOR, these blocks
+ * may be of varying size, non-contiguous, and overlapping. On the other hand,
  * this class does not implement the preconditioner interface expected by
  * Solver objects.
  *
index b7f64bd13d49f832d58805153bbbd8fcbae149fe..f8d6c58bcbc32fd9bd3c1d568812419c696c7b78 100644 (file)
@@ -179,8 +179,8 @@ public:
    * value (@p NaN). Note, however, that this check is only performed if the
    * @p isnan function is provided by the operating system, which is not
    * always true. The @p configure scripts checks for this and sets the flag
-   * @p DEAL_II_HAVE_ISNAN in the include file
-   * <tt>deal.II/base/config.h</tt> if this function was found.
+   * @p DEAL_II_HAVE_ISNAN in the include file <tt>deal.II/base/config.h</tt>
+   * if this function was found.
    *
    * <tt>check()</tt> additionally preserves @p step and @p check_value. These
    * values are accessible by <tt>last_value()</tt> and <tt>last_step()</tt>.
index 3fc27d1e6cc5e129bd4138aa1782a81ffe2f5dab..aefbecc70dfaaf36d658ac2c2770c1c1a8e43f47 100644 (file)
@@ -599,9 +599,9 @@ namespace TrilinosWrappers
     void reinit (const SparsityPattern &sparsity_pattern);
 
     /**
-     * This function copies the layout of @p sparse_matrix to the
-     * calling matrix. The values are not copied, but you can use
-     * copy_from() for this.
+     * This function copies the layout of @p sparse_matrix to the calling
+     * matrix. The values are not copied, but you can use copy_from() for
+     * this.
      *
      * This is a collective operation that needs to be called on all
      * processors in order to avoid a dead lock.
index 6bc11b43781173cafbb0cbb3e357fba12b9cd8fe..6316eb80d5b713ed4b80bd2c069e2bc2a1751bdb 100644 (file)
@@ -77,16 +77,16 @@ namespace MeshWorker
     /**
      * The number of the current face on the current cell.
      *
-     * This number is numbers::invalid_unsigned_int if the info object
-     * was initialized with a cell.
+     * This number is numbers::invalid_unsigned_int if the info object was
+     * initialized with a cell.
      */
     unsigned int face_number;
 
     /**
      * The number of the current subface on the current face
      *
-     * This number is numbers::invalid_unsigned_int if the info object
-     * was not initialized with a subface.
+     * This number is numbers::invalid_unsigned_int if the info object was not
+     * initialized with a subface.
      */
     unsigned int sub_number;
 
index 87b5da9ee14723ea34d6dc09443aebe10e8e708a..ee925555d0b7fb07d65fbf39a00aeda8ab7d6ce2 100644 (file)
@@ -85,9 +85,8 @@ protected:
   /**
    * A memory object to be used for temporary vectors.
    *
-   * The object is marked as mutable since we will need to use it
-   * to allocate temporary vectors also in functions that are
-   * const.
+   * The object is marked as mutable since we will need to use it to allocate
+   * temporary vectors also in functions that are const.
    */
   mutable GrowingVectorMemory<VECTOR> vector_memory;
 
index 5d609e0e3d61b708460c951139fa40024d0de883..836c90d932d36be47510d244a21bb88db00c21ef 100644 (file)
@@ -114,9 +114,9 @@ class DataPostprocessor: public Subscriptor
 {
 public:
   /**
-   * Destructor. This function doesn't actually do anything but
-   * is marked as virtual to ensure that data postprocessors can
-   * be destroyed through pointers to the base class.
+   * Destructor. This function doesn't actually do anything but is marked as
+   * virtual to ensure that data postprocessors can be destroyed through
+   * pointers to the base class.
    */
   virtual ~DataPostprocessor ();
 
index 9a46997c3efb8aab2be10de61a678851b47bb47c..c8ad4ca82ceba9d8bf2dc2aff196d1cb5247496d 100644 (file)
@@ -54,8 +54,8 @@ namespace Functions
    *
    * Once the FEFieldFunction knows where the points lie, it creates a
    * quadrature formula for those points, and calls
-   * FEValues::get_function_values or FEValues::get_function_gradients with the
-   * given quadrature points.
+   * FEValues::get_function_values or FEValues::get_function_gradients with
+   * the given quadrature points.
    *
    * If you only need the quadrature points but not the values of the finite
    * element function (you might want this for the adjoint interpolation), you

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.