add some more links

docs/source/compressible_basics.rst

@@ -65,7 +65,7 @@ The parameter for this solver are:
 
 :py:mod:`compressible_sdc` uses a 4th order accurate method with
 spectral-deferred correction (SDC) for the time integration.  This
-shares much in common with the ``compressible_fv4`` solver, aside from
+shares much in common with the :py:mod:`compressible_fv4` solver, aside from
 how the time-integration is handled.
 
 The parameters for this solver are:
@@ -78,7 +78,7 @@ Example problems
 
 .. note::
 
-   The 4th-order accurate solver (``compressible_fv4``) requires that
+   The 4th-order accurate solver (:py:mod:`compressible_fv4`) requires that
    the initialization create cell-averages accurate to 4th-order.  To
    allow for all the solvers to use the same problem setups, we assume
    that the initialization routines initialize cell-centers (which is

docs/source/installation.rst

@@ -21,7 +21,7 @@ The following steps are needed before running pyro:
 * add ``pyro/`` to your ``PYTHONPATH`` environment variable (note this is only
 needed if you wish to use pyro as a python
 module - this step is not necessary if you only run pyro via the
-commandline using the `pyro.py` script).  For
+commandline using the ``pyro.py`` script).  For
   the bash shell, this is done as:
 
     .. code-block:: none

docs/source/mesh_basics.rst

@@ -15,8 +15,8 @@ discretization. The basic theory of such methods is discussed in
    methods for converting between the two data centerings.
 
 
-``mesh.patch`` implementation and use
--------------------------------------
+:mod:`mesh.patch <mesh.patch>` implementation and use
+-----------------------------------------------------
 
 We import the basic mesh functionality as:
 
@@ -36,14 +36,16 @@ There are several main objects in the patch class that we interact with:
 
 * :func:`patch.CellCenterData2d <mesh.patch.CellCenterData2d>`: this
   is the main data object—it holds cell-centered data on a grid.  To
-  build a ``CellCenterData2d`` object you need to pass in the ``Grid2d``
-  object that defines the mesh. The ``CellCenterData2d`` object then
+  build a :func:`patch.CellCenterData2d <mesh.patch.CellCenterData2d>`
+  object you need to pass in the :func:`patch.Grid2d <mesh.patch.Grid2d>`
+  object that defines the mesh. The
+  :func:`patch.CellCenterData2d <mesh.patch.CellCenterData2d>` object then
   allocates storage for the unknowns that live on the grid. This class
   also provides methods to fill boundary conditions, retrieve the data
   in different fashions, and read and write the object from/to disk.
 
 * :func:`fv.FV2d <mesh.fv.FV2d>`: this is a special class derived from
-  ``patch.CellCenterData2d`` that implements some extra functions
+  :func:`patch.CellCenterData2d <mesh.patch.CellCenterData2d>` that implements some extra functions
   needed to convert between cell-center data and averages with
   fourth-order accuracy.
 
@@ -99,14 +101,14 @@ Jupyter notebook
 
 A Jupyter notebook that illustrates some of the basics of working with
 the grid is provided as :ref:`mesh-examples.ipynb`. This will
-demonstrate, for example, how to use the ``ArrayIndexer`` methods to
+demonstrate, for example, how to use the :func:`ArrayIndexer <mesh.array_indexer.ArrayIndexer>` methods to
 construct differences.
 
 
 Tests
 -----
 
-The actual filling of the boundary conditions is done by the ``fill_BC()``
+The actual filling of the boundary conditions is done by the :func:`fill_BC <mesh.patch.CellCenterData2d.fill_BC>`
 method. The script ``bc_demo.py`` tests the various types of boundary
 conditions by initializing a small grid with sequential data, filling
 the BCs, and printing out the results.

docs/source/multigrid_basics.rst

@@ -17,7 +17,7 @@ There are three solvers:
 * The class :func:`general_MG.GeneralMG2d <multigrid.general_MG.GeneralMG2d>` solves a general elliptic
   equation of the form :math:`\alpha \phi + \nabla \cdot ( \beta
   \nabla \phi) + \gamma \cdot \nabla \phi = f`.  This class inherits
-  the core functionality from ``MG.CellCenterMG2d``.
+  the core functionality from :func:`MG.CellCenterMG2d <multigrid.MG.CellCenterMG2d>`.
 
   This solver is the only one to support inhomogeneous boundary
   conditions.

docs/source/output.rst

@@ -39,7 +39,7 @@ Several simply utilities exist to operate on output files
 Reading and plotting manually
 -----------------------------
 
-pyro data can be read using the ``patch.read`` method. The following
+pyro output data can be read using the :func:`util.io.read <util.io.read>` method. The following
 sequence (done in a python session) reads in stored data (from the
 compressible Sedov problem) and plots data falling on a line in the x
 direction through the y-center of the domain (note: this will include

docs/source/particles_basics.rst

@@ -3,8 +3,8 @@ Particles
 
 A solver for modelling particles.
 
-``particles.particles`` implementation and use
-----------------------------------------------
+:mod:`particles.particles <particles.particles>` implementation and use
+-----------------------------------------------------------------------
 
 We import the basic particles module functionality as:
 
@@ -39,8 +39,8 @@ The particles can be initialized in a number of ways:
   which generates particles based on array of particle positions passed to the
   constructor.
 * The user can define their own ``particle_generator`` function and pass this into the
-  ``Particles`` constructor. This function takes the number of particles to be
-  generated and returns a dictionary of ``Particle`` objects.
+  :func:`Particles <particles.particles.Particles>` constructor. This function takes the number of particles to be
+  generated and returns a dictionary of :func:`Particle <particles.particles.Particle>` objects.
 
 We can turn on/off the particles solver using the following runtime paramters:
 
@@ -95,7 +95,7 @@ in as arguments to this function as they cannot be accessed using the standard
 Plotting particles
 ------------------
 
-Given the ``Particles`` object ``particles``, we can plot the particles by getting
+Given the :func:`Particles <particles.particles.Particles>` object ``particles``, we can plot the particles by getting
 their positions using
 
 .. code-block:: python
@@ -128,7 +128,7 @@ x-position, we can plot them on the figure axis ``ax`` using the following code:
       ax.set_xlim([myg.xmin, myg.xmax])
       ax.set_ylim([myg.ymin, myg.ymax])
 
-Applying this to the Kelvin-Helmholtz problem with the ``compressible`` solver,
+Applying this to the Kelvin-Helmholtz problem with the :mod:`compressible <compressible>` solver,
 we can produce a plot such as the one below, where the particles have been
 plotted on top of the fluid density.
 

docs/source/running.rst

@@ -54,11 +54,11 @@ an interface that enables simulations to be set up and run in a Jupyter notebook
 ``examples/examples.ipynb`` for an example notebook. A simulation can be set up and run
 by carrying out the following steps:
 
-* create a ``Pyro`` object, initializing it with a specific solver
+* create a :func:`Pyro <pyro.Pyro>` object, initializing it with a specific solver
 * initialize the problem, passing in runtime parameters and inputs
 * run the simulation
 
-For example, if we wished to use the ``compressible`` solver to run the
+For example, if we wished to use the :mod:`compressible <compressible>` solver to run the
 Kelvin-Helmholtz problem ``kh``, we would do the following:
 
 .. code-block:: python

docs/source/testing.rst

@@ -9,7 +9,7 @@ script in the root directory.
 Unit tests
 ----------
 
-pyro implements unit tests using py.test.  These can be run via::
+pyro implements unit tests using ``py.test``.  These can be run via::
 
    ./test.py -u
 
@@ -36,5 +36,3 @@ We can compare to the stored benchmarks simply by running::
    may mean that we do not pass the regression tests.  In this case, one would
    need to create a new set of benchmarks for that machine and use those for
    future tests.
-
-