Description: Replace calls to \htmladdnormallink with \href and swap arguments.
  \htmladdnormallink is no longer supported in TexLive 2022 so replace with \href
  and swap the input arguments around.
Bug-Debian: https://bugs.debian.org/1013616
Author: Jonathan Bergh <bergh.jonathan@gmail.com>
Last-Update: 2022-09-22

--- a/Doc/Tutorial/paper.tex
+++ b/Doc/Tutorial/paper.tex
@@ -14,7 +14,6 @@
 % \+ permits optional breaking of a word across lines without the 
 % hyphen.
 \newcommand{\+}{\discretionary{}{}{}}
-\newcommand{\link}{\htmladdnormallink}
 
 \begin{document}        % The beginning of the document.
 
@@ -30,7 +29,7 @@
 \maketitle
 
 \section*{Preface}
-This document provides an introduction to Discrete Element Method (DEM) modelling using the ESyS-Particle Simulation Software developed by the \link{Centre for Geoscience Computing}{http://earth.uq.edu.au/centre-geoscience-computing} at \link{The University of Queensland}{http://www.uq.edu.au}. The guide is intended for new users and is written as a step-by-step tutorial on the basic principles and usage of the ESyS-Particle software. Readers are encouraged to obtain \link{a copy of the software}{https://launchpad.net/esys-particle/} and try the examples presented here. Readers are assumed to have had some experience using \link{Python}{http://www.python.org} and to be familiar with the fundamental principles of the DEM. If you have never used Python before, the \link{Python Language Tutorial}{http://docs.python.org/tut/tut.html} is an excellent starting point.
+This document provides an introduction to Discrete Element Method (DEM) modelling using the ESyS-Particle Simulation Software developed by the \href{http://earth.uq.edu.au/centre-geoscience-computing}{Centre for Geoscience Computing} at \href{http://www.uq.edu.au}{The University of Queensland}. The guide is intended for new users and is written as a step-by-step tutorial on the basic principles and usage of the ESyS-Particle software. Readers are encouraged to obtain \href{https://launchpad.net/esys-particle/}{a copy of the software} and try the examples presented here. Readers are assumed to have had some experience using \href{http://www.python.org}{Python} and to be familiar with the fundamental principles of the DEM. If you have never used Python before, the \href{http://docs.python.org/tut/tut.html}{Python Language Tutorial} is an excellent starting point.
 
 
 \tableofcontents
--- a/Doc/Tutorial/tables/interaction_groups.tex
+++ b/Doc/Tutorial/tables/interaction_groups.tex
@@ -4,73 +4,57 @@
 \begin{tabular}{|c|c|c|c|} \cline{2-4}
   \multicolumn{1}{c|}{} & 
   \multicolumn{1}{p{40 mm}|}{
-    \centering{\link{\textbf{NRotSphere}}
-      {http://esys.geocomp.uq.edu.au/esys-particle_python_doc/current/pythonapi/html/esys.lsm.LsmPy.NRotSphere-class.html}}
+    \centering{\href{http://esys.geocomp.uq.edu.au/esys-particle_python_doc/current/pythonapi/html/esys.lsm.LsmPy.NRotSphere-class.html}{\textbf{NRotSphere}}}
   } & 
   \multicolumn{1}{p{40 mm}|}{
-    \centering{\link{\textbf{RotSphere}}
-      {http://esys.geocomp.uq.edu.au/esys-particle_python_doc/current/pythonapi/html/esys.lsm.LsmPy.RotSphere-class.html}}
+    \centering{\href{http://esys.geocomp.uq.edu.au/esys-particle_python_doc/current/pythonapi/html/esys.lsm.LsmPy.RotSphere-class.html}{\textbf{RotSphere}}}
   } & 
   \multicolumn{1}{p{40 mm}|}{
-    \centering{\link{\textbf{RotThermalSphere}}
-      {http://esys.geocomp.uq.edu.au/esys-particle_python_doc/current/pythonapi/html/esys.lsm.LsmPy.RotThermalSphere-class.html}}
+    \centering{\href{http://esys.geocomp.uq.edu.au/esys-particle_python_doc/current/pythonapi/html/esys.lsm.LsmPy.RotThermalSphere-class.html}{\textbf{RotThermalSphere}}}
   } 
   \\\hline
   % Start Body Forces
   & 
   \multicolumn{3}{c|}{
-    \link{Gravity}
-      {http://esys.geocomp.uq.edu.au/esys-particle_python_doc/current/pythonapi/html/esys.lsm.LsmPy.GravityPrms-class.html}
+    \href{http://esys.geocomp.uq.edu.au/esys-particle_python_doc/current/pythonapi/html/esys.lsm.LsmPy.GravityPrms-class.html}{Gravity}
   }
   \\\cline{2-4}
   & 
   \multicolumn{3}{c|}{
-    \link{Damping}
-      {http://esys.geocomp.uq.edu.au/esys-particle_python_doc/current/pythonapi/html/esys.lsm.LsmPy.DampingPrms-class.html}
+    \href{http://esys.geocomp.uq.edu.au/esys-particle_python_doc/current/pythonapi/html/esys.lsm.LsmPy.DampingPrms-class.html}{Damping}
   } 
   \\\cline{2-4}
   \raisebox{1.25 ex}[0 pt]{\textbf{Body Forces}} & 
   \multicolumn{3}{c|}{
-    \link{LinDamping}
-      {http://esys.geocomp.uq.edu.au/esys-particle_python_doc/current/pythonapi/html/esys.lsm.LsmPy.LinDampingPrms-class.html}
+    \href{http://esys.geocomp.uq.edu.au/esys-particle_python_doc/current/pythonapi/html/esys.lsm.LsmPy.LinDampingPrms-class.html}{Damping}
   } 
   \\\cline{2-4}
   & 
   & 
-  \link{RotDamping}
-    {http://esys.geocomp.uq.edu.au/esys-particle_python_doc/current/pythonapi/html/esys.lsm.LsmPy.RotDampingPrms-class.html}
+  \href{http://esys.geocomp.uq.edu.au/esys-particle_python_doc/current/pythonapi/html/esys.lsm.LsmPy.RotDampingPrms-class.html}{RotDamping}
   &
   \\\hline\hline
   % End Body Forces
   % Start Unbonded Particle-Particle Interactions
   \textbf{Unbonded} &  &  &  \\
   \textbf{Particle-Particle} & 
-  \raisebox{2 ex}[0 pt]{\link{NRotElastic}
-    {http://esys.geocomp.uq.edu.au/esys-particle_python_doc/current/pythonapi/html/esys.lsm.LsmPy.NRotElasticPrms-class.html}} & 
-  \raisebox{2 ex}[0 pt]{\link{RotElastic}
-    {http://esys.geocomp.uq.edu.au/esys-particle_python_doc/current/pythonapi/html/esys.lsm.LsmPy.RotElasticPrms-class.html}} &
-  \raisebox{2 ex}[0 pt]{\link{RotThermalElastic}
-    {http://esys.geocomp.uq.edu.au/esys-particle_python_doc/current/pythonapi/html/esys.lsm.LsmPy.RotThermalElasticPrms-class.html}}
+  \raisebox{2 ex}[0 pt]{\href{http://esys.geocomp.uq.edu.au/esys-particle_python_doc/current/pythonapi/html/esys.lsm.LsmPy.NRotElasticPrms-class.html}{NRotElastic}} & 
+  \raisebox{2 ex}[0 pt]{\href{http://esys.geocomp.uq.edu.au/esys-particle_python_doc/current/pythonapi/html/esys.lsm.LsmPy.RotElasticPrms-class.html}{RotElastic}} &
+  \raisebox{2 ex}[0 pt]{\href{http://esys.geocomp.uq.edu.au/esys-particle_python_doc/current/pythonapi/html/esys.lsm.LsmPy.RotThermalElasticPrms-class.html}{RotThermalElastic}}
   \\[-1.35 ex] \cline{2-4} \\[-1.35 ex]
   \textbf{Interactions} & 
-  \raisebox{0.5 ex}[0 pt]{\link{NRotFriction}
-    {http://esys.geocomp.uq.edu.au/esys-particle_python_doc/current/pythonapi/html/esys.lsm.LsmPy.NRotFrictionPrms-class.html}} & 
-  \raisebox{0.5 ex}[0 pt]{\link{RotFriction}
-    {http://esys.geocomp.uq.edu.au/esys-particle_python_doc/current/pythonapi/html/esys.lsm.LsmPy.RotFrictionPrms-class.html}} &
-  \raisebox{0.5 ex}[0 pt]{\link{RotThermalFriction}
-    {http://esys.geocomp.uq.edu.au/esys-particle_python_doc/current/pythonapi/html/esys.lsm.LsmPy.RotThermalFrictionPrms-class.html}}
+  \raisebox{0.5 ex}[0 pt]{\href{http://esys.geocomp.uq.edu.au/esys-particle_python_doc/current/pythonapi/html/esys.lsm.LsmPy.NRotFrictionPrms-class.html}{NRotFriction}} & 
+  \raisebox{0.5 ex}[0 pt]{\href{http://esys.geocomp.uq.edu.au/esys-particle_python_doc/current/pythonapi/html/esys.lsm.LsmPy.RotFrictionPrms-class.html}{RotFriction}} &
+  \raisebox{0.5 ex}[0 pt]{\href{http://esys.geocomp.uq.edu.au/esys-particle_python_doc/current/pythonapi/html/esys.lsm.LsmPy.RotThermalFrictionPrms-class.html}{RotThermalFriction}}
   \\\hline\cline{1-4}
   % End Unbonded Particle-Particle Interactions
   % Start Bonded Particle-Particle Interactions
   \textbf{Bonded} &  &  & 
   \\
   \textbf{Particle-Particle} &
-  \link{NRotBond}
-    {http://esys.geocomp.uq.edu.au/esys-particle_python_doc/current/pythonapi/html/esys.lsm.LsmPy.NRotBondPrms-class.html} & 
-  \link{RotBond}
-    {http://esys.geocomp.uq.edu.au/esys-particle_python_doc/current/pythonapi/html/esys.lsm.LsmPy.RotBondPrms-class.html} &
-  \link{RotThermalBond}
-    {http://esys.geocomp.uq.edu.au/esys-particle_python_doc/current/pythonapi/html/esys.lsm.LsmPy.RotThermalBondPrms-class.html}
+  \href{http://esys.geocomp.uq.edu.au/esys-particle_python_doc/current/pythonapi/html/esys.lsm.LsmPy.NRotBondPrms-class.html}{NRotBond} & 
+  \href{http://esys.geocomp.uq.edu.au/esys-particle_python_doc/current/pythonapi/html/esys.lsm.LsmPy.RotBondPrms-class.html}{RotBond} &
+  \href{http://esys.geocomp.uq.edu.au/esys-particle_python_doc/current/pythonapi/html/esys.lsm.LsmPy.RotThermalBondPrms-class.html}{RotThermalBond}
   \\
   \textbf{Interactions} &  &  &
   \\\hline\hline
@@ -78,46 +62,39 @@
   % Start UnBonded Wall-Particle Interactions
   \textbf{Unbonded} & 
   \multicolumn{3}{c|}{
-    \link{NRotElasticWall}
-      {http://esys.geocomp.uq.edu.au/esys-particle_python_doc/current/pythonapi/html/esys.lsm.LsmPy.NRotElasticWallPrms-class.html}
+    \href{http://esys.geocomp.uq.edu.au/esys-particle_python_doc/current/pythonapi/html/esys.lsm.LsmPy.NRotElasticWallPrms-class.html}{NRotElasticWall}
   } 
   \\\cline{2-4}
   \textbf{Wall-Particle} & 
   \multicolumn{3}{c|}{
-    \link{NRotElasticLinMesh}
-      {http://esys.geocomp.uq.edu.au/esys-particle_python_doc/current/pythonapi/html/esys.lsm.LsmPy.NRotElasticLinMeshPrms-class.html}
+    \href{http://esys.geocomp.uq.edu.au/esys-particle_python_doc/current/pythonapi/html/esys.lsm.LsmPy.NRotElasticLinMeshPrms-class.html}{NRotElasticLinMesh}
   } 
   \\\cline{2-4}
   \textbf{Interactions} & 
   \multicolumn{3}{c|}{
-    \link{NRotElasticTriMesh}
-      {http://esys.geocomp.uq.edu.au/esys-particle_python_doc/current/pythonapi/html/esys.lsm.LsmPy.NRotElasticTriMeshPrms-class.html}
+    \href{http://esys.geocomp.uq.edu.au/esys-particle_python_doc/current/pythonapi/html/esys.lsm.LsmPy.NRotElasticTriMeshPrms-class.html}{NRotElasticTriMesh}
   } 
   \\\hline\cline{1-4}
   % End UnBonded Wall-Particle Interactions
   % Start Bonded Wall-Particle Interactions
   & 
   \multicolumn{3}{c|}{
-    \link{NRotBondedWall}
-      {http://esys.geocomp.uq.edu.au/esys-particle_python_doc/current/pythonapi/html/esys.lsm.LsmPy.NRotBondedWallPrms-class.html}
+    \href{http://esys.geocomp.uq.edu.au/esys-particle_python_doc/current/pythonapi/html/esys.lsm.LsmPy.NRotBondedWallPrms-class.html}{NRotBondedWall}
   } 
   \\\cline{2-4}
   \raisebox{1.25 ex}[0 pt]{\textbf{Bonded}} & 
   \multicolumn{3}{c|}{
-    \link{NRotBondedLinMesh}
-      {http://esys.geocomp.uq.edu.au/esys-particle_python_doc/current/pythonapi/html/esys.lsm.LsmPy.NRotBondedLinMeshPrms-class.html}
+    \href{http://esys.geocomp.uq.edu.au/esys-particle_python_doc/current/pythonapi/html/esys.lsm.LsmPy.NRotBondedLinMeshPrms-class.html}{NRotBondedLinMesh}
   } 
   \\\cline{2-4}
   \raisebox{1.25 ex}[0 pt]{\textbf{Wall-Particle}} & 
   \multicolumn{3}{c|}{
-    \link{NRotBondedTriMesh}
-      {http://esys.geocomp.uq.edu.au/esys-particle_python_doc/current/pythonapi/html/esys.lsm.LsmPy.NRotBondedTriMeshPrms-class.html}
+    \href{http://esys.geocomp.uq.edu.au/esys-particle_python_doc/current/pythonapi/html/esys.lsm.LsmPy.NRotBondedTriMeshPrms-class.html}{NRotBondedTriMesh}
   } 
   \\\cline{2-4}
   \raisebox{1.25 ex}[0 pt]{\textbf{Interactions}} & 
   \multicolumn{3}{c|}{
-    \link{NRotSoftBondedWall}
-      {http://esys.geocomp.uq.edu.au/esys-particle_python_doc/current/pythonapi/html/esys.lsm.LsmPy.NRotSoftBondedWallPrms-class.html}
+    \href{http://esys.geocomp.uq.edu.au/esys-particle_python_doc/current/pythonapi/html/esys.lsm.LsmPy.NRotSoftBondedWallPrms-class.html}{NRotSoftBondedWall}
   } 
   \\\hline
   % End Bonded Wall-Particle Interactions
--- a/Doc/Tutorial/bodytext.tex
+++ b/Doc/Tutorial/bodytext.tex
@@ -5,7 +5,7 @@
 
 ESyS-Particle is an Open Source implementation of the DEM designed for execution on multi-core Personal Computers (PCs), clusters or supercomputers running Linux-based operating systems. A modular, object-oriented DEM simulation engine written in C++ comprises the core of the software. Spatial domain decomposition is implemented using a master-slave strategy with inter-process communications using the Message Passing Interface (MPI) 1.0 standard. A verlet list neighbour search algorithm is implemented for detecting neighbouring particles and a variety of interaction laws are implemented for bonded or unbonded interactions between particles. Particles may have up to three translational and three rotational degrees of freedom as well as thermal properties. An explicit first-order finite difference time integration scheme is employed. Provision is made for file storage of both the entire model state or specific field variables during simulations.
 
-Since the applications for the DEM are broad and varied, ESyS-Particle provides a simple Application Programming Interface (API) allowing users to design simulations via scripts written in the \link{Python}{http://www.python.org} programming language. For numerous applications, there is no need to modify the C++ simulation engine or re-compile the software. The Python API allows users to
+Since the applications for the DEM are broad and varied, ESyS-Particle provides a simple Application Programming Interface (API) allowing users to design simulations via scripts written in the \href{http://www.python.org}{Python} programming language. For numerous applications, there is no need to modify the C++ simulation engine or re-compile the software. The Python API allows users to
 \begin{itemize}
 \item specify the initial locations and properties of particles and walls, 
 \item define the types of interactions acting on these objects,
@@ -191,7 +191,7 @@
 \noindent
 This time, rather than simply computing all $10000$ timesteps with a single subroutine call (\texttt{sim.run()}), we explicitly implement the time integration loop (via the \texttt{for}-statement). The \texttt{sim.runTimeStep()} subroutine call instructs the simulation object to compute only one timestep of the simulation.  
 
-After the timestep is completed, we check whether 100 timesteps have passed (via the \texttt{if}-statement). If so, we firstly obtain a \texttt{particles} list from the simulation object by calling \texttt{sim.getParticleList()}. \texttt{particles} is a Python list data structure where each member of the list is an ESyS-Particle \texttt{NRotSphere} object. \texttt{NRotSphere} objects have a number of subroutines that permit the user to obtain various information about individual particles (e.g.\ particle position, velocity, mass, radius, etc.). For more information about the available subroutines refer to the \link{\texttt{NRotSphere} class documentation}{http://esys.geocomp.uq.edu.au/esys-particle_python_doc/current/pythonapi/html/esys.lsm.LsmPy.NRotSphere-class.html}.
+After the timestep is completed, we check whether 100 timesteps have passed (via the \texttt{if}-statement). If so, we firstly obtain a \texttt{particles} list from the simulation object by calling \texttt{sim.getParticleList()}. \texttt{particles} is a Python list data structure where each member of the list is an ESyS-Particle \texttt{NRotSphere} object. \texttt{NRotSphere} objects have a number of subroutines that permit the user to obtain various information about individual particles (e.g.\ particle position, velocity, mass, radius, etc.). For more information about the available subroutines refer to the \href{http://esys.geocomp.uq.edu.au/esys-particle_python_doc/current/pythonapi/html/esys.lsm.LsmPy.NRotSphere-class.html}{\texttt{NRotSphere} class documentation}.
 
 \vskip 5mm
 \begin{minipage}{5.75in}
@@ -327,9 +327,9 @@
 
 \subsection{Generation of particle snapshots (via subroutine calls)}
 
-The previous two examples illustrated simple ways to output data from ESyS-Particle simulations. In this example we will introduce a way to generate beautiful snapshots of the particle assembly at various times during a simulation. This is achieved using the ESyS-Particle \texttt{esys.lsm.vis.povray} module and an external package called \link{POVray}{http://www.povray.org} that is ideal for generating images of 3D objects or scenes\footnote{Take a break for the moment and enjoy the amazing computer-generated images in the \link{POVray Hall of Fame}{http://hof.povray.org/}!}. The ESyS-Particle \texttt{povray} module provides a relatively simple interface between particle simulations and POVray. 
+The previous two examples illustrated simple ways to output data from ESyS-Particle simulations. In this example we will introduce a way to generate beautiful snapshots of the particle assembly at various times during a simulation. This is achieved using the ESyS-Particle \texttt{esys.lsm.vis.povray} module and an external package called \href{http://www.povray.org}{POVray} that is ideal for generating images of 3D objects or scenes\footnote{Take a break for the moment and enjoy the amazing computer-generated images in the \href{http://hof.povray.org/}{POVray Hall of Fame}!}. The ESyS-Particle \texttt{povray} module provides a relatively simple interface between particle simulations and POVray. 
 
-This part of the tutorial involves implementation of a Python subroutine. If you are not already familiar with writing subroutines in Python, I recommend you first study \link{Chapter 4 of the Python Language Tutorial}{http://docs.python.org/tut/node6.html}.  We will modify \texttt{bingle\_output.py} for this example.  The complete code-listing is available in Appendix~\ref{code:bingle_vis} entitled \texttt{bingle\_vis.py}.
+This part of the tutorial involves implementation of a Python subroutine. If you are not already familiar with writing subroutines in Python, I recommend you first study \href{http://docs.python.org/tut/node6.html}{Chapter 4 of the Python Language Tutorial}.  We will modify \texttt{bingle\_output.py} for this example.  The complete code-listing is available in Appendix~\ref{code:bingle_vis} entitled \texttt{bingle\_vis.py}.
 
 Since we will be making use of the ESyS-Particle \texttt{povray} module, we need to add a third import statement to the top of our script: 
 
@@ -338,7 +338,7 @@
 \end{verbatim}
 
 \noindent
-ESyS-Particle currently has two visualisation modules -- \texttt{povray} and \texttt{vtk}. Both utilise external libraries for rendering images of simulation data (\link{POVray}{http://www.povray.org} and \link{VTK}{http://www.vtk.org} respectively). The ESyS-Particle visualisation modules are designed to provide a common interface to these two rendering engines (so that either package may be used with minimal changes to your Python script). Each module has both advantages and disadvantages. \texttt{povray} produces very beautiful images of particle assemblies with the possibility of rendering particles with various textures and special effects, but it lacks tools specifically designed for scientific visualisation of datasets (e.g.\ for generating isosurfaces or contours). \texttt{vtk} is the opposite, providing great scientific visualisation tools and an interactive graphical interface but lacking strong support for rendering particles nicely. 
+ESyS-Particle currently has two visualisation modules -- \texttt{povray} and \texttt{vtk}. Both utilise external libraries for rendering images of simulation data (\href{http://www.povray.org}{POVray} and \href{http://www.vtk.org}{VTK} respectively). The ESyS-Particle visualisation modules are designed to provide a common interface to these two rendering engines (so that either package may be used with minimal changes to your Python script). Each module has both advantages and disadvantages. \texttt{povray} produces very beautiful images of particle assemblies with the possibility of rendering particles with various textures and special effects, but it lacks tools specifically designed for scientific visualisation of datasets (e.g.\ for generating isosurfaces or contours). \texttt{vtk} is the opposite, providing great scientific visualisation tools and an interactive graphical interface but lacking strong support for rendering particles nicely. 
 
 Having imported the \texttt{povray} module, we now implement a Python subroutine called \texttt{snapshot()} designed to render an image of the particle assembly and store it as a file. The code-fragment for implementing this subroutine is as follows:
 
@@ -452,7 +452,7 @@
 
 ESyS-Particle provides a mechanism to resolve many of these issues in the form of a \texttt{Runnable} class. A \texttt{Runnable} is a user-defined class that can be called by a simulation object once per timestep either before or after the force computations and time-integration. \texttt{Runnable} classes can be implemented as modules that can be reused in subsequent simulations simply by adding an import statement and some lines of initialisation code to your simulation script. This is a powerful feature of ESyS-Particle, offering the user the possibility to develop runtime data analysis and visualisation utilities that can be reused whenever they are needed with little or no modification to the \texttt{Runnable} itself.  
 
-The aim for this tutorial example is to implement the \texttt{snapshot()} subroutine from the previous example as a \texttt{Runnable} module. We will discuss how to call this from within your simulation script and how to deploy the module so that it can be easily reused in subsequent simulation scripts. If you are not already familiar with classes and inheritance in Python, I recommend you first study \link{Chapter 9 of the Python Language Tutorial}{http://docs.python.org/tut/node11.html}. We will also touch on some topics covered in \link{Chapter 6 of the Python Tutorial}{http://docs.python.org/tut/node8.html}. The complete code-listings for this example are found in Appendix~\ref{code:POVsnaps} \texttt{POVsnaps.py} and Appendix~\ref{code:bingle_Runnable} \texttt{bingle\_Runnable.py}.
+The aim for this tutorial example is to implement the \texttt{snapshot()} subroutine from the previous example as a \texttt{Runnable} module. We will discuss how to call this from within your simulation script and how to deploy the module so that it can be easily reused in subsequent simulation scripts. If you are not already familiar with classes and inheritance in Python, I recommend you first study \href{http://docs.python.org/tut/node11.html}{Chapter 9 of the Python Language Tutorial}. We will also touch on some topics covered in \href{http://docs.python.org/tut/node8.html}{Chapter 6 of the Python Tutorial}. The complete code-listings for this example are found in Appendix~\ref{code:POVsnaps} \texttt{POVsnaps.py} and Appendix~\ref{code:bingle_Runnable} \texttt{bingle\_Runnable.py}.
 
 \subsubsection{Implementation of a snapshot \texttt{Runnable}}
 
@@ -588,7 +588,7 @@
 Once your \texttt{Runnable\_scripts} directory is in your \texttt{PYTHONPATH}, Python will be able to find your module whenever it encounters an import statement like \texttt{from POVsnaps import POVsnaps}. You have now successfully deployed your \texttt{Runnable} as a reusable Python module. From now on, pretty snapshots of your particle simulations are only 3 lines of code away!
 
 \vskip 5mm
-\noindent \textbf{\emph{EXERCISE:} Another very useful \texttt{Runnable} is one that stores the particle positions to a text file at specified intervals. Write a \texttt{Runnable} to achieve this and store it in your \texttt{Runnable\_scripts} directory for later use (HINT: you will only need to implement a simple \texttt{self.\_\_init\_\_()} subroutine and a \texttt{self.run()} subroutine for this. If you are unfamiliar with writing text files in Python, refer to \link{Section 7.2 of the Python Language Tutorial}{http://docs.python.org/tut/node9.html\#SECTION009200000000000000000}).}
+\noindent \textbf{\emph{EXERCISE:} Another very useful \texttt{Runnable} is one that stores the particle positions to a text file at specified intervals. Write a \texttt{Runnable} to achieve this and store it in your \texttt{Runnable\_scripts} directory for later use (HINT: you will only need to implement a simple \texttt{self.\_\_init\_\_()} subroutine and a \texttt{self.run()} subroutine for this. If you are unfamiliar with writing text files in Python, refer to \href{http://docs.python.org/tut/node9.html\#SECTION009200000000000000000}{Section 7.2 of the Python Language Tutorial}).}
 
 \vskip 5mm
 \begin{minipage}{5.75in}
@@ -1648,7 +1648,7 @@
 \end{verbatim}
 
 \noindent
-Most of the \texttt{FieldSaver} parameters should now be familiar.  A new \texttt{fileFormat} called \texttt{SUM} is used here. This file format stores the sum of the kinetic energy of each particle. The output format is an ASCII text file with the total kinetic energy written once per timestep.  A number of other fields may also be output using \texttt{ParticleScalarFieldSavers} or \texttt{ParticleVectorFieldSavers}. A list of valid \texttt{fieldNames} for various types of \texttt{FieldSav\+ers} is provided in Appendix \ref{tables}.  Other helpful information can be found on this \link{ESyS-Particle wiki documentation page}{https://wiki.geocomp.uq.edu.au/index.php/Documentation_and_Presentations}. 
+Most of the \texttt{FieldSaver} parameters should now be familiar.  A new \texttt{fileFormat} called \texttt{SUM} is used here. This file format stores the sum of the kinetic energy of each particle. The output format is an ASCII text file with the total kinetic energy written once per timestep.  A number of other fields may also be output using \texttt{ParticleScalarFieldSavers} or \texttt{ParticleVectorFieldSavers}. A list of valid \texttt{fieldNames} for various types of \texttt{FieldSav\+ers} is provided in Appendix \ref{tables}.  Other helpful information can be found on this \href{https://wiki.geocomp.uq.edu.au/index.php/Documentation_and_Presentations}{ESyS-Particle wiki documentation page}. 
 
 The second quantity is the total strain energy stored within bonds connecting particles. The total strain energy is simply the sum of the potential energies of the rotational bonds connecting each particle-pair. The following code-fragment initialises an \texttt{InteractionScalarFieldSaver} to store the total strain energy each timestep:
 
@@ -1733,12 +1733,12 @@
 
 In the following tutorial we will encounter some post-processing tools provided with ESyS-Particle. These tools are designed for post-simulation analysis of data stored in \texttt{CheckPointer} output files to permit visualisation and analysis of data that is not easily computed during simulations. We will demonstrate how to convert \texttt{CheckPoint} files into a format suitable for interactive visualisation using popular third-party software such as ParaView and VisIt. We will also see how to visualise the locations of broken bonds and also the shapes of fragments produced during uniaxial compression simulations. 
 
-%In the following tutorials we will start to discuss some of the more advanced features of ESyS-Particle. These include the use of a external helper module called \texttt{LSMGenGeo} that provides the capacity to create particle models of siginificantly greater geometrical complexity than the basic tools covered already (such as \texttt{CubicBlock} and \texttt{RandomBoxPacker}).  We will also introduce some post-processing tools provided with ESyS-Particle designed for post-simulation analysis of data stored in checkpoint files. These tools include a conversion tool to permit interactive visualisation of ESyS-Particle checkpoint files using third-party software such as \link{ParaView}{http://www.paraview.org} and \link{VisIt}{https://wci.llnl.gov/codes/visit/}. 
+%In the following tutorials we will start to discuss some of the more advanced features of ESyS-Particle. These include the use of a external helper module called \texttt{LSMGenGeo} that provides the capacity to create particle models of siginificantly greater geometrical complexity than the basic tools covered already (such as \texttt{CubicBlock} and \texttt{RandomBoxPacker}).  We will also introduce some post-processing tools provided with ESyS-Particle designed for post-simulation analysis of data stored in checkpoint files. These tools include a conversion tool to permit interactive visualisation of ESyS-Particle checkpoint files using third-party software such as \href{http://www.paraview.org}{ParaView} and \href{https://wci.llnl.gov/codes/visit/}{VisIt}. 
 
 \newpage
 \section{Post-processing and data visualisation}
 
-ESyS-Particle is primarily designed as a high-performance parallel DEM simulation engine. The Python API makes designing and executing different simulations relatively simple and straightforward, however the data output mechanisms (\texttt{FieldSavers} and \texttt{CheckPointers}) are relatively basic. For most applications, post-processing of simulation output files will be necessary to obtain useful results. ESyS-Particle is packaged with a few tools designed to aid in the post-processing of simulation data to obtain particular results or convert the output into formats that can be visualised using freely available third-party visualisation tools (such as \link{ParaView}{http://www.paraview.org} and \link{VisIt}{https://wci.llnl.gov/codes/visit/}). 
+ESyS-Particle is primarily designed as a high-performance parallel DEM simulation engine. The Python API makes designing and executing different simulations relatively simple and straightforward, however the data output mechanisms (\texttt{FieldSavers} and \texttt{CheckPointers}) are relatively basic. For most applications, post-processing of simulation output files will be necessary to obtain useful results. ESyS-Particle is packaged with a few tools designed to aid in the post-processing of simulation data to obtain particular results or convert the output into formats that can be visualised using freely available third-party visualisation tools (such as \href{http://www.paraview.org}{ParaView} and \href{https://wci.llnl.gov/codes/visit/}{VisIt}). 
 
 In this tutorial, we will discuss some of these post-processing tools and how to use them for more advanced visualisation of simulation results. By way of motivation we will use the uniaxial compression simulation (\texttt{rot\_compress.py}) discussed in the previous tutorial. By adding a \texttt{CheckPointer} to our simulation and post-processing the checkpoint files, we will be able to:
 \begin{itemize}
@@ -1771,7 +1771,7 @@
 
 \subsection{Interactive visualisation of simulation data}
 
-Perhaps the most versatile of ESyS-Particle's post-processing tools is \texttt{dump2vtk}. This tool will convert a sequence of \texttt{CheckPoint} files (also known as \emph{dump} files) into VTK unstructured mesh files. VTK (short for \link{Visualisation Tool Kit}{http://www.vtk.org}) is a popular library for three-dimensional post-processing and visualisation of scientific datasets. Although designed primarily for advanced visualisation and analysis of mesh-based datasets (e.g. from finite difference or finite element software), VTK has quite some utility for post-analysis of DEM simulation data also. Third-party visualisation software (such as \link{ParaView}{http://www.paraview.org} and \link{VisIt}{https://wci.llnl.gov/codes/visit/}) provide interactive 3D visualisation capabilities that make these packages (in combination with \texttt{dump2vtk}) a powerful addition to an ESyS-Particle modeller's arsenal.  
+Perhaps the most versatile of ESyS-Particle's post-processing tools is \texttt{dump2vtk}. This tool will convert a sequence of \texttt{CheckPoint} files (also known as \emph{dump} files) into VTK unstructured mesh files. VTK (short for \href{http://www.vtk.org}{Visualisation Tool Kit}) is a popular library for three-dimensional post-processing and visualisation of scientific datasets. Although designed primarily for advanced visualisation and analysis of mesh-based datasets (e.g. from finite difference or finite element software), VTK has quite some utility for post-analysis of DEM simulation data also. Third-party visualisation software (such as \href{http://www.paraview.org}{ParaView} and \href{https://wci.llnl.gov/codes/visit/}{VisIt}) provide interactive 3D visualisation capabilities that make these packages (in combination with \texttt{dump2vtk}) a powerful addition to an ESyS-Particle modeller's arsenal.  
 
 \begin{figure}
 \resizebox{\textwidth}{!}{