======================================================================
CURRENT ISSUES
======================================================================

  0. Orientation of cohesive cells is not consistent over fault
     surface. Unit tests now expose problem. [Matt is working on fixing this]

  1. Need check to make sure quadrature scheme is compatible with
  cells in mesh.

  2. Need better error trapping when using LineParser. State of
  ifstream is insufficient. Need state of istringstream buffer, but it
  is often !good() at eof(). Test of !good() and !eof()?

  3. Need to add in documentation that fault id corresponds to the
  material-id for cohesive cells.

======================================================================
KNOWN DEFICIENCIES
======================================================================

  Can't use block Jacobi preconditioner when Dirichlet BC overlap with
  fault BC's, because we end up with a DOF associated with a Lagrange
  multiplier that is "free". Not sure if this is okay, when the fault
  is at an angle to the boundary.

    Might be able to fix this problem by examining constraints
    relative to orientation and if orientation coincides with
    preexisting constraint, then constrain Lagrange multiplier DOF.

----------------------------------------------------------------------
List of missing features (EqSim/PyLith 0.8) and new features.

    Missing features
      EqSim
        Absorbing boundaries
        Dynamic fault interface conditions
        Fault constitutive models
        Output of surface/fault information
      PyLith 0.8
        Traction boundary conditions
        Viscoelastic material models (several)
        Output of stress/strain information

    New features
      EqSim
        Multiple cell types
        1-D and 2-D simulations
        Importing of meshes from CUBIT
	Exporting to VTK files
        Availability as open-source with documentation
      PyLith 0.8
        Dislocation-based fault implementation
        Importing of meshes from CUBIT and LaGriT
        User-friendly specification of boundary conditions and parameters

======================================================================
MAIN PRIORITIES (Brad)
======================================================================

Create 6x6x4 meshes for examples.
  CUBIT
    Add GUI instructions in journal files.
  LaGriT
    Figure out why fault orientations are not consistent for LaGriT mesh.

Create meshes for benchmarks

  strike-slip
    tet (LaGriT)
    hex (CUBIT)
  reverse
    tet (LaGriT)
    hex (CUBIT)

  FaultCohesiveKin
    unit test for multiple cohesive cells for hex8 mesh
      normal okay with rollover of fault dip?

1. Additional unit tests

  b. ElasticityExplicit and ElasticityImplicit
    i. multiple materials
    ii. partially constrained DOF

======================================================================
SECONDARY PRIORITIES
======================================================================

Want to take advantage of symmetry and block structure of Jacobian
matrix when possible.

Additional unit tests
  a. FaultCohesive
    i. Add checking of faultMesh [not currently used]

Add check to make sure every material supplied by user exists in the
mesh.
  
check test routines that create mesh to make sure they clear factory
(*mesh)->getFactory()->clear(); necessary?

1. Allow use of all elasticity constants (9 for 2-D, 36 for 3-D).
   a. Materials C++ code
   b. Integrator C++ code
   b. Material C++ unit tests

2. Implement absorbing boundary conditions

3. Reimplement SolutionIO.

   Follow implementation of MeshIO. SolutionIO implements extracting
   data from Sieve and calls virtual functions to write data.

   a. Reimplement SolutionIOVTK
   b. Implement SolutionIOHDF5

4. Implement MeshIOHDF5 & HDF5 (helper class)
   a. C++ objects
   b. unit tests at C++ level
   c. Python object (MeshIOHDF5)
   d. bindings
   e. unit tests at Python level

======================================================================
UNRESOLVED ISSUES
======================================================================

======================================================================
THINGS WE NEED SIEVE TO DO (Matt)
======================================================================

3. Distribute mesh/bc in scalable manner. 

  Inputs:
    * PETSc Mesh (with bc) (global on each processor)
    * number of processors
  Outputs:
    * PETSc Mesh on each processor (restricted to processor)

  [DONE]

4. Global refinement of mesh.

  Inputs:
    * PETSc Mesh (original)
    * refinement factor (limited to factor of 2?)
  Outputs:
    * PETSc Mesh (refined)

5. Construct mesh with higher order cells from mesh with lower order cells.

  Many mesh generators do not know how to construct higher order
  elements, so we will need a general utility for doing this.

  Inputs:
    * PETSc Mesh
    * some sort of map (Python object) defining how to construct
      higher order reference cell from lower order reference cell.
  Output:
    * PETSc Mesh

  Note: I think this would give us incredible flexibility in selecting
  the appropriate discretization for a problem. For example, I think
  it would allow us to use spectral elements.

6. Trial run with quadratic elements

7. Trial run with fully interpolated mesh

======================================================================
QUESTIONS FOR LEIF
======================================================================