]> https://gitweb.dealii.org/ - dealii.git/commitdiff
Fix typos caught by the typos program. 15386/head
authorDavid Wells <drwells@email.unc.edu>
Tue, 20 Jun 2023 14:10:04 +0000 (10:10 -0400)
committerDavid Wells <drwells@email.unc.edu>
Tue, 20 Jun 2023 16:45:11 +0000 (12:45 -0400)
39 files changed:
contrib/python-bindings/source/export_mapping.cc
contrib/python-bindings/source/export_triangulation.cc
contrib/python-bindings/source/triangulation_wrapper.cc
contrib/utilities/indent.py
doc/news/changes/incompatibilities/20221211Munch
doc/news/changes/incompatibilities/20230511Turcksin
doc/news/changes/minor/20230118Heinz
examples/step-27/doc/results.dox
examples/step-44/step-44.cc
examples/step-50/doc/results.dox
examples/step-50/step-50.cc
examples/step-69/doc/results.dox
examples/step-82/step-82.cc
include/deal.II/base/config.h.in
include/deal.II/base/hdf5.h
include/deal.II/base/mpi.h
include/deal.II/base/parsed_convergence_table.h
include/deal.II/base/time_stepping.templates.h
include/deal.II/base/vectorization.h
include/deal.II/fe/fe_series.h
include/deal.II/fe/fe_tools.h
include/deal.II/lac/lapack_full_matrix.h
include/deal.II/lac/petsc_precondition.h
include/deal.II/lac/scalapack.h
include/deal.II/lac/solver_gmres.h
include/deal.II/matrix_free/cuda_fe_evaluation.h
include/deal.II/matrix_free/cuda_matrix_free.h
include/deal.II/matrix_free/matrix_free.h
include/deal.II/multigrid/mg_transfer_global_coarsening.templates.h
include/deal.II/numerics/data_out_dof_data.templates.h
include/deal.II/numerics/rtree.h
source/CMakeLists.txt
source/base/data_out_base.cc
source/dofs/dof_tools.cc
source/fe/fe_dg_vector.cc
source/grid/grid_generator.cc
source/lac/scalapack.cc
source/multigrid/mg_tools.cc
source/numerics/smoothness_estimator.cc

index ea94e3d8555e520db4cab437ad20350388609d5f..c932e2c689c9e1a640d849a8993ea17284f3d195 100644 (file)
@@ -37,7 +37,7 @@ namespace python
     " face with the given face number face_no. Ideally the point is     \n"
     " near the face face_no, but any point in the cell can technically  \n"
     " be projected. The returned point is of dimension dim with         \n"
-    " dim-1 coodinate value explicitly set to zero.                     \n";
+    " dim-1 coordinate value explicitly set to zero.                    \n";
 
 
   void
index a8ca3380a00af34f2d7e85dadec949f1f28fe058..15a432b7755dd130d7eb4d24093454576dd7c749 100644 (file)
@@ -229,8 +229,8 @@ namespace python
     "with respect to the origin. Additional points are sums of these dim    \n"
     "vectors. Colorizing is done according to hyper_rectangle().            \n"
     "Note: This function silently reorders the vertices on the cells to     \n"
-    "lexicographic ordering (see GridReordering::reoder_grid()). In other   \n"
-    "words, if reordering of the vertices does occur, the ordering of       \n"
+    "lexicographic ordering (see GridTools::consistently_order_cells()). In \n"
+    "other words, if reordering of the vertices does occur, the ordering of \n"
     "vertices in the array of corners will no longer refer to the same      \n"
     "triangulation.                                                         \n";
 
index 2a7d9dfe4dbd42383c3b8c1a52ca8e700923f7b9..5eb2bb611e41cc0e9736f64d77458cb699630458 100644 (file)
@@ -1191,7 +1191,7 @@ namespace python
     AssertThrow(
       spacedim == dim,
       ExcMessage(
-        "This function is only implementd for dim equal to spacedim."));
+        "This function is only implemented for dim equal to spacedim."));
     // Extract the PointWrapper object from the python list
     const int size = boost::python::len(vertices);
     AssertThrow(size > 0, ExcMessage("The vertices list is empty."));
@@ -1718,7 +1718,7 @@ namespace python
     else
       AssertThrow(false,
                   ExcMessage(
-                    "Thie combination of dim-spacedim is not supported."));
+                    "This combination of dim-spacedim is not supported."));
   }
 
 
index d437e023f6e9c0cf49990d93b789d540e3f3d1fe..4a445203fb7fa1f7e3e77f0b1926c59733743f53 100644 (file)
@@ -276,7 +276,7 @@ def process(arguments):
     # Blocks (some) threads until all the threads finished their tasks.
     # Works similar to MPI_Barrier().
     # In other words, threads wait until all the tasks in task_queue
-    # have finshed.
+    # have finished.
     #
     task_queue.join()
 
index 5c6f5448e14790fed758761adba2d0813b499e74..bba77cd82b6d060a171e2ded0a1657ec5992b3cf 100644 (file)
@@ -1,9 +1,9 @@
-Fixed: The function ParamerHandler::add_parameter() used to
+Fixed: The function ParameterHandler::add_parameter() used to
 call the internal action. Within that step, the action
 converts the default value to a string and back afterwards.
 This can lead to round-off errors so that the default
 values might change in the case of floating-point numbers.
-The action is not called any more during ParamerHandler::add_parameter(),
+The action is not called any more during ParameterHandler::add_parameter(),
 fixing the problem.
 <br>
 (Peter Munch, Magdalena Schreter, 2022/12/11)
index b6971dd72abad581513406fcff70e65b777a9e21..dcac6cc7adb2ff6aabf94dd0abbfbd7724d17c62 100644 (file)
@@ -1,3 +1,3 @@
-Extensive rework of CUDAWrappers::MatrixFree and CUDAWrappers::FEEvalution.
+Extensive rework of CUDAWrappers::MatrixFree and CUDAWrappers::FEEvaluation.
 <br>
 (Bruno Turcksin, 2023/05/11)
index 011d2a0d70a5657842e997913e209093782dd263..baa1e870f91ebed990084f842bd121d05bb83889 100644 (file)
@@ -1,4 +1,4 @@
 Improved: Introduce a function that only checks if Bounding Boxes are overlapping.
-Fixed: If a 1D BBox is completely contained in another one, it was not recognized as mergable neighbor.
+Fixed: If a 1D BBox is completely contained in another one, it was not recognized as mergeable neighbor.
 <br>
 (Johannes Heinz, 2022/07/07)
index 2285c905adf62cc7569832793a5b1a0bfb372abd..bd4bc18e0b4347303e11f9b55f8c1b437ca8e5b9 100644 (file)
@@ -296,6 +296,6 @@ it, we recommend reading step-18 for the former and step-40 for the
 latter case first for further background information on the topic, and
 then come back to this tutorial to try out your newly acquired skills.
 
-We go one step further in step-75: Here, we combine hp-adapative and
+We go one step further in step-75: Here, we combine hp-adaptive and
 MatrixFree methods in combination with
 parallel::distributed::Triangulation objects.
index 800c457a06534bc86a3d0f484f821313fc0c5e3f..056c1a9ea722e8fa345603418788a0038563402d 100644 (file)
@@ -73,7 +73,7 @@
 
 // Defined in these two headers are some operations that are pertinent to
 // finite strain elasticity. The first will help us compute some kinematic
-// quantities, and the second provides some stanard tensor definitions.
+// quantities, and the second provides some standard tensor definitions.
 #include <deal.II/physics/elasticity/kinematics.h>
 #include <deal.II/physics/elasticity/standard_tensors.h>
 
index 64a5b1095bae704aba6276bcbc70dfbbce3e3fa5..f344529403e5252caf64f019e1254ad588489dad 100644 (file)
@@ -293,7 +293,7 @@ matrix in 2d, and a $27\times 27$ matrix in 3d; for the coarse mesh we
 use on the $L$-shaped domain of the current program, these sizes are
 $21\times 21$ in 2d and $117\times 117$ in 3d. But if the coarse mesh
 consists of hundreds or thousands of cells, this approach will no
-longer work and might start to dominate the overall run-time of each V-cyle.
+longer work and might start to dominate the overall run-time of each V-cycle.
 A common approach is then to solve the coarse mesh problem using an
 algebraic multigrid preconditioner; this would then, however, require
 assembling the coarse matrix (even for the matrix-free version) as
index ad560b96e8d562007a336d599831a0585be62908..8a58c77b19a15642e17d39ac4545e2a642a419a1 100644 (file)
@@ -909,7 +909,7 @@ void LaplaceProblem<dim, degree>::assemble_multigrid()
 // This function has two parts in the integration loop: applying the negative
 // of matrix $A$ to $u_0$ by submitting the negative of the gradient, and adding
 // the right-hand side contribution by submitting the value $f$. We must be sure
-// to use `read_dof_values_plain()` for evaluating $u_0$ as `read_dof_vaues()`
+// to use `read_dof_values_plain()` for evaluating $u_0$ as `read_dof_values()`
 // would set all Dirichlet values to zero.
 //
 // Finally, the system_rhs vector is of type LA::MPI::Vector, but the
index fae5d89c3f648f83f02fea2d81ce9c578488f9a4..4677771529f98f759796cdb4afab673aad8a84dd 100644 (file)
@@ -199,7 +199,7 @@ One can also with relative ease further extend this to the 3d case:
 Solving this becomes expensive, however: The simulation was done with
 1,817 million degrees of freedom (continuous $Q_1$ finite elements)
 per component (for a total of 9.09 billion spatial degrees of freedom)
-and ran on 30,720 MPI ranks. The code achieved an average througput of
+and ran on 30,720 MPI ranks. The code achieved an average throughput of
 969M grid points per second (0.04M gridpoints per second per CPU). The
 front and back wall show a "Schlieren plot": the magnitude of the
 gradient of the density on an exponential scale from white (low) to
index 398f2ad44150fc02bd05b646ed73cd2ea146d165..7e40cb38cf7800628da8cfa7096ef1451ae22aef 100644 (file)
@@ -1351,7 +1351,7 @@ namespace Step82
     // neighboring <code>neighbor_cell</code> of <code>cell</code>, namely we
     // fill-in the variable <code>discrete_hessians_neigh[face_no][i][q]</code>.
     // For the lifting terms, we only need to add the contribution of the
-    // face adjecent to <code>cell</code> and <code>neighbor_cell</code>.
+    // face adjacent to <code>cell</code> and <code>neighbor_cell</code>.
     for (unsigned int face_no = 0; face_no < cell->n_faces(); ++face_no)
       {
         const typename DoFHandler<dim>::face_iterator face =
index b668817737aeb914ee4871ec9b95e627814c219b..98ab0768ab9855136f36aae5cb11539060687d6d 100644 (file)
 /*
  * This sets the largest number of vectorization bits detected for the given
  * compiler flags and hardware (e.g. 256 for AVX on x86-64 architectures) for
- * use in deal.II's instrinsics-based VectorizedArray class.
+ * use in deal.II's intrinsics-based VectorizedArray class.
  */
 #define DEAL_II_VECTORIZATION_WIDTH_IN_BITS @DEAL_II_VECTORIZATION_WIDTH_IN_BITS@
 
index 1f85ce833e71dd5549ecd77f305ac440c5c4f063..9af59f410e2c00f202abb1d2be5f81083a189498 100644 (file)
@@ -399,7 +399,7 @@ namespace HDF5
 
   protected:
     /**
-     * Name of the HDF5Oject. In the case of File, @p name corresponds to the
+     * Name of the HDF5Object. In the case of File, @p name corresponds to the
      * file name. In the case of Group and DataSet @p name corresponds to the
      * name of the object in the HDF5 file.
      */
index 0ce8e90a1d96b20c5f3c9b48950a3ddd9d77df61..b77fd3e7c8ce5444f66b9ecc13c07b11dd38d775 100644 (file)
@@ -1029,7 +1029,7 @@ namespace Utilities
      * @note This function performs a single reduction sweep.
      *
      * @pre Size of the input ArrayView has to be the same on all processes
-     *   and the input and output ArrayVew have to have the same size.
+     *   and the input and output ArrayView have to have the same size.
      */
     void
     min_max_avg(const ArrayView<const double> &my_values,
index 081930085438726c5b23d781503fd2ca76cf1aa5..bee344c06c3c410c282bf22a950b15aa7ba68779 100644 (file)
@@ -106,7 +106,7 @@ class ParameterHandler;
  * By calling the method add_parameters() passing a ParameterHandler object,
  * the following options will be defined in the given ParameterHandler object
  * (in the current level of the ParameterHandler object, i.e., whatever level
- * you have entered with the ParamterHandler::enter_subsection() method),
+ * you have entered with the ParameterHandler::enter_subsection() method),
  * and can be modified at run time through a parameter file:
  * @code
  * set Enable computation of the errors = true
index 785b522fe16547deba491bcf556bf9655e88a583..6add0c2d195ffdc083cbac5b0e2dcdfb6db7aaa2 100644 (file)
@@ -50,11 +50,11 @@ namespace TimeStepping
     AssertThrow(
       F.size() == 0,
       ExcMessage(
-        "RungeKutta methods cannot handle more that one function to integate."));
+        "RungeKutta methods cannot handle more that one function to integrate."));
     AssertThrow(
       J_inverse.size() == 0,
       ExcMessage(
-        "RungeKutta methods cannot handle more that one function to integate."));
+        "RungeKutta methods cannot handle more that one function to integrate."));
 
     return evolve_one_time_step(F[0], J_inverse[0], t, delta_t, y);
   }
index 17bc6dfd8db6425b9d2ac19376f55e7c5bc1505f..cde2f78ee50a2e26f700413944e585b7935e70ce 100644 (file)
@@ -4138,7 +4138,7 @@ vectorized_load_and_transpose(const unsigned int          n_entries,
   const unsigned int n_chunks = n_entries / 4;
 
   // To avoid warnings about uninitialized variables, need to initialize one
-  // variable to a pre-exisiting value in out, which will never get used in
+  // variable to a pre-existing value in out, which will never get used in
   // the end. Keep the initialization outside the loop because of a bug in
   // gcc-9.1 which generates a "vmovapd" instruction instead of "vmovupd" in
   // case t3 is initialized to zero (inside/outside of loop), see
index d55cd9c030c4b1d92b6d4c6986db15be37468a33..11f0dea7d06ac77d91f027146eca2f8f5a008274 100644 (file)
@@ -543,7 +543,7 @@ FESeries::process_coefficients(
   std::vector<double>       norm_values;
 
   // first, parse all table elements into a map of predicate values and
-  // coefficients. We could have stored (predicate values ->TableIndicies) map,
+  // coefficients. We could have stored (predicate values ->TableIndices) map,
   // but its processing would have been much harder later on.
   std::map<unsigned int, std::vector<CoefficientType>> pred_to_values;
   internal::FESeriesImplementation::fill_map(coefficients,
index 6d1093f9a3b3cf578bf3fee11819ea8fea0423ac..4ed8c6a8ffcf766b4130949de2ee767f457253f5 100644 (file)
@@ -495,7 +495,7 @@ namespace FETools
    * with M>N unknowns is well-defined, but often yields funny and non-
    * intuitive results. Secondly, one would think that if the quadrature point
    * data is defined in the support points of the finite element, i.e. the
-   * quadrature points of <tt>ths_quadrature</tt> equal
+   * quadrature points of <tt>rhs_quadrature</tt> equal
    * <tt>fe.get_unit_support_points()</tt>, then the projection should be the
    * identity, i.e. each degree of freedom of the finite element equals the
    * value of the given data in the support point of the corresponding shape
index 9e5a47a62192417098c44785d25d27862d79788f..84f0181b01336d09893a0e1d6a4ef7156922c039 100644 (file)
@@ -793,7 +793,7 @@ public:
    * values of A. V is a NxN orthonal matrix containing the right singular
    * vectors corresponding the singular values of A.
    *
-   * Note that the variable #svd_vt contains the tranpose of V and can be
+   * Note that the variable #svd_vt contains the transpose of V and can be
    * accessed by get_svd_vt(), while U is accessed with get_svd_u().
    */
   void
index aa285c15fc0f5111a2a405cd1ac6a6088d12284c..95eb7214a5e77cf16edc42cbfe9926d5b92a9e9c 100644 (file)
@@ -96,7 +96,7 @@ namespace PETScWrappers
     Tvmult(VectorBase &dst, const VectorBase &src) const;
 
     /**
-     * Explictly call setup. This is usually not needed since PETSc will
+     * Explicitly call setup. This is usually not needed since PETSc will
      * automatically call the setup function when needed.
      */
     void
index 802c9be379494b79742d5df991e2419456ad2d02..b549be8ff9d85e80736e71036b39409e6224ef9b 100644 (file)
@@ -641,7 +641,7 @@ public:
    * vectors. The residual sum of squares for each column is given by the sum of
    * squares of elements $M$ to $N-1$ in that column.
    *
-   * If(!tranpose) then $\mathbf{B} \in \mathbb{R}^{M \times N_{\rm RHS}}$,
+   * If(!transpose) then $\mathbf{B} \in \mathbb{R}^{M \times N_{\rm RHS}}$,
    * otherwise $\mathbf{B} \in \mathbb{R}^{N \times N_{\rm RHS}}$.
    * The matrices $\mathbf{A}$ and $\mathbf{B}$ must have an identical block
    * cyclic distribution for rows and columns.
index 16f27c73dbaa7fccda824b7bc63cd2f2721c7fbe..fa2ad318ec3aa967e34ee14e7a93b3931e238fac 100644 (file)
@@ -922,7 +922,7 @@ namespace internal
                 !is_dealii_compatible_distributed_vector<VectorType>::value,
                 VectorType> * = nullptr>
     double
-    substract_and_norm(
+    subtract_and_norm(
       const unsigned int dim,
       const internal::SolverGMRESImplementation::TmpVectors<VectorType>
         &                   orthogonal_vectors,
@@ -944,7 +944,7 @@ namespace internal
                 is_dealii_compatible_distributed_vector<VectorType>::value,
                 VectorType> * = nullptr>
     double
-    substract_and_norm(
+    subtract_and_norm(
       const unsigned int dim,
       const internal::SolverGMRESImplementation::TmpVectors<VectorType>
         &                   orthogonal_vectors,
@@ -1183,7 +1183,7 @@ namespace internal
                      classical_gram_schmidt)
             {
               Tvmult_add(dim, vv, orthogonal_vectors, h);
-              norm_vv = substract_and_norm(dim, orthogonal_vectors, h, vv);
+              norm_vv = subtract_and_norm(dim, orthogonal_vectors, h, vv);
             }
           else
             {
index e707c51116a9fde0b368243facbf55051b95a9b7..e14f432d6eba92ef790950ccabc3c683135ce35a 100644 (file)
@@ -121,7 +121,7 @@ namespace CUDAWrappers
      * the function DoFAccessor::get_interpolated_dof_values when no
      * constraints are present, but it also includes constraints from hanging
      * nodes, so once can see it as a similar function to
-     * AffineConstraints::read_dof_valuess as well.
+     * AffineConstraints::read_dof_values() as well.
      */
     DEAL_II_HOST_DEVICE void
     read_dof_values(const Number *src);
index d1185e6f72a4a03f447623e48e7bbb6d0caf0477..f93e0b3ea4c1a2e27dc6c3129a78bb253a8ec73e 100644 (file)
@@ -81,7 +81,7 @@ namespace CUDAWrappers
    * write to vectors in parallel without having to explicitly synchronize
    * access to these vectors and matrices. This class does not implement any
    * shape values, all it does is to cache the respective data. To implement
-   * finite element operations, use the class CUDAWrappers::FEEvalutation.
+   * finite element operations, use the class CUDAWrappers::FEEvaluation.
    *
    * This class traverse the cells in a different order than the usual
    * Triangulation class in deal.II.
index de95bf44fada8f6dde21218eb22616f08d7b4961..b7c305adec103f12047f4b865d6dfdea10de7775 100644 (file)
@@ -1483,7 +1483,7 @@ public:
    * To be able to evaluate all face integrals (with values or gradients
    * from the neighboring cells), all ghost values from neighboring cells are
    * updated. Use
-   * FEFaceEvalution::reinit(cell, face_no) to access quantities on arbitrary
+   * FEFaceEvaluation::reinit(cell, face_no) to access quantities on arbitrary
    * faces of a cell and the respective neighbors.
    *
    * @param cell_operation Pointer to member function of `CLASS` with the
index 70ad11a2b24318d8cabc5f475d00e55170cef2ff..c2084e1341515af29defdd1beae2ea937c94fe8c 100644 (file)
@@ -3768,10 +3768,10 @@ namespace internal
       std::vector<Point<dim>> points;
       points.resize(local_support_point_indices.size());
 
-      const auto locally_onwed_support_point =
+      const auto locally_owned_support_point =
         dof_handler_support_points->locally_owned_dofs();
       std::vector<unsigned int> indices_state(
-        locally_onwed_support_point.n_elements(),
+        locally_owned_support_point.n_elements(),
         numbers::invalid_unsigned_int);
 
       AssertIndexRange(local_support_point_indices.size(),
@@ -3798,10 +3798,10 @@ namespace internal
           cell->get_dof_indices(dof_indices);
 
           for (const unsigned int q : fe_values.quadrature_point_indices())
-            if (locally_onwed_support_point.is_element(dof_indices[q]))
+            if (locally_owned_support_point.is_element(dof_indices[q]))
               {
                 const auto index =
-                  locally_onwed_support_point.index_within_set(dof_indices[q]);
+                  locally_owned_support_point.index_within_set(dof_indices[q]);
 
                 if (indices_state[index] != numbers::invalid_unsigned_int)
                   {
index 22be5910f55cfd9b6c0c955612487fed62d42da5..eb7f003a60715e5ecb3a5e3049a8330bf0d49d26 100644 (file)
@@ -190,14 +190,14 @@ namespace internal
     inline std::vector<Point<2>>
     generate_simplex_evaluation_points(const unsigned int n_subdivisions)
     {
-      std::vector<Point<2>> evalution_points;
+      std::vector<Point<2>> evaluation_points;
 
       generate_simplex_evaluation_points_recursively(
         {{Point<2>(0.0, 0.0), Point<2>(1.0, 0.0), Point<2>(0.0, 1.0)}},
         n_subdivisions,
-        evalution_points);
+        evaluation_points);
 
-      return evalution_points;
+      return evaluation_points;
     }
 
 
index a6542cbb4e4640929d408afee2327d06397bfa89..cbdaefe186d6ed390e104c1d8bb2a6d0b2840839 100644 (file)
@@ -337,7 +337,7 @@ struct ExtractLevelVisitor
 
   /**
    * Implements the visitor interface for InternalNode objects. If the node
-   * belongs to the @p target_leve, then fill the bounding box vector.
+   * belongs to the @p target_level, then fill the bounding box vector.
    */
   inline void
   operator()(InternalNode const &node);
@@ -500,7 +500,7 @@ void
 ExtractLevelVisitor<Value, Options, Translator, Box, Allocators>::operator()(
   const ExtractLevelVisitor::InternalNode &node)
 {
-  using ElmentsType =
+  using ElementsType =
     typename boost::geometry::index::detail::rtree::elements_type<
       InternalNode>::type;
 
@@ -512,7 +512,7 @@ ExtractLevelVisitor<Value, Options, Translator, Box, Allocators>::operator()(
       boxes.resize(offset + elements.size());
 
       unsigned int i = offset;
-      for (typename ElmentsType::const_iterator it = elements.begin();
+      for (typename ElementsType::const_iterator it = elements.begin();
            it != elements.end();
            ++it)
         {
@@ -525,7 +525,7 @@ ExtractLevelVisitor<Value, Options, Translator, Box, Allocators>::operator()(
   const size_t level_backup = level;
   ++level;
 
-  for (typename ElmentsType::const_iterator it = elements.begin();
+  for (typename ElementsType::const_iterator it = elements.begin();
        it != elements.end();
        ++it)
     {
index dd12760edb9d493cf62ad67329ac65edbde5f496..57c668cc1429d90f3b1828d1cfce12a50560b7ce 100644 (file)
@@ -37,7 +37,7 @@ endif()
 
 #
 # Automatically add the current source and binary directory as include
-# directory. The binary directory is needed in order to find the expaned
+# directory. The binary directory is needed in order to find the expanded
 # .inst include files.
 #
 set(CMAKE_INCLUDE_CURRENT_DIR true)
@@ -77,7 +77,7 @@ add_subdirectory(arborx)
 
 #
 # Define a "dealii", i.e., "${DEAL_II_TARGET_NAME}", target that contains
-# DEAL_II_CXX_FLAGS[_DEBUG|_RELEASE] and otherwsie aliases dealii_debug or
+# DEAL_II_CXX_FLAGS[_DEBUG|_RELEASE] and otherwise aliases dealii_debug or
 # dealii_release depending on the downstream CMAKE_BUILD_TYPE.
 #
 
index 9ff9a01fa95470d026e6c2260f63aba18ec58795..dc1ba232a7e930a69b2d72a4d12c162f1d3728f8 100644 (file)
@@ -4367,7 +4367,7 @@ namespace DataOutBase
     float max_color_value = std::numeric_limits<float>::min();
 
     // Array for z-coordinates of points. The elevation determined by a function
-    // if spacedim=2 or the z-cooridate of the grid point if spacedim=3
+    // if spacedim=2 or the z-coordinate of the grid point if spacedim=3
     double heights[4] = {0, 0, 0, 0};
 
     // compute the cells for output and enter them into the set above note that
index 20994ff6909b46a08d7b52082427c0df74d8aa92..6417a7acf33f711524781f20f3a2077043339f7f 100644 (file)
@@ -506,11 +506,11 @@ namespace DoFTools
 
     // next set up a table for the degrees of freedom on each of the cells
     // whether it is something interesting or not
-    std::vector<unsigned char> local_component_asssociation =
+    std::vector<unsigned char> local_component_association =
       internal::get_local_component_association(fe, component_mask);
     std::vector<bool> local_selected_dofs(fe.n_dofs_per_cell());
     for (unsigned int i = 0; i < fe.n_dofs_per_cell(); ++i)
-      local_selected_dofs[i] = component_mask[local_component_asssociation[i]];
+      local_selected_dofs[i] = component_mask[local_component_association[i]];
 
     // then loop over all cells and do work
     std::vector<types::global_dof_index> indices(fe.n_dofs_per_cell());
index 988e105c6e2395624513c3320359ad5647d4bb1e..060889cc6039389f156f8837498862e1265fe6d5 100644 (file)
@@ -36,7 +36,7 @@ template <int dim, int spacedim>
 std::string
 FE_DGNedelec<dim, spacedim>::get_name() const
 {
-  // note that the FETools::get_fe_by_nam function depends on the
+  // note that FETools::get_fe_by_name() depends on the
   // particular format of the string
   // this function returns, so they
   // have to be kept in synch
index 965d423801e38dd58fe87b80b933a0e54f167f08..e0a2ed86994372e17341e886efae037c7aa78902 100644 (file)
@@ -1090,7 +1090,7 @@ namespace GridGenerator
                     const double alpha = bias_alpha(1 - (1.0 * iy) / n_cells_y);
                     // define points on upper/lower horizontal far field side,
                     // i.e. face DG or FI. Incline factor to move points G and I
-                    // to the right by distance incline_facor*lenght_b2
+                    // to the right by distance incline_factor*length_b2
                     const Point<2> p(ix * dx + center_mesh +
                                        incline_factor * length_b2 * ix /
                                          n_cells_x_1,
index 7180b59dc116460082de27a0571c2c09ba0f60ce..4ef1ca0b35a6021cacd0a42b9b2d62b8147e0154 100644 (file)
@@ -2020,10 +2020,10 @@ ScaLAPACKMatrix<NumberType>::compute_SVD(ScaLAPACKMatrix<NumberType> *U,
   Assert(row_block_size == column_block_size,
          ExcDimensionMismatch(row_block_size, column_block_size));
 
-  const bool left_singluar_vectors  = (U != nullptr) ? true : false;
-  const bool right_singluar_vectors = (VT != nullptr) ? true : false;
+  const bool left_singular_vectors  = (U != nullptr) ? true : false;
+  const bool right_singular_vectors = (VT != nullptr) ? true : false;
 
-  if (left_singluar_vectors)
+  if (left_singular_vectors)
     {
       Assert(n_rows == U->n_rows, ExcDimensionMismatch(n_rows, U->n_rows));
       Assert(U->n_rows == U->n_columns,
@@ -2035,7 +2035,7 @@ ScaLAPACKMatrix<NumberType>::compute_SVD(ScaLAPACKMatrix<NumberType> *U,
       Assert(grid->blacs_context == U->grid->blacs_context,
              ExcDimensionMismatch(grid->blacs_context, U->grid->blacs_context));
     }
-  if (right_singluar_vectors)
+  if (right_singular_vectors)
     {
       Assert(n_columns == VT->n_rows,
              ExcDimensionMismatch(n_columns, VT->n_rows));
@@ -2055,11 +2055,11 @@ ScaLAPACKMatrix<NumberType>::compute_SVD(ScaLAPACKMatrix<NumberType> *U,
 
   if (grid->mpi_process_is_active)
     {
-      char        jobu   = left_singluar_vectors ? 'V' : 'N';
-      char        jobvt  = right_singluar_vectors ? 'V' : 'N';
+      char        jobu   = left_singular_vectors ? 'V' : 'N';
+      char        jobvt  = right_singular_vectors ? 'V' : 'N';
       NumberType *A_loc  = this->values.data();
-      NumberType *U_loc  = left_singluar_vectors ? U->values.data() : nullptr;
-      NumberType *VT_loc = right_singluar_vectors ? VT->values.data() : nullptr;
+      NumberType *U_loc  = left_singular_vectors ? U->values.data() : nullptr;
+      NumberType *VT_loc = right_singular_vectors ? VT->values.data() : nullptr;
       int         info   = 0;
       /*
        * by setting lwork to -1 a workspace query for optimal length of work is
index fda2da3d8e5721addd64afe77f60f50727e05789..ae4d802c059e1dea1128a88a9374e61dfd99a033 100644 (file)
@@ -1568,23 +1568,23 @@ namespace MGTools
       const std::vector<types::global_dof_index> &n_cells_on_levels,
       const MPI_Comm                              comm)
     {
-      std::vector<types::global_dof_index> n_cells_on_leves_max(
+      std::vector<types::global_dof_index> n_cells_on_levels_max(
         n_cells_on_levels.size());
-      std::vector<types::global_dof_index> n_cells_on_leves_sum(
+      std::vector<types::global_dof_index> n_cells_on_levels_sum(
         n_cells_on_levels.size());
 
-      Utilities::MPI::max(n_cells_on_levels, comm, n_cells_on_leves_max);
-      Utilities::MPI::sum(n_cells_on_levels, comm, n_cells_on_leves_sum);
+      Utilities::MPI::max(n_cells_on_levels, comm, n_cells_on_levels_max);
+      Utilities::MPI::sum(n_cells_on_levels, comm, n_cells_on_levels_sum);
 
       const unsigned int n_proc = Utilities::MPI::n_mpi_processes(comm);
 
-      const double ideal_work = std::accumulate(n_cells_on_leves_sum.begin(),
-                                                n_cells_on_leves_sum.end(),
+      const double ideal_work = std::accumulate(n_cells_on_levels_sum.begin(),
+                                                n_cells_on_levels_sum.end(),
                                                 0) /
                                 static_cast<double>(n_proc);
       const double workload_imbalance =
-        std::accumulate(n_cells_on_leves_max.begin(),
-                        n_cells_on_leves_max.end(),
+        std::accumulate(n_cells_on_levels_max.begin(),
+                        n_cells_on_levels_max.end(),
                         0) /
         ideal_work;
 
index 172db68d24ed70b504af4ffa2caf253ca928c936..8b484ba01e6349ba3ec99a3a208cf13db480b771 100644 (file)
@@ -77,7 +77,7 @@ namespace SmoothnessEstimator
        * FESeries::process_coefficients() which requires a predicate to be
        * specified. The predicate should operate on TableIndices and return a
        * pair of <code>bool</code> and <code>unsigned int</code>. The latter is
-       * the value of the map from TableIndicies to unsigned int.  It is used to
+       * the value of the map from TableIndices to unsigned int.  It is used to
        * define subsets of coefficients from which we search for the one with
        * highest absolute value, i.e. $l^\infty$-norm. The <code>bool</code>
        * parameter defines which indices should be used in processing. In the
@@ -342,7 +342,7 @@ namespace SmoothnessEstimator
        * which requires a predicate to be specified. The predicate should
        * operate on TableIndices and return a pair of <code>bool</code> and
        * <code>unsigned int</code>. The latter is the value of the map from
-       * TableIndicies to unsigned int.  It is used to define subsets of
+       * TableIndices to unsigned int.  It is used to define subsets of
        * coefficients from which we search for the one with highest absolute
        * value, i.e. $l^\infty$-norm. The <code>bool</code> parameter defines
        * which indices should be used in processing. In the current case we are

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.