Context Navigation

← Previous Changeset
Next Changeset →

Changeset 7064

Timestamp:

May 22, 2009, 4:40:11 PM (14 years ago)

Author:

rwilson

Message:

Fiddling with layout of user guide.

Location:

anuga_core/documentation/user_manual

Files:

: 11 edited

anuga_user_manual.tex (modified) (197 diffs)
copyright.tex (modified) (7 diffs)
demos/cairns/ExportResults.py (modified) (4 diffs)
demos/cairns/GetTimeseries.py (modified) (2 diffs)
demos/cairns/project.py (modified) (5 diffs)
demos/cairns/runcairns.py (modified) (12 diffs)
demos/channel1.py (modified) (4 diffs)
demos/channel2.py (modified) (5 diffs)
demos/channel3.py (modified) (5 diffs)
demos/runup.py (modified) (5 diffs)
update_anuga_user_manual.py (modified) (1 diff)

Legend:

: Unmodified
: Added
: Removed

anuga_core/documentation/user_manual/anuga_user_manual.tex

-                      r6887
+                      r7064
 % Complete documentation on the extended LaTeX markup used for Python
 % documentation is available in ``Documenting Python'', which is part
+% documentation is available in ''Documenting Python'', which is part
 % of the standard documentation for Python.  It may be found online
 % at:
+%
 %     http://www.python.org/doc/current/doc/doc.html
 %labels
 …
 % Is latex failing with;
 % `modanuga_user_manual.ind' not found?
+% 'modanuga_user_manual.ind' not found?
 % try this command-line
 %   makeindex modanuga_user_manual.idx
 % To produce the modanuga_user_manual.ind file.
 %%%%%%%%%%%%%% TODO %%%%%%%%%%%%%%%%
 …
 % set_geo_reference
 \documentclass{manual}
 …
 \input{definitions}
+%%%%%
+% Set penalties for widows, etc, very high
+%%%%%
+\widowpenalty=10000
+\clubpenalty=10000
+\raggedbottom
 \title{\anuga User Manual}
 …
 % stages to make it easier to handle versions.
 \longdate       % Make date format long using datetime.sty
 %\settimeformat{xxivtime} % 24 hour Format
 …
 \ifhtml
 \date{\today} % latex2html does not know about datetime
+  \date{\today} % latex2html does not know about datetime
 \fi
 \input{version} % Get version info - this file may be modified by
                 % update_anuga_user_manual.py - if not a dummy
                 % will be used.
+                % will be used.
 %\release{1.0}   % release version; this is used to define the
 %                % \version macro
 …
 \setcounter{secnumdepth}{3}
+% experimental code to get fig/table placement correct.
+% doesn't have much effect.
+%% Alter some LaTeX defaults for better treatment of figures:
+%    % See p.105 of "TeX Unbound" for suggested values.
+%    % See pp. 199-200 of Lamport's "LaTeX" book for details.
+%    %   General parameters, for ALL pages:
+%    \renewcommand{\topfraction}{0.9}   % max fraction of floats at top
+%    \renewcommand{\bottomfraction}{0.8}        % max fraction of floats at bottom
+%    %   Parameters for TEXT pages (not float pages):
+%    \setcounter{topnumber}{2}
+%    \setcounter{bottomnumber}{2}
+%    \setcounter{totalnumber}{4}     % 2 may work better
+%    \setcounter{dbltopnumber}{2}    % for 2-column pages
+%    \renewcommand{\dbltopfraction}{0.9}        % fit big float above 2-col. text
+%    \renewcommand{\textfraction}{0.07} % allow minimal text w. figs
+%    %   Parameters for FLOAT pages (not text pages):
+%    \renewcommand{\floatpagefraction}{0.7}     % require fuller float pages
+%       % N.B.: floatpagefraction MUST be less than topfraction !!
+%    \renewcommand{\dblfloatpagefraction}{0.7}  % require fuller float pages
+%
+%    % remember to use [htp] or [htpb] for placement
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 \begin{document}
 \maketitle
 % This makes the contents more accessible from the front page of the HTML.
 \ifhtml
 \chapter*{Front Matter\label{front}}
+  \chapter*{Front Matter\label{front}}
 \fi
 …
 \input{copyright}
 \begin{abstract}
 \label{def:anuga}
 …
 governing equation using a finite-volume method.
+\anuga also incorporates a mesh generator %, called \code{graphical
+                                %mesh generator},
+that
+\anuga also incorporates a mesh generator that
 allows the user to set up the geometry of the problem interactively as
 well as tools for interpolation and surface fitting, and a number of
 …
 small Python programs based on the \anuga library
 functions. Computationally intensive components are written for
+efficiency in C routines working directly with the Numerical Python
+structures.
+efficiency in C routines working directly with Python numpy structures.
 \end{abstract}
 …
 \tableofcontents
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 \chapter{Introduction}
 …
 The purpose of this user manual is to introduce the new user to the
 inundation software, describe what it can do and give step-by-step
+inundation software system, describe what it can do and give step-by-step
 instructions for setting up and running hydrodynamic simulations.
+The stable release of \anuga and this manual are available on sourceforge at \url{http://sourceforge.net/projects/anuga}. A snapshot of work in progress is available through the \anuga software repository at \url{https://datamining.anu.edu.au/svn/ga/anuga_core} where the more adventurous reader might like to go.
+The stable release of \anuga and this manual are available on sourceforge ati
+\url{http://sourceforge.net/projects/anuga}. A snapshot of work in progress is
+available through the \anuga software repository at
+\url{https://datamining.anu.edu.au/svn/ga/anuga_core}
+where the more adventurous reader might like to go.
 …
 which will be covered in separate publications and by documentation
 in the source code.
 \section{Audience}
 …
 \url{http://datamining.anu.edu.au/\~{}ole/work/teaching/ctac2006/exercise1.pdf}.
 Readers also need to have a general understanding of scientific modelling,
+as well as
+enough programming experience to adapt the code to different
+as well as enough programming experience to adapt the code to different
 requirements.
 \pagebreak
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 \chapter{Background}
 Modelling the effects on the built environment of natural hazards such
 …
 and around structures such as buildings.  \anuga is also capable
 of modelling hydraulic jumps due to the ability of the finite-volume
+method to accommodate discontinuities in the solution/footnote{While \anuga works with discontinuities in the conserved quantities stage, xmomentum and ymomentum, it does not allow discontinuities in the bed elevation}.
+method to accommodate discontinuities in the solution
+\footnote{While \anuga works with discontinuities in the conserved quantities stage,
+          xmomentum and ymomentum, it does not allow discontinuities in the bed elevation}.
 To set up a particular scenario the user specifies the geometry
 (bathymetry and topography), the initial water level (stage),
 boundary conditions such as tide, and any forcing terms that may
 drive the system such as rain_fall, abstraction of water, wind stress or atmospheric pressure
+drive the system such as rainfall, abstraction of water, wind stress or atmospheric pressure
 gradients. Gravity and frictional resistance from the different
 terrains in the model are represented by predefined forcing terms.
 See section \ref{sec:forcing terms} for details on forcing terms available in ANUGA.
+See section \ref{sec:forcing terms} for details on forcing terms available in \anuga.
 The built-in mesh generator, called \code{graphical\_mesh\_generator},
 …
 and can be readily adapted to changing requirements throughout its
 lifetime.  Computationally intensive components are written for
 efficiency in C routines working directly with the Numerical Python
+efficiency in C routines working directly with Python numeric
 structures.  The animation tool developed for \anuga is based on
 OpenSceneGraph, an Open Source Software (OSS) component allowing high
 …
 Although a powerful and flexible tool for hydrodynamic modelling, \anuga has a
 number of limitations that any potential user need to be aware of. They are
+number of limitations that any potential user needs to be aware of. They are:
 \begin{itemize}
 …
   %flow under ceilings or in pipes
   \item All spatial coordinates are assumed to be UTM (meters). As such,
   ANUGA is unsuitable for modelling flows in areas larger than one UTM zone
+  \anuga is unsuitable for modelling flows in areas larger than one UTM zone
   (6 degrees wide).
   \item Fluid is assumed to be inviscid - i.e.\ no kinematic viscosity included.
+  \item Fluid is assumed to be inviscid -- i.e.\ no kinematic viscosity included.
   \item The finite volume is a very robust and flexible numerical technique,
   but it is not the fastest method around. If the geometry is sufficiently
   simple and if there is no need for wetting or drying, a finite-difference
   method may be able to solve the problem faster than \anuga.
   %\item Mesh resolutions near coastlines with steep gradients need to be...
+%\item Mesh resolutions near coastlines with steep gradients need to be...
   \item Frictional resistance is implemented using Manning's formula, but
+  \anuga has not yet been fully validated in regard to bottom roughness
+  %\item ANUGA contains no tsunami-genic functionality relating to
+  %earthquakes.
+  \anuga has not yet been fully validated in regard to bottom roughness.
+%\item ANUGA contains no tsunami-genic functionality relating to earthquakes.
 \end{itemize}
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 \chapter{Getting Started}
 …
 the second is a more realistic example.
 \section{A Simple Example}
 \label{sec:simpleexample}
 …
 (bathymetry and topography), the initial water level, boundary
 conditions such as tide, and any forcing terms that may drive the
 system such as rain_fall, abstraction of water, wind stress or atmospheric pressure gradients.
+system such as rainfall, abstraction of water, wind stress or atmospheric pressure gradients.
 Frictional resistance from the different terrains in the model is
 represented by predefined forcing terms. In this example, the
 …
 involved in the computation are the friction and elevation.
+Water depth can be obtained through the equation
+\begin{tabular}{rcrcl}
+  \code{depth} &=& \code{stage} &$-$& \code{elevation}
+\end{tabular}
+Water depth can be obtained through the equation:
+\begin{verbatim}
+depth = stage - elevation
+\end{verbatim}
 \subsection{Outline of the Program}
 In outline, \file{runup.py} performs the following steps:
 \begin{enumerate}
    \item Sets up a triangular mesh.
    \item Sets certain parameters governing the mode of
+operation of the model-specifying, for instance, where to store the model output.
+         operation of the model, specifying, for instance,
+         where to store the model output.
    \item Inputs various quantities describing physical measurements, such
+as the elevation, to be specified at each mesh point (vertex).
+         as the elevation, to be specified at each mesh point (vertex).
    \item Sets up the boundary conditions.
    \item Carries out the evolution of the model through a series of time
+steps and outputs the results, providing a results file that can
+be visualised.
+         steps and outputs the results, providing a results file that can
+         be viewed.
 \end{enumerate}
 …
 For reference we include below the complete code listing for
 \file{runup.py}. Subsequent paragraphs provide a
 `commentary' that describes each step of the program and explains it
+'commentary' that describes each step of the program and explains it
 significance.
 …
 scenario. This is carried out through the statement:
 {\small \begin{verbatim}
     points, vertices, boundary = rectangular_cross(10, 10)
 \end{verbatim}}
+\begin{verbatim}
+points, vertices, boundary = rectangular_cross(10, 10)
+\end{verbatim}
 The function \function{rectangular_cross} is imported from a module
 …
 several other schemes that can be used for setting up meshes, but we
 shall not discuss these.) The above assignment sets up a $10 \times
 $ rectangular mesh, triangulated in a regular way. The assignment
 {\small \begin{verbatim}
     points, vertices, boundary = rectangular_cross(m, n)
 \end{verbatim}}
+$ rectangular mesh, triangulated in a regular way. The assignment:
+\begin{verbatim}
+points, vertices, boundary = rectangular_cross(m, n)
+\end{verbatim}
 returns:
 \begin{itemize}
    \item a list \code{points} giving the coordinates of each mesh point,
    \item a list \code{vertices} specifying the three vertices of each triangle, and
    \item a dictionary \code{boundary} that stores the edges on
+   the boundary and associates each with one of the symbolic tags \code{`left'}, \code{`right'},
+   \code{`top'} or \code{`bottom'}.
+         the boundary and associates each with one of the symbolic tags \code{'left'}, \code{'right'},
+         \code{'top'} or \code{'bottom'}.
 \end{itemize}
 …
 given in Section \ref{sec:meshexample}.
 \subsection{Initialising the Domain}
 …
 \code{domain}, through the assignment:
 {\small \begin{verbatim}
     domain = Domain(points, vertices, boundary)
 \end{verbatim}}
+\begin{verbatim}
+domain = Domain(points, vertices, boundary)
+\end{verbatim}
 This creates an instance of the \class{Domain} class, which
 …
 directory to be used for data:
+{\small \begin{verbatim}
+    domain.set_name('runup')
+\end{verbatim}}
+{\small \begin{verbatim}
+    domain.set_datadir('.')
+\end{verbatim}}
+\begin{verbatim}
+domain.set_name('runup')
+domain.set_datadir('.')
+\end{verbatim}
 In addition, the following statement now specifies that the
 …
 to be stored:
+{\small \begin{verbatim}
+    domain.set_quantities_to_be_stored(['stage', 'xmomentum',
+    'ymomentum'])
+\end{verbatim}}
+\begin{verbatim}
+domain.set_quantities_to_be_stored(['stage', 'xmomentum', 'ymomentum'])
+\end{verbatim}
 \subsection{Initial Conditions}
 …
 \method{set\_quantity}, used to specify these quantities. It is a
 flexible method that allows the user to set quantities in a variety
 of ways---using constants, functions, numeric arrays, expressions
+of ways -- using constants, functions, numeric arrays, expressions
 involving other quantities, or arbitrary data points with associated
 values, all of which can be passed as arguments. All quantities can
 …
 forms in which we can invoke \method{set\_quantity}.
 \subsubsection{Elevation}
 The elevation, or height of the bed, is set using a function,
+The elevation, or height of the bed, is set using a function
 defined through the statements below, which is specific to this
 example and specifies a particularly simple initial configuration
 for demonstration purposes:
 {\small \begin{verbatim}
     def f(x,y):
         return -x/2
 \end{verbatim}}
+\begin{verbatim}
+def f(x,y):
+    return -x/2
+\end{verbatim}
 This simply associates an elevation with each point \code{(x, y)} of
 …
 \code{elevation} is assigned through the simple statement:
 {\small \begin{verbatim}
     domain.set_quantity('elevation', f)
 \end{verbatim}}
+\begin{verbatim}
+domain.set_quantity('elevation', f)
+\end{verbatim}
 NOTE: If using function to set \code{elevation} it must be vector
 …
 The assignment of the friction quantity (a forcing term)
 demonstrates another way we can use \method{set\_quantity} to set
 quantities---namely, assign them to a constant numerical value:
 {\small \begin{verbatim}
     domain.set_quantity('friction', 0.1)
 \end{verbatim}}
+quantities -- namely, assign them to a constant numerical value:
+\begin{verbatim}
+domain.set_quantity('friction', 0.1)
+\end{verbatim}
 This specifies that the Manning friction coefficient is set to 0.1
 …
 The stage (the height of the water surface) is related to the
+elevation and the depth at any time by the equation
+{\small \begin{verbatim}
+    stage = elevation + depth
+\end{verbatim}}
+elevation and the depth at any time by the equation:
+\begin{verbatim}
+stage = elevation + depth
+\end{verbatim}
 For this example, we simply assign a constant value to \code{stage},
 using the statement
 {\small \begin{verbatim}
     domain.set_quantity('stage', -.4)
 \end{verbatim}}
+using the statement:
+\begin{verbatim}
+domain.set_quantity('stage', -0.4)
+\end{verbatim}
 which specifies that the surface level is set to a height of $-0.4$,
 …
 Although it is not necessary for this example, it may be useful to
 digress here and mention a variant to this requirement, which allows
 us to illustrate another way to use \method{set\_quantity}---namely,
+us to illustrate another way to use \method{set\_quantity} -- namely,
 incorporating an expression involving other quantities. Suppose,
 instead of setting a constant value for the stage, we wished to
 …
 would do this by means of the statements:
 {\small \begin{verbatim}
     h = 0.05 # Constant depth
     domain.set_quantity('stage', expression = 'elevation + %f' %h)
 \end{verbatim}}
+\begin{verbatim}
+h = 0.05    # Constant depth
+domain.set_quantity('stage', expression='elevation + %f' % h)
+\end{verbatim}
 That is, the value of \code{stage} is set to $\code{h} = 0.05$ plus
 …
 The reader will probably appreciate that this capability to
 incorporate expressions into statements using \method{set\_quantity}
 greatly expands its power.) See Section \ref{sec:initial conditions} for more
+greatly expands its power. See Section \ref{sec:initial conditions} for more
 details.
 …
 The boundary conditions are specified as follows:
+{\small \begin{verbatim}
+    Br = Reflective_boundary(domain)
+    Bt = Transmissive_boundary(domain)
+    Bd = Dirichlet_boundary([0.2,0.,0.])
+    Bw = Time_boundary(domain=domain,
+                f=lambda t: [(0.1*sin(t*2*pi)-0.3), 0.0, 0.0])
+\end{verbatim}}
+\begin{verbatim}
+Br = Reflective_boundary(domain)
+Bt = Transmissive_boundary(domain)
+Bd = Dirichlet_boundary([0.2, 0.0, 0.0])
+Bw = Time_boundary(domain=domain, f=lambda t: [(0.1*sin(t*2*pi)-0.3), 0.0, 0.0])
+\end{verbatim}
 The effect of these statements is to set up a selection of different
 …
 elements. The boundary conditions introduced here may be briefly described as
 follows:
 \begin{itemize}
     \item \textbf{Reflective boundary}\label{def:reflective boundary} Returns same \code{stage} as
       as present in its neighbour volume but momentum vector
       reversed 180 degrees (reflected).
       Specific to the shallow water equation as it works with the
       momentum quantities assumed to be the second and third conserved
       quantities. A reflective boundary condition models a solid wall.
+          as present in its neighbour volume but momentum vector
+          reversed 180 degrees (reflected).
+          Specific to the shallow water equation as it works with the
+          momentum quantities assumed to be the second and third conserved
+          quantities. A reflective boundary condition models a solid wall.
     \item \textbf{Transmissive boundary}\label{def:transmissive boundary}
       Returns same conserved quantities as
       those present in its neighbour volume. This is one way of modelling
       outflow from a domain, but it should be used with caution if flow is
       not steady state as replication of momentum at the boundary
       may cause numerical instabilities propagating into the domain and
       eventually causing ANUGA to crash. If this occurs,
       consider using e.g. a Dirichlet boundary condition with a stage value
       less than the elevation at the boundary.
+          Returns same conserved quantities as
+          those present in its neighbour volume. This is one way of modelling
+          outflow from a domain, but it should be used with caution if flow is
+          not steady state as replication of momentum at the boundary
+          may cause numerical instabilities propagating into the domain and
+          eventually causing ANUGA to crash. If this occurs,
+          consider using e.g. a Dirichlet boundary condition with a stage value
+          less than the elevation at the boundary.
     \item \textbf{Dirichlet boundary}\label{def:dirichlet boundary} Specifies
       constant values for stage, $x$-momentum and $y$-momentum at the boundary.
+          constant values for stage, $x$-momentum and $y$-momentum at the boundary.
     \item \textbf{Time boundary}\label{def:time boundary} Like a Dirichlet
       boundary but with behaviour varying with time.
+          boundary but with behaviour varying with time.
 \end{itemize}
 …
 three variables \code{points}, \code{vertices} and \code{boundary}.
 In the code we are discussing, these three variables are returned by
 the function \code{rectangular}; however, the example given in
+the function \code{rectangular}. The example given in
 Section \ref{sec:realdataexample} illustrates another way of
 assigning the values, by means of the function
 \code{create\_mesh\_from\_regions}.
+\code{create_mesh_from_regions}.
 These variables store the data determining the mesh as follows. (You
 …
 helps to clarify the following discussion, even though that example
 is a \emph{non-rectangular} mesh.)
 \begin{itemize}
+\item The variable \code{points} stores a list of 2-tuples giving the
+coordinates of the mesh points.
+\item The variable \code{vertices} stores a list of 3-tuples of
+numbers, representing vertices of triangles in the mesh. In this
+list, the triangle whose vertices are \code{points[i]},
+\code{points[j]}, \code{points[k]} is represented by the 3-tuple
+\code{(i, j, k)}.
+\item The variable \code{boundary} is a Python dictionary that
+not only stores the edges that make up the boundary but also assigns
+symbolic tags to these edges to distinguish different parts of the
+boundary. An edge with endpoints \code{points[i]} and
+\code{points[j]} is represented by the 2-tuple \code{(i, j)}. The
+keys for the dictionary are the 2-tuples \code{(i, j)} corresponding
+to boundary edges in the mesh, and the values are the tags are used
+to label them. In the present example, the value \code{boundary[(i,
+j)]} assigned to \code{(i, j)]} is one of the four tags
+\code{`left'}, \code{`right'}, \code{`top'} or \code{`bottom'},
+depending on whether the boundary edge represented by \code{(i, j)}
+occurs at the left, right, top or bottom of the rectangle bounding
+the mesh. The function \code{rectangular} automatically assigns
+these tags to the boundary edges when it generates the mesh.
+    \item The variable \code{points} stores a list of 2-tuples giving the
+          coordinates of the mesh points.
+    \item The variable \code{vertices} stores a list of 3-tuples of
+          numbers, representing vertices of triangles in the mesh. In this
+          list, the triangle whose vertices are \code{points[i]},
+          \code{points[j]}, \code{points[k]} is represented by the 3-tuple
+          \code{(i, j, k)}.
+    \item The variable \code{boundary} is a Python dictionary that
+          not only stores the edges that make up the boundary but also assigns
+          symbolic tags to these edges to distinguish different parts of the
+          boundary. An edge with endpoints \code{points[i]} and
+          \code{points[j]} is represented by the 2-tuple \code{(i, j)}. The
+          keys for the dictionary are the 2-tuples \code{(i, j)} corresponding
+          to boundary edges in the mesh, and the values are the tags are used
+          to label them. In the present example, the value \code{boundary[(i, j)]}
+          assigned to \code{(i, j)]} is one of the four tags
+          \code{'left'}, \code{'right'}, \code{'top'} or \code{'bottom'},
+          depending on whether the boundary edge represented by \code{(i, j)}
+          occurs at the left, right, top or bottom of the rectangle bounding
+          the mesh. The function \code{rectangular} automatically assigns
+          these tags to the boundary edges when it generates the mesh.
 \end{itemize}
 …
 to an edge depending on which part of the boundary it belongs to.
 (In Section \ref{sec:realdataexample} we describe an example that
 uses different boundary tags --- in general, the possible tags are entirely selectable by the user when generating the mesh and not
 limited to `left', `right', `top' and `bottom' as in this example.)
+uses different boundary tags -- in general, the possible tags are entirely selectable by the user when generating the mesh and not
+limited to 'left', 'right', 'top' and 'bottom' as in this example.)
 All segments in bounding polygon must be tagged. If a tag is not supplied, the default tag name 'exterior' will be assigned by ANUGA.
 Using the boundary objects described above, we assign a boundary
+condition to each part of the boundary by means of a statement like
+{\small \begin{verbatim}
+    domain.set_boundary({'left': Br, 'right': Bw, 'top': Br, 'bottom': Br})
+\end{verbatim}}
+It is critical that all tags are assoctiated with a boundary conditing in this statement. If not the program will halt with a statement like
+condition to each part of the boundary by means of a statement like:
 \begin{verbatim}
+domain.set_boundary({'left': Br, 'right': Bw, 'top': Br, 'bottom': Br})
+\end{verbatim}
+It is critical that all tags are associated with a boundary condition in this statement.
+If not the program will halt with a statement like:
+\begin{verbatim}
 Traceback (most recent call last):
   File "mesh_test.py", line 114, in ?
 …
 \end{verbatim}
+The command \code{set\_boundary} stipulates that, in the current example, the right
+The command \code{set_boundary} stipulates that, in the current example, the right
 boundary varies with time, as defined by the lambda function, while the other
 boundaries are all reflective.
 …
 \code{stage}, $x$-momentum and $y$-momentum, respectively.)
+{\small \begin{verbatim}
+    Bw = Time_boundary(domain=domain,
+                       f=lambda t: [(0.1*sin(t*2*pi)-0.3), 0.0, 0.0])
+\end{verbatim}}
+\begin{verbatim}
+Bw = Time_boundary(domain=domain, f=lambda t: [(0.1*sin(t*2*pi)-0.3), 0.0, 0.0])
+\end{verbatim}
 \subsection{Evolution}\index{evolution}
+The final statement \nopagebreak[3]
+{\small \begin{verbatim}
+    for t in domain.evolve(yieldstep = 0.1, duration = 4.0):
+        print domain.timestepping_statistics()
+\end{verbatim}}
+causes the configuration of the domain to `evolve', over a series of
+The final statement:
+\begin{verbatim}
+for t in domain.evolve(yieldstep=0.1, duration=4.0):
+    print domain.timestepping_statistics()
+\end{verbatim}
+causes the configuration of the domain to 'evolve', over a series of
 steps indicated by the values of \code{yieldstep} and
 \code{duration}, which can be altered as required.  The value of
 …
 outputs.  Behind the scenes more time steps are generally taken.
 \subsection{Output}
 The output is a NetCDF file with the extension \code{.sww}. It
 contains stage and momentum information and can be used with the
+ANUGA viewer \code{animate} (see Section \ref{sec:animate})
+visualisation package
+to generate a visual display. See Section \ref{sec:file formats}
+ANUGA viewer \code{animate} visualisation package to generate a visual
+display (see Section \ref{sec:animate}). See Section \ref{sec:file formats}
 (page \pageref{sec:file formats}) for more on NetCDF and other file
 formats.
 …
 The code can be run in various ways:
 \begin{itemize}
   \item{from a Windows or Unix command line} as in\ \code{python runup.py}
 …
 Figure \ref{fig:runup2} shows later snapshots for $t=2.3$ and
 $t=4$ where the system has been evolved and the wave is encroaching
 on the previously dry bed.  All figures are screenshots from an
+interactive animation tool called animate which is part of \anuga and
+distributed as in the package anuga\_viewer.
 Animate is described in more detail is Section \ref{sec:animate}.
+\begin{figure}[hbt]
+on the previously dry bed.
+All figures are screenshots from an interactive animation tool called \code{animate}
+which is part of \anuga and distributed as in the package anuga\_viewer.
+\code{animate} is described in more detail is Section \ref{sec:animate}.
+\begin{figure}[htp]
   \centerline{\includegraphics[width=75mm, height=75mm]
     {graphics/bedslopestart.jpg}}
   \caption{Runup example viewed with the ANUGA viewer}
   \label{fig:runupstart}
 \end{figure}
+\begin{figure}[hbt]
+\begin{figure}[htp]
   \centerline{
    \includegraphics[width=75mm, height=75mm]{graphics/bedslopeduring.jpg}
+    \includegraphics[width=75mm, height=75mm]{graphics/bedslopeduring.jpg}
     \includegraphics[width=75mm, height=75mm]{graphics/bedslopeend.jpg}
+   }
   \caption{Runup example viewed with ANGUA viewer}
   \label{fig:runup2}
 \end{figure}
 \clearpage
-%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 \section{A slightly more complex example}
 …
 The next example is about waterflow in a channel with varying boundary conditions and
 more complex topograhies. These examples build on the
+more complex topographies. These examples build on the
 concepts introduced through the \file{runup.py} in Section \ref{sec:simpleexample}.
 The example will be built up through three progressively more complex scripts.
 \subsection{Overview}
 As in the case of \file{runup.py}, the actions carried
 out by the program can be organised according to this outline:
 \begin{enumerate}
    \item Set up a triangular mesh.
    \item Set certain parameters governing the mode of
+operation of the model---specifying, for instance, where to store the
+model output.
+         operation of the model -- specifying, for instance, where to store the
+         model output.
    \item Set up initial conditions for various quantities such as the elevation, to be specified at each mesh point (vertex).
    \item Set up the boundary conditions.
    \item Carry out the evolution of the model through a series of time
+steps and output the results, providing a results file that can be
+visualised.
+         steps and output the results, providing a results file that can be
+         viewed.
 \end{enumerate}
 \subsection{The Code}
 Here is the code for the first version of the channel flow \file{channel1.py}:
 \verbatiminput{demos/channel1.py}
 In discussing the details of this example, we follow the outline
 given above, discussing each major step of the code in turn.
 …
 \subsection{Establishing the Mesh}\index{mesh, establishing}
 In this example we use a similar simple structured triangular mesh as in \code{runup.py}
+In this example we use a similar simple structured triangular mesh as in \file{runup.py}
 for simplicity, but this time we will use a symmetric one and also
 change the physical extent of the domain. The assignment
 {\small \begin{verbatim}
+    points, vertices, boundary = rectangular_cross(m, n,
+                                                   len1=length, len2=width)
+\end{verbatim}}
 returns a m x n mesh similar to the one used in the previous example, except that now the
+change the physical extent of the domain. The assignment:
+\begin{verbatim}
+points, vertices, boundary = rectangular_cross(m, n, len1=length, len2=width)
+\end{verbatim}
+returns an \code{m x n} mesh similar to the one used in the previous example, except that now the
 extent in the x and y directions are given by the value of \code{length} and \code{width}
 respectively.
+Defining m and n in terms of the extent as in this example provides a convenient way of
+controlling the resolution: By defining dx and dy to be the desired size of each hypothenuse in the mesh we can write the mesh generation as follows:
+{\small \begin{verbatim}
+length = 10.
+width = 5.
+Defining \code{m} and \code{n} in terms of the extent as in this example provides a convenient way of
+controlling the resolution: By defining \code{dx} and \code{dy} to be the desired size of each
+hypothenuse in the mesh we can write the mesh generation as follows:
+\begin{verbatim}
+length = 10.0
+width = 5.0
 dx = dy = 1           # Resolution: Length of subdivisions on both axes
 points, vertices, boundary = rectangular_cross(int(length/dx), int(width/dy),
                                                len1=length, len2=width)
+\end{verbatim}}
+which yields a mesh of length=10m, width=5m with 1m spacings. To increase the resolution, as we will later in this example, one merely decrease the values of dx and dy.
+\end{verbatim}
+which yields a mesh of length=10m, width=5m with 1m spacings. To increase the resolution,
+as we will later in this example, one merely decreases the values of \code{dx} and \code{dy}.
 The rest of this script is as in the previous example.
+% except for an application of the 'expression' form of \code{set\_quantity} where we use the value of \code{elevation} to define the (dry) initial condition for \code{stage}:
+%{\small \begin{verbatim}
+% except for an application of the 'expression' form of \code{set\_quantity} where we use
+% the value of \code{elevation} to define the (dry) initial condition for \code{stage}:
+%\begin{verbatim}
 %  domain.set_quantity('stage', expression='elevation')
+%\end{verbatim}}
+%\end{verbatim}
 \section{Model Output}
 …
 The following figure is a screenshot from the \anuga visualisation
 tool \code{animate} of output from this example.
+\begin{figure}[hbt]
+\begin{figure}[htp]
   \centerline{\includegraphics[height=75mm]
     {graphics/channel1.png}}%
   \caption{Simple channel example viewed with the ANUGA viewer.}
   \label{fig:channel1}
 \end{figure}
 \subsection{Changing boundary conditions on the fly}
 \label{sec:change boundary}
 Here is the code for the second version of the channel flow \file{channel2.py}:
 \verbatiminput{demos/channel2.py}
 This example differs from the first version in that a constant outflow boundary condition has
+been defined
+{\small \begin{verbatim}
+    Bo = Dirichlet_boundary([-5, 0, 0]) # Outflow
+\end{verbatim}}
+been defined:
+\begin{verbatim}
+Bo = Dirichlet_boundary([-5, 0, 0])    # Outflow
+\end{verbatim}
 and that it is applied to the right hand side boundary when the water level there exceeds 0m.
+{\small \begin{verbatim}
+\begin{verbatim}
 for t in domain.evolve(yieldstep = 0.2, finaltime = 40.0):
     domain.write_time()
 …
         print 'Stage > 0: Changing to outflow boundary'
         domain.set_boundary({'right': Bo})
+\end{verbatim}}
+\end{verbatim}
 \label{sec:change boundary code}
+The if statement in the timestepping loop (evolve) gets the quantity
+\code{stage} and obtain the interpolated value at the point (10m,
+The \code{if} statement in the timestepping loop (evolve) gets the quantity
+\code{stage} and obtains the interpolated value at the point (10m,
 .5m) which is on the right boundary. If the stage exceeds 0m a
 message is printed and the old boundary condition at tag 'right' is
+replaced by the outflow boundary using the method
+{\small \begin{verbatim}
+    domain.set_boundary({'right': Bo})
+\end{verbatim}}
+replaced by the outflow boundary using the method:
+\begin{verbatim}
+domain.set_boundary({'right': Bo})
+\end{verbatim}
 This type of dynamically varying boundary could for example be
+used to model the
+breakdown of a sluice door when water exceeds a certain level.
+used to model the breakdown of a sluice door when water exceeds a certain level.
 \subsection{Output}
+The text output from this example looks like this
+{\small \begin{verbatim}
+The text output from this example looks like this:
+\begin{verbatim}
 ...
 Time = 15.4000, delta t in [0.03789902, 0.03789916], steps=6 (6)
 …
 Time = 16.2000, delta t in [0.03789892, 0.03789904], steps=6 (6)
 ...
+\end{verbatim}}
+\end{verbatim}
 \subsection{Flow through more complex topograhies}
 Here is the code for the third version of the channel flow \file{channel3.py}:
 \verbatiminput{demos/channel3.py}
 …
 contains obstacles.
+This is accomplished here by defining the function \code{topography} as follows
+{\small \begin{verbatim}
+This is accomplished here by defining the function \code{topography} as follows:
+\begin{verbatim}
 def topography(x,y):
+    """Complex topography defined by a function of vectors x and y
+    """
+    """Complex topography defined by a function of vectors x and y."""
     z = -x/10
 …
     N = len(x)
     for i in range(N):
         # Step
         if 10 < x[i] < 12:
 …
     return z
+\end{verbatim}}
+In addition, changing the resolution to dx=dy=0.1 creates a finer mesh resolving the new featurse better.
+A screenshot of this model at time == 15s is
+\begin{figure}[hbt]
+\end{verbatim}
+In addition, changing the resolution to \code{dx = dy = 0.1} creates a finer mesh resolving the new features better.
+A screenshot of this model at time 15s is:
+\begin{figure}[htp]
   \centerline{\includegraphics[height=75mm]
     {graphics/channel3.png}}
   \caption{More complex flow in a channel}
   \label{fig:channel3}
 …
-\clearpage
-%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 \section{An Example with Real Data}
 \label{sec:realdataexample} The following discussion builds on the
 concepts introduced through the \file{runup.py} example and
 …
 As in the case of \file{runup.py}, the actions carried
 out by the program can be organised according to this outline:
 \begin{enumerate}
    \item Set up a triangular mesh.
    \item Set certain parameters governing the mode of
 operation of the model---specifying, for instance, where to store the
 model output.
+         operation of the model -- specifying, for instance, where to store the
+         model output.
    \item Input various quantities describing physical measurements, such
 as the elevation, to be specified at each mesh point (vertex).
+         as the elevation, to be specified at each mesh point (vertex).
    \item Set up the boundary conditions.
    \item Carry out the evolution of the model through a series of time
+steps and output the results, providing a results file that can be
+visualised.
+         steps and output the results, providing a results file that can be
+         visualised.
 \end{enumerate}
 \subsection{The Code}
 …
 In its simplest form, the mesh-generator creates the mesh within a single
 polygon whose vertices are at geographical locations specified by
 the user. The user specifies the \emph{resolution}---that is, the
 maximal area of a triangle used for triangulation---and a triangular
+the user. The user specifies the \emph{resolution} -- that is, the
+maximal area of a triangle used for triangulationR -- and a triangular
 mesh is created inside the polygon using a mesh generation engine.
 On any given platform, the same mesh will be returned.
 …
 %triangulation is carried out within a pentagon.
+%\begin{figure}[hbt]
+%\begin{figure}[htp]
 %  \caption{Mesh points are created inside the polygon}
   %\label{fig:pentagon}
 %\end{figure}
 Boundary tags are not restricted to \code{`left'}, \code{`bottom'},
 \code{`right'} and \code{`top'}, as in the case of
+Boundary tags are not restricted to \code{'left'}, \code{'bottom'},
+\code{'right'} and \code{'top'}, as in the case of
 \file{runup.py}. Instead the user specifies a list of
 tags appropriate to the configuration being modelled.
 …
 a number of \emph{interior polygons}, each with a specified
 resolution. It is also
 possible to specify one or more `holes'---that is, areas bounded by
+possible to specify one or more 'holes' -- that is, areas bounded by
 polygons in which no triangulation is required.
 %\begin{figure}[hbt]
+%\begin{figure}[htp]
 %  \caption{Interior meshes with individual resolution}
 %  \label{fig:interior meshes}
 …
 extension \code{.tsh}. In the present case, the binary file format
 \code{.msh} is used. See Section \ref{sec:file formats} (page
 \pageref{sec:file formats}) for more on file formats.)
+\pageref{sec:file formats}) for more on file formats.
 In practice, the details of the polygons used are read from a
 …
 would decrease to the order of tens of metres.
+\begin{figure}[hbt]
+\centerline{\includegraphics[scale=0.5]{graphics/cairns3.jpg}}
+\caption{Landscape of the Cairns scenario.}
+\label{fig:cairns3d}
+\clearpage
+\begin{figure}[htp]
+  \centerline{\includegraphics[scale=0.5]{graphics/cairns3.jpg}}
+  \caption{Landscape of the Cairns scenario.}
+  \label{fig:cairns3d}
 \end{figure}
 The following statements are used to read in the specific polygons
 from \code{project.cairns} and assign a defined resolution to
 each polygon.
 {\small \begin{verbatim}
     islands_res = 100000
     cairns_res = 100000
     shallow_res = 500000
     interior_regions = [[project.poly_cairns, cairns_res],
                         [project.poly_island0, islands_res],
                         [project.poly_island1, islands_res],
                         [project.poly_island2, islands_res],
                         [project.poly_island3, islands_res],
                         [project.poly_shallow, shallow_res]]
 \end{verbatim}}
+\begin{verbatim}
+islands_res = 100000
+cairns_res = 100000
+shallow_res = 500000
+interior_regions = [[project.poly_cairns,  cairns_res],
+                    [project.poly_island0, islands_res],
+                    [project.poly_island1, islands_res],
+                    [project.poly_island2, islands_res],
+                    [project.poly_island3, islands_res],
+                    [project.poly_shallow, shallow_res]]
+\end{verbatim}
 Figure \ref{fig:cairnspolys}
 illustrates the polygons used for the Cairns scenario.
+\begin{figure}[hbt]
+\clearpage
+\begin{figure}[htp]
   \centerline{\includegraphics[scale=0.5]
       {graphics/cairnsmodel.jpg}}
 …
 \end{figure}
+The statement
+{\small \begin{verbatim}
+The statement:
+\begin{verbatim}
 remainder_res = 10000000
 create_mesh_from_regions(project.bounding_polygon,
 …
                          use_cache=True,
                          verbose=True)
+\end{verbatim}}
+\end{verbatim}
 is then used to create the mesh, taking the bounding polygon to be
 the polygon \code{bounding\_polygon} specified in \file{project.py}.
 The argument \code{boundary\_tags} assigns a dictionary, whose keys
 are the names of the boundary tags used for the bounding
 polygon---\code{`top'}, \code{`ocean\_east'}, \code{`bottom'}, and
 \code{`onshore'}--- and whose values identify the indices of the
+polygon -- \code{'top'}, \code{'ocean\_east'}, \code{'bottom'}, and
+\code{'onshore'} -- and whose values identify the indices of the
 segments associated with each of these tags.
 The polygon may be arranged either clock-wise or counter clock-wise and the
 …
 (Here, the values associated with each boundary tag are one-element lists, but they can have as many indices as there are edges)
 If polygons intersect, or edges coincide (or are even very close) the resolution may be undefined in some regions.
 Use the underlying mesh interface for such cases. See Section
 \ref{sec:mesh interface}.
+Use the underlying mesh interface for such cases.
+See Section \ref{sec:mesh interface}.
 If a segment is omitted in the tags definition an Exception is raised.
 …
 areas to be generated irrespective of the requested resolution.
 Make sure points on polygons are spaced to be no closer than the smallest resolution requested.
 \subsection{Initialising the Domain}
 …
 \code{meshname}, as follows:
+{\small \begin{verbatim}
+    domain = Domain(meshname, use_cache=True, verbose=True)
+\end{verbatim}}
+\begin{verbatim}
+domain = Domain(meshname, use_cache=True, verbose=True)
+\end{verbatim}
 Providing a filename instead of the lists used in \file{runup.py}
 …
 taken from \file{project.py}.
+{\small \begin{verbatim}
+    domain.set_name(project.basename)
+    domain.set_datadir(project.outputdir)
+    domain.set_quantities_to_be_stored(['stage', 'xmomentum',
+        'ymomentum'])
+\end{verbatim}}
+\begin{verbatim}
+domain.set_name(project.basename)
+domain.set_datadir(project.outputdir)
+domain.set_quantities_to_be_stored(['stage', 'xmomentum', 'ymomentum'])
+\end{verbatim}
 \subsection{Initial Conditions}
 Quantities for \file{runcairns.py} are set
 using similar methods to those in \file{runup.py}. However,
 …
 ancillary points file.
 \subsubsection{Stage}
 …
 object \code{tsunami\_source}, assigned by means of a function
 \function{slide\_tsunami}. This is similar to how we set elevation in
 \file{runup.py} using a function---however, in this case the
+\file{runup.py} using a function -- however, in this case the
 function is both more complex and more interesting.
 …
 We assign the friction exactly as we did for \file{runup.py}:
+{\small \begin{verbatim}
+    domain.set_quantity('friction', 0.0)
+\end{verbatim}}
+\begin{verbatim}
+domain.set_quantity('friction', 0.0)
+\end{verbatim}
 \subsubsection{Elevation}
 …
 The elevation is specified by reading data from a file:
 {\small \begin{verbatim}
     domain.set_quantity('elevation',
                         filename = project.dem_name + '.pts',
                         use_cache = True,
                         verbose = True)
 \end{verbatim}}
+\begin{verbatim}
+domain.set_quantity('elevation',
+                    filename=project.dem_name+'.pts',
+                    use_cache=True,
+                    verbose=True)
+\end{verbatim}
 %However, before this step can be executed, some preliminary steps
 %are needed to prepare the file from which the data is taken. Two
 %source files are used for this data---their names are specified in
+%source files are used for this data -- their names are specified in
 %the file \file{project.py}, in the variables \code{coarsedemname}
 %and \code{finedemname}. They contain `coarse' and `fine' data,
 %respectively---that is, data sampled at widely spaced points over a
+%and \code{finedemname}. They contain 'coarse' and 'fine' data,
+%respectively -- that is, data sampled at widely spaced points over a
 %large region and data sampled at closely spaced points over a
 %smaller subregion. The data in these files is combined through the
 %statement
 %{\small \begin{verbatim}
+%\begin{verbatim}
 %combine_rectangular_points_files(project.finedemname + '.pts',
 %                                 project.coarsedemname + '.pts',
 %                                 project.combineddemname + '.pts')
+%\end{verbatim}}
+%\end{verbatim}
+%
 %The effect of this is simply to combine the datasets by eliminating
 %any coarse data associated with points inside the smaller region
 …
 boundary tag names introduced when we established the mesh. In place of the four
 boundary types introduced for \file{runup.py}, we use the reflective
+boundary for each of the
+eight tagged segments defined by \code{create_mesh_from_regions}:
+{\small \begin{verbatim}
+boundary for each of the eight tagged segments defined by \code{create_mesh_from_regions}:
+\begin{verbatim}
 Bd = Dirichlet_boundary([0.0,0.0,0.0])
+domain.set_boundary( {'ocean_east': Bd, 'bottom': Bd, 'onshore': Bd,
+                          'top': Bd} )
+\end{verbatim}}
+domain.set_boundary({'ocean_east': Bd, 'bottom': Bd, 'onshore': Bd, 'top': Bd})
+\end{verbatim}
 \subsection{Evolution}
 With the basics established, the running of the `evolve' step is
+With the basics established, the running of the 'evolve' step is
 very similar to the corresponding step in \file{runup.py}. For the slide
+scenario,
+the simulation is run for 5000 seconds with the output stored every ten seconds.
+For this example, we choose to apply the slide at 60 seconds into the simulation.
+{\small \begin{verbatim}
+    import time t0 = time.time()
+    for t in domain.evolve(yieldstep = 10, finaltime = 60):
+            domain.write_time()
+            domain.write_boundary_statistics(tags = 'ocean_east')
+        # add slide
+        thisstagestep = domain.get_quantity('stage')
+        if allclose(t, 60):
+            slide = Quantity(domain)
+            slide.set_values(tsunami_source)
+            domain.set_quantity('stage', slide + thisstagestep)
+        for t in domain.evolve(yieldstep = 10, finaltime = 5000,
+                               skip_initial_step = True):
+            domain.write_time()
+scenario, the simulation is run for 5000 seconds with the output stored every ten seconds.
+For this example, we choose to apply the slide at 60 seconds into the simulation:
+\begin{verbatim}
+import time
+t0 = time.time()
+for t in domain.evolve(yieldstep=10, finaltime=60):
+        domain.write_time()
         domain.write_boundary_statistics(tags = 'ocean_east')
+\end{verbatim}}
+    # add slide
+    thisstagestep = domain.get_quantity('stage')
+    if allclose(t, 60):
+        slide = Quantity(domain)
+        slide.set_values(tsunami_source)
+        domain.set_quantity('stage', slide + thisstagestep)
+    for t in domain.evolve(yieldstep=10, finaltime=5000,
+                           skip_initial_ste=True):
+        domain.write_time()
+    domain.write_boundary_statistics(tags = 'ocean_east')
+\end{verbatim}
 For the fixed wave scenario, the simulation is run to 10000 seconds,
 …
 parts of the simulation to be viewed at higher time resolution.
+{\small \begin{verbatim}
+\begin{verbatim}
 # save every two mins leading up to wave approaching land
+    for t in domain.evolve(yieldstep = 120, finaltime = 5000):
+        domain.write_time()
+        domain.write_boundary_statistics(tags = 'ocean_east')
+    # save every 30 secs as wave starts inundating ashore
+    for t in domain.evolve(yieldstep = 10, finaltime = 10000,
+                           skip_initial_step = True):
+        domain.write_time()
+        domain.write_boundary_statistics(tags = 'ocean_east')
+\end{verbatim}}
+for t in domain.evolve(yieldstep=120, finaltime=5000):
+    domain.write_time()
+    domain.write_boundary_statistics(tags='ocean_east')
+# save every 30 secs as wave starts inundating ashore
+for t in domain.evolve(yieldstep=10, finaltime=10000, skip_initial_step=True):
+    domain.write_time()
+    domain.write_boundary_statistics(tags='ocean_east')
+\end{verbatim}
 \section{Exploring the Model Output}
 Now that the scenario has been run, the user can view the output in a number of ways.
 As described earlier, the user may run animate to view a three-dimensional representation
+As described earlier, the user may run \code{animate} to view a three-dimensional representation
 of the simulation.
 The user may also be interested in a maximum inundation map. This simply shows the
 maximum water depth over the domain and is achieved with the function sww2dem (described in
 Section \ref{sec:basicfileconversions}).
+maximum water depth over the domain and is achieved with the function \code{sww2dem}
+described in Section \ref{sec:basicfileconversions}).
 \file{ExportResults.py} demonstrates how this function can be used:
 \verbatiminput{demos/cairns/ExportResults.py}
 The script generates an maximum water depth ASCII grid at a defined
+The script generates a maximum water depth ASCII grid at a defined
 resolution (here 100 m$^2$) which can then be viewed in a GIS environment, for
 example. The parameters used in the function are defined in \file{project.py}.
 …
 coastline.
+\begin{figure}[hbt]
+\centerline{\includegraphics[scale=0.5]{graphics/slidedepth.jpg}}
+\caption{Maximum inundation map for the Cairns slide scenario. \bf Note, this
+inundation map has been based on a purely hypothetical scenario which was
+designed explictiy for demonstration purposes only.}
+\label{fig:maxdepthcairnsslide}
+\clearpage
+\begin{figure}[htp]
+  \centerline{\includegraphics[scale=0.5]{graphics/slidedepth.jpg}}
+  \caption{Maximum inundation map for the Cairns slide scenario. \bf Note, this
+           inundation map has been based on a purely hypothetical scenario which was
+           designed explictiy for demonstration purposes only.}
+  \label{fig:maxdepthcairnsslide}
 \end{figure}
+\begin{figure}[hbt]
+\centerline{\includegraphics[scale=0.5]{graphics/fixedwavedepth.jpg}}
+\caption{Maximum inundation map for the Cairns fixed wave scenario.
+\bf Note, this
+inundaiton map has been based on a purely hypothetical scenario which was
+designed explictiy for demonstration purposes only.}
+\label{fig:maxdepthcairnsfixedwave}
+\clearpage
+\begin{figure}[htp]
+  \centerline{\includegraphics[scale=0.5]{graphics/fixedwavedepth.jpg}}
+  \caption{Maximum inundation map for the Cairns fixed wave scenario.
+           \bf Note, this inundation map has been based on a purely hypothetical scenario which was
+           designed explictiy for demonstration purposes only.}
+  \label{fig:maxdepthcairnsfixedwave}
 \end{figure}
+\clearpage
 The user may also be interested in interrogating the solution at a particular spatial
 …
 identified for the Cairns scenario, as shown in Figure \ref{fig:cairnsgauges}.
 \begin{figure}[hbt]
 \centerline{\includegraphics[scale=0.5]{graphics/cairnsgauges.jpg}}
 \caption{Point locations to show time series information for the Cairns scenario.}
 \label{fig:cairnsgauges}
+\begin{figure}[htp]
+  \centerline{\includegraphics[scale=0.5]{graphics/cairnsgauges.jpg}}
+  \caption{Point locations to show time series information for the Cairns scenario.}
+  \label{fig:cairnsgauges}
 \end{figure}
 These locations
 must be stored in either a .csv or .txt file. The corresponding .csv file for
 the gauges shown in Figure \ref{fig:cairnsgauges} is \file{gauges.csv}
+the gauges shown in Figure \ref{fig:cairnsgauges} is \file{gauges.csv}:
 \verbatiminput{demos/cairns/gauges.csv}
 …
 northings, and each gauge is given a name. The elevation column can be zero here.
 This information is then passed to the function \code{sww2csv_gauges} (shown in
 \file{GetTimeseries.py} which generates the csv files for each point location. The csv files
+\file{GetTimeseries.py} which generates the csv files for each point location. The CSV files
 can then be used in \code{csv2timeseries_graphs} to create the timeseries plot for each desired
 quantity. \code{csv2timeseries_graphs} relies on \code{pylab} to be installed which is not part
 …
 Airport in Figure \ref{fig:airportboth}.
 \begin{figure}[hbt]
 \centerline{\includegraphics[scale=0.5]{graphics/gaugeElfordReefstage.png}}
 \caption{Time series information of the quantity stage for the Elford Reef location for the
 fixed wave and slide scenario.}
 \label{fig:reef}
+\begin{figure}[htp]
+  \centerline{\includegraphics[scale=0.5]{graphics/gaugeElfordReefstage.png}}
+  \caption{Time series information of the quantity stage for the Elford Reef location for the
+           fixed wave and slide scenario.}
+  \label{fig:reef}
 \end{figure}
 \begin{figure}[hbt]
 \centerline{\includegraphics[scale=0.5]{graphics/gaugeCairnsAirportdepth.png}}
 \caption{Time series information of the quantity depth for the Cairns Airport
 location for the slide and fixed wave scenario.}
 \label{fig:airportboth}
+\begin{figure}[htp]
+  \centerline{\includegraphics[scale=0.5]{graphics/gaugeCairnsAirportdepth.png}}
+  \caption{Time series information of the quantity depth for the Cairns Airport
+           location for the slide and fixed wave scenario.}
+  \label{fig:airportboth}
 \end{figure}
-%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 …
 following headings, which correspond to the outline of the examples
 described in Chapter \ref{ch:getstarted}:
 \begin{itemize}
     \item Establishing the Mesh: Section \ref{sec:establishing the mesh}
     \item Initialising the Domain: Section \ref{sec:initialising the domain}
     \item Specifying the Quantities: Section \ref{sec:quantitis}
+%    \item Specifying the Quantities: Section \ref{sec:quantities}
     \item Initial Conditions: Section \ref{sec:initial conditions}
     \item Boundary Conditions: Section \ref{sec:boundary conditions}
 …
 The listings are intended merely to give the reader an idea of what
 each feature is, where to find it and how it can be used---they do
+each feature is, where to find it and how it can be used -- they do
 not give full specifications; for these the reader
 may consult the code. The code for every function or class contains
 a documentation string, or `docstring', that specifies the precise
+a documentation string, or 'docstring', that specifies the precise
 syntax for its use. This appears immediately after the line
 introducing the code, between two sets of triple quotes.
 …
 \module{mesh\_interface} in a subfolder of \module{inundation} called
 \code{pmesh}. In Linux or Unix syntax, the pathname of the file
 containing the function, relative to \file{inundation}, would be
 \begin{center}
+%    \code{pmesh/mesh\_interface.py}
     \code{pmesh}$\slash$\code{mesh\_interface.py}
+\end{center}
+containing the function, relative to \file{inundation}, would be:
+\begin{verbatim}
+pmesh/mesh_interface.py
+\end{verbatim}
 \label{sec:mesh interface}
+while in Windows syntax it would be
+\begin{center}
+    \code{pmesh}$\backslash$\code{mesh\_interface.py}
+\end{center}
+while in Windows syntax it would be:
+\begin{verbatim}
+pmesh\mesh_interface.py
+\end{verbatim}
 Rather than using either of these forms, in this chapter we specify
 the location simply as \code{pmesh.mesh\_interface}, in keeping with
+the location simply as \code{pmesh.mesh_interface}, in keeping with
 the usage in the Python statement for importing the function,
 namely:
+\begin{center}
+    \code{from pmesh.mesh\_interface import create\_mesh\_from\_regions}
+\end{center}
+\begin{verbatim}
+from pmesh.mesh_interface import create_mesh_from_regions
+\end{verbatim}
 Each listing details the full set of parameters for the class or
 …
 and are omitted from the descriptions given below:
+%\begin{center}
+\begin{tabular}{ll}  %\hline
+%\textbf{Name } & \textbf{Description}\\
+%\hline
+\emph{use\_cache} & Specifies whether caching is to be used for improved performance. See Section \ref{sec:caching} for details on the underlying caching functionality\\
+\emph{verbose} & If \code{True}, provides detailed terminal output
+to the user\\  % \hline
+%\begin{tabular}{ll}
+\begin{tabular}{p{2.0cm} p{14.0cm}}
+  \emph{use\_cache} & Specifies whether caching is to be used for improved performance.
+                      See Section \ref{sec:caching} for details on the underlying caching functionality\\
+  \emph{verbose} & If \code{True}, provides detailed terminal output to the user\\
 \end{tabular}
+%\end{center}
 \section{Mesh Generation}\index{Mesh!generation}
 …
 very simple mesh comprising just 11 points and 10 triangles.
+\begin{figure}[h]
+\begin{figure}[htp]
   \begin{center}
     \includegraphics[width=90mm, height=90mm]{triangularmesh.jpg}
   \end{center}
   \caption{A simple mesh}
   \label{fig:simplemesh}
 \end{figure}
+\clearpage
 The variables \code{points}, \code{triangles} and \code{boundary}
 represent the data displayed in Figure \ref{fig:simplemesh} as
 follows. The list \code{points} stores the coordinates of the
+points, and may be displayed schematically as in Table
+\ref{tab:points}.
+\begin{table}
+points, and may be displayed schematically as in Table \ref{tab:points}.
+\begin{table}[htp]
   \begin{center}
     \begin{tabular}[t]{|c|cc|} \hline
 …
     \end{tabular}
   \end{center}
+  \caption{Point coordinates for mesh in
+    Figure \protect \ref{fig:simplemesh}}
+  \caption{Point coordinates for mesh in Figure \protect \ref{fig:simplemesh}}
   \label{tab:points}
 \end{table}
 …
 and $(3,0,1)$.
+\begin{table}
+\begin{table}[htp]
   \begin{center}
+    \begin{tabular}{|c|ccc|} \hline
+      index & \multicolumn{3}{c|}{\code{points}}\\ \hline
+    \begin{tabular}{|c|ccc|}
+      \hline
+      index & \multicolumn{3}{c|}{\code{points}}\\
+      \hline
 & 0 & 1 & 3\\
 & 1 & 2 & 4\\
 …
 & 7 & 9 & 8\\
 & 1 & 4 & 3\\
+& 5 & 10 & 9\\  \hline
+& 5 & 10 & 9\\
+      \hline
     \end{tabular}
   \end{center}
 …
 triangles and associates a tag with each.
+\refmodindex[pmesh.meshinterface]{pmesh.mesh\_interface}\label{sec:meshgeneration}
+\begin{funcdesc}  {create\_mesh\_from\_regions}{bounding_polygon,
+% \refmodindex[pmesh.meshinterface]{pmesh.mesh\_interface}
+\label{sec:meshgeneration}
+\begin{funcdesc} {create\_mesh\_from\_regions}{bounding_polygon,
                              boundary_tags,
                              maximum_triangle_area,
 …
 \end{funcdesc}
 \subsection{Advanced mesh generation}
 …
 to build a mesh outline, such as \code{add\_vertices} and
 \code{add\_region\_from\_polygon}.
 \end{classdesc}
 \subsubsection{Key Methods of Class Mesh}
+\begin{methoddesc} {add\_hole}{x,y}
+\begin{methoddesc} {add\_hole}{self, x, y}
 Module: \module{pmesh.mesh},  Class: \class{Mesh}
 …
 when the boundary of the hole has already been defined, by selecting a
 point within the boundary.
+\end{methoddesc}
+\end{methoddesc}
 \begin{methoddesc}  {add\_hole\_from\_polygon}{self, polygon, tags=None}
 Module: \module{pmesh.mesh},  Class: \class{Mesh}
 This method is used to add a `hole' within a region ---that is, to
+This method is used to add a 'hole' within a region -- that is, to
 define a interior region where the triangular mesh will not be
 generated---to a \class{Mesh} instance. The region boundary is described by
+generated -- to a \class{Mesh} instance. The region boundary is described by
 the polygon passed in.  Additionally, the user specifies a list of
 boundary tags, one for each edge of the bounding polygon.
 \end{methoddesc}
 \begin{methoddesc}  {add\_points_and_segments}{self, points, segments,
 …
 [[0,1],[1,2]]} to make a polyline between points 0, 1 and 2. A tag for
 each segment can optionally be added.
+\end{methoddesc}
+\begin{methoddesc} {add\_region}{x,y}
+\end{methoddesc}
+\begin{methoddesc} {add\_region}{self, x, y}
 Module: \module{pmesh.mesh},  Class: \class{Mesh}
 …
 a point within the boundary.  A region instance is returned.  This can
 be used to set the resolution.
 \end{methoddesc}
 \begin{methoddesc}  {add\_region\_from\_polygon}{self, polygon,
+segment_tags=None, region_tag=None
+                                max_triangle_area=None}
+                     segment_tags=None, region_tag=None, max_triangle_area=None}
 Module: \module{pmesh.mesh},  Class: \class{Mesh}
 …
 user specifies a list of segment tags, one for each edge of the
 bounding polygon.  The regional tag is set using  \code{region}.
+\end{methoddesc}
+\begin{methoddesc} {add\_vertices}{point_data}
+\end{methoddesc}
+\begin{methoddesc} {add\_vertices}{self, point_data}
 Module: \module{pmesh.mesh},  Class: \class{Mesh}
 …
 \end{methoddesc}
 \begin{methoddesc} {auto\_segment}{raw_boundary=raw_boundary,
+\begin{methoddesc} {auto\_segment}{self, raw_boundary=raw_boundary,
                     remove_holes=remove_holes,
                     smooth_indents=smooth_indents,
 …
 useful since a set of user vertices need to be outlined by segments
 before generate_mesh is called.
+\end{methoddesc}
+\begin{methoddesc}  {export\_mesh_file}{self,ofile}
+\end{methoddesc}
+\begin{methoddesc}  {export\_mesh_file}{self, ofile}
 Module: \module{pmesh.mesh},  Class: \class{Mesh}
 …
 \end{methoddesc}
+\begin{methoddesc}  {import_ungenerate_file}{self,ofile, tag=None,
+\begin{methoddesc}  {import_ungenerate_file}{self, ofile, tag=None,
 region_tag=None}
 Module: \module{pmesh.mesh},  Class: \class{Mesh}
 …
 \end{methoddesc}
+%%%%%%
 \section{Initialising the Domain}\index{Initialising the Domain}
 \label{sec:initialising the domain}
 …
     Returns the name assigned to the domain by \code{set\_name}. If no name has been
     assigned, returns \code{`domain'}.
+    assigned, returns \code{'domain'}.
 \end{methoddesc}
 …
     Since different operating systems use different formats for specifying pathnames,
     it is necessary to specify path separators using the Python code \code{os.sep}, rather than
     the operating-specific ones such as `$\slash$' or `$\backslash$'.
+    the operating-specific ones such as '$\slash$' or '$\backslash$'.
     For this to work you will need to include the statement \code{import os}
     in your code, before the first appearance of \code{set\_datadir}.
 …
     the statements:
     {\small \begin{verbatim}
         import os
         domain.set_datadir{'project' + os.sep + 'data'}
     \end{verbatim}}
+    \begin{verbatim}
+import os
+domain.set_datadir{'project' + os.sep + 'data'}
+    \end{verbatim}
 \end{methoddesc}
 …
 \end{methoddesc}
 \begin{methoddesc} {set\_minimum_allowed_height}{}
     Module: \module{shallow\_water.shallow\_water\_domain}
 …
 \end{methoddesc}
 \begin{methoddesc} {set\_minimum_storable_height}{}
     Module: \module{shallow\_water.shallow\_water\_domain}
 …
     that seems to be caused by friction creep.
 \end{methoddesc}
 \begin{methoddesc} {set\_maximum_allowed_speed}{}
 …
 \end{methoddesc}
 \begin{methoddesc} {set\_time}{time=0.0}
     Module: \module{abstract\_2d\_finite\_volumes.domain}
 …
     to \code{n} will cause an error.)
 \end{methoddesc}
 \begin{methoddesc} {set\_store\_vertices\_uniquely}{flag}
 …
 file and the same data stored in the model domain. This must be borne in mind when comparing
 data from the sww files with that of the model internally.
+\end{methoddesc}
+\end{methoddesc}
 % Structural methods
 …
 \end{methoddesc}
 \begin{methoddesc}{get\_vertex\_coordinates}{absolute=False}
     \label{pg:get vertex coordinates}
 …
     Default is False as many parts of ANUGA expects relative coordinates.
 \end{methoddesc}
 \begin{methoddesc}{get\_centroid\_coordinates}{absolute=False}
 …
 \end{methoddesc}
 \begin{methoddesc}{get\_triangles}{indices=None}
         Return Mx3 integer array where M is the number of triangles.
         Each row corresponds to one triangle and the three entries are
         indices into the mesh nodes which can be obtained using the method
         get\_nodes()
         Optional argument, indices is the set of triangle ids of interest.
+    Return Mx3 integer array where M is the number of triangles.
+    Each row corresponds to one triangle and the three entries are
+    indices into the mesh nodes which can be obtained using the method
+    get\_nodes()
+    Optional argument, indices is the set of triangle ids of interest.
 \end{methoddesc}
 \begin{methoddesc}{get\_disconnected\_triangles}{}
+Get mesh based on nodes obtained from get_vertex_coordinates.
+        Return array Mx3 array of integers where each row corresponds to
+        a triangle. A triangle is a triplet of indices into
+        point coordinates obtained from get_vertex_coordinates and each
+        index appears only once.\\
+        This provides a mesh where no triangles share nodes
+        (hence the name disconnected triangles) and different
+        nodes may have the same coordinates.\\
+        This version of the mesh is useful for storing meshes with
+        discontinuities at each node and is e.g. used for storing
+        data in sww files.\\
+        The triangles created will have the format
+    {\small \begin{verbatim}
+        [[0,1,2],
+         [3,4,5],
+         [6,7,8],
+         ...
+         [3*M-3 3*M-2 3*M-1]]
+     \end{verbatim}}
+\end{methoddesc}
+%%%%%%
+    Get mesh based on nodes obtained from get_vertex_coordinates.
+    Return array Mx3 array of integers where each row corresponds to
+    a triangle. A triangle is a triplet of indices into
+    point coordinates obtained from get_vertex_coordinates and each
+    index appears only once.\\
+    This provides a mesh where no triangles share nodes
+    (hence the name disconnected triangles) and different
+    nodes may have the same coordinates.\\
+    This version of the mesh is useful for storing meshes with
+    discontinuities at each node and is e.g. used for storing
+    data in sww files.\\
+    The triangles created will have the format:
+    \begin{verbatim}
+[[0,1,2],
+ [3,4,5],
+ [6,7,8],
+ ...
+ [3*M-3 3*M-2 3*M-1]]
+    \end{verbatim}
+\end{methoddesc}
 \section{Initial Conditions}\index{Initial Conditions}
 \label{sec:initial conditions}
 …
 \begin{methoddesc}{set\_quantity}{name,
     numeric = None,
     quantity = None,
     function = None,
     geospatial_data = None,
     expression = None,
     filename = None,
     attribute_name = None,
     alpha = None,
     location = 'vertices',
     indices = None,
     verbose = False,
     use_cache = False}
+    numeric=None,
+    quantity=None,
+    function=None,
+    geospatial_data=None,
+    expression=None,
+    filename=None,
+    attribute_name=None,
+    alpha=None,
+    location='vertices',
+    indices=None,
+    verbose=False,
+    use_cache=False}
   Module: \module{abstract\_2d\_finite\_volumes.domain}
   (see also \module{abstract\_2d\_finite\_volumes.quantity.set\_values})
+This function is used to assign values to individual quantities for a
+domain. It is very flexible and can be used with many data types: a
+statement of the form \code{domain.set\_quantity(name, x)} can be used
+to define a quantity having the name \code{name}, where the other
+argument \code{x} can be any of the following:
+\begin{itemize}
+\item a number, in which case all vertices in the mesh gets that for
+the quantity in question.
+\item a list of numbers or a Numeric array ordered the same way as the mesh vertices.
+\item a function (e.g.\ see the samples introduced in Chapter 2)
+\item an expression composed of other quantities and numbers, arrays, lists (for
+example, a linear combination of quantities, such as
+\code{domain.set\_quantity('stage','elevation'+x))}
+\item the name of a file from which the data can be read. In this case, the optional argument attribute\_name will select which attribute to use from the file. If left out, set\_quantity will pick one. This is useful in cases where there is only one attribute.
+\item a geospatial dataset (See Section \ref{sec:geospatial}).
+Optional argument attribute\_name applies here as with files.
+\end{itemize}
+Exactly one of the arguments
+  numeric, quantity, function, points, filename
+must be present.
+Set quantity will look at the type of the second argument (\code{numeric}) and
+determine what action to take.
+Values can also be set using the appropriate keyword arguments.
+If x is a function, for example, \code{domain.set\_quantity(name, x)}, \code{domain.set\_quantity(name, numeric=x)}, and \code{domain.set\_quantity(name, function=x)}
+are all equivalent.
+Other optional arguments are
+\begin{itemize}
+\item \code{indices} which is a list of ids of triangles to which set\_quantity should apply its assignment of values.
+\item \code{location} determines which part of the triangles to assign
+  to. Options are 'vertices' (default), 'edges', 'unique vertices', and 'centroids'.
+  If 'vertices' are use, edge and centroid values are automatically computed as the appropriate averages. This option ensures continuity of the surface.
+  If, on the other hand, 'centroids' is used vertex and edge values will be set to the same value effectively creating a piecewise constant surface with possible discontinuities at the edges.
+\end{itemize}
+%%%
+\anuga provides a number of predefined initial conditions to be used
+with \code{set\_quantity}. See for example callable object
+\code{slump\_tsunami} below.
+\end{methoddesc}
+  This function is used to assign values to individual quantities for a
+  domain. It is very flexible and can be used with many data types: a
+  statement of the form \code{domain.set\_quantity(name, x)} can be used
+  to define a quantity having the name \code{name}, where the other
+  argument \code{x} can be any of the following:
+  \begin{itemize}
+    \item a number, in which case all vertices in the mesh gets that for
+          the quantity in question.
+    \item a list of numbers or a numeric array ordered the same way as the mesh vertices.
+    \item a function (e.g.\ see the samples introduced in Chapter 2)
+    \item an expression composed of other quantities and numbers, arrays, lists (for
+          example, a linear combination of quantities, such as
+    \code{domain.set\_quantity('stage','elevation'+x))}
+    \item the name of a file from which the data can be read. In this case, the optional
+          argument attribute\_name will select which attribute to use from the file. If left out,
+          set\_quantity will pick one. This is useful in cases where there is only one attribute.
+    \item a geospatial dataset (See Section \ref{sec:geospatial}).
+          Optional argument attribute\_name applies here as with files.
+  \end{itemize}
+  Exactly one of the arguments
+    numeric, quantity, function, points, filename
+  must be present.
+  \code{set_quantity} will look at the type of the second argument (\code{numeric}) and
+  determine what action to take.
+  Values can also be set using the appropriate keyword arguments.
+  If x is a function, for example, \code{domain.set\_quantity(name, x)}, \code{domain.set\_quantity(name, numeric=x)},
+  and \code{domain.set\_quantity(name, function=x)} are all equivalent.
+  Other optional arguments are
+  \begin{itemize}
+    \item \code{indices} which is a list of ids of triangles to which set\_quantity should apply its assignment of values.
+    \item \code{location} determines which part of the triangles to assign
+                          to. Options are 'vertices' (default), 'edges', 'unique vertices', and 'centroids'.
+                          If 'vertices' are use, edge and centroid values are automatically computed as the
+                          appropriate averages. This option ensures continuity of the surface.
+                          If, on the other hand, 'centroids' is used vertex and edge values will be set to the
+                          same value effectively creating a piecewise constant surface with possible discontinuities at the edges.
+  \end{itemize}
+  \anuga provides a number of predefined initial conditions to be used
+  with \code{set\_quantity}. See for example callable object \code{slump\_tsunami} below.
+\end{methoddesc}
 \begin{methoddesc}{add\_quantity}{name,
     numeric = None,
     quantity = None,
     function = None,
     geospatial_data = None,
     expression = None,
     filename = None,
     attribute_name = None,
     alpha = None,
     location = 'vertices',
     indices = None,
     verbose = False,
     use_cache = False}
+    numeric=None,
+    quantity=None,
+    function=None,
+    geospatial_data=None,
+    expression=None,
+    filename=None,
+    attribute_name=None,
+    alpha=None,
+    location='vertices',
+    indices=None,
+    verbose=False,
+    use_cache=False}
   Module: \module{abstract\_2d\_finite\_volumes.domain}
   (see also \module{abstract\_2d\_finite\_volumes.domain.set\_quantity})
+\label{add quantity}
+This function is used to \emph{add} values to individual quantities for a
+domain. It has the same syntax as \code{domain.set\_quantity(name, x)}.
+A typical use of this function is to add structures to an existing elevation model:
+{\small
+\begin{verbatim}
+    # Create digital elevation model from points file
+    domain.set_quantity('elevation',
+                        filename = 'elevation_file.pts,
+                        verbose = True)
+    # Add buildings from file
+    building_polygons, building_heights = csv2building_polygons(building_file)
+    B = []
+    for key in building_polygons:
+        poly = building_polygons[key]
+        elev = building_heights[key]
+        B.append((poly, elev))
+    domain.add_quantity('elevation', Polygon_function(B, default=0.0))
+\end{verbatim}}
+\end{methoddesc}
+  \label{add quantity}
+  This function is used to \emph{add} values to individual quantities for a
+  domain. It has the same syntax as \code{domain.set\_quantity(name, x)}.
+  A typical use of this function is to add structures to an existing elevation model:
+  \begin{verbatim}
+# Create digital elevation model from points file
+domain.set_quantity('elevation', filename='elevation_file.pts, verbose=True)
+# Add buildings from file
+building_polygons, building_heights = csv2building_polygons(building_file)
+B = []
+for key in building_polygons:
+    poly = building_polygons[key]
+    elev = building_heights[key]
+    B.append((poly, elev))
+domain.add_quantity('elevation', Polygon_function(B, default=0.0))
+  \end{verbatim}
+\end{methoddesc}
 \begin{funcdesc}{set_region}{tag, quantity, X, location='vertices'}
 …
   (see also \module{abstract\_2d\_finite\_volumes.quantity.set\_values})
 This function is used to assign values to individual quantities given
 a regional tag.   It is similar to \code{set\_quantity}.
 For example, if in the mesh-generator a regional tag of 'ditch' was
 used, set\_region can be used to set elevation of this region to
 -10m. X is the constant or function to be applied to the quantity,
 over the tagged region.  Location describes how the values will be
 applied.  Options are 'vertices' (default), 'edges', 'unique
 vertices', and 'centroids'.
 This method can also be called with a list of region objects.  This is
 useful for adding quantities in regions, and having one quantity
 value based on another quantity. See  \module{abstract\_2d\_finite\_volumes.region} for
 more details.
+  This function is used to assign values to individual quantities given
+  a regional tag.   It is similar to \code{set\_quantity}.
+  For example, if in the mesh-generator a regional tag of 'ditch' was
+  used, set\_region can be used to set elevation of this region to
+  -10m. X is the constant or function to be applied to the quantity,
+  over the tagged region.  Location describes how the values will be
+  applied.  Options are 'vertices' (default), 'edges', 'unique
+  vertices', and 'centroids'.
+  This method can also be called with a list of region objects.  This is
+  useful for adding quantities in regions, and having one quantity
+  value based on another quantity. See  \module{abstract\_2d\_finite\_volumes.region} for
+  more details.
 \end{funcdesc}
 \begin{funcdesc}{slump_tsunami}{length, depth, slope, width=None, thickness=None,
 …
                 domain=None,
                 verbose=False}
 Module: \module{shallow\_water.smf}
 This function returns a callable object representing an initial water
 displacement generated by a submarine sediment failure. These failures can take the form of
 a submarine slump or slide. In the case of a slide, use \code{slide_tsunami} instead.
 The arguments include as a minimum, the slump or slide length, the water depth to the centre of sediment
 mass, and the bathymetric slope. Other slump or slide parameters can be included if they are known.
+  Module: \module{shallow\_water.smf}
+  This function returns a callable object representing an initial water
+  displacement generated by a submarine sediment failure. These failures can take the form of
+  a submarine slump or slide. In the case of a slide, use \code{slide_tsunami} instead.
+  The arguments include as a minimum, the slump or slide length, the water depth to the centre of sediment
+  mass, and the bathymetric slope. Other slump or slide parameters can be included if they are known.
 \end{funcdesc}
-%%%
 \begin{funcdesc}{file\_function}{filename,
+    domain = None,
+    quantities = None,
+    interpolation_points = None,
+    verbose = False,
+    use_cache = False}
+Module: \module{abstract\_2d\_finite\_volumes.util}
+Reads the time history of spatial data for
+specified interpolation points from a NetCDF file (\code{filename})
+and returns
+a callable object. \code{filename} could be a \code{sww} or \code{sts} file.
+Returns interpolated values based on the input
+file using the underlying \code{interpolation\_function}.
+\code{quantities} is either the name of a single quantity to be
+interpolated or a list of such quantity names. In the second case, the resulting
+function will return a tuple of values---one for each quantity.
+\code{interpolation\_points} is a list of absolute coordinates or a
+geospatial object
+for points at which values are sought.
+\code{boundary_polygon} is a list of coordinates specifying the vertices of the boundary. This must be the same polygon as used when calling \code{create_mesh_from_regions}. This argument can only be used when reading boundary data from the STS format.
+The model time stored within the file function can be accessed using
+the method \code{f.get\_time()}
+The underlying algorithm used is as follows:\\
+Given a time series (i.e.\ a series of values associated with
+different times), whose values are either just numbers, a set of
+ numbers defined at the vertices of a triangular mesh (such as those
+ stored in SWW files) or a set of
+ numbers defined at a number of points on the boundary (such as those
+ stored in STS files), \code{Interpolation\_function} is used to
+ create a callable object that interpolates a value for an arbitrary
+ time \code{t} within the model limits and possibly a point \code{(x,
+ y)} within a mesh region.
+ The actual time series at which data is available is specified by
+ means of an array \code{time} of monotonically increasing times. The
+ quantities containing the values to be interpolated are specified in
+ an array---or dictionary of arrays (used in conjunction with the
+ optional argument \code{quantity\_names}) --- called
+ \code{quantities}. The optional arguments \code{vertex\_coordinates}
+ and \code{triangles} represent the spatial mesh associated with the
+ quantity arrays. If omitted the function must be created using an STS file
+ or a TMS file.
+ Since, in practice, values need to be computed at specified points,
+ the syntax allows the user to specify, once and for all, a list
+ \code{interpolation\_points} of points at which values are required.
+ In this case, the function may be called using the form \code{f(t,
+ id)}, where \code{id} is an index for the list
+ \code{interpolation\_points}.
+    domain=None,
+    quantities=None,
+    interpolation_points=None,
+    verbose=False,
+    use_cache=False}
+  Module: \module{abstract\_2d\_finite\_volumes.util}
+  Reads the time history of spatial data for
+  specified interpolation points from a NetCDF file (\code{filename})
+  and returns
+  a callable object. \code{filename} could be a \code{sww} or \code{sts} file.
+  Returns interpolated values based on the input
+  file using the underlying \code{interpolation\_function}.
+  \code{quantities} is either the name of a single quantity to be
+  interpolated or a list of such quantity names. In the second case, the resulting
+  function will return a tuple of values -- one for each quantity.
+  \code{interpolation\_points} is a list of absolute coordinates or a
+  geospatial object
+  for points at which values are sought.
+  \code{boundary_polygon} is a list of coordinates specifying the vertices of the boundary.
+  This must be the same polygon as used when calling \code{create_mesh_from_regions}.
+  This argument can only be used when reading boundary data from the STS format.
+  The model time stored within the file function can be accessed using
+  the method \code{f.get\_time()}
+  The underlying algorithm used is as follows:\\
+  Given a time series (i.e.\ a series of values associated with
+  different times), whose values are either just numbers, a set of
+  numbers defined at the vertices of a triangular mesh (such as those
+  stored in SWW files) or a set of
+  numbers defined at a number of points on the boundary (such as those
+  stored in STS files), \code{Interpolation\_function} is used to
+  create a callable object that interpolates a value for an arbitrary
+  time \code{t} within the model limits and possibly a point \code{(x,
+  y)} within a mesh region.
+  The actual time series at which data is available is specified by
+  means of an array \code{time} of monotonically increasing times. The
+  quantities containing the values to be interpolated are specified in
+  an array -- or dictionary of arrays (used in conjunction with the
+  optional argument \code{quantity\_names}) -- called
+  \code{quantities}. The optional arguments \code{vertex\_coordinates}
+  and \code{triangles} represent the spatial mesh associated with the
+  quantity arrays. If omitted the function must be created using an STS file
+  or a TMS file.
+  Since, in practice, values need to be computed at specified points,
+  the syntax allows the user to specify, once and for all, a list
+  \code{interpolation\_points} of points at which values are required.
+  In this case, the function may be called using the form \code{f(t,
+  id)}, where \code{id} is an index for the list
+  \code{interpolation\_points}.
 \end{funcdesc}
 …
 %% means of an array \code{time} of monotonically increasing times. The
 %% quantities containing the values to be interpolated are specified in
 %% an array---or dictionary of arrays (used in conjunction with the
 %% optional argument \code{quantity\_names}) --- called
+%% an array -- or dictionary of arrays (used in conjunction with the
+%% optional argument \code{quantity\_names}) -- called
 %% \code{quantities}. The optional arguments \code{vertex\_coordinates}
 %% and \code{triangles} represent the spatial mesh associated with the
 …
-%%%%%%
 \section{Boundary Conditions}\index{boundary conditions}
 \label{sec:boundary conditions}
 …
 represented by objects such as \code{Reflective\_boundary(domain)} and
 \code{Dirichlet\_boundary([0.2, 0.0, 0.0])}, described in the examples
 in Chapter 2. Alternatively, you may prefer to ``roll your own'',
+in Chapter 2. Alternatively, you may prefer to ''roll your own'',
 following the method explained in Section \ref{sec:roll your own}.
 …
 \begin{methoddesc}{set\_boundary}{boundary_map}
+Module: \module{abstract\_2d\_finite\_volumes.domain}
+This function allows you to assign a boundary object (corresponding to a
+pre-defined or user-specified boundary condition) to every boundary segment that
+has been assigned a particular tag.
+This is done by specifying a dictionary \code{boundary\_map}, whose values are the boundary objects
+and whose keys are the symbolic tags.
+  Module: \module{abstract\_2d\_finite\_volumes.domain}
+  This function allows you to assign a boundary object (corresponding to a
+  pre-defined or user-specified boundary condition) to every boundary segment that
+  has been assigned a particular tag.
+  This is done by specifying a dictionary \code{boundary\_map}, whose values are the boundary objects
+  and whose keys are the symbolic tags.
 \end{methoddesc}
 \begin{methoddesc} {get\_boundary\_tags}{}
+Module: \module{abstract\_2d\_finite\_volumes.domain}
+Returns a list of the available boundary tags.
+\end{methoddesc}
+%%%
+  Module: \module{abstract\_2d\_finite\_volumes.domain}
+  Returns a list of the available boundary tags.
+\end{methoddesc}
 \subsection{Predefined boundary conditions}
 \begin{classdesc}{Reflective\_boundary}{Boundary}
 Module: \module{shallow\_water}
 Reflective boundary returns same conserved quantities as those present in
 the neighbouring volume but reflected.
 This class is specific to the shallow water equation as it works with the
 momentum quantities assumed to be the second and third conserved quantities.
+  Module: \module{shallow\_water}
+  Reflective boundary returns same conserved quantities as those present in
+  the neighbouring volume but reflected.
+  This class is specific to the shallow water equation as it works with the
+  momentum quantities assumed to be the second and third conserved quantities.
 \end{classdesc}
+%%%
+\begin{classdesc}{Transmissive\_boundary}{domain = None}
+\label{pg: transmissive boundary}
+Module: \module{abstract\_2d\_finite\_volumes.generic\_boundary\_conditions}
+A transmissive boundary returns the same conserved quantities as
+those present in the neighbouring volume.
+The underlying domain must be specified when the boundary is instantiated.
+\begin{classdesc}{Transmissive\_boundary}{domain=None}
+  \label{pg: transmissive boundary}
+  Module: \module{abstract\_2d\_finite\_volumes.generic\_boundary\_conditions}
+  A transmissive boundary returns the same conserved quantities as
+  those present in the neighbouring volume.
+  The underlying domain must be specified when the boundary is instantiated.
 \end{classdesc}
-%%%
 \begin{classdesc}{Dirichlet\_boundary}{conserved_quantities=None}
 Module: \module{abstract\_2d\_finite\_volumes.generic\_boundary\_conditions}
 A Dirichlet boundary returns constant values for each of conserved
 quantities. In the example of \code{Dirichlet\_boundary([0.2, 0.0, 0.0])},
 the \code{stage} value at the boundary is 0.2 and the \code{xmomentum} and
 \code{ymomentum} at the boundary are set to 0.0. The list must contain
 a value for each conserved quantity.
+  Module: \module{abstract\_2d\_finite\_volumes.generic\_boundary\_conditions}
+  A Dirichlet boundary returns constant values for each of conserved
+  quantities. In the example of \code{Dirichlet\_boundary([0.2, 0.0, 0.0])},
+  the \code{stage} value at the boundary is 0.2 and the \code{xmomentum} and
+  \code{ymomentum} at the boundary are set to 0.0. The list must contain
+  a value for each conserved quantity.
 \end{classdesc}
-%%%
 \begin{classdesc}{Time\_boundary}{domain = None, f = None}
 Module: \module{abstract\_2d\_finite\_volumes.generic\_boundary\_conditions}
 A time-dependent boundary returns values for the conserved
 quantities as a function \code{f(t)} of time. The user must specify
 the domain to get access to the model time.
+Optional argument \code{default\_boundary} can be used to specify another boundary object to be used in case model time exceeds the time availabel in the file used by \code{File\_boundary}.
+The \code{default\_boundary} could be a simple Dirichlet condition or
+even another \code{Time\_boundary}
 typically using data pertaining to another time interval.
+  Module: \module{abstract\_2d\_finite\_volumes.generic\_boundary\_conditions}
+  A time-dependent boundary returns values for the conserved
+  quantities as a function \code{f(t)} of time. The user must specify
+  the domain to get access to the model time.
+  Optional argument \code{default\_boundary} can be used to specify another boundary object
+  to be used in case model time exceeds the time availabel in the file used by \code{File\_boundary}.
+  The \code{default\_boundary} could be a simple Dirichlet condition or
+  even another \code{Time\_boundary} typically using data pertaining to another time interval.
 \end{classdesc}
-%%%
 \begin{classdesc}{File\_boundary}{Boundary}
 Module: \module{abstract\_2d\_finite\_volumes.generic\_boundary\_conditions}
 This method may be used if the user wishes to apply a SWW file, STS file or
 a time series file (TMS) to a boundary segment or segments.
 The boundary values are obtained from a file and interpolated to the
 appropriate segments for each conserved quantity.
+Optional argument \code{default\_boundary} can be used to specify another boundary object to be used in case model time exceeds the time availabel in the file used by \code{File\_boundary}.
+The \code{default\_boundary} could be a simple Dirichlet condition or
+even another \code{File\_boundary}
 typically using data pertaining to another time interval.
+  Module: \module{abstract\_2d\_finite\_volumes.generic\_boundary\_conditions}
+  This method may be used if the user wishes to apply a SWW file, STS file or
+  a time series file (TMS) to a boundary segment or segments.
+  The boundary values are obtained from a file and interpolated to the
+  appropriate segments for each conserved quantity.
+  Optional argument \code{default\_boundary} can be used to specify another boundary object
+  to be used in case model time exceeds the time availabel in the file used by \code{File\_boundary}.
+  The \code{default\_boundary} could be a simple Dirichlet condition or
+  even another \code{File\_boundary} typically using data pertaining to another time interval.
 \end{classdesc}
 \begin{classdesc}{Field\_boundary}{Boundary}
+Module: \module{shallow\_water.shallow\_water\_domain}
+This method works in the same way as \code{File\_boundary} except that it
+allows for the value of stage to be offset by a constant specified in the
+keyword argument \code{mean\_stage}.
+This functionality allows for models to be run for a range of tides using
+the same boundary information (from .sts, .sww or .tms files). The tidal value
+for each run would then be specified in the keyword argument
+\code{mean\_stage}.
+If \code{mean\_stage} = 0.0, \code{Field\_boundary} and \code{File\_boundary}
+behave identically.
+Note that if the optional argument \code{default\_boundary} is specified
+it's stage value will be adjusted by \code{mean\_stage} just like the values
+obtained from the file.
+See \code{File\_boundary} for further details.
+  Module: \module{shallow\_water.shallow\_water\_domain}
+  This method works in the same way as \code{File\_boundary} except that it
+  allows for the value of stage to be offset by a constant specified in the
+  keyword argument \code{mean\_stage}.
+  This functionality allows for models to be run for a range of tides using
+  the same boundary information (from .sts, .sww or .tms files). The tidal value
+  for each run would then be specified in the keyword argument
+  \code{mean\_stage}.
+  If \code{mean\_stage} = 0.0, \code{Field\_boundary} and \code{File\_boundary}
+  behave identically.
+  Note that if the optional argument \code{default\_boundary} is specified
+  it's stage value will be adjusted by \code{mean\_stage} just like the values
+  obtained from the file.
+  See \code{File\_boundary} for further details.
 \end{classdesc}
-%%%
-%\begin{classdesc}{Transmissive\_Momentum\_Set\_Stage\_boundary}{Boundary}
 \begin{classdesc}{Transmissive\_momentum\_set\_stage\_boundary}{Boundary}
+Module: \module{shallow\_water}
+\label{pg: transmissive momentum set stage boundary}
+This boundary returns same momentum conserved quantities as
+those present in its neighbour volume but sets stage as in a Time\_boundary.
+The underlying domain must be specified when boundary is instantiated
+This type of boundary is useful when stage is known at the boundary as a
+function of time, but momenta (or speeds) aren't.
+This class is specific to the shallow water equation as it works with the
+momentum quantities assumed to be the second and third conserved quantities.
+In some circumstances, this boundary condition may cause numerical instabilities for similar reasons as what has been observed with the simple fully transmissive boundary condition (see Page \pageref{pg: transmissive boundary}).
+This could for example be the case if a planar wave is reflected out through this boundary.
+  Module: \module{shallow\_water}
+  \label{pg: transmissive momentum set stage boundary}
+  This boundary returns same momentum conserved quantities as
+  those present in its neighbour volume but sets stage as in a Time\_boundary.
+  The underlying domain must be specified when boundary is instantiated
+  This type of boundary is useful when stage is known at the boundary as a
+  function of time, but momenta (or speeds) aren't.
+  This class is specific to the shallow water equation as it works with the
+  momentum quantities assumed to be the second and third conserved quantities.
+  In some circumstances, this boundary condition may cause numerical instabilities for similar
+  reasons as what has been observed with the simple fully transmissive boundary condition
+  (see Page \pageref{pg: transmissive boundary}).
+  This could for example be the case if a planar wave is reflected out through this boundary.
 \end{classdesc}
 \begin{classdesc}{Transmissive\_stage\_zero\_momentum\_boundary}{Boundary}
+Module: \module{shallow\_water}
+\label{pg: transmissive stage zero momentum boundary}
+This boundary returns same stage conserved quantities as
+those present in its neighbour volume but sets momentum to zero.
+The underlying domain must be specified when boundary is instantiated
+This type of boundary is useful when stage is known at the boundary as a
+function of time, but momentum should be set to zero. This is for example the case where a boundary is needed in the ocean on the two sides perpendicular to the coast to maintain the wave height of the incoming wave.
+This class is specific to the shallow water equation as it works with the
+momentum quantities assumed to be the second and third conserved quantities.
+This boundary condition should not cause the numerical instabilities seen with the transmissive momentum
+boundary conditions (see Page \pageref{pg: transmissive boundary} and Page \pageref{pg: transmissive momentum set stage boundary}).
+  Module: \module{shallow\_water}
+  \label{pg: transmissive stage zero momentum boundary}
+  This boundary returns same stage conserved quantities as
+  those present in its neighbour volume but sets momentum to zero.
+  The underlying domain must be specified when boundary is instantiated
+  This type of boundary is useful when stage is known at the boundary as a
+  function of time, but momentum should be set to zero. This is for example
+  the case where a boundary is needed in the ocean on the two sides perpendicular
+  to the coast to maintain the wave height of the incoming wave.
+  This class is specific to the shallow water equation as it works with the
+  momentum quantities assumed to be the second and third conserved quantities.
+  This boundary condition should not cause the numerical instabilities seen with the transmissive momentum
+  boundary conditions (see Page \pageref{pg: transmissive boundary} and
+  Page \pageref{pg: transmissive momentum set stage boundary}).
 \end{classdesc}
 \begin{classdesc}{Dirichlet\_discharge\_boundary}{Boundary}
 Module: \module{shallow\_water}
 Sets stage (stage0)
 Sets momentum (wh0) in the inward normal direction.
+  Module: \module{shallow\_water}
+  Sets stage (stage0)
+  Sets momentum (wh0) in the inward normal direction.
 \end{classdesc}
 \subsection{User-defined boundary conditions}
 …
 \section{Forcing Terms}\index{Forcing terms}
 \label{sec:forcing terms}
 \anuga provides a number of predefined forcing functions to be used with simulations.
+Gravity and friction are always calculated using the elevation and friction quantities, but the user may additionally add forcing terms to the list
+Gravity and friction are always calculated using the elevation and friction quantities,
+but the user may additionally add forcing terms to the list
 \code{domain.forcing\_terms} and have them affect the model.
+Currently, predefined forcing terms are
+Currently, predefined forcing terms are:
 \begin{funcdesc}{General\_forcing}{}
   Module: \module{shallow\_water.shallow\_water\_domain}
 …
                 The parametr \code{rate} can be \code{None} at initialisation but must be specified
                 before forcing term is applied (i.e. simulation has started).
                 The default value is 0.0 - i.e.\ no forcing.
+                The default value is 0.0 -- i.e.\ no forcing.
     \item \code{center, radius}: Optionally restrict forcing to a circle with given center and radius.
     \item \code{polygon}: Optionally restrict forcing to an area enclosed by given polygon.
+    \item \code{polygon}: Optionally restrict forcing to an area enclosed by given polygon.
   \end{itemize}
   Note specifying both center, radius and polygon will cause an exception to be thrown.
 …
   \bigskip
   Example:
+  {\scriptsize \begin{verbatim}
+    P = [[x0, y0], [x1, y0], [x1, y1], [x0, y1]] # Square polygon
+    xmom = General_forcing(domain, 'xmomentum', polygon=P)
+    ymom = General_forcing(domain, 'ymomentum', polygon=P)
+    xmom.rate = f
+    ymom.rate = g
+    domain.forcing_terms.append(xmom)
+    domain.forcing_terms.append(ymom)
+  \end{verbatim}}
+  Here, \code{f}, \code{g} are assumed to be defined as functions of time providing a time dependent rate of change for xmomentum and ymomentum respectively.
+  \begin{verbatim}
+P = [[x0, y0], [x1, y0], [x1, y1], [x0, y1]]    # Square polygon
+xmom = General_forcing(domain, 'xmomentum', polygon=P)
+ymom = General_forcing(domain, 'ymomentum', polygon=P)
+xmom.rate = f
+ymom.rate = g
+domain.forcing_terms.append(xmom)
+domain.forcing_terms.append(ymom)
+  \end{verbatim}
+  Here, \code{f}, \code{g} are assumed to be defined as functions of time providing
+  a time dependent rate of change for xmomentum and ymomentum respectively.
   P is assumed to be polygon, specified as a list of points.
 \end{funcdesc}
 \begin{funcdesc}{Inflow}{}
 …
                 function of time. Positive values indicate inflow,
                 negative values indicate outflow.
                 Note: The specified flow will be divided by the area of
                 the inflow region and then applied to update the
                 stage quantity.
     \item \code{center, radius}: Optionally restrict forcing to a circle with given center and radius.
     \item \code{polygon}: Optionally restrict forcing to an area enclosed by given polygon.
+    \item \code{polygon}: Optionally restrict forcing to an area enclosed by given polygon.
   \end{itemize}
   \bigskip
   Example:
+  {\scriptsize \begin{verbatim}
+    hydrograph = Inflow(center=(320, 300), radius=10,
+                        rate=file_function('QPMF_Rot_Sub13.tms'))
+    domain.forcing_terms.append(hydrograph)
+  \end{verbatim}}
+  \begin{verbatim}
+hydrograph = Inflow(center=(320, 300), radius=10, rate=file_function('QPMF_Rot_Sub13.tms'))
+domain.forcing_terms.append(hydrograph)
+  \end{verbatim}
   Here, \code{'QPMF_Rot_Sub13.tms'} is assumed to be a NetCDF file in the format \code{tms} defining a timeseries for a hydrograph.
 \end{funcdesc}
 \begin{funcdesc}{Rainfall}{}
 …
     \item \code{domain}: a reference to the domain being evolved
     \item \code{rate}: Total rain rate over the specified domain.
                   Note: Raingauge Data needs to reflect the time step.
                   For example: if rain gauge is mm read every \code{dt} seconds, then the input
+                  Note: Raingauge Data needs to reflect the time step.
+                  For example: if rain gauge is mm read every \code{dt} seconds, then the input
                   here is as \code{mm/dt} so 10 mm in 5 minutes becomes
 /(5x60) = 0.0333mm/s.
                   This parameter can be either a constant or a
                   function of time. Positive values indicate rain being added (or be used for general infiltration),
                   negative values indicate outflow at the specified rate (presumably this could model evaporation or abstraction).
     \item \code{center, radius}: Optionally restrict forcing to a circle with given center and radius.
     \item \code{polygon}: Optionally restrict forcing to an area enclosed by given polygon.
+    \item \code{polygon}: Optionally restrict forcing to an area enclosed by given polygon.
   \end{itemize}
   \bigskip
   Example:
+  {\scriptsize \begin{verbatim}
     catchmentrainfall = Rainfall(rate=file_function('Q100_2hr_Rain.tms'))
     domain.forcing_terms.append(catchmentrainfall)
+  \end{verbatim}}
+  \begin{verbatim}
+catchmentrainfall = Rainfall(rate=file_function('Q100_2hr_Rain.tms'))
+domain.forcing_terms.append(catchmentrainfall)
+  \end{verbatim}
   Here, \code{'Q100_2hr_Rain.tms'} is assumed to be a NetCDF file in the format \code{tms} defining a timeseries for the rainfall.
 \end{funcdesc}
 \begin{funcdesc}{Culvert\_flow}{}
   Module: \module{culver\_flows.culvert\_class}
 …
   This class modifies the quantities \code{stage, xmomentum, ymomentum} in areas at both ends of the culvert.
+  The Culvert\_flow forcing term uses \code{Inflow} and {General\_forcing} to update the quantities. The flow drection is determined on-the-fly so
+  openings are referenced simple as opening0 and opening1 with either being able to take the role as Inflow and Outflow.
+  The Culvert\_flow forcing term uses \code{Inflow} and {General\_forcing} to update the quantities.
+  The flow drection is determined on-the-fly so openings are referenced simple as opening0 and opening1
+  with either being able to take the role as Inflow and Outflow.
   The Culvert\_flow class takes as input:
 …
   \end{itemize}
   The user can specify different culvert routines. Hower ANUGA currently provides only one, namely the \code{boyd\_generalised\_culvert\_model} as used in the example below.
+  \bigskip
+  The user can specify different culvert routines. Hower ANUGA currently provides only one, namely the
+  \code{boyd\_generalised\_culvert\_model} as used in the example below.
   Example:
+  {\scriptsize \begin{verbatim}
+    from anuga.culvert_flows.culvert_class import Culvert_flow
+    from anuga.culvert_flows.culvert_routines import boyd_generalised_culvert_model
+    culvert1 = Culvert_flow(domain,
+                           label='Culvert No. 1',
+                           description='This culvert is a test unit 1.2m Wide by 0.75m High',
+                           end_point0=[9.0, 2.5],
+                           end_point1=[13.0, 2.5],
+                           width=1.20,height=0.75,
+                           culvert_routine=boyd_generalised_culvert_model,
+                           number_of_barrels=1,
+                           verbose=True)
+    culvert2 = Culvert_flow(domain,
+                           label='Culvert No. 2',
+                           description='This culvert is a circular test with d=1.2m',
+                           end_point0=[9.0, 1.5],
+                           end_point1=[30.0, 3.5],
+                           diameter=1.20,
+                           invert_level0=7,
+                           culvert_routine=boyd_generalised_culvert_model,
+                           number_of_barrels=1,
+                           verbose=True)
+    domain.forcing_terms.append(culvert1)
+    domain.forcing_terms.append(culvert2)
+  \end{verbatim}}
+  \begin{verbatim}
+from anuga.culvert_flows.culvert_class import Culvert_flow
+from anuga.culvert_flows.culvert_routines import boyd_generalised_culvert_model
+culvert1 = Culvert_flow(domain,
+                        label='Culvert No. 1',
+                        description='This culvert is a test unit 1.2m Wide by 0.75m High',
+                        end_point0=[9.0, 2.5],
+                        end_point1=[13.0, 2.5],
+                        width=1.20,height=0.75,
+                        culvert_routine=boyd_generalised_culvert_model,
+                        number_of_barrels=1,
+                        verbose=True)
+culvert2 = Culvert_flow(domain,
+                        label='Culvert No. 2',
+                        description='This culvert is a circular test with d=1.2m',
+                        end_point0=[9.0, 1.5],
+                        end_point1=[30.0, 3.5],
+                        diameter=1.20,
+                        invert_level0=7,
+                        culvert_routine=boyd_generalised_culvert_model,
+                        number_of_barrels=1,
+                        verbose=True)
+domain.forcing_terms.append(culvert1)
+domain.forcing_terms.append(culvert2)
+  \end{verbatim}
 \end{funcdesc}
 …
 \label{sec:evolution}
+  \begin{methoddesc}{evolve}{yieldstep = None, finaltime = None, duration = None, skip_initial_step = False}
+\begin{methoddesc}{evolve}{yieldstep=None, finaltime=None, duration=None, skip_initial_step=False}
   Module: \module{abstract\_2d\_finite\_volumes.domain}
 …
   You can include \method{evolve} in a statement of the type:
+  {\small \begin{verbatim}
+      for t in domain.evolve(yieldstep, finaltime):
+          <Do something with domain and t>
+  \end{verbatim}}
+  \end{methoddesc}
+  \begin{verbatim}
+for t in domain.evolve(yieldstep, finaltime):
+    <Do something with domain and t>
+  \end{verbatim}
+\end{methoddesc}
 \subsection{Diagnostics}
 \label{sec:diagnostics}
+  \begin{funcdesc}{statistics}{}
+\begin{funcdesc}{statistics}{}
   Module: \module{abstract\_2d\_finite\_volumes.domain}
   \end{funcdesc}
   \begin{funcdesc}{timestepping\_statistics}{}
+\end{funcdesc}
+\begin{funcdesc}{timestepping\_statistics}{}
   Module: \module{abstract\_2d\_finite\_volumes.domain}
+  Returns a string of the following type for each
+  timestep:
+  Returns a string of the following type for each timestep:
   \code{Time = 0.9000, delta t in [0.00598964, 0.01177388], steps=12
   (12)}
 …
   this diagnostics may help pinpoint problem areas where excessive speeds
   are generated.
+  \end{funcdesc}
+  \begin{funcdesc}{boundary\_statistics}{quantities = None, tags = None}
+\end{funcdesc}
+\begin{funcdesc}{boundary\_statistics}{quantities=None, tags=None}
   Module: \module{abstract\_2d\_finite\_volumes.domain}
+  Returns a string of the following type when \code{quantities = 'stage'} and \code{tags = ['top', 'bottom']}:
+  {\small \begin{verbatim}
+ Boundary values at time 0.5000:
+  Returns a string of the following type when \code{quantities = 'stage'}
+  and \code{tags = ['top', 'bottom']}:
+  \begin{verbatim}
+Boundary values at time 0.5000:
     top:
         stage in [ -0.25821218,  -0.02499998]
     bottom:
         stage in [ -0.27098821,  -0.02499974]
+  \end{verbatim}}
+  \end{funcdesc}
+  \begin{funcdesc}{get\_quantity}{name, location='vertices', indices = None}
+  \end{verbatim}
+\end{funcdesc}
+\begin{funcdesc}{get\_quantity}{name, location='vertices', indices=None}
   Module: \module{abstract\_2d\_finite\_volumes.domain}
   This function returns a Quantity object Q.
+  Access to it's values should be done through Q.get\__values documented on Page \pageref{pg:get values}.
+  \end{funcdesc}
+  \begin{funcdesc}{set\_quantities\_to\_be\_monitored}{}
+  Access to its values should be done through Q.get\__values documented on Page \pageref{pg:get values}.
+\end{funcdesc}
+\begin{funcdesc}{set\_quantities\_to\_be\_monitored}{}
   Module: \module{abstract\_2d\_finite\_volumes.domain}
 …
   Optional parameters \code{polygon} and \code{time\_interval} may be specified to restrict the
   extremum computation.
   \end{funcdesc}
   \begin{funcdesc}{quantity\_statistics}{}
+\end{funcdesc}
+\begin{funcdesc}{quantity\_statistics}{}
   Module: \module{abstract\_2d\_finite\_volumes.domain}
 …
   \begin{verbatim}
   Monitored quantities at time 1.0000:
     stage-elevation:
       values since time = 0.00 in [0.00000000, 0.30000000]
       minimum attained at time = 0.00000000, location = (0.16666667, 0.33333333)
       maximum attained at time = 0.00000000, location = (0.83333333, 0.16666667)
     ymomentum:
       values since time = 0.00 in [0.00000000, 0.06241221]
       minimum attained at time = 0.00000000, location = (0.33333333, 0.16666667)
       maximum attained at time = 0.22472667, location = (0.83333333, 0.66666667)
     xmomentum:
       values since time = 0.00 in [-0.06062178, 0.47886313]
       minimum attained at time = 0.00000000, location = (0.16666667, 0.33333333)
       maximum attained at time = 0.35103646, location = (0.83333333, 0.16666667)
+Monitored quantities at time 1.0000:
+  stage-elevation:
+    values since time = 0.00 in [0.00000000, 0.30000000]
+    minimum attained at time = 0.00000000, location = (0.16666667, 0.33333333)
+    maximum attained at time = 0.00000000, location = (0.83333333, 0.16666667)
+  ymomentum:
+    values since time = 0.00 in [0.00000000, 0.06241221]
+    minimum attained at time = 0.00000000, location = (0.33333333, 0.16666667)
+    maximum attained at time = 0.22472667, location = (0.83333333, 0.66666667)
+  xmomentum:
+    values since time = 0.00 in [-0.06062178, 0.47886313]
+    minimum attained at time = 0.00000000, location = (0.16666667, 0.33333333)
+    maximum attained at time = 0.35103646, location = (0.83333333, 0.16666667)
   \end{verbatim}
 …
   at every internal timestep.
+  These values are also stored in the sww file for post processing.
+  \end{funcdesc}
+  \begin{funcdesc}{get\_values}{location='vertices', indices = None}
+  These values are also stored in the SWW file for post processing.
+\end{funcdesc}
+\begin{funcdesc}{get\_values}{location='vertices', indices=None}
   \label{pg:get values}
   Module: \module{abstract\_2d\_finite\_volumes.quantity}
   Extract values for quantity as a Numeric array.
   {\small \begin{verbatim}
   Inputs:
           interpolation_points: List of x, y coordinates where value is
                                 sought (using interpolation). If points
                                 are given, values of location and indices
                                 are ignored. Assume either absolute UTM
                                 coordinates or geospatial data object.
           location: Where values are to be stored.
                     Permissible options are: vertices, edges, centroids
                     and unique vertices. Default is 'vertices'
   \end{verbatim}}
+  Extract values for quantity as a numeric array.
+  \begin{verbatim}
+Inputs:
+  interpolation_points: List of x, y coordinates where value is
+                        sought (using interpolation). If points
+                        are given, values of location and indices
+                        are ignored. Assume either absolute UTM
+                        coordinates or geospatial data object.
+  location: Where values are to be stored.
+            Permissible options are: vertices, edges, centroids
+            and unique vertices. Default is 'vertices'
+  \end{verbatim}
   The returned values will have the leading dimension equal to length of the indices list or
   N (all values) if indices is None.
   In case of location == 'centroids' the dimension of returned
   values will be a list or a Numerical array of length N, N being
+  values will be a list or a numeric array of length N, N being
   the number of elements.
 …
   The values will be stored in elements following their
   internal ordering.
+  \end{funcdesc}
+  \begin{funcdesc}{set\_values}{location='vertices', indices = None}
+\end{funcdesc}
+\begin{funcdesc}{set\_values}{location='vertices', indices=None}
   Module: \module{abstract\_2d\_finite\_volumes.quantity}
 …
   The method \code{set\_values} is always called by \code{set\_quantity}
   behind the scenes.
+  \end{funcdesc}
+  \begin{funcdesc}{get\_integral}{}
+\end{funcdesc}
+\begin{funcdesc}{get\_integral}{}
   Module: \module{abstract\_2d\_finite\_volumes.quantity}
   Return computed integral over entire domain for this quantity
+  \end{funcdesc}
+  \begin{funcdesc}{get\_maximum\_value}{indices = None}
+\end{funcdesc}
+\begin{funcdesc}{get\_maximum\_value}{indices=None}
   Module: \module{abstract\_2d\_finite\_volumes.quantity}
 …
   We do not seek the maximum at vertices as each vertex can
+  have multiple values - one for each triangle sharing it.
+  \end{funcdesc}
+  \begin{funcdesc}{get\_maximum\_location}{indices = None}
+  have multiple values -- one for each triangle sharing it.
+\end{funcdesc}
+\begin{funcdesc}{get\_maximum\_location}{indices=None}
   Module: \module{abstract\_2d\_finite\_volumes.quantity}
 …
   We do not seek the maximum at vertices as each vertex can
   have multiple values - one for each triangle sharing it.
+  have multiple values -- one for each triangle sharing it.
   If there are multiple cells with same maximum value, the
   first cell encountered in the triangle array is returned.
+  \end{funcdesc}
+  \begin{funcdesc}{get\_wet\_elements}{indices=None}
+\end{funcdesc}
+\begin{funcdesc}{get\_wet\_elements}{indices=None}
   Module: \module{shallow\_water.shallow\_water\_domain}
   Return indices for elements where h $>$ minimum_allowed_height
   Optional argument indices is the set of element ids that the operation applies to.
+  \end{funcdesc}
+  \begin{funcdesc}{get\_maximum\_inundation\_elevation}{indices=None}
+\end{funcdesc}
+\begin{funcdesc}{get\_maximum\_inundation\_elevation}{indices=None}
   Module: \module{shallow\_water.shallow\_water\_domain}
 …
   Example to find maximum runup elevation:\\
      z = domain.get_maximum_inundation_elevation()
+  \end{funcdesc}
+  \begin{funcdesc}{get\_maximum\_inundation\_location}{indices=None}
+\end{funcdesc}
+\begin{funcdesc}{get\_maximum\_inundation\_location}{indices=None}
   Module: \module{shallow\_water.shallow\_water\_domain}
 …
   Example to find maximum runup location:\\
      x, y = domain.get_maximum_inundation_location()
   \end{funcdesc}
+\end{funcdesc}
 …
 After a model has been run, it is often useful to extract various information from the sww
 output file (see Section \ref{sec:sww format}). This is typically more convenient than using the
 diagnostics described in Section \ref{sec:diagnostics} which rely on the model running - something
+diagnostics described in Section \ref{sec:diagnostics} which rely on the model running -- something
 that can be very time consuming. The sww files are easy and quick to read and offer much information
 about the model results such as runup heights, time histories of selected quantities,
 …
   Return highest elevation where depth is positive ($h > 0$)
+  Example to find maximum runup elevation:\\
+  max_runup = get_maximum_inundation_elevation(filename,
+  polygon=None,
+  time_interval=None,
+  verbose=False)
+  Example to find maximum runup elevation:
+  \begin{verbatim}
+max_runup = get_maximum_inundation_elevation(filename,
+                                             polygon=None,
+                                             time_interval=None,
+                                             verbose=False)
+  \end{verbatim}
   filename is a NetCDF sww file containing ANUGA model output.
 …
 \end{funcdesc}
 \begin{funcdesc}{get\_maximum\_inundation\_location}{filename, polygon=None,
     time_interval=None, verbose=False}
 …
   Return location (x,y) of highest elevation where depth is positive ($h > 0$)
+  Example to find maximum runup location:\\
+  max_runup_location = get_maximum_inundation_location(filename,
+  polygon=None,
+  time_interval=None,
+  verbose=False)
+  filename is a NetCDF sww file containing ANUGA model output.
+  Optional arguments polygon and time_interval restricts the maximum runup calculation
+  Example to find maximum runup location:
+  \begin{verbatim}
+max_runup_location = get_maximum_inundation_location(filename,
+                                                     polygon=None,
+                                                     time_interval=None,
+                                                     verbose=False)
+  \end{verbatim}
+  \code{filename} is a NetCDF sww file containing ANUGA model output.
+  Optional arguments \code{polygon} and \code{time_interval} restricts the maximum runup calculation
   to a points that lie within the specified polygon and time interval.
 …
   is None signifying "No Runup" or "Everything is dry".
   See doc string for general function get_maximum_inundation_data for details.
+  See the 'doc' string for general function \code{get_maximum_inundation_data} for details.
 \end{funcdesc}
+\begin{funcdesc}{sww2timeseries}{swwfiles, gauge_filename, production_dirs, report = None, reportname = None,
+plot_quantity = None, generate_fig = False, surface = None, time_min = None, time_max = None, time_thinning = 1,
+time_unit = None, title_on = None, use_cache = False, verbose = False}
+\begin{funcdesc}{sww2timeseries}{swwfiles, gauge_filename, production_dirs, report=None, reportname=None,
+plot_quantity=None, generate_fig=False, surface=None, time_min=None, time_max=None, time_thinning=1,
+time_unit=None, title_on=None, use_cache=False, verbose=False}
   Module: \module{anuga.abstract\_2d\_finite\_volumes.util}
   Return csv files for the location in the \code{gauge_filename} and can also return plots of them
+  See doc string for general function sww2timeseries for details.
+  See the 'doc' string for general function \code{sww2timeseries} for details.
 \end{funcdesc}
 \begin{funcdesc}{get\_flow\_through\_cross\_section}{filename, cross\_section, verbose=False}
 …
   \begin{itemize}
         \item filename: Name of sww file containing ANUGA model output.
         \item polyline: Representation of desired cross section - it may contain multiple
           sections allowing for complex shapes. Assume absolute UTM coordinates.
+        \item polyline: Representation of desired cross section -- it may contain multiple
+                        sections allowing for complex shapes. Assume absolute UTM coordinates.
   \end{itemize}
 …
   \begin{verbatim}
   cross_section = [[x, 0], [x, width]]
   time, Q = get_flow_through_cross_section(filename,
                                            cross_section,
                                            verbose=False)
+cross_section = [[x, 0], [x, width]]
+time, Q = get_flow_through_cross_section(filename,
+                                         cross_section,
+                                         verbose=False)
   \end{verbatim}
+  See doc string for general function get\_maximum\_inundation\_data for details.
+  See the 'doc' string for general function \code{get_maximum_inundation_data} for details.
 \end{funcdesc}
 \section{Other}
+  \begin{funcdesc}{domain.create\_quantity\_from\_expression}{string}
+  Handy for creating derived quantities on-the-fly as for example
+\begin{funcdesc}{domain.create\_quantity\_from\_expression}{string}
+  Handy for creating derived quantities on-the-fly as for example:
   \begin{verbatim}
   Depth = domain.create_quantity_from_expression('stage-elevation')
+  exp = '(xmomentum*xmomentum + ymomentum*ymomentum)**0.5')
   Absolute_momentum = domain.create_quantity_from_expression(exp)
+Depth = domain.create_quantity_from_expression('stage-elevation')
+exp = '(xmomentum*xmomentum + ymomentum*ymomentum)**0.5'
+Absolute_momentum = domain.create_quantity_from_expression(exp)
   \end{verbatim}
   %See also \file{Analytical\_solution\_circular\_hydraulic\_jump.py} for an example of use.
+  \end{funcdesc}
+\end{funcdesc}
 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
-%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 \chapter{\anuga System Architecture}
 \section{File Formats}
 …
 \bigskip
 \begin{center}
 \begin{tabular}{|ll|}  \hline
+\textbf{Extension} & \textbf{Description} \\
+\hline\hline
+\code{.sww} & NetCDF format for storing model output with mesh information
+\code{f(t,x,y)}\\
+\code{.sts} & NetCDF format for storing model ouput \code{f(t,x,y)} without any mesh information\\
+\code{.tms} & NetCDF format for storing time series \code{f(t)}\\
+\code{.csv/.txt} & ASCII format called points csv for storing
+arbitrary points and associated attributes\\
+\code{.pts} & NetCDF format for storing arbitrary points and
+associated attributes\\
+\code{.asc} & ASCII format of regular DEMs as output from ArcView\\
+\code{.prj} & Associated ArcView file giving more metadata for
+\code{.asc} format\\
+\code{.ers} & ERMapper header format of regular DEMs for ArcView\\
+\code{.dem} & NetCDF representation of regular DEM data\\
+\code{.tsh} & ASCII format for storing meshes and associated
+boundary and region info\\
+\code{.msh} & NetCDF format for storing meshes and associated
+boundary and region info\\
+\code{.nc} & Native ferret NetCDF format\\
+\code{.geo} & Houdinis ASCII geometry format (?) \\  \par \hline
+%\caption{File formats used by \anuga}
+  \textbf{Extension} & \textbf{Description} \\
+  \hline\hline
+  \code{.sww} & NetCDF format for storing model output with mesh information \code{f(t,x,y)}\\
+  \code{.sts} & NetCDF format for storing model ouput \code{f(t,x,y)} without any mesh information\\
+  \code{.tms} & NetCDF format for storing time series \code{f(t)}\\
+  \code{.csv/.txt} & ASCII format called points csv for storing arbitrary points and associated attributes\\
+  \code{.pts} & NetCDF format for storing arbitrary points and associated attributes\\
+  \code{.asc} & ASCII format of regular DEMs as output from ArcView\\
+  \code{.prj} & Associated ArcView file giving more metadata for \code{.asc} format\\
+  \code{.ers} & ERMapper header format of regular DEMs for ArcView\\
+  \code{.dem} & NetCDF representation of regular DEM data\\
+  \code{.tsh} & ASCII format for storing meshes and associated boundary and region info\\
+  \code{.msh} & NetCDF format for storing meshes and associated boundary and region info\\
+  \code{.nc} & Native ferret NetCDF format\\
+  \code{.geo} & Houdinis ASCII geometry format (?) \\  \par \hline
+  %\caption{File formats used by \anuga}
 \end{tabular}
 \end{center}
 The above table shows the file extensions used to identify the
 formats of files. However, typically, in referring to a format we
 capitalise the extension and omit the initial full stop---thus, we
 refer, for example, to `SWW files' or `PRJ files'.
+capitalise the extension and omit the initial full stop -- thus, we
+refer, for example, to 'SWW files' or 'PRJ files'.
 \bigskip
 …
 \begin{tabular}{ll}
+ASC, PRJ  $\rightarrow$  DEM  $\rightarrow$  PTS & Convert
+DEMs to native \code{.pts} file\\
+NC $\rightarrow$ SWW & Convert MOST boundary files to
+boundary \code{.sww}\\
+PTS + TSH $\rightarrow$ TSH with elevation & Least squares fit\\
+TSH $\rightarrow$ SWW & Convert TSH to \code{.sww}-viewable using
+\code{animate}\\
+TSH + Boundary SWW $\rightarrow$ SWW & Simulation using
+\code{\anuga}\\
+Polygonal mesh outline $\rightarrow$ & TSH or MSH
+  ASC, PRJ  $\rightarrow$  DEM  $\rightarrow$  PTS & Convert DEMs to native \code{.pts} file\\
+  NC $\rightarrow$ SWW & Convert MOST boundary files to boundary \code{.sww}\\
+  PTS + TSH $\rightarrow$ TSH with elevation & Least squares fit\\
+  TSH $\rightarrow$ SWW & Convert TSH to \code{.sww}-viewable using \code{animate}\\
+  TSH + Boundary SWW $\rightarrow$ SWW & Simulation using \code{\anuga}\\
+  Polygonal mesh outline $\rightarrow$ & TSH or MSH
 \end{tabular}
 \bigskip
 …
 \subsection{SWW, STS and TMS Formats}
 \label{sec:sww format}
+The SWW, STS and TMS formats are all NetCDF formats, and are of key
+importance for \anuga.
+The SWW, STS and TMS formats are all NetCDF formats, and are of key importance for \anuga.
 An SWW file is used for storing \anuga output and therefore pertains
 …
 \begin{itemize}
+    \item \code{x} and \code{y}: coordinates of the points, represented as Numeric arrays
+    \item \code{elevation}, a Numeric array storing bed-elevations
+    \item \code{volumes}, a list specifying the points at the vertices of each of the
+    triangles
+  \item \code{x} and \code{y}: coordinates of the points, represented as numeric arrays
+  \item \code{elevation}, a numeric array storing bed-elevations
+  \item \code{volumes}, a list specifying the points at the vertices of each of the triangles
     % Refer here to the example to be provided in describing the simple example
+    \item \code{time}, a Numeric array containing times for model
+    evaluation
+  \item \code{time}, a numeric array containing times for model evaluation
 \end{itemize}
 The contents of an SWW file may be viewed using the anuga viewer
 …
 variables:
 \begin{itemize}
+    \item \code{x} and \code{y}: coordinates of the points, represented as Numeric arrays
+    \item \code{permutation}: Original indices of the points as specified by
+    the optional \code{ordering\_file}
+    (see the function \code{urs2sts} in Section \ref{sec:basicfileconversions}).
+    \item \code{elevation}, a Numeric array storing bed-elevations
+  \item \code{x} and \code{y}: coordinates of the points, represented as numeric arrays
+  \item \code{permutation}: Original indices of the points as specified by the optional \code{ordering\_file}
+                            (see the function \code{urs2sts} in Section \ref{sec:basicfileconversions}).
+  \item \code{elevation}: a numeric array storing bed-elevations
     % Refer here to the example to be provided in describing the simple example
+    \item \code{time}, a Numeric array containing times for model
+    evaluation
+  \item \code{time}: a numeric array containing times for model evaluation
 \end{itemize}
+The only difference between the STS format and the SWW format is the former does not contain a list specifying the points at the vertices of each of the triangles (\code{volumes}). Consequenlty information (arrays) stored within an STS file such as \code{elevation} can be accessed in exactly the same way as it would be extraced from an SWW file.
+A TMS file is used to store time series data that is independent of
+position.
+The only difference between the STS format and the SWW format is the former does
+not contain a list specifying the points at the vertices of each of the triangles
+(\code{volumes}). Consequently information (arrays) stored within an STS file such
+as \code{elevation} can be accessed in exactly the same way as it would be extracted
+from an SWW file.
+A TMS file is used to store time series data that is independent of position.
 \subsection{Mesh File Formats}
 …
 an MSH file, which is a NetCDF file. A mesh file can be generated
 from the function \function{create\_mesh\_from\_regions} (see
 Section \ref{sec:meshgeneration}) and used to initialise a domain.
 A mesh file can define the outline of the mesh---the vertices and
+Section \ref{sec:meshgeneration}) and be used to initialise a domain.
+A mesh file can define the outline of the mesh -- the vertices and
 line segments that enclose the region in which the mesh is
 created---and the triangular mesh itself, which is specified by
+created -- and the triangular mesh itself, which is specified by
 listing the triangles and their vertices, and the segments, which
 are those sides of the triangles that are associated with boundary
 conditions.
 In addition, a mesh file may contain `holes' and/or `regions'. A
+In addition, a mesh file may contain 'holes' and/or 'regions'. A
 hole represents an area where no mesh is to be created, while a
 region is a labelled area used for defining properties of a mesh,
 …
 A mesh file can also contain a georeference, which describes an
+offset to be applied to $x$ and $y$ values --- e.g.\ to the vertices.
+offset to be applied to $x$ and $y$ values -- e.g.\ to the vertices.
 \subsection{Formats for Storing Arbitrary Points and Attributes}
 A CSV/TXT file is used to store data representing
 …
 The format for an CSV/TXT file is:\\
+%\begin{verbatim}
+            first line:   \code{[column names]}\\
+            other lines:  \code{[x value], [y value], [attributes]}\\
+            for example:\\
+            \code{x, y, elevation, friction}\\
+            \code{0.6, 0.7, 4.9, 0.3}\\
+            \code{1.9, 2.8, 5, 0.3}\\
+            \code{2.7, 2.4, 5.2, 0.3}
+        The delimiter is a comma. The first two columns are assumed to
+        be x, y coordinates.
+ \\
+first line:   \code{[column names]}\\
+other lines:  \code{[x value], [y value], [attributes]}\\
+for example:
+\begin{verbatim}
+x, y, elevation, friction}
+.6, 0.7, 4.9, 0.3}
+.9, 2.8, 5, 0.3}
+.7, 2.4, 5.2, 0.3}
+\end{verbatim}
+The delimiter is a comma. The first two columns are assumed to
+be x, y coordinates.
 A PTS file is a NetCDF representation of the data held in an points CSV
 file. If the data is associated with a set of $N$ points, then the
 data is stored using an $N \times 2$ Numeric array of float
 variables for the points and an $N \times 1$ Numeric array for each
+data is stored using an $N \times 2$ numeric array of float
+variables for the points and an $N \times 1$ numeric array for each
 attribute.
-%\end{verbatim}
 \subsection{ArcView Formats}
 …
 to represent metadata for a DEM.
 \subsection{DEM Format}
 A DEM file in \anuga is a NetCDF representation of regular DEM data.
 \subsection{Other Formats}
 \subsection{Basic File Conversions}
 \label{sec:basicfileconversions}
   \begin{funcdesc}{sww2dem}{basename_in, basename_out = None,
             quantity = None,
             timestep = None,
             reduction = None,
             cellsize = 10,
             number_of_decimal_places = None,
             NODATA_value = -9999,
             easting_min = None,
             easting_max = None,
             northing_min = None,
             northing_max = None,
             expand_search = False,
             verbose = False,
             origin = None,
             datum = 'WGS84',
             format = 'ers'}
+\begin{funcdesc}{sww2dem}{basename_in, basename_out=None,
+            quantity=None,
+            timestep=None,
+            reduction=None,
+            cellsize=10,
+            number_of_decimal_places=None,
+            NODATA_value=-9999,
+            easting_min=None,
+            easting_max=None,
+            northing_min=None,
+            northing_max=None,
+            expand_search=False,
+            verbose=False,
+            origin=None,
+            datum='WGS84',
+            format='ers'}
   Module: \module{shallow\_water.data\_manager}
 …
   within a specified rectangular area. The \code{reduction} input refers to a function
   to reduce the quantities over all time step of the SWW file, example, maximum.
+  \end{funcdesc}
+  \begin{funcdesc}{dem2pts}{basename_in, basename_out=None,
+\end{funcdesc}
+\begin{funcdesc}{dem2pts}{basename_in, basename_out=None,
             easting_min=None, easting_max=None,
             northing_min=None, northing_max=None,
 …
   Takes DEM data (a NetCDF file representation of data from a regular Digital
   Elevation Model) and converts it to PTS format.
   \end{funcdesc}
   \begin{funcdesc}{urs2sts}{basename_in, basename_out=None,
+\end{funcdesc}
+\begin{funcdesc}{urs2sts}{basename_in, basename_out=None,
             weights=None, verbose=False,
             origin=None,mean_stage=0.0,
 …
   Module: \module{shallow\_water.data\_manager}
   Takes urs data in (timeseries data in mux2 format) and converts it to STS format. The optional filename \code{ordering\_filename} specifies the permutation of indices of points to select along with their longitudes and latitudes. This permutation will also be
   stored in the STS file. If absent, all points are taken and the permutation will be trivial, i.e. $0, 1, \ldots, N-1$, where $N$ is the total number of points stored.
   \end{funcdesc}
+  Takes URS data (timeseries data in mux2 format) and converts it to STS format.
+  The optional filename \code{ordering\_filename} specifies the permutation of indices
+  of points to select along with their longitudes and latitudes. This permutation will also be
+  stored in the STS file. If absent, all points are taken and the permutation will be trivial,
+  i.e. $0, 1, \ldots, N-1$, where $N$ is the total number of points stored.
+\end{funcdesc}
 \begin{funcdesc}{csv2building\_polygons}{file\_name, floor\_height=3}
+Module: \module{shallow\_water.data\_manager}
+Convert CSV files of the form:
+{\small
+\begin{verbatim}
+    easting,northing,id,floors
+.22,870785.46,2,0
+.48,870780.14,2,0
+.17,870772.62,2,0
+.35,870777.17,2,0
+.22,870785.46,2,0
+.30,871215.06,3,1
+.50,871215.70,3,1
+.30,871204.86,3,1
+.21,871204.33,3,1
+.30,871215.06,3,1
+\end{verbatim} }
+to a dictionary of polygons with id as key.
+The associated number of floors are converted to m above MSL and
+returned as a separate dictionary also keyed by id.
+  Module: \module{shallow\_water.data\_manager}
+  Convert CSV files of the form:
+  \begin{verbatim}
+easting,northing,id,floors
+.22,870785.46,2,0
+.48,870780.14,2,0
+.17,870772.62,2,0
+.35,870777.17,2,0
+.22,870785.46,2,0
+.30,871215.06,3,1
+.50,871215.70,3,1
+.30,871204.86,3,1
+.21,871204.33,3,1
+.30,871215.06,3,1
+  \end{verbatim}
+  to a dictionary of polygons with \code{id} as key.
+  The associated number of \code{floors} are converted to m above MSL and
+  returned as a separate dictionary also keyed by \code{id}.
 Optional parameter floor_height is the height of each building story.
+These can e.g. be converted to a Polygon\_function for use with add\_quantity
 as shown on page \pageref{add quantity}.
+  Optional parameter \code{floor_height} is the height of each building story.
+  These can e.g. be converted to a \code{Polygon_function} for use with \code{add_quantity}
+  as shown on page \pageref{add quantity}.
 \end{funcdesc}
-%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 …
 \label{cd:mathematical background}
 \section{Introduction}
 This chapter outlines the mathematics underpinning \anuga.
 …
 and tsunamis.
 \section{Finite Volume Method}
 \label{sec:fvm}
 …
 particular interest.
+\begin{figure}
+\begin{center}
+\includegraphics[width=8.0cm,keepaspectratio=true]{graphics/step-five}
+\caption{Triangular mesh used in our finite volume method. Conserved
+quantities $h$, $uh$ and $vh$ are associated with the centroid of
+each triangular cell.} \label{fig:mesh}
+\end{center}
+\end{figure}
+\begin{figure}[htp] \begin{center}
+  \includegraphics[width=8.0cm,keepaspectratio=true]{graphics/step-five}
+  \caption{Triangular mesh used in our finite volume method. Conserved
+           quantities $h$, $uh$ and $vh$ are associated with the centroid of
+           each triangular cell.}
+  \label{fig:mesh}
+\end{center} \end{figure}
 The equations constituting the finite-volume method are obtained by
 …
 where
 \begin{itemize}
+\item $\UU_i$ the vector of conserved quantities averaged over the $i$th cell,
+\item $\SSS_i$ is the source term associated with the $i$th cell,
+and
+\item $\HH_{ij}$ is the outward normal flux of
+material across the \textit{ij}th edge.
+  \item $\UU_i$ the vector of conserved quantities averaged over the $i$th cell,
+  \item $\SSS_i$ is the source term associated with the $i$th cell, and
+  \item $\HH_{ij}$ is the outward normal flux of material across the \textit{ij}th edge.
 \end{itemize}
 %\item $l_{ij}$ is the length of the edge between the $i$th and $j$th
 …
 We use a second order reconstruction to produce a piece-wise linear
 function construction of the conserved quantities for  all $x \in
 T_i$ for each cell (see Figure~\ref{fig:mesh:reconstruct}. This
+T_i$ for each cell (see Figure~\ref{fig:mesh:reconstruct}). This
 function is allowed to be discontinuous across the edges of the
 cells, but the slope of this function is limited to avoid
 …
 calculate an approximation of the flux across each edge.
+\begin{figure}
+\begin{center}
+\includegraphics[width=8.0cm,keepaspectratio=true]{graphics/step-reconstruct}
+\caption{From the values of the conserved quantities at the centroid
+of the cell and its neighbouring cells, a discontinuous piecewise
+linear reconstruction of the conserved quantities is obtained.}
+\label{fig:mesh:reconstruct}
+\end{center}
+\end{figure}
+\begin{figure}[htp] \begin{center}
+  \includegraphics[width=8.0cm,keepaspectratio=true]{graphics/step-reconstruct}
+  \caption{From the values of the conserved quantities at the centroid
+           of the cell and its neighbouring cells, a discontinuous piecewise
+           linear reconstruction of the conserved quantities is obtained.}
+  \label{fig:mesh:reconstruct}
+\end{center} \end{figure}
 In the computations presented in this paper we use an explicit Euler
 …
 of each triangle.
 \section{Flux limiting}
 The shallow water equations are solved numerically using a
 finite volume method on unstructured triangular grid.
+finite volume method on an unstructured triangular grid.
 The upwind central scheme due to Kurganov and Petrova is used as an
 approximate Riemann solver for the computation of inviscid flux functions.
 …
 small water depths near a wet/dry boundary we employ a new flux limiter that
 ensures that unphysical fluxes are never encounted.
 Let $u$ and $v$ be the velocity components in the $x$ and $y$ direction,
 …
 \]
 ANUGA has a global parameter $H_0$ that controls the minimal depth which
 is considered in the various equations. This parameter is typically set to
 …
 which converges quadratically to the true value with the multiple N.
+%The developed numerical model has been applied to several test cases as well as to real flows. Numerical tests prove the robustness and accuracy of the model.
+%The developed numerical model has been applied to several test cases
+%as well as to real flows. numeric tests prove the robustness and accuracy of the model.
 \section{Slope limiting}
+A multidimensional slope-limiting technique is employed to achieve second-order spatial accuracy and to prevent spurious oscillations. This is using the MinMod limiter and is documented elsewhere.
+However close to the bed, the limiter must ensure that no negative depths occur. On the other hand, in deep water, the bed topography should be ignored for the purpose of the limiter.
+A multidimensional slope-limiting technique is employed to achieve second-order spatial
+accuracy and to prevent spurious oscillations. This is using the MinMod limiter and is
+documented elsewhere.
+However close to the bed, the limiter must ensure that no negative depths occur.
+ On the other hand, in deep water, the bed topography should be ignored for the
+purpose of the limiter.
 Let $w, z, h$  be the stage, bed elevation and depth at the centroid and
 …
 \]
 Similarly, let $\bar{w_i}$ be the stage obtained from a gradient
 limiter limiting on depth respecting the bed slope.
 …
   \bar{h_i} = \bar{w_i} - z_i
 \]
 We introduce the concept of a balanced stage $w_i$ which is obtained as
 …
 %provides a numerical safety {??)
 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
-%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 \chapter{Basic \anuga Assumptions}
+ \section{Time}
+\section{Time}
 Physical model time cannot be earlier than 1 Jan 1970 00:00:00.
 If one wished to recreate scenarios prior to that date it must be done
 using some relative time (e.g. 0).
+The ANUGA domain has an attribute \code{starttime} which is used in cases where the simulation should be started later than the beginning of some input data such as those obtained from boundaries or forcing functions (hydrographs, file\_boundary etc)
+The \code{file\_boundary} may adjust domain.startime in case the input data does not itself start until a later time.
+The ANUGA domain has an attribute \code{starttime} which is used in cases where the
+simulation should be started later than the beginning of some input data such as those
+obtained from boundaries or forcing functions (hydrographs, file\_boundary etc).
+The \code{domain.startime} may be adjusted in \code{file_boundary} in the case the
+input data does not itself start until a later time.
 …
 \subsection{Projection}
+All spatial data relates to the WGS84 datum (or GDA94) and assumes a projection into UTM with false easting of 500000 and false northing of
+All spatial data relates to the WGS84 datum (or GDA94) and assumes a projection
+into UTM with false easting of 500000 and false northing of
 1000000 on the southern hemisphere (0 on the northern hemisphere).
 All locations must consequently be specified in Cartesian coordinates
 …
 It is important to realise that ANUGA for numerical precision uses coordinates that are relative
 to the lower left node of the rectangle containing the mesh ($x_{\mbox{min}}$, $y_{\mbox{min}}$).
 This origin is referred to internally as xllcorner, yllcorner following the ESRI ascii grid notation.
 The sww file format also includes xllcorner, yllcorner and any coordinate in the file should be adjusted
+This origin is referred to internally as \code{xllcorner}, \code{yllcorner} following the ESRI ASCII grid notation.
+The sww file format also includes \code{xllcorner}, \code{yllcorner} and any coordinate in the file should be adjusted
 by adding this origin. See Section \ref{sec:sww format}.
 Throughout the ANUGA interface functions have optional boolean arguments \code{absolute} which control
 whether spatial data received is using the internal representation (absolute=False) or the
 user coordinate set (absolute=True). See e.g. \code{get\_vertex\_coordinates} on \pageref{pg:get vertex coordinates}.
+Throughout the ANUGA interface, functions have optional boolean arguments \code{absolute} which controls
+whether spatial data received is using the internal representation (\code{absolute=False}) or the
+user coordinate set (\code{absolute=True}). See e.g. \code{get_vertex_coordinates} on \pageref{pg:get vertex coordinates}.
 DEMs, meshes and boundary conditions can have different origins. However, the internal representation in ANUGA
 …
 \subsection{Polygons}
 When generating a mesh it is assumed that polygons do not cross.
+Having polygons tht cross can cause the mesh generation to fail or bad
+meshes being produced.
+Having polygons that cross can cause bad meshes to be produced or the mesh generation itself may fail.
 %OLD
 …
 %                     run inundation simulation.
 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
-%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 \appendix
 \chapter{Supporting Tools}
 …
 This section describes a number of supporting tools, supplied with \anuga, that offer a
+variety of types of functionality and enhance the basic capabilities of \anuga.
+variety of types of functionality and can enhance the basic capabilities of \anuga.
 \section{caching}
 …
 The \code{cache} function is used to provide supervised caching of function
+results. A Python function call of the form
+      {\small \begin{verbatim}
+      result = func(arg1,...,argn)
+      \end{verbatim}}
+  can be replaced by
+      {\small \begin{verbatim}
+      from caching import cache
+      result = cache(func,(arg1,...,argn))
+      \end{verbatim}}
+  which returns the same output but reuses cached
+  results if the function has been computed previously in the same context.
+  \code{result} and the arguments can be simple types, tuples, list, dictionaries or
+  objects, but not unhashable types such as functions or open file objects.
+  The function \code{func} may be a member function of an object or a module.
+  This type of caching is particularly useful for computationally intensive
+  functions with few frequently used combinations of input arguments. Note that
+  if the inputs or output are very large caching may not save time because
+  disc access may dominate the execution time.
+  If the function definition changes after a result has been cached, this will be
+  detected by examining the functions \code{bytecode (co\_code, co\_consts,
+  func\_defaults, co\_argcount)} and the function will be recomputed.
+  However, caching will not detect changes in modules used by \code{func}.
+  In this case cache must be cleared manually.
+  Options are set by means of the function \code{set\_option(key, value)},
+  where \code{key} is a key associated with a
+  Python dictionary \code{options}. This dictionary stores settings such as the name of
+  the directory used, the maximum
+  number of cached files allowed, and so on.
+  The \code{cache} function allows the user also to specify a list of dependent files. If any of these
+  have been changed, the function is recomputed and the results stored again.
+  %Other features include support for compression and a capability to \ldots
+   \textbf{USAGE:} \nopagebreak
+    {\small \begin{verbatim}
+    result = cache(func, args, kwargs, dependencies, cachedir, verbose,
+                   compression, evaluate, test, return_filename)
+    \end{verbatim}}
+\section{ANUGA viewer - animate}
+results. A Python function call of the form:
+\begin{verbatim}
+result = func(arg1, ..., argn)
+\end{verbatim}
+can be replaced by:
+\begin{verbatim}
+from caching import cache
+result = cache(func,(arg1, ..., argn))
+\end{verbatim}
+which returns the same output but reuses cached
+results if the function has been computed previously in the same context.
+\code{result} and the arguments can be simple types, tuples, list, dictionaries or
+objects, but not unhashable types such as functions or open file objects.
+The function \code{func} may be a member function of an object or a module.
+This type of caching is particularly useful for computationally intensive
+functions with few frequently used combinations of input arguments. Note that
+if the inputs or output are very large caching may not save time because
+disc access may dominate the execution time.
+If the function definition changes after a result has been cached, this will be
+detected by examining the functions \code{bytecode (co\_code, co\_consts,
+func\_defaults, co\_argcount)} and the function will be recomputed.
+However, caching will not detect changes in modules used by \code{func}.
+In this case cache must be cleared manually.
+Options are set by means of the function \code{set\_option(key, value)},
+where \code{key} is a key associated with a
+Python dictionary \code{options}. This dictionary stores settings such as the name of
+the directory used, the maximum number of cached files allowed, and so on.
+The \code{cache} function allows the user also to specify a list of dependent files. If any of these
+have been changed, the function is recomputed and the results stored again.
+%Other features include support for compression and a capability to \ldots
+\textbf{USAGE:} \nopagebreak
+\begin{verbatim}
+result = cache(func, args, kwargs, dependencies, cachedir, verbose,
+               compression, evaluate, test, return_filename)
+\end{verbatim}
+\section{ANUGA viewer -- animate}
 \label{sec:animate}
+ The output generated by \anuga may be viewed by
+The output generated by \anuga may be viewed by
 means of the visualisation tool \code{animate}, which takes the
 \code{SWW} file output by \anuga and creates a visual representation
+\code{SWW} file generated by \anuga and creates a visual representation
 of the data. Examples may be seen in Figures \ref{fig:runupstart}
 and \ref{fig:runup2}. To view an \code{SWW} file with
 …
 file association to make files with the extension \code{.sww} open
 with \code{animate}. Alternatively, you can operate \code{animate}
 from the command line, in both Windows and Linux environments.
 On successful operation, you will see an interactive moving-picture
 display. You can use keys and the mouse to slow down, speed up or
+from the command line.
+Upon starting the viewer, you will see an interactive moving-picture
+display. You can use the keyboard and the mouse to slow down, speed up or
 stop the display, change the viewing position or carry out a number
 of other simple operations. Help is also displayed when you press
 the \code{h} key.
+The main keys operating the interactive screen are:\\
+The main keys operating the interactive screen are:
 \begin{center}
 \begin{tabular}{|ll|}   \hline
+\code{w} & toggle wireframe \\
+space bar & start/stop\\
+up/down arrows & increase/decrease speed\\
+left/right arrows & direction in time \emph{(when running)}\\
+& step through simulation \emph{(when stopped)}\\
+left mouse button & rotate\\
+middle mouse button & pan\\
+right mouse button & zoom\\  \hline
+  \code{h} & toggle on-screen help display \\
+  \code{w} & toggle wireframe \\
+  space bar & start/stop\\
+  up/down arrows & increase/decrease speed\\
+  left/right arrows & direction in time \emph{(when running)}\\
+                    & step through simulation \emph{(when stopped)}\\
+  left mouse button & rotate\\
+  middle mouse button & pan\\
+  right mouse button & zoom\\  \hline
 \end{tabular}
 \end{center}
 \vfill
 The following table describes how to operate animate from the command line:
+% \vfill
+The following table describes how to operate \code{animate} from the command line:
 Usage: \code{animate [options] swwfile \ldots}\\  \nopagebreak
 …
 \begin{tabular}{ll}
   \code{-hmin <float>} & Height below which transparency is set to
                                      zero\\
 …
 \begin{tabular}{ll}
   \code{-loop}  & Repeated (looped) playback of \code{.swm} files\\
 \end{tabular}
 …
   \code{-movie <dirname>} & Save numbered images to named directory and
                                      quit\\
   \code{-nosky} & Omit background sky\\
   \code{-scale <float>} & Vertical scale factor\\
   \code{-texture <file>} & Image to use for bedslope topography\\
 …
 \end{tabular}
+/pagebreak
 \section{utilities/polygons}
   \declaremodule{standard}{utilities.polygon}
   \refmodindex{utilities.polygon}
   \begin{classdesc}{Polygon\_function}{regions, default=0.0, geo_reference=None}
+\declaremodule{standard}{utilities.polygon}
+\refmodindex{utilities.polygon}
+\begin{classdesc}{Polygon\_function}{regions, default=0.0, geo_reference=None}
   Module: \code{utilities.polygon}
 …
   that are passed into the function. Typically they will be relative to
   some origin. In ANUGA, a typical call will take the form:
+  {\small \begin{verbatim}
+     set_quantity('elevation',
+                  Polygon_function([(P1, v1), (P2, v2)],
+                                   default=v3,
+                                   geo_reference=domain.geo_reference))
+  \end{verbatim}}
+  \end{classdesc}
+  \begin{funcdesc}{read\_polygon}{filename}
+  \begin{verbatim}
+set_quantity('elevation',
+             Polygon_function([(P1, v1), (P2, v2)],
+                              default=v3,
+                              geo_reference=domain.geo_reference))
+  \end{verbatim}
+\end{classdesc}
+\begin{funcdesc}{read\_polygon}{filename}
   Module: \code{utilities.polygon}
 …
   line of the file must contain exactly two numbers, separated by a comma, which are interpreted
   as coordinates of one vertex of the polygon.
   \end{funcdesc}
   \begin{funcdesc}{populate\_polygon}{polygon, number_of_points, seed = None, exclude = None}
+\end{funcdesc}
+\begin{funcdesc}{populate\_polygon}{polygon, number_of_points, seed = None, exclude = None}
   Module: \code{utilities.polygon}
   Populates the interior of the specified polygon with the specified number of points,
   selected by means of a uniform distribution function.
   \end{funcdesc}
   \begin{funcdesc}{point\_in\_polygon}{polygon, delta=1e-8}
+\end{funcdesc}
+\begin{funcdesc}{point\_in\_polygon}{polygon, delta=1e-8}
   Module: \code{utilities.polygon}
 …
   the returned point and the nearest point of the polygon is less than $\sqrt{2}$ times the
   second argument \code{delta}, which is taken as $10^{-8}$ by default.
   \end{funcdesc}
   \begin{funcdesc}{inside\_polygon}{points, polygon, closed = True, verbose = False}
+\end{funcdesc}
+\begin{funcdesc}{inside\_polygon}{points, polygon, closed = True, verbose = False}
   Module: \code{utilities.polygon}
   Used to test whether the members of a list of points
   are inside the specified polygon. Returns a Numeric
+  are inside the specified polygon. Returns a numeric
   array comprising the indices of the points in the list that lie inside the polygon.
   (If none of the points are inside, returns \code{zeros((0,), 'l')}.)
   Points on the edges of the polygon are regarded as inside if
   \code{closed} is set to \code{True} or omitted; otherwise they are regarded as outside.
   \end{funcdesc}
   \begin{funcdesc}{outside\_polygon}{points, polygon, closed = True, verbose = False}
+\end{funcdesc}
+\begin{funcdesc}{outside\_polygon}{points, polygon, closed = True, verbose = False}
   Module: \code{utilities.polygon}
   Exactly like \code{inside\_polygon}, but with the words `inside' and `outside' interchanged.
   \end{funcdesc}
   \begin{funcdesc}{is\_inside\_polygon}{point, polygon, closed=True, verbose=False}
+  Exactly like \code{inside\_polygon}, but with the words 'inside' and 'outside' interchanged.
+\end{funcdesc}
+\begin{funcdesc}{is\_inside\_polygon}{point, polygon, closed=True, verbose=False}
   Module: \code{utilities.polygon}
 …
   \code{False} otherwise. Points on the edges of the polygon are regarded as inside if
   \code{closed} is set to \code{True} or omitted; otherwise they are regarded as outside.
   \end{funcdesc}
   \begin{funcdesc}{is\_outside\_polygon}{point, polygon, closed=True, verbose=False}
+\end{funcdesc}
+\begin{funcdesc}{is\_outside\_polygon}{point, polygon, closed=True, verbose=False}
   Module: \code{utilities.polygon}
   Exactly like \code{is\_outside\_polygon}, but with the words `inside' and `outside' interchanged.
   \end{funcdesc}
   \begin{funcdesc}{point\_on\_line}{x, y, x0, y0, x1, y1}
+  Exactly like \code{is\_outside\_polygon}, but with the words 'inside' and 'outside' interchanged.
+\end{funcdesc}
+\begin{funcdesc}{point\_on\_line}{x, y, x0, y0, x1, y1}
   Module: \code{utilities.polygon}
 …
   \code{x, y} is on the line passing through the points with coordinates \code{x0, y0}
   and \code{x1, y1} (extended if necessary at either end).
   \end{funcdesc}
   \begin{funcdesc}{separate\_points\_by\_polygon}{points, polygon, closed = True, verbose = False}
+\end{funcdesc}
+\begin{funcdesc}{separate\_points\_by\_polygon}{points, polygon, closed = True, verbose = False}
     \indexedcode{separate\_points\_by\_polygon}
   Module: \code{utilities.polygon}
   \end{funcdesc}
   \begin{funcdesc}{polygon\_area}{polygon}
+\end{funcdesc}
+\begin{funcdesc}{polygon\_area}{polygon}
   Module: \code{utilities.polygon}
   Returns area of arbitrary polygon (reference http://mathworld.wolfram.com/PolygonArea.html)
+  \end{funcdesc}
+  \begin{funcdesc}{plot\_polygons}{polygons, style, figname, verbose = False}
+    Module: \code{utilities.polygon}
+    Plots each polygon contained in input polygon list, e.g.
+   \code{polygons = [poly1, poly2, poly3]} where \code{poly1 = [[x11,y11],[x12,y12],[x13,y13]]}
+   etc.  Each polygon can be closed for plotting purposes by assigning the style type to each
+   polygon in the list, e.g. \code{style = ['line','line','line']}. The default will be a line
+   type when \code{style = None}.
+   The subsequent plot will be saved to \code{figname} or defaulted to \code{test_image.png}.
+    The function returns a list containing the minimum and maximum of \code{x} and \code{y},
+    i.e. \code{[x_{min}, x_{max}, y_{min}, y_{max}]}.
+  \end{funcdesc}
+\end{funcdesc}
+\begin{funcdesc}{plot\_polygons}{polygons, style, figname, verbose = False}
+  Module: \code{utilities.polygon}
+  Plots each polygon contained in input polygon list, e.g.
+  \code{polygons = [poly1, poly2, poly3]} where \code{poly1 = [[x11,y11],[x12,y12],[x13,y13]]}
+  etc.  Each polygon can be closed for plotting purposes by assigning the style type to each
+  polygon in the list, e.g. \code{style = ['line','line','line']}. The default will be a line
+  type when \code{style = None}.
+  The subsequent plot will be saved to \code{figname} or defaulted to \code{test_image.png}.
+  The function returns a list containing the minimum and maximum of \code{x} and \code{y},
+  i.e. \code{[x_{min}, x_{max}, y_{min}, y_{max}]}.
+\end{funcdesc}
 \section{coordinate\_transforms}
 \section{geospatial\_data}
 …
 %\refmodindex{geospatial_data}
 \begin{classdesc}{Geospatial\_data}
+  {data_points = None,
+    attributes = None,
+    geo_reference = None,
+    default_attribute_name = None,
+    file_name = None}
+Module: \code{geospatial\_data}
+This class is used to store a set of data points and associated
+attributes, allowing these to be manipulated by methods defined for
+the class.
+The data points are specified either by reading them from a NetCDF
+or CSV file, identified through the parameter \code{file\_name}, or
+by providing their \code{x}- and \code{y}-coordinates in metres,
+either as a sequence of 2-tuples of floats or as an $M \times 2$
+Numeric array of floats, where $M$ is the number of points.
+Coordinates are interpreted relative to the origin specified by the
+object \code{geo\_reference}, which contains data indicating the UTM
+zone, easting and northing. If \code{geo\_reference} is not
+specified, a default is used.
+Attributes are specified through the parameter \code{attributes},
+set either to a list or array of length $M$ or to a dictionary whose
+keys are the attribute names and whose values are lists or arrays of
+length $M$. One of the attributes may be specified as the default
+attribute, by assigning its name to \code{default\_attribute\_name}.
+If no value is specified, the default attribute is taken to be the
+first one.
+Note that the Geospatial\_data object currently reads entire datasets
+into memory i.e.\ no memomry blocking takes place.
+For this we refer to the set\_quantity method which will read .pts and .csv files into \anuga using memory blocking allowing large files to be used.
+  {data_points=None,
+    attributes=None,
+    geo_reference=None,
+    default_attribute_name=None,
+    file_name=None}
+  Module: \code{geospatial\_data}
+  This class is used to store a set of data points and associated
+  attributes, allowing these to be manipulated by methods defined for
+  the class.
+  The data points are specified either by reading them from a NetCDF
+  or CSV file, identified through the parameter \code{file\_name}, or
+  by providing their \code{x}- and \code{y}-coordinates in metres,
+  either as a sequence of 2-tuples of floats or as an $M \times 2$
+  numeric array of floats, where $M$ is the number of points.
+  Coordinates are interpreted relative to the origin specified by the
+  object \code{geo\_reference}, which contains data indicating the UTM
+  zone, easting and northing. If \code{geo\_reference} is not
+  specified, a default is used.
+  Attributes are specified through the parameter \code{attributes},
+  set either to a list or array of length $M$ or to a dictionary whose
+  keys are the attribute names and whose values are lists or arrays of
+  length $M$. One of the attributes may be specified as the default
+  attribute, by assigning its name to \code{default\_attribute\_name}.
+  If no value is specified, the default attribute is taken to be the
+  first one.
+  Note that the Geospatial\_data object currently reads entire datasets
+  into memory i.e.\ no memomry blocking takes place.
+  For this we refer to the set\_quantity method which will read .pts and .csv
+  files into \anuga using memory blocking allowing large files to be used.
 \end{classdesc}
+\begin{methoddesc}{import\_points\_file}{delimiter = None, verbose = False}
+\end{methoddesc}
+\begin{methoddesc}{import\_points\_file}{delimiter=None, verbose=False}
+\end{methoddesc}
 \begin{methoddesc}{export\_points\_file}{ofile, absolute=False}
 …
 \end{methoddesc}
+\begin{methoddesc}{get\_data\_points}{absolute = True, as\_lat\_long =
+    False}
+\begin{methoddesc}{get\_data\_points}{absolute=True, as\_lat\_long=False}
     If \code{as\_lat\_long} is\code{True} the point information
     returned will be in Latitudes and Longitudes.
+\end{methoddesc}
+\end{methoddesc}
 \begin{methoddesc}{set\_attributes}{attributes}
 …
 \end{methoddesc}
+\begin{methoddesc}{get\_attributes}{attribute_name = None}
+\end{methoddesc}
+\begin{methoddesc}{get\_attributes}{attribute_name=None}
+\end{methoddesc}
 \begin{methoddesc}{get\_all\_attributes}{}
 …
 \end{methoddesc}
 \begin{methoddesc}{set\_default\_attribute\_name}{default_attribute_name}
 \end{methoddesc}
 \begin{methoddesc}{set\_geo\_reference}{geo_reference}
 \end{methoddesc}
 \begin{methoddesc}{add}{}
 \end{methoddesc}
 \begin{methoddesc}{clip}{}
+Clip geospatial data by a polygon
+Inputs are \code{polygon} which is either a list of points, an Nx2 array or
+a Geospatial data object and \code{closed}(optional) which determines
+whether points on boundary should be regarded as belonging to the polygon
+(\code{closed=True}) or not (\code{closed=False}).
+Default is \code{closed=True}.
+Returns new Geospatial data object representing points
+inside specified polygon.
+\end{methoddesc}
+  Clip geospatial data by a polygon
+  Inputs are \code{polygon} which is either a list of points, an Nx2 array or
+  a Geospatial data object and \code{closed}(optional) which determines
+  whether points on boundary should be regarded as belonging to the polygon
+  (\code{closed=True}) or not (\code{closed=False}).
+  Default is \code{closed=True}.
+  Returns new Geospatial data object representing points inside specified polygon.
+\end{methoddesc}
 \begin{methoddesc}{clip_outside}{}
+Clip geospatial data by a polygon
+Inputs are \code{polygon} which is either a list of points, an Nx2 array or
+a Geospatial data object and \code{closed}(optional) which determines
+whether points on boundary should be regarded as belonging to the polygon
+(\code{closed=True}) or not (\code{closed=False}).
+Default is \code{closed=True}.
+Returns new Geospatial data object representing points
+\emph{out}side specified polygon.
+  Clip geospatial data by a polygon
+  Inputs are \code{polygon} which is either a list of points, an Nx2 array or
+  a Geospatial data object and \code{closed}(optional) which determines
+  whether points on boundary should be regarded as belonging to the polygon
+  (\code{closed=True}) or not (\code{closed=False}).
+  Default is \code{closed=True}.
+  Returns new Geospatial data object representing points \emph{out}side specified polygon.
 \end{methoddesc}
 \begin{methoddesc}{split}{factor=0.5, seed_num=None, verbose=False}
+Returns two geospatial_data object, first is the size of the 'factor'
+smaller the original and the second is the remainder. The two
+new object are disjoin set of each other.
+Points of the two new geospatial_data object are selected RANDOMLY.
+Input - the (\code{factor}) which to split the object, if 0.1 then 10% of the
+together object will be returned
+Output - two geospatial_data objects that are disjoint sets of the original
+\end{methoddesc}
+\begin{methoddesc}{find_optimal_smoothing_parameter}{data_file, alpha_list=None, mesh_file=None, boundary_poly=None, mesh_resolution=100000,
+north_boundary=None, south_boundary=None, east_boundary=None, west_boundary=None, plot_name='all_alphas', split_factor=0.1, seed_num=None, cache=False, verbose=False}
+Removes a small random sample of points from 'data_file'. Creates
+models from resulting points in 'data_file' with different alpha values from 'alpha_list' and cross validates
+the predicted value to the previously removed point data. Returns the
+alpha value which has the smallest covariance.
+data_file: must not contain points outside the boundaries defined
+and it either a pts, txt or csv file.
+alpha_list: the alpha values to test in a single list
+mesh_file: name of the created mesh file or if passed in will read it.
+NOTE, if there is a mesh file mesh_resolution, north_boundary, south... etc will be ignored.
+mesh_resolution: the maximum area size for a triangle
+north_boundary... west_boundary: the value of the boundary
+plot_name: the name for the plot contain the results
+seed_num: the seed to the random number generator
+USAGE:
+convariance_value, alpha = find_optimal_smoothing_parameter(data_file=fileName,
+                                             alpha_list=[0.0001, 0.01, 1],
+                                             mesh_file=None,
+                                             mesh_resolution=3,
+                                             north_boundary=5,
+                                             south_boundary=-5,
+                                             east_boundary=5,
+                                             west_boundary=-5,
+                                             plot_name='all_alphas',
+                                             seed_num=100000,
+                                             verbose=False)
+OUTPUT: returns the minumum normalised covalance calculate AND the
+alpha that created it. PLUS writes a plot of the results
+NOTE: code will not work if the data_file extent is greater than the
+boundary_polygon or any of the boundaries, eg north_boundary...west_boundary
+\end{methoddesc}
+  Returns two geospatial_data object, first is the size of the 'factor'
+  smaller the original and the second is the remainder. The two
+  new object are disjoin set of each other.
+  Points of the two new geospatial_data object are selected RANDOMLY.
+  Input -- the (\code{factor}) which to split the object, if 0.1 then 10% of the
+  together object will be returned
+  Output -- two geospatial_data objects that are disjoint sets of the original
+\end{methoddesc}
+\begin{methoddesc}{find_optimal_smoothing_parameter}{data_file, alpha_list=None,
+                   mesh_file=None, boundary_poly=None, mesh_resolution=100000,
+                   north_boundary=None, south_boundary=None, east_boundary=None,
+                   west_boundary=None, plot_name='all_alphas', split_factor=0.1,
+                   seed_num=None, cache=False, verbose=False}
+  Removes a small random sample of points from 'data_file'. Creates
+  models from resulting points in 'data_file' with different alpha values from 'alpha_list' and cross validates
+  the predicted value to the previously removed point data. Returns the
+  alpha value which has the smallest covariance.
+  data_file: must not contain points outside the boundaries defined
+  and it either a pts, txt or csv file.
+  alpha_list: the alpha values to test in a single list
+  mesh_file: name of the created mesh file or if passed in will read it.
+  NOTE, if there is a mesh file mesh_resolution, north_boundary, south... etc will be ignored.
+  mesh_resolution: the maximum area size for a triangle
+  north_boundary... west_boundary: the value of the boundary
+  plot_name: the name for the plot contain the results
+  seed_num: the seed to the random number generator
+  USAGE:
+  convariance_value, alpha = find_optimal_smoothing_parameter(data_file=fileName,
+                                               alpha_list=[0.0001, 0.01, 1],
+                                               mesh_file=None,
+                                               mesh_resolution=3,
+                                               north_boundary=5,
+                                               south_boundary=-5,
+                                               east_boundary=5,
+                                               west_boundary=-5,
+                                               plot_name='all_alphas',
+                                               seed_num=100000,
+                                               verbose=False)
+  OUTPUT: returns the minumum normalised covalance calculate AND the
+  alpha that created it. PLUS writes a plot of the results
+  NOTE: code will not work if the data_file extent is greater than the
+  boundary_polygon or any of the boundaries, eg north_boundary...west_boundary
+\end{methoddesc}
 \section{Graphical Mesh Generator GUI}
 The program \code{graphical\_mesh\_generator.py} in the pmesh module
+The program \code{graphical_mesh_generator.py} in the pmesh module
 allows the user to set up the mesh of the problem interactively.
 It can be used to build the outline of a mesh or to visualise a mesh
 …
 by pressing the the middle mouse button (scroll bar).
 \section{alpha\_shape}
 \emph{Alpha shapes} are used to generate close-fitting boundaries
 around sets of points. The alpha shape algorithm produces a shape
 that approximates to the `shape formed by the points'---or the shape
+that approximates to the 'shape formed by the points' -- or the shape
 that would be seen by viewing the points from a coarse enough
 resolution. For the simplest types of point sets, the alpha shape
 …
 with instances of this class.
 \begin{classdesc}{Alpha\_Shape}{points, alpha = None}
 Module: \code{alpha\_shape}
 To instantiate this class the user supplies the points from which
 the alpha shape is to be created (in the form of a list of 2-tuples
 \code{[[x1, y1],[x2, y2]}\ldots\code{]}, assigned to the parameter
 \code{points}) and, optionally, a value for the parameter
 \code{alpha}. The alpha shape is then computed and the user can then
 retrieve details of the boundary through the attributes defined for
 the class.
+\begin{classdesc}{Alpha\_Shape}{points, alpha=None}
+  Module: \code{alpha\_shape}
+  To instantiate this class the user supplies the points from which
+  the alpha shape is to be created (in the form of a list of 2-tuples
+  \code{[[x1, y1],[x2, y2]}\ldots\code{]}, assigned to the parameter
+  \code{points}) and, optionally, a value for the parameter
+  \code{alpha}. The alpha shape is then computed and the user can then
+  retrieve details of the boundary through the attributes defined for
+  the class.
 \end{classdesc}
+\begin{funcdesc}{alpha\_shape\_via\_files}{point_file, boundary_file, alpha= None}
+Module: \code{alpha\_shape}
+This function reads points from the specified point file
+\code{point\_file}, computes the associated alpha shape (either
+using the specified value for \code{alpha} or, if no value is
+specified, automatically setting it to an optimal value) and outputs
+the boundary to a file named \code{boundary\_file}. This output file
+lists the coordinates \code{x, y} of each point in the boundary,
+using one line per point.
+\begin{funcdesc}{alpha\_shape\_via\_files}{point_file, boundary_file, alpha=None}
+  Module: \code{alpha\_shape}
+  This function reads points from the specified point file
+  \code{point\_file}, computes the associated alpha shape (either
+  using the specified value for \code{alpha} or, if no value is
+  specified, automatically setting it to an optimal value) and outputs
+  the boundary to a file named \code{boundary\_file}. This output file
+  lists the coordinates \code{x, y} of each point in the boundary,
+  using one line per point.
 \end{funcdesc}
 \begin{methoddesc}{set\_boundary\_type}{self,raw_boundary=True,
 …
                           expand_pinch=False,
                           boundary_points_fraction=0.2}
+Module: \code{alpha\_shape},  Class: \class{Alpha\_Shape}
+This function sets flags that govern the operation of the algorithm
+that computes the boundary, as follows:
+\code{raw\_boundary = True} returns raw boundary, i.e. the regular edges of the
+                alpha shape.\\
+\code{remove\_holes = True} removes small holes (`small' is defined by
+\code{boundary\_points\_fraction})\\
+\code{smooth\_indents = True} removes sharp triangular indents in
+boundary\\
+\code{expand\_pinch = True} tests for pinch-off and
+corrects---preventing a boundary vertex from having more than two edges.
+\end{methoddesc}
+  Module: \code{alpha\_shape},  Class: \class{Alpha\_Shape}
+  This function sets flags that govern the operation of the algorithm
+  that computes the boundary, as follows:
+  \code{raw\_boundary = True} returns raw boundary, i.e. the regular edges of the
+                  alpha shape.\\
+  \code{remove\_holes = True} removes small holes ('small' is defined by
+  \code{boundary\_points\_fraction})\\
+  \code{smooth\_indents = True} removes sharp triangular indents in
+  boundary\\
+  \code{expand\_pinch = True} tests for pinch-off and
+  corrects -- preventing a boundary vertex from having more than two edges.
+\end{methoddesc}
 \begin{methoddesc}{get\_boundary}{}
+Module: \code{alpha\_shape},  Class: \class{Alpha\_Shape}
+Returns a list of tuples representing the boundary of the alpha
+shape. Each tuple represents a segment in the boundary by providing
+the indices of its two endpoints.
+\end{methoddesc}
+  Module: \code{alpha\_shape},  Class: \class{Alpha\_Shape}
+  Returns a list of tuples representing the boundary of the alpha
+  shape. Each tuple represents a segment in the boundary by providing
+  the indices of its two endpoints.
+\end{methoddesc}
 \begin{methoddesc}{write\_boundary}{file_name}
+Module: \code{alpha\_shape},  Class: \class{Alpha\_Shape}
+Writes the list of 2-tuples returned by \code{get\_boundary} to the
+file \code{file\_name}, using one line per tuple.
+\end{methoddesc}
+  Module: \code{alpha\_shape},  Class: \class{Alpha\_Shape}
+  Writes the list of 2-tuples returned by \code{get\_boundary} to the
+  file \code{file\_name}, using one line per tuple.
+\end{methoddesc}
+\pagebreak
 \section{Numerical Tools}
 …
 may be found in the module \module{utilities.numerical\_tools}:
+\begin{tabular}{|p{8cm} p{8cm}|}  \hline
+\code{angle(v1, v2=None)} & Angle between two-dimensional vectors
+\code{v1} and \code{v2}, or between \code{v1} and the $x$-axis if
+\code{v2} is \code{None}. Value is in range $0$ to $2\pi$. \\
+\code{normal\_vector(v)} & Normal vector to \code{v}.\\
+\code{mean(x)} & Mean value of a vector \code{x}.\\
+\code{cov(x, y=None)} & Covariance of vectors \code{x} and \code{y}.
+If \code{y} is \code{None}, returns \code{cov(x, x)}.\\
+\code{err(x, y=0, n=2, relative=True)} & Relative error of
+$\parallel$\code{x}$-$\code{y}$\parallel$ to
+$\parallel$\code{y}$\parallel$ (2-norm if \code{n} = 2 or Max norm
+if \code{n} = \code{None}). If denominator evaluates to zero or if
+\code{y}
+is omitted or if \code{relative = False}, absolute error is returned.\\
+\code{norm(x)} & 2-norm of \code{x}.\\
+\code{corr(x, y=None)} & Correlation of \code{x} and \code{y}. If
+\code{y} is \code{None} returns autocorrelation of \code{x}.\\
+\code{ensure\_numeric(A, typecode = None)} & Returns a Numeric array
+for any sequence \code{A}. If \code{A} is already a Numeric array it
+will be returned unaltered. Otherwise, an attempt is made to convert
+it to a Numeric array. (Needed because \code{array(A)} can
+cause memory overflow.)\\
+\code{histogram(a, bins, relative=False)} & Standard histogram. If
+\code{relative} is \code{True}, values will be normalised against
+the total and thus represent frequencies rather than counts.\\
+\code{create\_bins(data, number\_of\_bins = None)} & Safely create
+bins for use with histogram. If \code{data} contains only one point
+or is constant, one bin will be created. If \code{number\_of\_bins}
+is omitted, 10 bins will be created.\\  \hline
+\begin{tabular}{|p{7.4cm} p{8.6cm}|}
+  \hline
+  \code{angle(v1, v2=None)} & Angle between two-dimensional vectors
+                              \code{v1} and \code{v2}, or between \code{v1} and the $x$-axis if
+                              \code{v2} is \code{None}. Value is in range $0$ to $2\pi$. \\
+  & \\
+  \code{normal\_vector(v)} & Normal vector to \code{v}.\\
+  & \\
+  \code{mean(x)} & Mean value of a vector \code{x}.\\
+  & \\
+  \code{cov(x, y=None)} & Covariance of vectors \code{x} and \code{y}.
+                          If \code{y} is \code{None}, returns \code{cov(x, x)}.\\
+  & \\
+  \code{err(x, y=0, n=2, relative=True)} & Relative error of $\parallel$\code{x}$-$\code{y}$\parallel$
+                                           to $\parallel$\code{y}$\parallel$ (2-norm if \code{n} = 2 or
+                                           Max norm if \code{n} = \code{None}). If denominator evaluates
+                                           to zero or if \code{y} is omitted or if \code{relative=False},
+                                           absolute error is returned.\\
+  & \\
+  \code{norm(x)} & 2-norm of \code{x}.\\
+  & \\
+  \code{corr(x, y=None)} & Correlation of \code{x} and \code{y}. If
+                           \code{y} is \code{None} returns autocorrelation of \code{x}.\\
+  & \\
+  \code{ensure\_numeric(A, typecode=None)} & Returns a numeric array for any sequence \code{A}. If
+                                             \code{A} is already a numeric array it will be returned
+                                             unaltered. Otherwise, an attempt is made to convert
+                                             it to a numeric array. (Needed because \code{array(A)} can
+                                             cause memory overflow.)\\
+  & \\
+  \code{histogram(a, bins, relative=False)} & Standard histogram. If \code{relative} is \code{True},
+                                              values will be normalised against the total and thus
+                                              represent frequencies rather than counts.\\
+  & \\
+  \code{create\_bins(data, number\_of\_bins=None)} & Safely create bins for use with histogram.
+                                                     If \code{data} contains only one point
+                                                     or is constant, one bin will be created.
+                                                     If \code{number\_of\_bins} is omitted,
+bins will be created.\\
+  \hline
+\end{tabular}
 \section{Finding the Optimal Alpha Value}
 …
 more to come very soon
+\end{tabular}
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 \chapter{Modules available in \anuga}
 …
 \label{mod:generalmesh}
 \section{\module{abstract\_2d\_finite\_volumes.neighbour\_mesh} }
 \declaremodule[neighbourmesh]{}{neighbour\_mesh}
 \label{mod:neighbourmesh}
 \section{\module{abstract\_2d\_finite\_volumes.domain}}
 …
    Otherwise check that it is compatible with dimenions of domain.
    Otherwise raise an exception
 \end{verbatim}
 \section{\module{shallow\_water}}
 D triangular domains for finite-volume
 computations of the shallow water wave equation.
 This module contains a specialisation of class Domain from module domain.py consisting of methods specific to the Shallow Water
 Wave Equation
 \declaremodule[shallowwater]{}{shallow\_water}
 \label{mod:shallowwater}
 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 \chapter{ANUGA Full-scale Validations}
 \section{Overview}
+There are some long-running validations that are not included in the small-scale validations that run when you execute the \module{validate_all.py}
+script in the \module{anuga_validation/automated_validation_test} directory.  These validations are not run automatically
+since they can take a large amount of time and require an internet connection and user input.
+There are some long-running validations that are not included in the small-scale
+validations that run when you execute the \module{validate_all.py}
+script in the \module{anuga_validation/automated_validation_test} directory.
+These validations are not run automatically since they can take a large amount
+of time and require an internet connection and user input.
 \section{Patong Beach}
 The Patong Beach validation is run from the \module{automated_validation_tests/patong_beach_validation}
+directory.  Just execute the \module{validate_patong.py} script in that directory.  This will run a Patong Beach
+simulation and compare the generated SWW file with a known good copy of that file.
+The script attempts to refresh the validation data files from master copies held on the Sourceforge
+project site.  If you don't have an internet connection you may still run the validation, as long as you have
+the required files.
+You may download the validation data files by hand and then run the validation.  Just go to the ANUGA Sourceforge
+project download page at \module{http://sourceforge.net/project/showfiles.php?group_id=172848} and select the
+\module{validation_data} package, \module{patong-1.0} release.  You need the \module{data.tgz} file and one or more
+of the \module{patong.sww.\{BASIC|TRIAL|FINAL\}.tgz} files.
+The BASIC validation is the quickest and the FINAL validation is the slowest.  The \module{validate.py} script
+will use whatever files you have, BASIC first and FINAL last.
+directory.  Just execute the \module{validate_patong.py} script in that directory.
+This will run a Patong Beach simulation and compare the generated SWW file with a
+known good copy of that file.
+The script attempts to refresh the validation data files from master copies held
+on the Sourceforge project site.  If you don't have an internet connection you
+may still run the validation, as long as you have the required files.
+You may download the validation data files by hand and then run the validation.
+Just go to the ANUGA Sourceforge project download page at
+\module{http://sourceforge.net/project/showfiles.php?group_id=172848} and select
+the \module{validation_data} package, \module{patong-1.0} release.  You need the
+\module{data.tgz} file and one or more of the \module{patong.sww.\{BASIC|TRIAL|FINAL\}.tgz}
+files.
+The BASIC validation is the quickest and the FINAL validation is the slowest.
+The \module{validate.py} script will use whatever files you have, BASIC first and
+FINAL last.
 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 …
 \chapter{Frequently Asked Questions}
+The Frequently Asked Questions have been move to the online FAQ at:
+The Frequently Asked Questions have been move to the online FAQ at: \\
 \url{https://datamining.anu.edu.au/anuga/wiki/FrequentlyAskedQuestions}
 …
 \begin{tabular}{|lp{10cm}|c|}  \hline
+%\begin{tabular}{|llll|}  \hline
+    \emph{Term} & \emph{Definition} & \emph{Page}\\  \hline
+    \indexedbold{\anuga} & Name of software (joint development between ANU and
+    GA) & \pageref{def:anuga}\\
+    \indexedbold{bathymetry} & offshore elevation &\\
+    \indexedbold{conserved quantity} & conserved (stage, x and y
+    momentum) & \\
+%    \indexedbold{domain} & The domain of a function is the set of all input values to the
+%    function.&\\
+    \indexedbold{Digital Elevation Model (DEM)} & DEMs are digital files consisting of points of elevations,
+sampled systematically at equally spaced intervals.& \\
+    \indexedbold{Dirichlet boundary} & A boundary condition imposed on a differential equation
+ that specifies the values the solution is to take on the boundary of the
+ domain. & \pageref{def:dirichlet boundary}\\
+    \indexedbold{edge} & A triangular cell within the computational mesh can be depicted
+    as a set of vertices joined by lines (the edges). & \\
+    \indexedbold{elevation} & refers to bathymetry and topography &\\
+    \indexedbold{evolution} & integration of the shallow water wave equations
+    over time &\\
+    \indexedbold{finite volume method} & The method evaluates the terms in the shallow water
+    wave equation as fluxes at the surfaces of each finite volume. Because the
+    flux entering a given volume is identical to that leaving the adjacent volume,
+    these methods are conservative. Another advantage of the finite volume method is
+    that it is easily formulated to allow for unstructured meshes. The method is used
+    in many computational fluid dynamics packages. & \\
+    \indexedbold{forcing term} & &\\
+    \indexedbold{flux} & the amount of flow through the volume per unit
+    time & \\
+    \indexedbold{grid} & Evenly spaced mesh & \\
+    \indexedbold{latitude} & The angular distance on a mericlear north and south of the
+    equator, expressed in degrees and minutes. & \\
+    \indexedbold{longitude} & The angular distance east or west, between the meridian
+    of a particular place on Earth and that of the Prime Meridian (located in Greenwich,
+    England) expressed in degrees or time.& \\
+    \indexedbold{Manning friction coefficient} & &\\
+    \indexedbold{mesh} & Triangulation of domain &\\
+    \indexedbold{mesh file} & A TSH or MSH file & \pageref{def:mesh file}\\
+    \indexedbold{NetCDF} & &\\
+    \indexedbold{node} & A point at which edges meet & \\
+    \indexedbold{northing} & A rectangular (x,y) coordinate measurement of distance
+    north from a north-south reference line, usually a meridian used as the axis of
+    origin within a map zone or projection. Northing is a UTM (Universal Transverse
+    Mercator) coordinate. & \\
+    \indexedbold{points file} & A PTS or CSV file & \\  \hline
+    \end{tabular}
+    \begin{tabular}{|lp{10cm}|c|}  \hline
+    \indexedbold{polygon} & A sequence of points in the plane. \anuga represents a polygon
+    either as a list consisting of Python tuples or lists of length 2 or as an $N \times 2$
+    Numeric array, where $N$ is the number of points.
+    The unit square, for example, would be represented either as
+    \code{[ [0,0], [1,0], [1,1], [0,1] ]} or as \code{array( [0,0], [1,0], [1,1],
+    [0,1] )}.
+    NOTE: For details refer to the module \module{utilities/polygon.py}. &
+    \\     \indexedbold{resolution} &  The maximal area of a triangular cell in a
+    mesh & \\
+    \indexedbold{reflective boundary} & Models a solid wall. Returns same conserved
+    quantities as those present in the neighbouring volume but reflected. Specific to the
+    shallow water equation as it works with the momentum quantities assumed to be the
+    second and third conserved quantities. & \pageref{def:reflective boundary}\\
+    \indexedbold{stage} & &\\
+%    \indexedbold{try this}
+    \indexedbold{animate} & visualisation tool used with \anuga &
+    \pageref{sec:animate}\\
+    \indexedbold{time boundary} & Returns values for the conserved
+quantities as a function of time. The user must specify
+the domain to get access to the model time. & \pageref{def:time boundary}\\
+    \indexedbold{topography} & onshore elevation &\\
+    \indexedbold{transmissive boundary} & & \pageref{def:transmissive boundary}\\
+    \indexedbold{vertex} & A point at which edges meet. & \\
+    \indexedbold{xmomentum} & conserved quantity (note, two-dimensional SWW equations say
+    only \code{x} and \code{y} and NOT \code{z}) &\\
+    \indexedbold{ymomentum}  & conserved quantity & \\  \hline
+    \end{tabular}
+  \emph{Term} & \emph{Definition} & \emph{Page}\\
+  \hline
+  \indexedbold{\anuga} & Name of software (joint development between ANU and GA) & \pageref{def:anuga}\\
+  \indexedbold{bathymetry} & offshore elevation & \\
+  \indexedbold{conserved quantity} & conserved (stage, x and y momentum) & \\
+%  \indexedbold{domain} & The domain of a function is the set of all input values to the function.& \\
+  \indexedbold{Digital Elevation Model (DEM)} & DEMs are digital files consisting of points of elevations,
+                                                sampled systematically at equally spaced intervals.& \\
+  \indexedbold{Dirichlet boundary} & A boundary condition imposed on a differential equation that specifies
+                                     the values the solution is to take on the boundary of the domain.
+                                   & \pageref{def:dirichlet boundary}\\
+  \indexedbold{edge} & A triangular cell within the computational mesh can be depicted
+                       as a set of vertices joined by lines (the edges). & \\
+  \indexedbold{elevation} & refers to bathymetry and topography & \\
+  \indexedbold{evolution} & integration of the shallow water wave equations over time & \\
+  \indexedbold{finite volume method} & The method evaluates the terms in the shallow water wave equation as
+                                       fluxes at the surfaces of each finite volume. Because the flux entering
+                                       a given volume is identical to that leaving the adjacent volume, these
+                                       methods are conservative. Another advantage of the finite volume method is
+                                       that it is easily formulated to allow for unstructured meshes. The method
+                                       is used in many computational fluid dynamics packages. & \\
+  \indexedbold{forcing term} & &\\
+  \indexedbold{flux} & the amount of flow through the volume per unit time & \\
+  \indexedbold{grid} & Evenly spaced mesh & \\
+  \indexedbold{latitude} & The angular distance on a mericlear north and south of the equator, expressed in degrees and minutes. & \\
+  \indexedbold{longitude} & The angular distance east or west, between the meridian of a particular place on Earth
+                            and that of the Prime Meridian (located in Greenwich, England) expressed in degrees or time.& \\
+  \indexedbold{Manning friction coefficient} & &\\
+  \indexedbold{mesh} & Triangulation of domain &\\
+  \indexedbold{mesh file} & A TSH or MSH file & \pageref{def:mesh file}\\
+  \indexedbold{NetCDF} & &\\
+  \indexedbold{node} & A point at which edges meet & \\
+  \indexedbold{northing} & A rectangular (x,y) coordinate measurement of distance north from a north-south
+                           reference line, usually a meridian used as the axis of origin within a map zone
+                           or projection. Northing is a UTM (Universal Transverse Mercator) coordinate. & \\
+  \indexedbold{points file} & A PTS or CSV file & \\
+  \hline
+\end{tabular}
+\begin{tabular}{|lp{10cm}|c|}
+  \hline
+  \indexedbold{polygon} & A sequence of points in the plane. \anuga represents a polygon either as a list
+                          consisting of Python tuples or lists of length 2 or as an $N \times 2$ numeric array,
+                          where $N$ is the number of points.
+                          The unit square, for example, would be represented either as \code{[ [0,0], [1,0], [1,1], [0,1] ]}
+                          or as \code{array( [0,0], [1,0], [1,1], [0,1] )}.
+                          NOTE: For details refer to the module \module{utilities/polygon.py}. & \\
+  \indexedbold{resolution} &  The maximal area of a triangular cell in a mesh & \\
+  \indexedbold{reflective boundary} & Models a solid wall. Returns same conserved quantities as those present in the
+                                      neighbouring volume but reflected. Specific to the shallow water equation as
+                                      it works with the momentum quantities assumed to be the second and third
+                                      conserved quantities. & \pageref{def:reflective boundary}\\
+  \indexedbold{stage} & &\\
+%  \indexedbold{try this}
+  \indexedbold{animate} & visualisation tool used with \anuga & \pageref{sec:animate}\\
+  \indexedbold{time boundary} & Returns values for the conserved quantities as a function of time.
+                                The user must specify the domain to get access to the model time.
+                              & \pageref{def:time boundary}\\
+  \indexedbold{topography} & onshore elevation &\\
+  \indexedbold{transmissive boundary} & & \pageref{def:transmissive boundary}\\
+  \indexedbold{vertex} & A point at which edges meet. & \\
+  \indexedbold{xmomentum} & conserved quantity (note, two-dimensional SWW equations say only
+                            \code{x} and \code{y} and NOT \code{z}) &\\
+  \indexedbold{ymomentum}  & conserved quantity & \\
+  \hline
+\end{tabular}
 %The \code{\e appendix} markup need not be repeated for additional
 %appendices.
+%
 …
 \begin{thebibliography}{99}
+%\begin{thebibliography}
 \bibitem[nielsen2005]{nielsen2005}
 {\it Hydrodynamic modelling of coastal inundation}.
 …
 \newblock A.~Kurganov, S.~Noelle, and G.~Petrova.
 \newblock {\em SIAM Journal of Scientific Computing}, 23(3):707--740, 2001.
+\end{thebibliography}{99}
+\end{thebibliography}
+% \end{thebibliography}{99}
 \end{document}

anuga_core/documentation/user_manual/copyright.tex

-                      r5566
+                      r7064
 Copyright \copyright 2004, 2005, 2006 Australian National University and Geoscience Australia. All rights reserved.
 Permission to use, copy, modify, and distribute this software for any
 purpose without fee is hereby granted under the terms of the GNU
 …
 Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307
 This work was produced at Geoscience Australia and the Australian
 National University funded by the Commonwealth of Australia. Neither
 …
 endorsement purposes.
 This document does not convey a warranty, express or implied,
 of merchantability or fitness for a particular purpose.
 \begin{center}
   %\vspace{0.5in}
    \anuga
    Manual typeset with \LaTeX
 \end{center}
   \vspace{0.5in}
+\vspace{0.5in}
 \textbf{Credits}:
 …
 \end{itemize}
 \textbf{License}:
 \begin{itemize}
 …
 \end{itemize}
+\pagebreak
 \textbf{Acknowledgments}:
 \begin{itemize}
+\item John Jakeman, Rudy van Drie, Ted Rigby, Joaquim Luis, Nils Goseberg, William Power, Petar Milevski, Trevor Dhu, Linda Stals, Matt Hardy, Jack Kelly and Christopher Zoppou who contributed to this project at various times.
+\item John Jakeman, Rudy van Drie, Ted Rigby, Joaquim Luis, Nils Goseberg, William Power,
+      Petar Milevski, Trevor Dhu, Linda Stals, Matt Hardy, Jack Kelly and Christopher
+      Zoppou who contributed to this project at various times.
 \item A stand alone visualiser (anuga\_viewer) based on Open-scene-graph was developed by Darran Edmundson.
+\item The mesh generator engine was written by Jonathan Richard Shewchuk and made freely available under the following license.
+See source code \code{triangle.c} for more details on the origins of this code. The license reads
+\item The mesh generator engine was written by Jonathan Richard Shewchuk and made freely
+      available under the following license.  See source code \code{triangle.c} for more
+      details on the origins of this code. The license reads
 {\tiny \begin{verbatim}
+\begin{verbatim}
 /*****************************************************************************/
 /*                                                                           */
 …
 /*    free, then you are not required to make any arrangement with me.)      */
 /*****************************************************************************/
 \end{verbatim}}
+\end{verbatim}
+\pagebreak
 \item Pmw is a toolkit for building high-level compound widgets in
 Python using the Tkinter module. Parts of Pmw have been encorpoated
 into the graphical mesh generator. The license for Pmw reads
 {\tiny \begin{verbatim}
+\begin{verbatim}
 """
 Pmw copyright
 …
 """
 \end{verbatim}}
+\end{verbatim}
 \end{itemize}

anuga_core/documentation/user_manual/demos/cairns/ExportResults.py

-                      r5408
+                      r7064
 import project, os
+import os
 import sys
+import project
 from anuga.shallow_water.data_manager import sww2dem
 …
 scenario = 'slide'
-#scenario = 'fixed_wave'
 name = scenario + sep + scenario + 'source'
 …
 print 'output dir:', name
 which_var = 4
+if which_var == 0:  # Stage
+if which_var == 0:    # Stage
     outname = name + '_stage'
     quantityname = 'stage'
 if which_var == 1:  # Absolute Momentum
+if which_var == 1:    # Absolute Momentum
     outname = name + '_momentum'
     quantityname = '(xmomentum**2 + ymomentum**2)**0.5'  #Absolute momentum
+    quantityname = '(xmomentum**2 + ymomentum**2)**0.5'    #Absolute momentum
 if which_var == 2:  # Depth
+if which_var == 2:    # Depth
     outname = name + '_depth'
     quantityname = 'stage-elevation'  #Depth
 if which_var == 3:  # Speed
+if which_var == 3:    # Speed
     outname = name + '_speed'
     quantityname = '(xmomentum**2 + ymomentum**2)**0.5/(stage-elevation+1.e-30)'  #Speed
 if which_var == 4:  # Elevation
+if which_var == 4:    # Elevation
     outname = name + '_elevation'
     quantityname = 'elevation'  #Elevation
 …
 print 'start sww2dem'
 sww2dem(name, basename_out = outname,
             quantity = quantityname,
             cellsize = 100,
             easting_min = project.eastingmin,
             easting_max = project.eastingmax,
             northing_min = project.northingmin,
             northing_max = project.northingmax,
             reduction = max,
             verbose = True,
             format = 'ers')
+sww2dem(name,
+        basename_out=outname,
+        quantity=quantityname,
+        cellsize=100,
+        easting_min=project.eastingmin,
+        easting_max=project.eastingmax,
+        northing_min=project.northingmin,
+        northing_max=project.northingmax,
+        reduction=max,
+        verbose=True,
+        format='ers')

anuga_core/documentation/user_manual/demos/cairns/GetTimeseries.py

-                      r4966
+                      r7064
 Note, this script will only work if pylab is installed on the platform
 """
 …
 sww2csv_gauges('slide'+sep+'slidesource.sww',
                 project.gauge_filename,
                 quantities = ['stage','speed','depth','elevation'],
+                quantities=['stage','speed','depth','elevation'],
                 verbose=True)
 sww2csv_gauges('fixed_wave'+sep+'fixed_wavesource.sww',
                project.gauge_filename,
                quantities = ['stage', 'speed','depth','elevation'],
+               quantities=['stage', 'speed','depth','elevation'],
                verbose=True)
 try:
     import pylab
     csv2timeseries_graphs(directories_dic={'slide'+sep:['Slide',0, 0],
                                            'fixed_wave'+sep:['Fixed Wave',0,0]},
                             output_dir='fixed_wave'+sep,
                             base_name='gauge_',
                             plot_numbers='',
                             quantities=['stage','speed','depth'],
                             extra_plot_name='',
                             assess_all_csv_files=True,
                             create_latex=False,
                             verbose=True)
+    csv2timeseries_graphs(directories_dic={'slide'+sep: ['Slide',0, 0],
+                                           'fixed_wave'+sep: ['Fixed Wave',0,0]},
+                          output_dir='fixed_wave'+sep,
+                          base_name='gauge_',
+                          plot_numbers='',
+                          quantities=['stage','speed','depth'],
+                          extra_plot_name='',
+                          assess_all_csv_files=True,
+                          create_latex=False,
+                          verbose=True)
 except ImportError:
     #ANUGA does not rely on pylab to work
     print 'must have pylab installed to generate plots'

anuga_core/documentation/user_manual/demos/cairns/project.py

-                      r6889
+                      r7064
+"""Common filenames and locations for topographic data, meshes and outputs.
+"""
+"""Common filenames and locations for topographic data, meshes and outputs."""
 from anuga.utilities.polygon import read_polygon, plot_polygons, \
                                     polygon_area, is_inside_polygon
 #------------------------------------------------------------------------------
 # Define scenario as either slide or fixed_wave.
 #------------------------------------------------------------------------------
-#scenario = 'slide'
 scenario = 'fixed_wave'
+#scenario = 'slide'
 #------------------------------------------------------------------------------
 # Filenames
 #------------------------------------------------------------------------------
 demname = 'cairns'
+demname = 'cairns'
 meshname = demname + '.msh'
 # Filename for locations where timeseries are to be produced
 gauge_filename = 'gauges.csv'
 #------------------------------------------------------------------------------
 # Domain definitions
 #------------------------------------------------------------------------------
 # bounding polygon for study area
 bounding_polygon = read_polygon('extent.csv')
 A = polygon_area(bounding_polygon)/1000000.0
+A = polygon_area(bounding_polygon) / 1000000.0
 print 'Area of bounding polygon = %.2f km^2' % A
 #------------------------------------------------------------------------------
 # Interior region definitions
 #------------------------------------------------------------------------------
 # Read interior polygons
 poly_cairns = read_polygon('cairns.csv')
 …
 # Optionally plot points making up these polygons
+#plot_polygons([bounding_polygon,poly_cairns,poly_island0,poly_island1,\
+#               poly_island2,poly_island3,poly_shallow],\
+#               style='boundingpoly',verbose=False)
+#plot_polygons([bounding_polygon, poly_cairns, poly_island0, poly_island1,
+#               poly_island2, poly_island3, poly_shallow],
+#               style='boundingpoly', verbose=False)
 # Define resolutions (max area per triangle) for each polygon
 default_res = 10000000 # Background resolution
+default_res = 10000000    # Background resolution
 islands_res = 100000
 cairns_res = 100000
 …
 # Define list of interior regions with associated resolutions
 interior_regions = [[poly_cairns, cairns_res],
+interior_regions = [[poly_cairns,  cairns_res],
                     [poly_island0, islands_res],
                     [poly_island1, islands_res],
 …
                     [poly_island3, islands_res],
                     [poly_shallow, shallow_res]]
 #------------------------------------------------------------------------------
 …
 # Data for landslide
 #------------------------------------------------------------------------------
 slide_origin = [451871, 8128376] # Assume to be on continental shelf
+slide_origin = [451871, 8128376]   # Assume to be on continental shelf
 slide_depth = 500.

anuga_core/documentation/user_manual/demos/cairns/runcairns.py

-                      r6889
+                      r7064
 # Import necessary modules
 #------------------------------------------------------------------------------
 # Standard modules
 import os
 …
 import project                 # Definition of file names and polygons
 #------------------------------------------------------------------------------
 # Preparation of topographic data
 # Convert ASC 2 DEM 2 PTS using source data and store result in source data
 #------------------------------------------------------------------------------
 # Create DEM from asc data
 convert_dem_from_ascii2netcdf(project.demname, use_cache=True, verbose=True)
 …
 dem2pts(project.demname, use_cache=True, verbose=True)
 #------------------------------------------------------------------------------
 # Create the triangular mesh and domain based on
 …
 # boundary and interior regions as defined in project.py
 #------------------------------------------------------------------------------
 domain = create_domain_from_regions(project.bounding_polygon,
                                     boundary_tags={'top': [0],
 …
                                     verbose=True)
 # Print some stats about mesh and domain
 print 'Number of triangles = ', len(domain)
 …
 # Setup parameters of computational domain
 #------------------------------------------------------------------------------
 domain.set_name('cairns_' + project.scenario) # Name of sww file
 domain.set_datadir('.')                       # Store sww output here
 domain.set_minimum_storable_height(0.01)      # Store only depth > 1cm
 #------------------------------------------------------------------------------
 # Setup initial conditions
 #------------------------------------------------------------------------------
 tide = 0.0
 domain.set_quantity('stage', tide)
 …
                     alpha=0.1)
 #------------------------------------------------------------------------------
 # Setup information for slide scenario (to be applied 1 min into simulation
 #------------------------------------------------------------------------------
 if project.scenario == 'slide':
     # Function for submarine slide
 …
                                    verbose=True)
 #------------------------------------------------------------------------------
 # Setup boundary conditions
 #------------------------------------------------------------------------------
 print 'Available boundary tags', domain.get_boundary_tags()
 Bd = Dirichlet_boundary([tide,0,0]) # Mean water level
 Bs = Transmissive_stage_zero_momentum_boundary(domain) # Neutral boundary
 if project.scenario == 'fixed_wave':
 …
     Bw = Time_boundary(domain=domain,
                        function=lambda t: [(60<t<3660)*50, 0, 0])
     domain.set_boundary({'ocean_east': Bw,
                          'bottom': Bs,
 …
                          'onshore': Bd,
                          'top': Bd})
 #------------------------------------------------------------------------------
 # Evolve system through time
 #------------------------------------------------------------------------------
 import time
 t0 = time.time()
 …
 if project.scenario == 'slide':
     for t in domain.evolve(yieldstep=10, finaltime=60):
         print domain.timestepping_statistics()
 …
         print domain.boundary_statistics(tags='ocean_east')
 if project.scenario == 'fixed_wave':
     # Save every two mins leading up to wave approaching land
     for t in domain.evolve(yieldstep=120, finaltime=5000):

anuga_core/documentation/user_manual/demos/channel1.py

-                      r5173
+                      r7064
 from anuga.shallow_water import Dirichlet_boundary
 #------------------------------------------------------------------------------
 # Setup computational domain
 …
 domain = Domain(points, vertices, boundary)  # Create domain
 domain.set_name('channel1')                  # Output name
 #------------------------------------------------------------------------------
 …
                     expression='elevation + 0.0')
 #------------------------------------------------------------------------------
 # Setup boundary conditions
 …
 domain.set_boundary({'left': Bi, 'right': Br, 'top': Br, 'bottom': Br})
 #------------------------------------------------------------------------------
 # Evolve system through time
 #------------------------------------------------------------------------------
 for t in domain.evolve(yieldstep = 0.2, finaltime = 40.0):
+for t in domain.evolve(yieldstep=0.2, finaltime=40.0):
     print domain.timestepping_statistics()

anuga_core/documentation/user_manual/demos/channel2.py

-                      r6889
+                      r7064
 from anuga.shallow_water import Time_boundary
 #------------------------------------------------------------------------------
 # Setup computational domain
 …
 domain.set_name('channel2')                 # Output name
 #------------------------------------------------------------------------------
 # Setup initial conditions