source: documentation/AnuGA_user_manual.tex @ 2277

%\newcommand{\code}[1]{{\small \tt #1}} %For use with one-line code snippets
        
\documentclass{report}


\title{AnuGA User Manual}
%\author{Howard Silcock}

% Can we get rid of indenting and put a blank line before each para?
% Find out how to change date format
% Relabel sections, subsections

\setlength{\parindent}{0mm} %\setlength{\parskip}{3pt}
\setlength{\oddsidemargin}{0.6in}\setlength{\evensidemargin}{0.6in}
\addtolength{\textheight}{1in} \addtolength{\textwidth}{0.5in}
\setlength{\marginparwidth}{0in}
\setlength{\topmargin}{0mm}\setlength{\headheight}{0in}

\begin{document}
\maketitle

\section*{Introduction}

\textbf{AnuGA} is a hydrodynamic inundation modelling tool that
allows users to model the effects of natural hazards such as
riverine flooding, storm surges and tsunami. It incorporates a
mesh generator, called \texttt{pmesh}, that allows the user to set
up
the geometry of the problem interactively.\\

\subsection*{Purpose}

The purpose of this user manual is to introduce the new user to
the software, describe what it can do and give step-by-step
instructions for setting up, configuring and running the software.

\subsection*{Scope}

This manual covers only what is needed to operate the software
after installation. It does not includes instructions for
installing the software or detailed API documentation, both of
which will be covered in separate publications.

\subsection*{Audience}

Readers aare assumed to be familiar with the operating environment
and have a general understanding of the problem background, as
well as enough programming experience to adapt the code to
different requirements, as described in this manual,  and to
understand the basic terminology of object-oriented programming.

\subsection*{Structure of This Manual}

This manual is structured as follows:

\begin{itemize}

    \item{A \emph{Getting Started} section}

    \item{Detailed descriptions of the various components}

\end{itemize}


\pagebreak\section*{Getting Started}

This section is designed to assist the reader to get started with
\textbf{AnuGA} by working through a simple example. What follows
is a discussion of the structure and operation of the file
\texttt{bedslope.py}, with just enough detail to allow the reader
to appreciate what's involved in setting up a scenario like the
one it depicts.

\subsection*{Overview}

This example carries out the solution of the shallow-water wave
equation in the simple case of a configuration comprising a flat
bed, sloping at a fixed angle in one direction and having a
constant depth across each line in the perpendicular direction.\\
\\
The example demonstrates many of the basic ideas involved in
setting up a more complex scenario. In the general case the user
specifies the geometry (bathymetry and topography), the initial
water level, boundary conditions such as tide, and any forcing
terms that may drive the system such as wind stress or atmospheric
pressure gradients. Frictional resistance from the different
terrains in the model is represented by predefined forcing
terms.\\
\\
The present example, as it represents a simple scenario, does not
include any forcing term, nor is the data taken from a file as it
would be in many typical cases. The quantities involved in the
present problem are:
\begin{itemize}
   \item elevation
   \item friction
   \item depth
   \item stage
\end{itemize}

%\emph{[More details of the problem background]}

\subsection*{Outline of the Program}

In outline, \texttt{bedslope.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, whether the
output is to be `smoothed'.

   \item Inputs various quantities describing physical measurements, such
as the elevation, to be specified at each mesh point.

   \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.

\end{enumerate}

\subsection*{The Code}

For reference we include below the complete code listing for
\texttt{bedslope.py}. Subsequent paragraphs provide a `commentary'
that describes each step of the program and explains it significance.\\
\\
\emph{[Can't work out how to prevent \LaTeX (or WinEdt) from
wrapping lines, even in \emph{verbatim} mode, without putting}
\verb+\\+\emph{s at the ends of lines!]}

{\scriptsize \begin{verbatim}
from pyvolution.mesh_factory import rectangular
from pyvolution.shallow_water import Domain, Reflective_boundary,
     Dirichlet_boundary, Time_boundary, Transmissive_boundary

#Create basic mesh
points, vertices, boundary = rectangular(10,10)

#Create shallow water domain
domain = Domain(points, vertices,boundary)
domain.smooth = False domain.visualise = False
domain.store = True domain.filename = 'bedslope'
domain.default_order = 2

#######################
# Initial conditions
def f(x,y):
    return -x/2

domain.set_quantity('elevation', f)
domain.set_quantity('friction', 0.1)

h = 0.05  # Constant depth
domain.set_quantity('stage', expression = 'elevation + %f' %h)


# Boundary conditions
from math import sin, pi
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.0, 0.0])


domain.set_boundary({'left': Bd, 'right': Br, 'top': Br, 'bottom': Br})


######################
#Evolution

domain.check_integrity()

for t in domain.evolve(yieldstep = 0.1, finaltime = 4.0):
    domain.write_time()


\end{verbatim}}


\subsection*{Establishing the Mesh}

The first task is to set up the triangular mesh to be used for the
scenario. This is carried out through the statement:

{\small \begin{verbatim}
    points, vertices, boundary = rectangular(10, 10) .
\end{verbatim}}

The function \texttt{rectangular} is imported from a module
\texttt{mesh\_factory} defined elsewhere. (\textbf{AnuGA} also
contains several other schemes that can be used for setting up
meshes, but we shall not discuss these now.) The above assignment
sets up a $10 \times 10$ rectangular mesh, triangulated in a
specific way. In general, the assignment

{\small \begin{verbatim}
    points, vertices, boundary = rectangular(m, n)
\end{verbatim}}

returns:

\begin{itemize}

   \item a list \texttt{points} of length $N$, where $N = (m + 1)(n + 1)$,
comprising the coordinates $(x, y)$ of each of the $N$ mesh
points,

   \item a list \texttt{vertices} of length $2mn$ (each entry specifies the three
vertices of one of the triangles used in the triangulation) , and

   \item a dictionary \texttt{boundary}, used to tag the triangle edges on
the boundaries. Each key corresponds to a triangle edge on one of
the four boundaries and its value is one of \texttt{`left'},
\texttt{`right'}, \texttt{`top'} and \texttt{`bottom'}, indicating
which boundary the edge in question belongs to.

\end{itemize}


\subsection*{Initialising the domain}

These variables are then used to set up a data structure
\texttt{domain}, through the assignment:

{\small \begin{verbatim}
    domain = Domain(points, vertices, boundary)
\end{verbatim}}

This uses a Python class \texttt{Domain}, imported from
\texttt{shallow\_water}, which is an extension of a more generic
class of the same name in the module \texttt{domain}, and inherits
some methods from the generic class but has others specific to the
shallow-water scenarios in which it is used. The following lines
set certain key options governing the domain: \emph{[more details
of what these do]}

{\scriptsize \begin{verbatim}
    domain.smooth = False
    domain.visualise = False
    domain.store = True
    domain.filename = 'bedslope'
    domain.default_order = 2
\end{verbatim}}


\subsection*{Specifying the Quantities}

The next task is to specify a number of quantities that we wish to
set for each mesh point. The class \texttt{Domain} has a method
\texttt{set\_quantity}, used to specify these quantities. It is a
particularly flexible method that allows the user to set
quantities in a variety of ways---using constants, functions,
numeric arrays or expressions involving other quantities, all of
which can be passed as arguments. The code in the present example
demonstrates a number of forms in which we can invoke
\texttt{set\_quantity}.


\subsubsection*{Elevation}

The elevation 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}
    \# Initial conditions
    def f(x,y):
        return -x/2
\end{verbatim}}

This simply associates an elevation with each point $(x, y)$ of
the plane.  It specifies that the bed slopes linearly in the $x$
direction, with slope $-\frac{1}{2}$,  and is constant in the $y$
direction.\\ %[screen shot?]
\\
Once the function $f$ is specified, the quantity
\texttt{elevation} is assigned through the simple statement:

{\small \begin{verbatim}
\begin{verbatim}
    domain.set_quantity('elevation', f)
\end{verbatim}}


\subsubsection*{Friction}

The assignment of the friction quantity demonstrates another way
we can use \texttt{set\_quantity} to set quantities---namely,
assign them to a constant numerical value:

{\small \begin{verbatim}
    domain.set_quantity('friction', 0.1)
\end{verbatim}}

This just specifies that the Manning friction coefficient is set
to 0.1 at every mesh point.

\subsubsection*{Depth}

Assigning depth illustrates a more complex way to use
\texttt{set\_quantity}, introducing an expression involving other
quantities:

{\small \begin{verbatim}
    h = 0.05 \# Constant depth
    domain.set_quantity('stage', expression = 'elevation + %f' %h)
\end{verbatim}}

Here the quantity \texttt{stage} is defined by taking the quantity
elevation already defined and adding a constant value $h = 0.05$
to it everywhere. This expresses the fact that the water depth is
everywhere constant, so the surface is a constant height above the
elevation of the bed.

\subsubsection*{Boundary Conditions}

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.0, 0.0])
\end{verbatim}}

The effect of these statements is to set up four alternative
boundary conditions and store them in variables that can be
assigned as needed. Each boundary condition specifies the
behaviour at a boundary in terms of the behaviour in neighbouring
elements. The boundary conditions may be briefly described as
follows:

\begin{description}
    \item[Reflective boundary]Returns same conserved
quantities as those present in its neighbour 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.
    \item[Transmissive boundary]Returns same conserved quantities as
    those present in its neighbour volume.
    \item[Dirichlet boundary]Specifies a fixed value at the
boundary.
    \item[Time boundary.]A Dirichlet boundary whose behaviour varies with time.
\end{description}

Once the four boundary types have been specified through the
statements above, they can be applied through a statement of the
form

{\small \begin{verbatim}
    domain.set_boundary({'left': Bd, 'right': Br, 'top': Br, 'bottom': Br})
\end{verbatim}}

This statement stipulates that, in the current example, the left
boundary is fixed, with an elevation of 0.2, while the other
boundaries are all reflective.


\subsection*{Evolution}

The final statement \nopagebreak[3]
{\small \begin{verbatim}
    for t in domain.evolve(yieldstep = 0.1, finaltime = 4.0):
        domain.write_time()
\end{verbatim}}

is the key step that causes the configuration of the domain to
`evolve' in accordance with the model embodied in the code, over a
series of steps indicated by the values of \texttt{yieldstep} and
\texttt{finaltime}, which can be altered as required.


\subsection*{Output}

%Give details here of the form of the output and explain how it can
%be used with swollen. Include screen shots.//

The output is a NetCDF file with the extension \texttt{.sww}. It
contains stage and momentum information and can be used with the
\texttt{swollen} package to generate a visual display.


\subsection*{How to Run the Code}

The code can be run in various ways:

\begin{itemize}
\item{from a Windows command line}

\item{within the Python IDLE environment}

\item{within emacs}

\item{from a Linux command line}
\end{itemize}




\pagebreak\section*{Glossary}

\begin{description}

    \item[AnuGA]

    \item[Default order]

    \item[Domain]

    \item[Dirichlet boundary]

    \item[Elevation]

    \item[Evolution]

    \item[Forcing]

    \item[IDLE]

    \item[Manning friction coefficient]

    \item[NetCDF]

    \item[pmesh]

    \item[pyvolution]

    \item[Quantity]

    \item[Reflective boundary]

    \item[Smoothing]

    \item[Stage]

    \item[Swollen]

    \item[Time boundary]

    \item[Transmissive boundary]



\end{description}

\end{document}