{\footnotesize
\begin{verbatim}
A description of BlockSolve95 example programs, a description of
the problem calling arguments is given below.
================================================================

grid0 -- Simple example.  Uses 3-d 7-point finite-difference
  stencil.  BlockSolve context set not to look for cliques or
  inodes.  Symmetric problem.

  . mpirun -np P grid0.ARCH PX PY PZ NX NY NZ

-----------------------------------------------------------------
grid1 -- An unbalanced grid example.  The processors on the left 
  and right ends of the grid use a 7 pt stencil, those in the middle 
  use a 27-pt stencil.  BlockSolve context set not to look for cliques
  and inodes.  Symmetric problem.

  . mpirun -np P grid1.ARCH PX PY PZ NX NY NZ

-----------------------------------------------------------------
grid2 -- A demonstration of running BlockSolve on two independent
  sets of processors simultaneously.  This problem is partitioned
  in only the x and y directions.  The processors on the left 
  and right ends of the grid use a 7 pt stencil; those in the middle 
  use a 27-pt stencil.  BlockSolve context set not to look for 
  cliques or inodes.  Symmetric problem.

  . mpirun -np P grid2.ARCH PX PY NX NY NZ

-----------------------------------------------------------------
grid3 -- A 2-D grid distributed across the processors.  The 2-D
  grid is partitioned in both dimensions among the processors.
  The number of processors *must* be the square of an integer,
  e.g., 9 but not 8.  Either a 5-pt or 9=pt stencil can be
  specified.  BlockSolve context set not to look for cliques or
  inodes.  Symmetric problem.

  . mpirun -np P grid3.ARCH NXY NST

-----------------------------------------------------------------
grid4 -- Simple example (same as grid0) but this code uses lower level 
  BlockSolve functions to set up the parallel sparse matrix data
  structures (done in get_mat4.c).  Uses 3-d 7-point finite-difference 
  stencil.  BlockSolve context set not to look for cliques or inodes.
  Symmetric problem.

  . mpirun -np P grid4.ARCH PX PY PZ NX NY NZ

-----------------------------------------------------------------
grid5 -- Can be used to test a variety of BlockSolve features.
  The grid problem is based on the 7-pt stencil; however, one
  can specify a number of components at each grid points.  Each
  of these components will have an identical nonzero structure
  (inode) in the sparse matrix.  One can specify either a symmetric
  or nonsymmetric nonzero structure.  One can specify whether the
  BlockSolve is to look for inode/cliques or not.

 . mpirun -np P grid5.ARCH PX PY PZ NX NY NZ SYM NC IN PRE METHOD SCALE NUM_RHS

-----------------------------------------------------------------
grid6 -- A demonstration of setting up the BlockSolve communication
  structure and using the same structures to solve multiple linear
  systems with the same nonzero structure but different nonzero 
  values.  In this case, we compute a sequence of preconditioners
  by varying the diagonal shift applied to the matrix used to
  compute in the computation of the incomplete factor.

 . mpirun -np P grid6.ARCH PX PY PZ NX NY NZ SYM IN NC
-----------------------------------------------------------------
grid7 -- This example uses SYMMLQ to solve the symmetric shifted
  system (A-s*B)x = b, where s is a shift and A and B are symmetric.
  (Note that this system is indefinite for large enough shift s.)
  Systems of this kind form the core computation in a shift
  and invert strategy within a Lanzcos iteration.  In the usual
  case, A would be the assembled stiffness matrix and B would be
  the associated mass matrix.  For this example, B has the same
  nonzero structure of A and its values are the absolute values
  of the values of A.  Note that SYMMLQ requires that the preconditioner
  (the incomplete factorization of A) be positive definite!

 . mpirun -np P grid7.ARCH PX PY PZ NX NY NZ PRE IN NC BMAT SHIFT
-----------------------------------------------------------------
grid8 --  This example solves the same problem as that in grid7
  except here we explicitly form the indefinite matrix C=(A-s*B) and 
  solve the resulting linear system system, Cx = b, using GMRES.
  One can use either ILU or ICC as a preconditioner, although
  for large shifts the diagonal of C must be shifted to avoid
  breakdown in the computation of the incomplete Cholesky factor.

 . mpirun -np P grid8.ARCH PX PY PZ NX NY NZ PRE IN NC SHIFT
-----------------------------------------------------------------

A description of possible example program arguments:

  .  ARCH = Machine architecture, e.g., sun4, rs6000, IRIX, etc.
  .  P    = number of processors
  .  PX   = the number of processors in the x direction
  .  PY   = the number of processors in the y direction
  .  PZ   = the number of processors in the z direction
  .  NX   = number of points in the x direction on each processor
  .  NY   = number of points in the y direction on each processor
  .  NZ   = number of points in the z direction on each processor
  .  NXY  = number of points in the x and y directions on each processor
  .  NST  = number of points used in the stencil
  .  SYM  = 0, use symmetric data structure, = 1, use nonsymmetric
  .  NC   = number of components per grid point
  .  IN   = 0, do not use, = 1, use inode/clique stuff
  .  PRE  = 0, use ICC, = 1, use ILU
  .  METHOD = 0, use CG, use GMRES
  .  SCALE = 0, do not scale system, = 1, scale system
  .  NUM_RHS = number of RHSs to solve for simultaneously
  .  BMAT = 0 = use identity for shift, 1 = use positive of A
  .  SHIFT = shift to use in the shift and invert system

\end{verbatim}
}
