]> https://gitweb.dealii.org/ - dealii.git/commitdiff
Host of documentation improvements to step-10 and elsewhere. 11014/head
authorKrishnakumar Gopalakrishnan <krishna.kumar@ucl.ac.uk>
Wed, 15 Jan 2020 18:41:24 +0000 (18:41 +0000)
committerWolfgang Bangerth <bangerth@colostate.edu>
Wed, 7 Oct 2020 00:11:32 +0000 (18:11 -0600)
examples/step-10/doc/intro.dox
examples/step-10/doc/results.dox
examples/step-10/step-10.cc
examples/step-69/doc/intro.dox
examples/step-69/step-69.cc

index 5236b0f70830b1dfd713a3ddd52b3caac5e94724..6958e86617da4693a64a2aa683a6a7f3735bfd57 100644 (file)
@@ -41,17 +41,16 @@ different methods.
 
 
 
-The first method uses a triangulated approximation of the circle with
-unit radius and integrates the function that is constant one over it. Of course, if
-the domain were the exact unit circle, then the area would be $\pi$, but
-since we only use an approximation by piecewise polynomial segments,
-the value of the area we integrate over is not exactly $\pi$. However, it is known that as
-we refine the triangulation, a $Q_p$ mapping approximates the boundary
-with an order $h^{p+1}$, where $h$ is the mesh
-size. We will check the values of the computed area of the circle and
-their convergence towards $\pi$ under mesh refinement for different
-mappings. We will also find a convergence behavior that is surprising
-at first, but has a good explanation.
+The first method uses a triangulated approximation of the circle with unit
+radius and integrates a unit magnitude constant function ($f = 1$) over it. Of
+course, if the domain were the exact unit circle, then the area would be $\pi$,
+but since we only use an approximation by piecewise polynomial segments, the
+value of the area we integrate over is not exactly $\pi$. However, it is known
+that as we refine the triangulation, a $Q_p$ mapping approximates the boundary
+with an order $h^{p+1}$, where $h$ is the mesh size. We will check the values
+of the computed area of the circle and their convergence towards $\pi$ under
+mesh refinement for different mappings. We will also find a convergence
+behavior that is surprising at first, but has a good explanation.
 
 
 
index 4b37071c78a095e73614c6ded24260284e661dfc..a9e004936b1a7d85e0b87dc110bc3a4b135bedec 100644 (file)
@@ -19,9 +19,9 @@ the aspect ratio of the generated output is actually 1:1, i.e. a
 circle is drawn as a circle on your screen, rather than as an
 ellipse. The third line switches off the key in the graphic, as that
 will only print information (the filename) which is not that important
-right now. Similarly, the third and fourth disable tic marks. The plot
-is then generated with a specific line width ("`lw`", here set to 4)
-and line type ("`lt`", here chosen by saying that the line should be
+right now. Similarly, the fourth and fifth disable tick marks. The plot
+is then generated with a specific line width ("lw", here set to 4)
+and line type ("lt", here chosen by saying that the line should be
 drawn using the RGB color "black").
 
 The following table shows the triangulated computational domain for $Q_1$,
index 67b4b1cb29ec1c5e63319a4c94e11db811f7b19f..ba5815f46f472d8e36abde38623b4ef1038927f6 100644 (file)
@@ -68,7 +68,8 @@ namespace Step10
   // of the library). Rather, we just pack the functionality into separate
   // functions. We make these functions templates on the number of space
   // dimensions to conform to usual practice when using deal.II, although we
-  // will only use them for two space dimensions.
+  // will only use them for two space dimensions and throw an exception when
+  // attempted to use for any other spatial dimension.
   //
   // The first of these functions just generates a triangulation of a circle
   // (hyperball) and outputs the $Q_p$ mapping of its cells for different values
@@ -165,14 +166,14 @@ namespace Step10
   // the triangulation, with $w(x_i)$ being the weight of quadrature point
   // $x_i$. The integrals on each cell are approximated by numerical
   // quadrature, hence the only additional ingredient we need is to set up a
-  // FEValues object that provides the corresponding `JxW' values of each
-  // cell. (Note that `JxW' is meant to abbreviate <i>Jacobian determinant
+  // FEValues object that provides the corresponding `JxW` values of each
+  // cell. (Note that `JxW` is meant to abbreviate <i>Jacobian determinant
   // times weight</i>; since in numerical quadrature the two factors always
   // occur at the same places, we only offer the combined quantity, rather
   // than two separate ones.) We note that here we won't use the FEValues
   // object in its original purpose, i.e. for the computation of values of
   // basis functions of a specific finite element at certain quadrature
-  // points. Rather, we use it only to gain the `JxW' at the quadrature
+  // points. Rather, we use it only to gain the `JxW` at the quadrature
   // points, irrespective of the (dummy) finite element we will give to the
   // constructor of the FEValues object. The actual finite element given to
   // the FEValues object is not used at all, so we could give any.
@@ -208,7 +209,7 @@ namespace Step10
 
         // We now create a finite element. Unlike the rest of the example
         // programs, we do not actually need to do any computations with shape
-        // functions; we only need the `JxW' values from an FEValues
+        // functions; we only need the `JxW` values from an FEValues
         // object. Hence we use the special finite element class FE_Nothing
         // which has exactly zero degrees of freedom per cell (as the name
         // implies, the local basis on each cell is the empty set). A more
@@ -216,14 +217,14 @@ namespace Step10
         const FE_Nothing<dim> fe;
 
         // Likewise, we need to create a DoFHandler object. We do not actually
-        // use it, but it will provide us with `active_cell_iterators' that
+        // use it, but it will provide us with `active_cell_iterators` that
         // are needed to reinitialize the FEValues object on each cell of the
         // triangulation.
         DoFHandler<dim> dof_handler(triangulation);
 
         // Now we set up the FEValues object, giving the Mapping, the dummy
         // finite element and the quadrature object to the constructor,
-        // together with the update flags asking for the `JxW' values at the
+        // together with the update flags asking for the `JxW` values at the
         // quadrature points only. This tells the FEValues object that it
         // needs not compute other quantities upon calling the
         // <code>reinit</code> function, thus saving computation time.
@@ -249,7 +250,7 @@ namespace Step10
           {
             // In this loop we first add the number of active cells of the
             // current triangulation to the table. This function automatically
-            // creates a table column with superscription `cells', in case
+            // creates a table column with superscription `cells`, in case
             // this column was not created before.
             table.add_value("cells", triangulation.n_active_cells());
 
@@ -260,13 +261,13 @@ namespace Step10
             // function below.
             dof_handler.distribute_dofs(fe);
 
-            // We define the variable area as `long double' like we did for
-            // the pi variable before.
+            // We define the variable area as `long double` like we did for
+            // the `pi` variable before.
             long double area = 0;
 
             // Now we loop over all cells, reinitialize the FEValues object
-            // for each cell, and add up all the `JxW' values for this cell to
-            // `area'...
+            // for each cell, and add up all the `JxW` values for this cell to
+            // `area`...
             for (const auto &cell : dof_handler.active_cell_iterators())
               {
                 fe_values.reinit(cell);
@@ -287,10 +288,10 @@ namespace Step10
             table.add_value("error", static_cast<double>(std::fabs(area - pi)));
           }
 
-        // We want to compute the convergence rates of the `error'
+        // We want to compute the convergence rates of the `error`
         // column. Therefore we need to omit the other columns from the
         // convergence rate evaluation before calling
-        // `evaluate_all_convergence_rates'
+        // `evaluate_all_convergence_rates`
         table.omit_column_from_convergence_rate_evaluation("cells");
         table.omit_column_from_convergence_rate_evaluation("eval.pi");
         table.evaluate_all_convergence_rates(
@@ -319,7 +320,7 @@ namespace Step10
     std::cout << "Computation of Pi by the perimeter:" << std::endl
               << "===================================" << std::endl;
 
-    // We take the same order of quadrature but this time a `dim-1'
+    // We take the same order of quadrature but this time a `dim-1`
     // dimensional quadrature as we will integrate over (boundary) lines
     // rather than over cells.
     const QGauss<dim - 1> quadrature(4);
@@ -355,8 +356,8 @@ namespace Step10
             dof_handler.distribute_dofs(fe);
 
             // Now we run over all cells and over all faces of each cell. Only
-            // the contributions of the `JxW' values on boundary faces are
-            // added to the long double variable `perimeter'.
+            // the contributions of the `JxW` values on boundary faces are
+            // added to the long double variable `perimeter`.
             long double perimeter = 0;
             for (const auto &cell : dof_handler.active_cell_iterators())
               for (const auto &face : cell->face_iterators())
@@ -403,10 +404,12 @@ int main()
     {
       std::cout.precision(16);
 
-      Step10::gnuplot_output<2>();
+      const unsigned int dim = 2;
 
-      Step10::compute_pi_by_area<2>();
-      Step10::compute_pi_by_perimeter<2>();
+      Step10::gnuplot_output<dim>();
+
+      Step10::compute_pi_by_area<dim>();
+      Step10::compute_pi_by_perimeter<dim>();
     }
   catch (std::exception &exc)
     {
index 2032eb929761805e95755da3226b213d06b6d3ae..27f73a166bcb7db2602dea24e7f23221ace512ff 100644 (file)
@@ -285,7 +285,7 @@ where
     (\mathbf{U}_i^{n},\mathbf{U}_j^{n}, \textbf{n}_{ij}),
     \lambda_{\text{max}} (\mathbf{U}_j^{n}, \mathbf{U}_i^{n},
     \textbf{n}_{ji}) \} \|\mathbf{c}_{ij}\|$ if $i \not = j$ is the so
-    called <i>graph-viscosity</i>. The graph-viscosity serves as a
+    called <i>graph viscosity</i>. The graph viscosity serves as a
     stabilization term, it is somewhat the discrete counterpart of
     $\epsilon \Delta \mathbf{u}$ that appears in the notion of viscosity
     solution described above. We will base our construction of $d_{ij}$ on
index bc7ad26450ef48e6e91397cd900f1ced5785003d..4181d13b6dc48c9f0be1dca37636e3156e8442ec 100644 (file)
@@ -88,6 +88,7 @@
 #include <fstream>
 #include <future>
 
+
 // @sect3{Class template declarations}
 //
 // We begin our actual implementation by declaring all classes with their
@@ -2182,7 +2183,7 @@ namespace Step69
   // The second thing to note is that we have to compute global minimum and
   // maximum $\max_j |\nabla r_j|$ and $\min_j |\nabla r_j|$. Following the
   // same ideas used to compute the time step size in the class member
-  // <code>%TimeStepping\<dim>::%step()</code> we define $\max_j |\nabla r_j|$
+  // <code>%TimeStepping<dim>::step()</code> we define $\max_j |\nabla r_j|$
   // and $\min_j |\nabla r_j|$ as atomic doubles in order to resolve any
   // conflicts between threads. As usual, we use
   // <code>Utilities::MPI::max()</code> and

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.