Changeset 2457

Timestamp:

Feb 28, 2006, 2:55:56 PM (19 years ago)

Author:

howard

Message:

Continuing update to the second example in Chapter 2. Added terms 'meshfile' and 'points file' to Glossary.

File:

• documentation/user_manual/anuga_user_manual.tex (modified) (10 diffs)

documentation/user_manual/anuga_user_manual.tex

@@ -286 +286 @@
 \begin{itemize}
 
-   \item a list \code{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 \code{vertices} of length $2mn$ (each entry specifies the three
-vertices of one of the triangles used in the triangulation) , and
+   \item a list \code{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 \code{vertices} %of length $2mn$ (each entry specifies the three
+%vertices of one of the triangles used in the triangulation) , and
 
    \item a dictionary \code{boundary}, used to tag the triangle edges on
@@ -492 +492 @@
 the \code{bedslope.py} example and introduces a second example,
 \code{run_sydney_smf.py}, that follows the same basic outline, but
-incorporates many more complex features.
+incorporates more complex features and refers to a real-life
+scenario, rather than the artificial illustrative one used in
+\code{bedslope.py}.
 
 \subsection{Overview}
@@ -607 +609 @@
 #-------------------------------------------------------------------------------
 
-#def get_polygon_from_file(filename): #    fid = open(filename) #
-lines = fid.readlines() #    fid.close()
-
-#    polygon = [] #    for line in lines[1:]: #       fields =
-line.split(',') #        x = float(fields[3]) #        y =
-float(fields[4]) #        polygon.append([x, y])
-
-#    return interior_polygon
-
-from pmesh.create_mesh import create_mesh_from_regions
-\end{verbatim}}
-
-
-{\scriptsize \begin{verbatim}
- num_polygons = 1 filelist = [] fileext
-= '.csv' filename = project.polygonptsfile interior_res = 50000
-
-for p in range(1, num_polygons+1):
-    thefilename = filename + str(p) + fileext
-    interior_polygon = get_polygon_from_file(thefilename)
-    interior_regions.append([interior_polygon, interior_res])
-
-# test
-#interior_regions = [[project.poly1, interior_res],
-#
-[project.poly2, interior_res]]
-# original
-#interior_regions =
-[[project.harbour_polygon_2, interior_res],
-#
+interior_regions = [[project.harbour_polygon_2, interior_res],
 [project.botanybay_polygon_2, interior_res]]
 
@@ -743 +716 @@
 In its simplest form, the technique creates the mesh within a single
 polygon whose vertices are at geographical locations specified by
-the user. A triangular mesh is created using points inside the
-polygon selected through a random process, the user specifying the
-\emph{resolution}---that is, the maximal area of a triangle used for
-triangulation.
-
-Figure XXX shows a simple example of this, in which the
-triangulation is carried out within a pentagon. Instead of using the
-four tags \code{`left'}, \code{`right'}, \code{`bottom'} and
-\code{`top'} that we used in the case of \code{bedslope.py} to
-distinguish boundary elements, the user can define tags appropriate
-to the configuration being modelled.
-
-While this simple version of the technique offers more flexibility
-than the rectangular grid, it doesn't provide a way to adapt to
+the user. The user specifies the \emph{resolution}---that is, the
+maximal area of a triangle used for triangulation---and mesh points
+are created inside the polygon through a random process. Figure XXX
+shows a simple example of this, in which the triangulation is
+carried out within a pentagon.
+
+Boundary tags are not restricted to \code{`left'}, \code{`right'},
+\code{`bottom'} and \code{`top'}, as in the case of
+\code{bedslope.py}. Instead the user specifies a list of tags
+appropriate to the configuration being modelled.
+
+While a mesh created inside a polygon offers more flexibility than
+one based on a rectangular grid, the technique of mesh creation that
+we have so far described doesn't provide a way to adapt to
 geographic or other features in the landscape, whose presence may
 require us to vary the resolution in the neighbourhood of the
-features. To achieve more flexibility we therefore extend the
-technique, allowing the user to specify a number of interior
+features. To achieve more flexibility, an extension of the technique
+is adopted, which allows the user to specify a number of interior
 polygons to be triangulated separately, possibly using different
 resolutions. See Figure XXX.
@@ -766 +739 @@
 The upshot is a general method that takes for its input a bounding
 polygon and (optionally) a list of interior polygons. It creates a
-triangular mesh inside the bounding polygon, using a specified
-resolution, but initially leaves the regions inside the interior
-polygons alone. It then triangulates each of these regions
-separately, using a separately specified resolution.
-
-The function used to implement this process is the function
+triangular mesh inside the bounding polygon, using a user-specified
+resolution, but then creates a separate triangulation inside each of
+the interior polygons, according to the resolution specified for
+that polygon.
+
+The function used to implement this process is
 \code{create_mesh_from_regions}. Its arguments include the bounding
 polygon and its resolution, a list of boundary tags, and a list of
@@ -778 +751 @@
 
 In practice, the details of the polygons used are read from a
-separate file \code{project.py}.
+separate file \code{project.py}. The resulting mesh is output to a
+\emph{meshfile}, which is a file of a specific format used to store
+the data specifying a mesh. (There are two formats for such a file:
+it can either be a binary file, with extension \code{.msh}, or an
+ASCII file, with extension \code{.tsh}. In the present case, the
+binary file format \code{.msh} is used. See Section \ref{sec:file
+formats} for more on file formats.) and assigned a name obtained by
+appending the extension \code{.msh} to the name specified in the
+input file \code{project.py}. This name is stored in the variable
+\code{meshname}.
 
 
@@ -784 +766 @@
 
 As with \code{bedslope.py}, once we have created the mesh, the next
-step is to create the data structure \code{domain}.
+step is to create the data structure \code{domain}. This is
+accomplished through the following statements:
 
 {\scriptsize \begin{verbatim}
@@ -793 +776 @@
 \end{verbatim}}
 
+The function \code{pmesh_to_domain_instance} converts a meshfile
+\code{meshname} into an instance of the data structure
+\code{domain}, allowing us to use methods like \code{set\_quantity}
+to set quantities and to apply other operations. In the case of
+\code{bedslope.py},
+
 \subsection{Specifying the Quantities}
+
+
 
 {\scriptsize \begin{verbatim}
@@ -820 +811 @@
 
 #-------------------------------------------------------------------------------
-# Setup initial conditions
+# Set up initial conditions
 #-------------------------------------------------------------------------------
 
@@ -1344 +1335 @@
     \item \indexedbold{Mesh}    triangulation of domain
 
+    \item \indexedbold{meshfile}  [generic word for either .tsh or
+    .msh file]
+
+    \item \indexedbold{points file}  [generic word for either .pts or
+    .xya file]
+
     \item \indexedbold{Grid} evenly spaced