
Priority: Top (T), High (H), Intermediate (I), Low (L). 


EASY

0. T. Improve the README that describes how to comapre phipams with GEM's output.  

1. T -- Add shell detection to the find_or_prompt_msms.sh script to appropriately configure gem to run MSMS

2. Make progress dialogs auto close on completion.

3. Write Motif library detection into configuration through autoconf

4. Find a true-type font implementation and add it to GEM for better
    font rendering. Perhaps, the easiest is just to make sure that the color bar scales, without the labels. 

5. Scale the colorMap with image size when images are dumped
         -- text and bar itself.

6. Somehow make it simple to correlate the toolbar with the window it is 
      connected to for multiple instances of GEM running simultaneously.

7. L. Parallelize electrostatics computations for SMPs and supercomputers.


8. port over the off-screen rendering to Mac OS X

9. H. write a detailed manual with pictures explaining how to use all of GEM's features.

10. I. shrink the open file dialog in the y direction so it will fit on small screens.

11. Support dumping a view matrix and inputting from command line when dumping an image
         -- see raster3d (but make it better)

12. Add byte swap detection for MEAD grids
         -- read in text center
         -- read in binary center at the end of the file
         -- compare text center to binary center
         -- if not within .01
            -- swap binary center
            -- if not within .01
                  not really a MEAD grid, pitch it
            -- else (within .01)
                  byte swap the grid

13. Do something to check to see if an atom is completely enclosed by other
    atoms before dumping them to xyzr for MSMS to avoid MSMS bailing out on
    this special case.

14. Add a grasp like coloring scheme option.

NOT TOO HARD, BUT NOT A PIE EITHER

0. T. Adopt internal structures for future implementation of the 
	multipole method. Ramu will have to be involved so that he can continue 	the development of this part  when John's gone. 

        a.) Construct a tree representation of the molecule.
           -  An initial implementation might use:
                     subunit -> chain -> residue -> atom
              However, this implementation would not guaranteed to
                 improve performance in the asymptotic case as required
                 by Fast Multipole Methods (FMM).
           -  A proper implementation should correctly subdivide the regions
                 based on distance which implies the need to construct
                 supersets.
           -  Either way, the implementation will require the construction
                 of an adjacency list specifying which residues, etc. are
                 adjacent by some rule (usually distance).  If chains are
                 used for instance, only chains that are separated by 1
                 chain worth of distance can be approximated as a single
                 point.
           -  Typically these trees are then used later to construct the
                 approximation.

	     b.) Just 3 levels of accuracy in the multipole expansion:
           - total charge (total charge of the unit)
           - dipole moment (two equal charges, q+ and q- within the struct)
           - quadrupole moment. (four charges, 2 q+ and 2 q- within the struc)
           - http://hyperphysics.phy-astr.gsu.edu/hbase/electric/elequad.html

       c.) Once these approximations are defined, and the tree is constructed
            (e.g. a residue is a child of a chain, which is a child of...)
            tree needs to specify neighbors and children.
           - For any point (p):
                Figure out where it lies in the tree by faking insertion
                     compute local and neighboring contributions exactly
                     by only approximating up the tree a certain amount 
                Use approximations that are stored in the tree for everything
                     outside the locale:
                     
       d.) The accuracy will be tested by comparisons.
            cut-off >> system size GEM (current GEM). 
            Let's limit the calculation to the surface. 
	         compute errors as RMS (GEM(full) - GEM(cut-off)) 
            as well as STD and MAX/MIN. 
            It would be useful to be able to output GEM surface potential 
            and then read it in and compare 


1. Break apart open-file operation into open file and view surface 
        open file to simply start with spacefill atom representation
        view surface to have options such as:
                           no coloring
                           electrostatic potential
                           residue name
                           atom name
                           induced charge
                           atom charge

2. Connect save grid operation into the status dialog to provide feedback
            regarding how much time is left to run.

3. Restructure surface to support fast determination of distance to the surface
            for an arbitrary point in space.

4. Modify the gvert format to be MSMS + potential + ... to allow reading in prior
       computations without recalculating or using a phimap.

5. Support directly user-specified points in space as sample points, display and/or
       output potential there directly. (command line and gui)

6. Support user-specified light properties, material properties, and shaders.

7. Optimize rendering further

8. add Connolly dot surface to surface display options (lit or unlit)

9. add support for reading in, displaying, writing, and interconverting APBS grids

HARD

1. Develop an internal surfacing algorithm by reverse engineering MSMS.

2. Optimize GEM grid outputs:
        Distance to the surface using either:
           a.)
               Rasterization algorithm for nearest point to the surface
                     Voronoi diagram
                     near-literal rasterization for inside/outside test
                     contact john if this doesn't make sense
           b.)
               Levelset methods for signed-distance function

        Fast Multipole method for sums (it is an approximation after all)

3. Investigate the effects of allowing alpha to not be a constant
        relate it to r0/r or some other available terms and approximate it
               on a point by point basis.
        
4. Support drawing potential fields as fogs or clouds around the molecule for
        phimaps, can this be easily done with the analytical formulation?
            -- at least support display for phimaps


5. Off-screen rendering without connecting to X display server at all even for pbuffers


COMPLETE OVERHAUL

1. Build in support for viewing and manipulating N molecules concurrently.

2. Build in support for M selected subsets of a given molecule by:
                  atom name
                  atom number
                  residue name
                  residue number
                  charge range

3. Support viewing options and reasonable management of N*M different viewing
        options for the N molecules.

4. Port the front-end code to TCL/Tk, leaving the OpenGL stuff mostly alone.
         -- push cross-platform and plugin capability
         -- hang a hat on something that will last longer than Motif

5. Restructure libraries to remove interdependencies
         -- structure data more rigorously
         -- remove the proliferation of functions that take vis as an argument
