]> https://gitweb.dealii.org/ - dealii.git/commitdiff
Improve the documentation for step-52. 142/head
authorBruno Turcksin <bruno.turcksin@gmail.com>
Fri, 12 Sep 2014 16:27:49 +0000 (11:27 -0500)
committerBruno Turcksin <bruno.turcksin@gmail.com>
Fri, 12 Sep 2014 16:27:49 +0000 (11:27 -0500)
doc/doxygen/tutorial/tutorial.h.in
doc/news/changes.h
examples/step-52/doc/intro.dox
examples/step-52/step-52.cc

index 9383cdd1e5072ff39a1d66db05ac605b568e19c0..91965c1d3d699231a1d0eda7202d65bbca5ceb11 100644 (file)
  *       </td></tr>
  *
  *   <tr valign="top">
+ *       <td>step-52/td>
+ *       <td> Solving the time dependent neutron diffusion equation using 
+ *       Runge-Kutta methods.
+ *       </td></tr>
+ *
+ *   <tr valign="top">
  *       <td>step-53</td>
  *       <td> Describing the geometry of complex domains and curved boundaries.
  *       </td></tr>
  *     </td>
  *     <td>step-33</td>
  *   </tr>
+ *
+ *   <tr valign="top">
+ *     <td> Time dependent neutron diffusion equation
+ *     </td>
+ *     <td>step-52</td>
+ *   </tr>
  * </table>
  */
index b1a6b045765f9764b99e1cae5790819495295896..b5cadb98a32b8431d12adf577e53e01428c6c097 100644 (file)
@@ -97,6 +97,11 @@ inconvenience this causes.
 
 
 <ol>
+  <li> New: The new tutorial program step-52 explains how to use the 
+  new time stepping methods.
+  <br>
+  (Bruno Turcksin, Damien Lebrun-Grandie, 2014/09/12)
+
   <li> New: The new tutorial program step-53 explains how to deal with
   complicated geometries.
   <br>
index 273e92ca9fb455527a86e30697f97a26e64f2dc7..2998354decded367e30b15da76dd194f086284c6 100644 (file)
@@ -2,6 +2,10 @@
 
 <i>This program was contributed by Bruno Turcksin and Damien Lebrun-Grandie.</i>
 
+<b>Note:</b> In order to run this program, deal.II must be configured to use
+the UMFPACK sparse direct solver. Refer to the <a
+href="../../readme.html#umfpack">ReadMe</a> for instructions how to do this.
+
 <a name="Intro"></a>
 <h1>Introducion</h1>
 
@@ -9,7 +13,7 @@ This program shows how to use Runge-Kutta methods to solve a time-dependent
 problem. It solves a small variation of the heat equation discussed first in
 step-26 but, since the purpose of this program is only to demonstrate using
 more advanced ways to interface with deal.II's time stepping algorithms, only
-solves a simple problem on a uniformly refined mesh.
+solves a simple problem on a uniformly refined mesh. 
 
 
 <h3>Problem statement</h3>
index d7308c9cd8947494a5347309462982840c55890d..dc00b6421a8ef7c410a545b122b58ed9e204dd06 100644 (file)
@@ -64,8 +64,16 @@ namespace Step52
 
   // @sect3{Diffusion}
 
-  // Now, here comes the declaration of the main class. Most of the functions in
-  // this class are not new and have been explained in previous tutorials.
+  // The next piece is the declaration of the main class. Most of the functions in
+  // this class are not new and have been explained in previous tutorials. The
+  // only interesting functions are <code>evaluate_diffusion</code> and
+  // <code>id_minus_tau_J_inverse</code>. <code>evaluate_diffusion</code> evaluates the
+  // diffusion equation, $M^{-1}(f(t,y))$, at a given time, for a given $\tau$
+  // and a given $y$. <code>id_minus_tau_J_inverse</code> evaluates
+  // $\left(I-\tau M^{-1} \frac{\partial f(t,y)}{\partial y}\right)^{-1}$ or
+  // equivalently $\left(M-\tau \frac{\partial f}{\partial y}\right)^{-1} M$ at
+  // a given time, for a given $\tau$ and $y$. This function is needed when an
+  // implicit method is used.
   class Diffusion
   {
   public:
@@ -80,13 +88,8 @@ namespace Step52
 
     double get_source(double time,const Point<2> &point) const;
 
-    // This function evaluates the diffusion equation $M^{-1}(f(t,y))$ at a given time and
-    // for a given y.
     Vector<double> evaluate_diffusion(const double time, const Vector<double> &y) const;
 
-    // Evaluate $\left(I-\tau M^{-1} \frac{\partial f(t,y)}{\partial y}\right)^{-1}$ or
-    // equivalently $\left(M-\tau \frac{\partial f}{\partial y}\right)^{-1} M$ at a given
-    // time, for a given $\tau$ and y.
     Vector<double> id_minus_tau_J_inverse(const double time,
                                           const double tau,
                                           const Vector<double> &y);
@@ -96,7 +99,7 @@ namespace Step52
     // The next three functions are the driver for the explicit methods, the
     // implicit methods, and the embedded explicit methods respectively. The
     // driver function for embedded explicit methods returns the number of
-    // steps executed since this number is adapted.
+    // steps executed.
     void explicit_method(TimeStepping::runge_kutta_method method,
                          const unsigned int n_time_steps,
                          const double       initial_time,
@@ -153,7 +156,7 @@ namespace Step52
 
   // @sect5{<code>Diffusion::setup_system</code>}
   // Now, we create the constraint matrix and the sparsity pattern. Then, we
-  // initialize the matrices that we will use and the solution vector.
+  // initialize the matrices and the solution vector.
   void Diffusion::setup_system()
   {
     dof_handler.distribute_dofs(fe);
@@ -255,7 +258,8 @@ namespace Step52
 
   // @sect5{<code>Diffusion:evaluate_diffusion</code>}
   //
-  // Now, the weak form of the diffusion equation is evaluated at a given time t and for a given vector y.
+  // Now, the weak form of the diffusion equation is evaluated at a given
+  // time $t$ and for a given vector $y$.
   Vector<double> Diffusion::evaluate_diffusion(const double time, const Vector<double> &y) const
   {
     Vector<double> tmp(dof_handler.n_dofs());
@@ -421,10 +425,11 @@ namespace Step52
 
 
   // @sect5{<code>Diffusion::explicit_method</code>}
-  // This function is the driver for all the explicit method. It call
-  // evolve_one_time_step which performs one time step. evolve_one_time_step
-  // needs to evaluate $M^{-1}(f(t,y))$, i.e it needs evaluate_diffusion.
-  // Because evaluate_diffusion is a member function, it needs to be bind to
+  // This function is the driver for all the explicit method. It calls
+  // <code>evolve_one_time_step</code> which performs one time step.
+  // <code>evolve_one_time_step</code> needs to evaluate $M^{-1}(f(t,y))$,
+  // i.e, it needs <code>evaluate_diffusion</code>. Because
+  // <code>evaluate_diffusion</code> is a member function, it needs to be bind to
   // $this$. Finally, the solution is output every 10 time steps.
   void Diffusion::explicit_method(TimeStepping::runge_kutta_method method,
                                   const unsigned int                n_time_steps,
@@ -451,9 +456,9 @@ namespace Step52
 
 
   // @sect5{<code>Diffusion::implicit_method</code>}
-  // This function is equivalent to explicit_method but for implicit methods.
-  // When using implicit methods, we need to evaluate $M^{-1}(f(t,y))$ and
-  // $\left(I-\tau M^{-1} \frac{\partial f(t,y)}{\partial y}\right)^{-1}$.
+  // This function is equivalent to <code>explicit_method</code> but for implicit
+  // methods. When using implicit methods, we need to evaluate $M^{-1}(f(t,y))$
+  // and $\left(I-\tau M^{-1} \frac{\partial f(t,y)}{\partial y}\right)^{-1}$.
   void Diffusion::implicit_method(TimeStepping::runge_kutta_method method,
                                   const unsigned int               n_time_steps,
                                   const double                     initial_time,
@@ -494,7 +499,7 @@ namespace Step52
   // Embedded methods use a guessed time step. If the error using this time step
   // is too large, the time step will be reduced. If the error is below the
   // threshold, a larger time step will be tried for the next time step.
-  // delta_t_guess is the guessed time step produced by the embedded method.
+  // </code>delta_t_guess</code> is the guessed time step produced by the embedded method.
   unsigned int Diffusion::embedded_explicit_method(TimeStepping::runge_kutta_method method,
                                                    const unsigned int n_time_steps,
                                                    const double initial_time,
@@ -516,7 +521,7 @@ namespace Step52
     unsigned int n_steps=0;
     while (time<final_time)
       {
-        // We choose the last time step such that the final time is exactly
+        // The last time step is chosend such that the final time is exactly
         // reached.
         if (time+time_step>final_time)
           time_step = final_time-time;
@@ -660,8 +665,8 @@ namespace Step52
 
 // @sect3{The <code>main()</code> function}
 //
-// The following <code>main</code> function is similar to previous examples as
-// well, and need not be commented on.
+// The following <code>main</code> function is similar to previous examples
+// and need not be commented on.
 int main ()
 {
   try

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.