// ---------------------------------------------------------------------
// $Id$
//
-// Copyright (C) 2009 - 2013 by the deal.II authors
+// Copyright (C) 2009 - 2014 by the deal.II authors
//
// This file is part of the deal.II library.
//
* @brief A module discussing the use of parallelism on distributed memory
* clusters.
*
+ * @dealiiVideoLecture{39,41,41.25,41.5}
+ *
* <h3>Overview</h3>
*
* deal.II can use multiple machine connected via MPI to parallelize
// ---------------------------------------------------------------------
// $Id$
//
-// Copyright (C) 2006 - 2013 by the deal.II authors
+// Copyright (C) 2006 - 2014 by the deal.II authors
//
// This file is part of the deal.II library.
//
* @ref MTToC "Table of Contents" below the lenghty list of members
* of this module.
*
+ * @dealiiVideoLecture{39,40}
+ *
* On machines with more than one processor (or multicore processors),
* it is often profitable to run several parts of the computations in
* %parallel. For example, one could have several threads running in
// ---------------------------------------------------------------------
// $Id$
//
-// Copyright (C) 2008 - 2013 by the deal.II authors
+// Copyright (C) 2008 - 2014 by the deal.II authors
//
// This file is part of the deal.II library.
//
* FESystem, which allows us to write code for systems of partial
* differential very much like we write code for single equations.
*
+ * @dealiiVideoLecture{19,20,21}
+ *
* <table class="tutorial" width="50%">
* <tr><th><b>%Table of contents</b></th></tr>
* <tr><td width="100%" valign="top">
$text = $text . ". (All video lectures are also available <a href=\"http://www.math.tamu.edu/~bangerth/videos.html\">here</a>.)";
s/(\@dealiiVideoLecture\{([0-9\.]+)(, *[0-9\.]+ *)*\})/$text/;
}
+
+
+# @dealiiVideoLectureSeeAlso works as above, but just expands into
+# regular text, no @note
+if (m/(\@dealiiVideoLectureSeeAlso\{([0-9\.]+)(, *[0-9\.]+ *)*\})/)
+{
+ $substext = $1;
+
+ $text = "See also ";
+
+ # add links to the individual lectures
+ $text = $text . "<a href=\"http://www.math.tamu.edu/~bangerth/videos.676.$2.html\">video lecture $2</a>";
+
+ if (length($3) > 0)
+ {
+ $x = $3;
+ $x =~ s/^, *//g;
+ @otherlectures = split (',', "$x");
+
+ foreach $lecture (@otherlectures)
+ {
+ $text = $text . ", <a href=\"http://www.math.tamu.edu/~bangerth/videos.676.$lecture.html\">video lecture $lecture</a>";
+ }
+ }
+
+ $text = $text . ".";
+ s/(\@dealiiVideoLectureSeeAlso\{([0-9\.]+)(, *[0-9\.]+ *)*\})/$text/;
+}
Bangerth's video lectures</a> on deal.II and computational science. In
particular, you can see the steps he executes to run this and other
programs, and you will get a much better idea of the tools that can be
-used to work with deal.II.
+used to work with deal.II. In particular, lectures 2 and 4 give an overview of
+deal.II and of the building blocks of any finite element code.
<h3> What this program does </h3>
As a general recommendation: If you expect to spend more than a few days
writing software in the future, do yourself the favor of learning tools that
can make your life more productive, in particular debuggers and integrated
-development environments. You will find that you will get the time spent
+development environments. (@dealiiVideoLectureSeeAlso{7,8,25})
+You will find that you will get the time spent
learning these tools back severalfold soon by being more productive!
Several of the video lectures referenced above show how to use tools
such as integrated development environments or debuggers.
As can be seen, we can easily get to almost four million unknowns. In fact, the
code's runtime with 8 processes was less than 7 minutes up to (and including)
-cycle 14, and 14 minutes including the second to last step. I lost the timing
-information for the last step, though, but you get the idea. All this is if
-the debug flag in the Makefile was changed to "off", i.e. "optimized", and
+cycle 14, and 14 minutes including the second to last step. (These are numbers
+relevant to when the code was initially written, in 2004.) I lost the timing
+information for the last step, though, but you get the idea. All this is after
+release mode has been enabled by running <code>make release</code>, and
with the generation of graphical output switched off for the reasons stated in
-the program comments above. The biggest 2d computations we did had roughly 7.1
+the program comments above.
+(@dealiiVideoLectureSeeAlso{18})
+The biggest 2d computations we did had roughly 7.1
million unknowns, and were done on 32 processes. It took about 40 minutes.
Not surprisingly, the limiting factor for how far one can go is how much memory
one has, since every process has to hold the entire mesh and DoFHandler objects,
<h3>%Boundary conditions</h3>
+@dealiiVideoLecture{21.5}
+
The weak form just derived immediately presents us with different
possibilities for imposing boundary conditions:
<ol>
<h4>2D calculations</h4>
Running the program with the space dimension set to 2 in <code>main()</code>
-yields the following output (when the flag is set to optimized in the
-Makefile):
+yields the following output (in "release mode", @dealiiVideoLectureSeeAlso{18}):
@code
examples/\step-22> make run
-============================ Remaking Makefile.dep
-==============optimized===== \step-22.cc
-============================ Linking \step-22
-============================ Running \step-22
Refinement cycle 0
Number of active cells: 64
Number of degrees of freedom: 679 (594+85)
<a name="Intro"></a>
<h1>Introduction</h1>
+@dealiiVideoLecture{28}
+
This is the first of a number of tutorial programs that will finally
cover "real" time-dependent problems, not the slightly odd form of time
dependence found in step-18 or the DAE model of step-21. In particular, this program introduces
(Of course, execution times will differ if you run the program
locally.) The fact that most of the time is spent on assembling
the system matrix and generating output is due to the many assertion
-that need to be checked in debug mode. In optimized mode these parts
+that need to be checked in debug mode. In release mode these parts
of the program run much faster whereas solving the linear system is
hardly sped up at all:
<img src="http://www.dealii.org/images/steps/developer/step-4.solution-2d.png" alt="">
</p>
+(@dealiiVideoLectureSeeAlso{11,32})
The picture shows the solution of the problem under consideration as
a 3D plot. As can be seen, the solution is almost flat in the interior
of the domain and has a higher curvature near the boundary. This, of
complex, so debugging is an important aspect. We support safe
programming by using assertions that check the validity of
parameters and %internal states in a debug mode, but are removed
- in optimized mode.
+ in optimized mode. (@dealiiVideoLectureSeeAlso{18})
<li> Regarding the mathematical side, we show how to support a
variable coefficient in the elliptic operator and how to use
preconditioned iterative solvers for the linear systems of
are in assembling matrix and right hand side, but these are easily
understood as well.
-In the example, we will want to solve the elastic equations. They are
+@dealiiVideoLecture{19}
+
+In this tutorial program we will want to solve the elastic equations. They are
an extension to Laplace's equation with a vector-valued solution that
describes the displacement in each space direction of a rigid body
which is subject to a force. Of course, the force is also
projects / dealii.git / commitdiff