]> https://gitweb.dealii.org/ - dealii-svn.git/commitdiff
Various updates.
authorwolf <wolf@0785d39b-7218-0410-832d-ea1e28bc413d>
Sun, 28 Nov 1999 19:47:59 +0000 (19:47 +0000)
committerwolf <wolf@0785d39b-7218-0410-832d-ea1e28bc413d>
Sun, 28 Nov 1999 19:47:59 +0000 (19:47 +0000)
git-svn-id: https://svn.dealii.org/trunk@1954 0785d39b-7218-0410-832d-ea1e28bc413d

deal.II/doc/tutorial/chapter-1.elements/dofs.html
deal.II/doc/tutorial/chapter-1.elements/grid_creation.html
deal.II/doc/tutorial/chapter-1.elements/hanging_nodes.html
deal.II/doc/tutorial/chapter-1.elements/matrix_structure.html
deal.II/doc/tutorial/chapter-1.elements/title.html
deal.II/doc/tutorial/chapter-1.elements/toc.html
deal.II/doc/tutorial/images/sparsity_1.jpg [new file with mode: 0644]
deal.II/doc/tutorial/images/sparsity_2.jpg [new file with mode: 0644]
deal.II/doc/tutorial/index.html

index b86fc91d268a5deafc686c133d23ff02a961776e..e5fb3575aff595985986c36a489a2e5b7b73ce39 100644 (file)
 <h1>Degrees of Freedom</h1>
 
 <p>
-Degrees of freedom - short DoFs -are virtually the most important entities you will 
-encounter in <acronym>deal.II</acronym>. Most of the task of setting up
-your problem is accomplished by manipulating them.
+Degrees of freedom - short DoFs - are needed to associate a numering
+to the shape functions living on our triangulation. Using this
+numbering, we can then interpret the discretized operator as a matrix,
+where the matrix row and column numbers are identified with the DoF
+numbers, and likewise the index of a vector denotes the number of the
+respective degree of freedom.
 </p>
 <p>
 For now we will only discuss how and when to number and renumber the
@@ -49,7 +52,7 @@ afterwards the structure will be invalid.
 <h2>How to Distribute and Renumber Degrees of Freedom</h2>
 <p>
 The degrees of freedom are distributed on a triangulation using the function<br>
-<code>void DoFHandler::distribute_dofs(const FiniteElement&lt;dim&gt; &amp;)</code><br>
+<code>void DoFHandler&lt;dim&gt;::distribute_dofs(const FiniteElement&lt;dim&gt; &amp;)</code><br>
 The argument to <code>distribute_dofs</code> is a finite element that describes
 how many degrees of freedom are located on vertices, lines etc. 
 (<code>FiniteElement</code> objects have much more functionality than only storing
@@ -74,42 +77,53 @@ The finite elements used are bilinear.
 #include &lt;grid/grid_generator.h&gt;
 #include &lt;fe/fe_lib.lagrange.h&gt;
 
-Triangulation&lt;dim&gt; tr;
-DoFHandler&lt;dim&gt; dof;
-FEQ1&lt;dim&gt; fe;
+// first build up the triangulation
+Triangulation&lt;dim&gt; triangulation;
+GridGenerator::hyper_cube (triangulation,-1,1);
+
+// you may want to refine the triangulation a bit here
+...
 
-GridGenerator&lt;dim&gt;::hyper_cube(tr,-1,1);
-dof.distribute_dofs(fe);
+// then associate a DoFHandler object with this triangulation...
+DoFHandler&lt;dim&gt; dof_handler (&tria);
+
+// ...and distribute degrees of freedom for linear elements
+FEQ1&lt;dim&gt; fe;
+dof_handler.distribute_dofs(fe);
 </code>
 </pre>
 
 <p>
-For a number of solution algorithms this way of numbering is way below optimal.
+For a number of solution algorithms this way of numbering is way below
+optimal. In particular, as mentioned above, the degrees of freedom are
+numbered starting on the active cells of coarser levels and going to
+finer levels, but depending on how your triangulation was refined, the
+order in which the cells are traversed will have no geometrical
+pattern. Likewise, the distribution of DoF numbers will look mostly
+random.
+</p>
+<p>
+For some problems, it is better if the numbering of DoFs is roughly
+into a certain direction, for example from inflow to outflow in
+hyperbolic problems.
 To achieve a kind of numbering better suited to your problem the <acronym>deal.II</acronym> 
-offers the function<br>
-<code>void DoFHandler::renumber_dofs(const RenumberingMethod method,const bool use_constraints=false, const vector&lt;int&gt; &amp;starting_points=vector&lt;int&gt;())</code><br>
-or alternatively, the easier to use<br>
-<code>void DoFHandler::renumber_dofs(const RenumberingMethod method)</code><br>
-The methods available are <code>Cuthill_McKee</code> and <code>reverse_Cuthill_McKee</code>. Both algorithms are usually better than the one used
-by <code>distribute_dofs</code> and neither is optimal (there is no algorithm
+offers the class
+<code>DoFRenumbering</code> with several functions implementing
+different ways of renumbering.
+The methods presently available are Cuthill-McKee and reverse
+Cuthill-McKee, and some other methods you will only want to ask for in
+more advanced applications. The first two algorithms are usually much
+better than the one used 
+by <code>distribute_dofs</code>, but neither is optimal (there is no algorithm
 that accomplishes optimal results within a reasonable amount of time).
-Both algorithms require a good index to start with to achieve good results.
-Whenever you know a good set of starting indices you might wish to use the 
-first way of calling <code>renumber_dofs</code>,
-in every other case the second way is more advisable.
-<p class="Example">
-<span class="example">Example:</span> We use the definitions from the
-<a href="#ex_distribute">first example</a> given above. We renumber our 
-degrees of freedom with the 
-<code>Cuthill_McKee</code> method.
+Both algorithms require a good point to start numbering from (for
+example one or more degrees of freedom on the inflow boundary) to
+achieve good results.
 </p>
-<pre class="example">
-<code>
-dof.renumber_dofs(Cuthill_McKee);
-</code>
-</pre>
-
-<h2>Access to triangulation cells, faces and vertices</h2>
+<p>
+The documentation of the <code>DoFRenumbering</code> gives a good
+overview of how the methods mentioned above work, and how the
+functions performing the re-enumerations have to be called.
 
 
 <!-- Page Foot -->
index d62a59f8f937981f1619c03d2bff032c46fa3419..2723502a42e9a4a04c7734612016941f0eddc701 100644 (file)
 <h2>Different kinds of grids</h2>
 
 <p>
-All numerics are done on a grid. 
+The numerics for which this library was written is always done on a grid. 
 Choosing the right kind of grid can be essential for solving your problem.
 A grid should be chosen to fit your problem space in the best way possible.
 This chapter describes coarse grids for the triangulation of your domain.
 </p>
-<p>Please remember throughout this chapter:
-<b>A triangulation must be void before it is initialized !</b>
-</p>
 <p>
-<acronym>deal.II</acronym> offers three fundamental grid types: 
+<acronym>deal.II</acronym> offers various ways to produce grids for
+standard domains, such as 
 a <a href="#cube">hypercube</a>, a <a href="#ball">hyperball</a> 
-and a <a href="#L">hyper_L</a>. Furthermore it is possible to 
+and a <a href="#L">hyper_L</a>. There may be more in the meantime (for
+example I can now see a ring domain), and you may want to check out
+the documentation of the <tt>GridGenerator</tt> class for this.
+<p>
+Furthermore it is possible to 
 <a href="#file">read a triangulation from a <tt>ucd</tt>-file</a> or 
 <a href="#program">generate a custom grid from within a program</a>.
 </p>
+<p>We note before actually going to some code snippets that
+a triangulation object must be empty before it is initialized with a
+grid. However, you need not fear now, since the library will tell you
+if you try to initialize a triangulation which is already initialized;
+in general, the library will warn you about almost all errors you do,
+since in the debug version there are very many checks.
+</p>
 
 <h3><a name="cube">Hypercube</a></h3>
 
 <p>
 A hypercube can be created using the function<br>
-<code>void GridGenerator&lt;dim&gt;::hyper_cube(Triangulation&lt;dim&gt; &amp;tria,const double left=0.,const double right=1.)</code><br>
+<code>void GridGenerator::hyper_cube(Triangulation&lt;dim&gt; &amp;tria,const double left=0.,const double right=1.)</code><br>
 The cube created is the tensor product of the left and right edges which
 default to 0 and 1, creating the unit hypercube. The hypercube will consist of
-exactly one cell. In two dimensions, this amounts to a unit square, in three, to a unit cube.  
+exactly one cell. In two dimensions, this amounts to a unit square, in
+three, to a unit cube. In one dimension, you simply get a line.
 </p>
 
 <table class="figure">
@@ -60,10 +70,10 @@ function calls needed. Be sure to use them in their appropriate places.
 #include &lt;grid/tria.h&gt;
 #include &lt;grid/grid_generator.h&gt;
 
-const unsigned int dim=2;  // Two dimensions; to create a cube set to three
-Triangulation&lt;dim&gt; tr;
+const unsigned int dim=2;  // Two dimensions; to create a cube set to dim=3
+Triangulation&lt;dim&gt; triangulation;
 
-GridGenerator&lt;dim&gt;::hyper_cube(tr,-1,1);
+GridGenerator::hyper_cube (triangulation, -1, 1);
 </code>
 </pre>
 
@@ -71,7 +81,7 @@ GridGenerator&lt;dim&gt;::hyper_cube(tr,-1,1);
 <h3><a name="ball">Hyperball</a></h3>
 <p>
 A hyperball can be created using the function<br>
-<code>void GridGenerator&lt;dim&gt;::hyper_ball(Triangulation&lt;dim&gt; &amp;tria,const Point&lt;dim&gt; center=0.,const double radius=1.)</code><br>
+<code>void GridGenerator::hyper_ball(Triangulation&lt;dim&gt; &amp;tria,const Point&lt;dim&gt; center=0.,const double radius=1.)</code><br>
 This will create a hyperball of given centre and radius where the location of the centre defaults to the origin and the radius to unity.
 </p>
 
@@ -95,14 +105,21 @@ This example will create a hyperball with unit radius centred on (1,0).
 #include &lt;base/point.h&gt;
 
 const unsigned int dim=2;  // For example
-Triangulation&lt;dim&gt; tr;
+Triangulation&lt;dim&gt; triangulation;
 Point&lt;dim&gt; centre(1,0); // Taking (1,0) as the centre of the ball
 
-GridGenerator&lt;dim&gt;::hyper_ball(tr,centre,1);
+GridGenerator::hyper_ball (triangulation, centre, 1);
 
 </code>
 </pre>
 
+As can be seen above, the unrefined ball (or circle) does not look
+very much like a ball (or circle). After several refinement
+steps, it looks much better, though. However, along the rays pointing
+outward in the initial grid, the cells ar distorted even in the fine
+grid and if you want to do high-accuracy computations on circles, you
+may want to use a better coarse grid than the one on the left.
+
 
 <h3><a name="L">Hyper-L</a></h3>
 <p>
@@ -123,7 +140,11 @@ can be used to test the efficiency of error estimators.
 </p>
 
 <table class="figure">
-<caption class="figure" align="bottom">Hyper-L in three dimensions</caption>
+<caption class="figure" align="bottom">
+Hyper-L in three dimensions (not a good picture, since the proportions
+of short and long lines is not exactly one half, but you might get a
+clue about it)
+</caption>
 <td>
   <img src="../images/Hyper-L.gif" alt="Hyper-L" width=348 height=321>
 </td>
@@ -141,9 +162,9 @@ This example will create the default hyper-L.
 #include &lt;grid/grid_generator.h&gt;
 
 const unsigned int dim=2;  // For example
-Triangulation&lt;dim&gt; tr;
+Triangulation&lt;dim&gt; triangulation;
 
-GridGenerator&lt;dim&gt;::hyper_L(tr,-1,1);
+GridGenerator::hyper_L (triangulation, -1, 1);
 </code>
 </pre>
 
@@ -151,14 +172,21 @@ GridGenerator&lt;dim&gt;::hyper_L(tr,-1,1);
 <h3><a name="file">Reading a grid from a file</a></h3>
 
 <p>In many problems taken from real life you will find those grid types
-insufficient and you will need to create your own grid. Fortunately,
-this is possible. <acronym>deal.II</acronym> offers the possibility of
+insufficient and you will need to create your own grid. 
+This is possible: <acronym>deal.II</acronym> offers the possibility of
 reading a complete triangulation from a file in the <tt>ucd</tt>-format 
 used by avs. A <tt>ucd</tt>-file can be read with the function<br> 
 <code>void DataIn::read_ucd(istream&)</code><br>
 </p>
 
-<p><span class="parhead">Vertex numbering in input files:</span>
+<p><span class="parhead">
+Since the creation of input grids is probably not something you need to do on a
+daily basis, we will only very briefly describe the format of the
+input file. More information can be found in the documentation of the
+<code>GridIn</code> class.
+</p>
+<p>
+Vertex numbering in input files:</span>
 The vertex numbering must start at the vertex with the lowest number for lines
 and be counterclockwise for quads. Also, faces between adjacent cells
 must face in the same direction. This must be ensured by you, or by the
@@ -181,9 +209,10 @@ for creating grid cells and their properties. This is done in the order
 <li>boundaries</li>
 <li>create a triangulation from this information</li>
 </ol>
-You first create the vertices, then create cells by assigning vertices
-to them, then you set the boundary conditions. Last you use this information
-to create a triangulation. This is probably best illustrated by an example.
+In fact, this is the way the functions in the
+<code>GridGenerator</code> class use to produce the grids we have
+shown above.
+</p>
 <p class="example">
 <span class="example">Example:</span> Below we show the includes,
 definitions and
@@ -229,20 +258,23 @@ for (unsigned int i=0; i&lt;3; ++i)
 // to distinguish them from cell data like vertices and material.
 SubCellData boundary_info;                                       
 
-// We are using a boundary of cell number 1
+// We want to describe a line in 2d, which would be a cell in 1d,
+// which is why we can use the object for a 1d cell
+// (CellData&lt;1&gt;) for its description:
 boundary_info.boundary_lines.push_back (CellData&lt;1&gt;());
 
-// The boundary gets a material id of 
-boundary_info.boundary_lines.back().material_id = 1;
+// The boundary gets a material id of 1. The boundary id of lines in 2d
+// will be interpreted as the boundary id
+boundary_info.boundary_lines[0].material_id = 1;
 
-// The boundary is between vertices number 1 and 3
+// The boundary is between vertices number 0 and 3
 boundary_info.boundary_lines[0].vertices[0] = 0; 
 boundary_info.boundary_lines[0].vertices[1] = 3;
 
 // From this information the triangulation is created 
 coarse_grid-&gt;create_triangulation (vector&lt;Point&lt;2&gt; &gt;(&vertices[0],
                                                        &vertices[8]),
-                                                       cells, boundary_info);
+                                      cells, boundary_info);
 </code>
 </pre>
 
index 16edd8c19db4c3b4b866791490d9ec589958cfd9..e324d1905b35bf29abfdedea9b40cf4a7393e176 100644 (file)
 
 <h1>Hanging Nodes</h1>
 
-This chapter discusses locally refined grids, which are the only ones with
-hanging nodes. A node is called hanging if its value is subject to a 
-constraint.
-In particular, nodes on the boundary of your domain
-are not hanging.
+This chapter discusses one aspect of locally refined grids. Using the
+approach chosen in <acronym>deal.II</acronym>, grids are produced with
+so-called hanging nodes.
+A node is called hanging if its value is subject to a 
+constraint induced by the requirement of globally continuous
+functions. We will make this clearer in the following.
 
-<h2>When do you get hanging nodes ?</h2>
+<h2>When do you get hanging nodes?</h2>
 
 <p>
-You get hanging nodes after each refinement. Hanging nodes are those that 
+You get hanging nodes after some refinements. Hanging nodes are those that 
 are situated on the boundary of a larger active cell. The global function 
 is assumed
 to be linear on the boundary of each active cell, therefore the value
@@ -63,6 +64,9 @@ with function values <code>x1</code> and <code>x2</code>. If you get
 a hanging node on this boundary during refinement it will be situated
 in the middle and therefore its value - the value of the function on 
 the boundary at this point - will be <code>x3 = 1/2 (x1+x2)</code>.
+The value <code>x3</code> is therefore not a free degree of freedom,
+but it is bound by this constraining equation and we will have to take
+this into account.
 </p>
 
 <h3>Mathematical implications, or<br>
@@ -107,7 +111,7 @@ or, taking
 
 <p>
 It is not possible to generate <code>~A</code> directly, but 
-w can generate <code>A</code> and condense it to <code>~A</code>
+we can generate <code>A</code> and condense it to <code>~A</code>
 using the constraints, solve the system and obtain <code>u</code> by
 <code>u=Cy</code>.
 </p>
index 61838520ff5133a9ceab78111946a74951f2f4d2..d2f2d868174b07c20798fa6b489008ecf8129eff 100644 (file)
@@ -28,6 +28,28 @@ very large, and therefore storage is expensive in terms of memory.
 providing means of generating memory efficient structures for sparse
 matrices where only non-zero elements are stored.
 </p>
+<p>
+To show only two example of matrices which are quite typical of finite
+element discretizations of partial differential equations, we present
+the following two graphics, in which each dot represents a non-zero
+entry of the matrix:
+</p>
+<p>
+ <img src="../images/sparsity_1.jpg" alt="Sparsity 1" width="45%">
+ <img src="../images/sparsity_2.jpg" alt="Sparsity 2" width="45%">
+</p>
+<p>
+The first is a 300x300 matrix, the second has approximately 4000 rows
+and columns. As can be seen, the vast majority of entries is zero, and
+we can also guess that the proportion of zeroes is even growing as the
+matrix size is increased (this is in fact so, but can not so clearly
+be seen from the pictures, admittedly). The equation discretized to
+yield these matrices is rather complex, so the number of non-zero
+entries per row is quite large for finite element matrices.
+Both matrices were derived after renumbering of the degrees of freedom
+using the algorithm of Cuthill-McKee, which concentrates the entries
+around the diagonal of the matrix.
+
 
 <h2>Ways of dealing with matrix structures provided by <acronym>deal.II</acronym></h2>
 <p>
@@ -44,16 +66,49 @@ tell the matrix for which elements to allocate memory.
 The <acronym>deal.II</acronym> function initializing a standard sparse matrix
 structure is <code>void SparseMatrixStruct::reinit(const unsigned int m, const unsigned int n, const unsigned int max_per_row)</code>. It takes as its arguments
 the size of the matrix in question and the maximum number of non-zero elements
-in one row.
-This number can be calculated with 
-<code>int DoFHandler::max_couplings_between_dofs()</code>.
-<em>Beware: This function was written to cope with refined grids only !
-If your grid consists exclusively of cells next to boundaries its 
-return value will be wrong.</em>
-This matrix structure can then be used to generate a matrix using 
-<code>void SparseMatrix::reinit(const SparseMatrixStruct &sparsity)</code>.
-In cases of locally refined grids you will also need to take care of the constraints to your
-matrix given by the <a href="hanging_nodes.html">hanging nodes</a>.
+in one row. This first sets up a blank sparsity pattern which,
+however, has as yet no information which entries are non-zero.
+</p>
+<p>
+Before going on with showing how to find out which elements are
+non-zero, we have to talk about how to find out about the maximum
+number of non-zero entries per row which we will need for our matrix.
+Since this number depends of the actual finite element used (higher
+order elements need more non-zero entries than linear elements, for
+example), of the equation under consideration, and of some properties
+of the triangulation on which we want to do our computations. Since
+all these factors can't be considered by the user all the time, there
+is a library function which does the necessary computations for you:
+<code>unsigned int DoFHandler::max_couplings_between_dofs()</code>.
+We note that this function was written to cope with refined grids, and
+if you only have structured grids without local refinement and hanging
+nodes, the result of this function will overestimate the maximal
+number of non-zero entries per row.
+</p>
+<p>
+After having fixed the basic properties of the sparsity structure, we
+can tell it which entries actually are non-zero. This is again done
+using a library function,
+<code>DoFHandler::make_sparsity_pattern</code>. Then we have to take
+into account that constraints due to hanging nodes (see the previous
+chapter) add some more non-zero entries, which is again done using 
+some library functions (see the example below). After this, we can
+instruct the sparsity pattern to throw out all unused elements
+(in those rows where the actual number of non-zero elements is less
+than the maximal number given to <code>reinit</code>, we can discard
+the unused one to save some more memory). This is discussed in the
+next subsection.
+</p>
+<p>
+This matrix structure can then be used to serve as sparsity pattern to
+one or several matrices using 
+<code>void SparseMatrix::reinit(const SparseMatrixStruct&sparsity)</code>.
+We note the distinction that the <code>SparseMatrixStruct</code> only
+stores the places of the non-zero elements, while the
+<code>SparseMatrix</code> actually stores the values of these
+elements. The separation was made since often several matrices are
+needed with the same sparsity pattern, but different entry values;
+this way, we can save some memory space.
 </p>
 
 <p class="Example">
@@ -68,25 +123,29 @@ appropriate places. This example initializes a sparse square matrix structure.
 
 
 const unsigned int dim=2; // For example
-SparseMatrixStruct&lt;double&gt; sparsity_pattern;
-DoFHandler&lt;dim&gt; dof;
-ConstraintMatrix hanging_nodes;  // Only necessary for locally refined grids
+SparseMatrixStruct sparsity_pattern;
+DoFHandler&lt;dim&gt; dof_handler;
 
-// Your degrees of freedom must already be distributed
+// set up a triangulation, refine it, associate the DoFHandler object
+// shown above to it, and distribute the degrees of freedom
+...
 
-sparsity_pattern.reinit(dof.n_dofs(),dof.n_dofs(),dof.max_couplings_between_dofs());
+// now fix the size of the matrix and the maximal number
+// of non-zero entries:
+sparsity_pattern.reinit (dof_handler.n_dofs(),
+                         dof_handler.n_dofs(),
+                         dof_handler.max_couplings_between_dofs());
+
+// tell the sparsity pattern which entries are non-zero:
+dof_handler.make_sparsity_pattern (sparsity_pattern); 
 
 // Condense the <a href="hanging_nodes.html">hanging nodes</a> into
-// the matrix, taking into account the constraints to the hanging nodes.
-// This must be done before the matrix structure is compressed, but only
-// on locally refined grids.
+// the matrix structure, taking into account the constraints due to
+// the hanging nodes. 
 // You can skip this part if your grid is not locally refined.
-
-dof.make_sparsity_pattern(sparsity_pattern); 
-hanging_nodes.clear();
-dof.make_constraint_matrix(hanging_nodes);
-hanging_nodes.condense(sparsity_pattern);
-
+ConstraintMatrix hanging_nodes; 
+dof_handler.make_constraint_matrix(hanging_nodes);
+hanging_nodes.condense (sparsity_pattern);
 </code>
 </pre>
 
@@ -127,6 +186,19 @@ sparsity_pattern.compress();
 </pre>
 
 
+<h3>More complex matrices</h3>
+
+Finally, we note that in some cases not all variables in a system of
+partial differential equations couple to each other, or that the
+operators have a special structure. For this reason, there are more
+specialized version of the
+<code>DoFHandler::make_sparsity_pattern</code> and 
+<code>SparseMatrixStruct::reinit</code> functions, which allow you to
+more flexibly determine the actual number of non-zero elements of all
+or individual rows. See the documentation of the respective classes
+for more information.
+
+
 <!-- Page Foot -->
 <hr>
 <table class="navbar">      
index 52150dac85f23918646477f488d3a0865789b2f4..08e3cc5c6a25476835baf9fbf379733608d522ba 100644 (file)
@@ -19,7 +19,8 @@
 
 <!-- Title Frame -->
 
-<h1 class="chapter_title">The deal.II tutorial - Chapter 0 - Structure of a Finite Element Program</h1>
+<h1 class="chapter_title">The deal.II tutorial - Chapter 0 - Basic
+Elements of a Finite Element Program</h1>
 
 </body>
 </html>
index 94b578185806018fa1964aa0c070376331d65c97..48b793463f78773040d458608f0689af88b1bcd1 100644 (file)
 </head>
 <body lang="en">
 
-<h1>Structure of a Finite Element Program</h1>
+<h1>Basic Elements of a Finite Element Program</h1>
 
 <h2>About this tutorial</h2> 
 <p>
 This part of the <acronym>deal.II</acronym> documentation will discuss
-how to build a finite element program. We will take a look at the general
+some building blocks of a finite element program. We will take a look at the general
 structure of programs of this kind and at the various possibilities 
 in that respect offered by <acronym>deal.II</acronym>. The order of
 the <a href="#toc">table of contents</a> below reflects the order in which
 you need to perform the tasks. Some things may be left out according to
-your needs.
+your needs. The application in actual programs can be found in other
+chapters of this tutorial.
 </p>
 
 <h2><a name="toc">Table of contents</a></h2>
diff --git a/deal.II/doc/tutorial/images/sparsity_1.jpg b/deal.II/doc/tutorial/images/sparsity_1.jpg
new file mode 100644 (file)
index 0000000..f0f1c07
Binary files /dev/null and b/deal.II/doc/tutorial/images/sparsity_1.jpg differ
diff --git a/deal.II/doc/tutorial/images/sparsity_2.jpg b/deal.II/doc/tutorial/images/sparsity_2.jpg
new file mode 100644 (file)
index 0000000..aef82c1
Binary files /dev/null and b/deal.II/doc/tutorial/images/sparsity_2.jpg differ
index 96be3330a34e5c14a4f4f400fa38f39fcff47a9c..8f66c1ea3ea1a51442186d0225ab3c290c22a100 100644 (file)
@@ -9,24 +9,11 @@
     <meta name="author" content="Jan Schrage <schrage@gaia.iwr.uni-heidelberg.de>">
     <meta name="keywords" content="deal.II,deal.II tutorial,deal II"></head>
   <body>
-    <img align=right valign=top alt="Deal Logo" src="../pictures/deal100.gif">
+    <img align=right valign=top width="50%" alt="Deal Logo" src="../pictures/deal100.gif">
     <h1>The <acronym>deal.II</acronym> Tutorial</h1>
     
     <h2>or <acronym>deal.II</acronym> in several easy and some more hard lessons</h2>
     
-    <h3>Prerequisites</h3>
-    <p>
-      This tutorial is written in <a href="http://www.w3.org/TR/REC-html40">HTML
-       4.0</a> which your browser may or may not support. If you run into problems
-      you are advised to try a recent browser or one that is able to parse Document
-      Type Definitions. The reason for this is the math support of HTML 4.0. Most
-      people should, however, not run into any
-      problems.</p>
-    <p>
-      You yourself should have some background knowledge on numerical methods, finite 
-      elements and C++.
-    </p>
-
     <h3>Usage of this document</h3>
     <p>
       This tutorial is split into several parts, starting with an outline of
     <h3>On <acronym>deal.II</acronym></h3>
     <p>
       <acronym>deal.II</acronym> is short for Differential Equations Analysis Library, version II,
-      which says it all, really. Its purpose it the solution of partial differential
-      equations on unstructured grids with error control. You can find more
+      which says it all, really. Its purpose is the solution of partial differential
+      equations on unstructured, locally refined grids with error control. You can find more
       information on <acronym>deal.II</acronym> and some examples at 
-      <a href="http://gaia.iwr.uni-heidelberg.de/~deal/">
-       http://gaia.iwr.uni-heidelberg.de/~deal/</a>. <acronym>deal.II</acronym> was written 
-      by the numerics group at the IWR, University of Heidelberg.
+      <a href="http://gaia.iwr.uni-heidelberg.de/~deal/">the
+      <acronym>deal.II</acronym> homepage </a>.
+      <acronym>deal.II</acronym> was written 
+      by the numerics group at the IWR, University of Heidelberg,
+      mainly by Wolfgang Bangerth and in parts by Guido Kanschat, but
+      several others have contributed as well.
     </p>
-    <h3><a href="00.fe_structure/index.html">Chapter 0: Structure of a
-       Finite Element Program</a> </h3>
+
+    <p>
+    The structure of this tutorial is as follows:
+    <p>
+
+    <h4><a href="00.fe_structure/index.html">Chapter 0: Basic Elements of a
+       Finite Element Program</a> </h4>
     <p> (also available in a <a href="00.fe_structure/toc.html">version without frames</a>)
     </p>
     <p>We will discuss the various elements needed for a working
-      finite element program and some of the possibilitier 
+      finite element program and some of the possibilities 
       <acronym>deal.II</acronym> offers in this respect.
     </p>
     
-    <h3><a href="01.laplace/index.html">Chapter 1: The Laplace
-       Problem</a> </h3>
+    <h4><a href="01.laplace/index.html">Chapter 1: The very simple Laplace
+       Problem</a> </h4>
     <p>
       (also available in a <a href="01.laplace/toc.html">version without frames</a>)
     </p>
     <p>
+      ***********
       We will solve the stationary Laplace problem on a square grid with  
       boundary conditions of the form <code>cos(2*PI*x)cos(2*PI*y)</code>.
       You can also obtain the <a href="01.laplace/source.html">source code</a>.
@@ -87,7 +83,7 @@
     <hr>
     
     <address>
-      <a href="mailto:schrage@gaia.iwr.uni-heidelberg.de">Jan Schrage</a></address>
+      <a href="mailto:deal@gaia.iwr.uni-heidelberg.de">The deal.II group</a></address>
     <p>
       Last modified: $Date$
     </p>

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.