Merge pull request #1949 from DLR-AMR/fix-typos

Other: Fix typos and indent doxygen comments

Author: sandro-elsweijer

example/IO/forest/netcdf/t8_write_forest_netcdf.cxx

@@ -54,13 +54,13 @@ T8_EXTERN_C_BEGIN ();
 */
 struct t8_example_netcdf_adapt_data
 {
-  t8_3D_point midpoint;             /* Midpoint of a aphere */
+  t8_3D_point midpoint;             /* Midpoint of a sphere */
   double refine_if_inside_radius;   /* refine all elements inside this radius from the sphere's midpoint */
   double coarsen_if_outside_radius; /* coarsen all element families outside of this radius from the sphere's midpoint */
 };
 
 /** This functions describe an adapt_function, an adapt_function describes the refinement/coarsening rules for a forest
-* \note If an element is inside a given radius from the midpoint of the hypercube, this element is refined. If a family of elements is outiside a given radius from the midpoint of the hypercube, it is coarsened. 
+* \note If an element is inside a given radius from the midpoint of the hypercube, this element is refined. If a family of elements is outside a given radius from the midpoint of the hypercube, it is coarsened. 
 * \note A detailed description of the adaption process is found in step 3 of the tutorial located in 't8code/example/tutorials'.
 */
 int
@@ -109,7 +109,7 @@ t8_example_netcdf_adapt (t8_forest_t forest)
 {
   t8_forest_t forest_adapt;
 
-  /* The adapt data which controls which elements will be refined or corsened based on the given radii */
+  /* The adapt data which controls which elements will be refined or coarsened based on the given radii */
   struct t8_example_netcdf_adapt_data adapt_data = {
     t8_3D_point ({ 0.5, 0.5, 0.5 }), /* Midpoints of the sphere. */
     0.2,                             /* Refine if inside this radius. */
@@ -195,7 +195,7 @@ t8_example_compare_performance_netcdf_var_properties (sc_MPI_Comm comm, int fore
   /* Construct a 3D hybrid hypercube as a cmesh */
   cmesh = t8_cmesh_new_hypercube_hybrid (comm, 1, 0);
 
-  /* Build a (partioined) uniform forest */
+  /* Build a (partitioned) uniform forest */
   forest = t8_forest_new_uniform (cmesh, default_scheme, forest_refinement_level, 0, comm);
 
   /* If the adapt_forest flag is set, the forest will be adapted */
@@ -343,12 +343,12 @@ t8_example_netcdf_write_forest (sc_MPI_Comm comm, int forest_refinement_level, i
 
   t8_global_productionf ("New cmesh was created\n");
 
-  /* Build a (partioined) uniform forest */
+  /* Build a (partitioned) uniform forest */
   forest = t8_forest_new_uniform (cmesh, default_scheme, level, 0, comm);
 
   t8_global_productionf ("New forest was created\n");
 
-  /* Eventually, adapt the forest (based on the flag aadapt_forest) */
+  /* Eventually, adapt the forest (based on the flag adapt_forest) */
   if (adapt_forest) {
     /** \note The forest is not repartitioned after the adapt-step.
    * Therefore, the workload may not be evenly distributed among the processes.

example/advect/t8_advection.cxx

@@ -112,10 +112,9 @@ typedef struct
     *element_data_adapt; /**< element_data for the adapted forest, used during adaptation to interpolate values */
   /* We store the phi values in an extra array, since this data must exist for ghost
    * element as well and is communicated with other processes in ghost_exchange. */
-  sc_array_t *phi_values; /**< For each element and ghost its phi value. */
-  sc_array_t
-    *phi_values_adapt; /**< phi values for the adapted forest, used during adaptaption to interpolate values. */
-  sc_MPI_Comm comm;    /**< MPI communicator used */
+  sc_array_t *phi_values;       /**< For each element and ghost its phi value. */
+  sc_array_t *phi_values_adapt; /**< phi values for the adapted forest, used during adaptation to interpolate values. */
+  sc_MPI_Comm comm;             /**< MPI communicator used */
   sc_statinfo_t stats[ADVECT_NUM_STATS]; /**< Runtimes and other statistics. */
   double t;                              /**< Current simulation time */
   double T;                              /**< End time */
@@ -142,7 +141,7 @@ typedef struct
   t8_3D_point midpoint;           /**< coordinates of element midpoint in R^3 */
   double vol;                     /**< Volume of this element */
   double phi_new;                 /**< Value of solution at midpoint in next time step */
-  double *fluxes[MAX_FACES];      /**< The fluxes to each neeighbor at a given face */
+  double *fluxes[MAX_FACES];      /**< The fluxes to each neighbor at a given face */
   int flux_valid[MAX_FACES];      /**< If > 0, this flux was computed, if 0 memory was allocated
                                                    for this flux, but not computed. If < 0, no memory was allocated. */
   int level;                      /**< The refinement level of the element. */
@@ -343,7 +342,7 @@ t8_advect_flux_upwind_1d (const t8_advect_problem_t *problem, const t8_locidx_t
   }
   /* Compute u at the interval boundary. */
   problem->u (x_j_half, problem->t, u_at_x_j_half);
-  /* In 1D we are only interested in the firs coordinate of u */
+  /* In 1D we are only interested in the first coordinate of u */
 
   sign = face == 0 ? -1 : 1;
   if (sign * u_at_x_j_half[0] >= 0) {
@@ -929,7 +928,7 @@ t8_advect_problem_init (t8_cmesh_t cmesh, t8_flow_function_3d_fn u, t8_example_l
   problem->num_time_steps = 0;            /* current time step */
   problem->comm = comm;                   /* MPI communicator */
   problem->vtk_count = 0;                 /* number of pvtu files written */
-  problem->band_width = band_width;       /* width of the refinemen band around 0 level-set */
+  problem->band_width = band_width;       /* width of the refinement band around 0 level-set */
   problem->dim = dim;                     /* dimension of the mesh */
   problem->dummy_op = dummy_op;           /* If true, emulate more computational load per element */
 

src/t8_forest/t8_forest_general.h

@@ -571,7 +571,7 @@ t8_forest_leaf_face_orientation (t8_forest_t forest, const t8_locidx_t ltreeid,
  * \note Important! This routine allocates memory which must be freed. Do it like this:
  *
  *   if (num_neighbors > 0) {
- *     scheme->element_destroy (pneigh_eclass, num_neighbors, neighbors);
+ *     scheme->element_destroy (pneigh_eclass, num_neighbors, pneighbor_leaves);
  *     T8_FREE (pneighbor_leaves);
  *     T8_FREE (pelement_indices);
  *     T8_FREE (dual_faces);
@@ -613,7 +613,7 @@ t8_forest_leaf_face_neighbors (t8_forest_t forest, t8_locidx_t ltreeid, const t8
  * \note Important! This routine allocates memory which must be freed. Do it like this:
  *
  *   if (num_neighbors > 0) {
- *     scheme->element_destroy (pneigh_eclass, num_neighbors, neighbors);
+ *     scheme->element_destroy (pneigh_eclass, num_neighbors, pneighbor_leaves);
  *     T8_FREE (pneighbor_leaves);
  *     T8_FREE (pelement_indices);
  *     T8_FREE (dual_faces);
@@ -913,7 +913,7 @@ t8_forest_new_uniform (t8_cmesh_t cmesh, const t8_scheme_c *scheme, const int le
 /** Build a adapted forest from another forest.
  * \param [in]    forest_from The forest to refine
  * \param [in]    adapt_fn    Adapt function to use
- * \param [in]    recursive   If true adptation is recursive
+ * \param [in]    recursive   If true adaptation is recursive
  * \param [in]    do_face_ghost If true, a layer of ghost elements is created for the forest.
  * \param [in]    user_data   If not NULL, the user data pointer of the forest is set to this value.
  * \return        A new forest that is adapted from \a forest_from.

src/t8_forest/t8_forest_ghost.cxx

@@ -90,7 +90,7 @@ typedef struct
 } t8_ghost_remote_tree_t;
 
 /**
- * This struct stores information about the data that the current process needds from a specific remote_process
+ * This struct stores information about the data that the current process needs from a specific remote_process
  * as ghost data, such as the number of remote elements and the remote trees.
 */
 typedef struct

src/t8_schemes/t8_default/t8_default_common/t8_default_common.hxx

@@ -235,8 +235,8 @@ class t8_default_scheme_common: public t8_scheme_helpers<TEclass, TUnderlyingEcl
   }
 
   /** Count how many leaf descendants of a given uniform level an element would produce.
-   * \param [in] element     The element to be checked.
-   * \param [in] level A refinement level.
+   * \param [in] element   The element to be checked.
+   * \param [in] level     A refinement level.
    * \return Suppose \a element is uniformly refined up to level \a level. The return value
    * is the resulting number of elements (of the given level).
    * Each default element (except pyramids) refines into 2^{dim * (level - level(t))}

src/t8_schemes/t8_default/t8_default_hex/t8_default_hex.hxx

@@ -359,7 +359,7 @@ class t8_default_scheme_hex: public t8_default_scheme_common<T8_ECLASS_HEX, t8_d
    *                        \see t8_cmesh_set_join
    *  \param [in] sign      Depending on the topological orientation of the two tree faces,
    *                        either 0 (both faces have opposite orientation)
-   *                        or 1 (both faces have the same top. orientattion).
+   *                        or 1 (both faces have the same top. orientation).
    *                        \ref t8_eclass_face_orientation
    *  \param [in] is_smaller_face Flag to declare whether \a elem1 belongs to
    *                        the smaller face. A face f of tree T is smaller than
@@ -491,7 +491,7 @@ class t8_default_scheme_hex: public t8_default_scheme_common<T8_ECLASS_HEX, t8_d
   element_get_last_descendant (const t8_element_t *elem, t8_element_t *desc, int level) const;
 
   /** Construct the successor in a uniform refinement of a given element.
-   * \param [in] elem    The element whose successor should be constructed.
+   * \param [in] elem      The element whose successor should be constructed.
    * \param [in,out] succ  The successor element whose entries will be set.
    */
   void
@@ -539,7 +539,7 @@ class t8_default_scheme_hex: public t8_default_scheme_common<T8_ECLASS_HEX, t8_d
    *  reference space of the tree.
    *
    * \param [in] elem         The element.
-   * \param [in] ref_coords The coordinates \f$ [0,1]^\mathrm{dim} \f$ of the point
+   * \param [in] ref_coords   The coordinates \f$ [0,1]^\mathrm{dim} \f$ of the point
    *                          in the reference space of the element.
    * \param [in] num_coords   Number of \f$ dim\f$-sized coordinates to evaluate.
    * \param [out] out_coords  The coordinates of the points in the
@@ -559,7 +559,7 @@ class t8_default_scheme_hex: public t8_default_scheme_common<T8_ECLASS_HEX, t8_d
 #if T8_ENABLE_DEBUG
   /** Query whether a given element can be considered as 'valid' and it is
    *  safe to perform any of the above algorithms on it.
-   * \param [in]      element  The element to be checked.
+   * \param [in] element  The element to be checked.
    * \return          True if \a element is safe to use. False otherwise.
    * \note            An element that is constructed with \ref element_new
    *                  must pass this test.
@@ -579,9 +579,9 @@ class t8_default_scheme_hex: public t8_default_scheme_common<T8_ECLASS_HEX, t8_d
   * and the level of the triangle. This function is only available in the
   * debugging configuration.
   *
-  * \param [in]        elem  The element to print
-  * \param [in]        debug_string  String printed to debug
-  * \param [in]        string_size  String size of \a debug_string.
+  * \param [in] elem          The element to print
+  * \param [in] debug_string  String printed to debug
+  * \param [in] string_size   String size of \a debug_string.
   */
   void
   element_to_string (const t8_element_t *elem, char *debug_string, const int string_size) const;
@@ -594,12 +594,12 @@ class t8_default_scheme_hex: public t8_default_scheme_common<T8_ECLASS_HEX, t8_d
   set_to_root (t8_element_t *elem) const;
 
   /** Pack multiple elements into contiguous memory, so they can be sent via MPI.
-   * \param [in] elements Array of elements that are to be packed
-   * \param [in] count Number of elements to pack
-   * \param [in,out] send_buffer Buffer in which to pack the elements
-   * \param [in] buffer_size size of the buffer (in order to check that we don't access out of range)
-   * \param [in, out] position the position of the first byte that is not already packed
-   * \param [in] comm MPI Communicator
+   * \param [in] elements         Array of elements that are to be packed
+   * \param [in] count            Number of elements to pack
+   * \param [in,out] send_buffer  Buffer in which to pack the elements
+   * \param [in] buffer_size      size of the buffer (in order to check that we don't access out of range)
+   * \param [in, out] position    the position of the first byte that is not already packed
+   * \param [in] comm             MPI Communicator
   */
   void
   element_MPI_Pack (t8_element_t **const elements, const unsigned int count, void *send_buffer, int buffer_size,
@@ -614,12 +614,12 @@ class t8_default_scheme_hex: public t8_default_scheme_common<T8_ECLASS_HEX, t8_d
   element_MPI_Pack_size (const unsigned int count, sc_MPI_Comm comm, int *pack_size) const;
 
   /** Unpack multiple elements from contiguous memory that was received via MPI.
-   * \param [in] recvbuf Buffer from which to unpack the elements
-   * \param [in] buffer_size size of the buffer (in order to check that we don't access out of range)
+   * \param [in] recvbuf       Buffer from which to unpack the elements
+   * \param [in] buffer_size   size of the buffer (in order to check that we don't access out of range)
    * \param [in, out] position the position of the first byte that is not already packed
-   * \param [in] elements Array of initialised elements that is to be filled from the message
-   * \param [in] count Number of elements to unpack
-   * \param [in] comm MPI Communicator
+   * \param [in] elements      Array of initialised elements that is to be filled from the message
+   * \param [in] count         Number of elements to unpack
+   * \param [in] comm          MPI Communicator
   */
   void
   element_MPI_Unpack (void *recvbuf, const int buffer_size, int *position, t8_element_t **elements,

src/t8_schemes/t8_default/t8_default_line/t8_default_line.hxx

@@ -371,7 +371,7 @@ class t8_default_scheme_line: public t8_default_scheme_common<T8_ECLASS_LINE, t8
    *                        \see t8_cmesh_set_join
    *  \param [in] sign      Depending on the topological orientation of the two tree faces,
    *                        either 0 (both faces have opposite orientation)
-   *                        or 1 (both faces have the same top. orientattion).
+   *                        or 1 (both faces have the same top. orientation).
    *                        \ref t8_eclass_face_orientation
    *  \param [in] is_smaller_face Flag to declare whether \a elem1 belongs to
    *                        the smaller face. A face f of tree T is smaller than
@@ -550,7 +550,7 @@ class t8_default_scheme_line: public t8_default_scheme_common<T8_ECLASS_LINE, t8
    *  reference space of the tree.
    *
    * \param [in] elem         The element.
-   * \param [in] ref_coords The coordinates \f$ [0,1]^\mathrm{dim} \f$ of the point
+   * \param [in] ref_coords   The coordinates \f$ [0,1]^\mathrm{dim} \f$ of the point
    *                          in the reference space of the element.
    * \param [in] num_coords   Number of \f$ dim\f$-sized coordinates to evaluate.
    * \param [out] out_coords  The coordinates of the points in the
@@ -590,9 +590,9 @@ class t8_default_scheme_line: public t8_default_scheme_common<T8_ECLASS_LINE, t8
   * and the level of the triangle. This function is only available in the
   * debugging configuration.
   *
-  * \param [in]        elem  The element to print
-  * \param [in]        debug_string  String printed to debug
-  * \param [in]        string_size  String size of \a debug_string.
+  * \param [in] elem          The element to print
+  * \param [in] debug_string  String printed to debug
+  * \param [in] string_size   String size of \a debug_string.
   */
   void
   element_to_string (const t8_element_t *elem, char *debug_string, const int string_size) const;
@@ -604,32 +604,32 @@ class t8_default_scheme_line: public t8_default_scheme_common<T8_ECLASS_LINE, t8
   set_to_root (t8_element_t *elem) const;
 
   /** Pack multiple elements into contiguous memory, so they can be sent via MPI.
-   * \param [in] elements Array of elements that are to be packed
-   * \param [in] count Number of elements to pack
-   * \param [in,out] send_buffer Buffer in which to pack the elements
-   * \param [in] buffer_size size of the buffer (in order to check that we don't access out of range)
-   * \param [in, out] position the position of the first byte that is not already packed
-   * \param [in] comm MPI Communicator
+   * \param [in] elements         Array of elements that are to be packed
+   * \param [in] count            Number of elements to pack
+   * \param [in,out] send_buffer  Buffer in which to pack the elements
+   * \param [in] buffer_size      size of the buffer (in order to check that we don't access out of range)
+   * \param [in, out] position    the position of the first byte that is not already packed
+   * \param [in] comm             MPI Communicator
   */
   void
   element_MPI_Pack (t8_element_t **const elements, const unsigned int count, void *send_buffer, int buffer_size,
                     int *position, sc_MPI_Comm comm) const;
 
   /** Determine an upper bound for the size of the packed message of \b count elements
-   * \param [in] count Number of elements to pack
-   * \param [in] comm MPI Communicator
+   * \param [in] count      Number of elements to pack
+   * \param [in] comm       MPI Communicator
    * \param [out] pack_size upper bound on the message size
   */
   void
   element_MPI_Pack_size (const unsigned int count, sc_MPI_Comm comm, int *pack_size) const;
 
   /** Unpack multiple elements from contiguous memory that was received via MPI.
-   * \param [in] recvbuf Buffer from which to unpack the elements
-   * \param [in] buffer_size size of the buffer (in order to check that we don't access out of range)
-   * \param [in, out] position the position of the first byte that is not already packed
-   * \param [in] elements Array of initialised elements that is to be filled from the message
-   * \param [in] count Number of elements to unpack
-   * \param [in] comm MPI Communicator
+   * \param [in] recvbuf        Buffer from which to unpack the elements
+   * \param [in] buffer_size    size of the buffer (in order to check that we don't access out of range)
+   * \param [in, out] position  the position of the first byte that is not already packed
+   * \param [in] elements       Array of initialised elements that is to be filled from the message
+   * \param [in] count          Number of elements to unpack
+   * \param [in] comm           MPI Communicator
   */
   void
   element_MPI_Unpack (void *recvbuf, const int buffer_size, int *position, t8_element_t **elements,