Description of the Rosetta Design Wizard

The goal of the Rosetta Design Wizard is assist the user in using
their geometric intuition more fully in the design of proteins.
Computers are good at analyzing vast quantities of candidate designs
for quantifiable attributes.  Humans have remarkable spatial and
geometric intuition that can, for certain problems out preform the
most powerful computers.  Currently Rosetta is quite good, but design
of proteins can still benefit from the human eye.  The Rosetta Design
Wizard seeks to allow the user to visualize and manipulate the the
input and the output of Rosetta, thus contributing to the Rosetta
design cycle.

A PyMol wizard is a python module that inherits the from PyMol's
Wizard class.  The PyMol Wizard class exposes access to the wizard
panel on the on the left and a label in the upper right of the of the
secondary window, and exposes access to event handling for user
actions.  Additionally PyMol exposes most of the actions a user can
make in an API.

A user interacts with the Rosetta Design Wizard to specify a design
task then run Rosetta and graphically visualized the resulting design
and score.

All Rosetta dependent functionality is collected in a Rosetta_io
class. This allows for the continual development of Rosetta to not
affect the integrity of the Rosetta Design code base.  For each macro
molecular complex loaded into PyMol, the Rosetta Design Wizard
maintains a molComplex object as an internal representation of the
task associated with the object.  The user experiences the Rosetta
Design Wizard's design task through multiple external views: Residues
are rendered with distinct colors, user-space selections are
associated with PyMol objects, textual representations are displayed
in a text box in a separate window titled ResTable.  The textual
representations are: compact, where only the non-default residues are
displayed with range specification where appropriate; complete, where
every residue's task specification is displayed; and compatibility
modes for Rosetta++ and (mini)Rosetta resfile syntax.  Each textual
representation can be sorted by residue or by task specification. To
specify the task, the user may: make a PyMol selection then select
from the wizard panel menu a task specification; enable a PyMol
selection on the selection menu associated with all residues having a
particular task specification then add or remove residues by clicking
directly on the PyMol object rendering; issue a command at the PyMol
prompt to mark all residues contained in a PyMol selection string with
a particular residue specification; edit the ResTable directly; or the
use may load a resfile from a text file.

Once a task is specified, the user may select 'Run Rosetta' from the
wizard panel, which passes the internal representation of the task to
Rosetta.  Rosetta returns a pdb file into PyMol as an object.  The
combined score is printed in the label of the upper right corner of
the secondary window.




addendum:

The molComplex object stores information about the tasks for each
residue.  There is a list of all residue ids, where a residue id is a
tuple (chain, pdb residue number).  Then there is a lookup table for
each piece of information used to specify a task where each table is
indexed by residue id.  So there is a lookup table for the task ids
such as 'NATRO' or 'PIKAA'.  There is a separate lookup table for the
amino acids associated with the task, should the task need it
specified.  In the future there will be a lookup table for the number
of chi angles to be varied.  Next there is a table of molten
selections indexed by task id that points to a list of the residue ids
associated with each active task.  So, for example, if all residues
have the default task, then molten selections will only have one entry
pointing to the list of all the residue ids.


The rosetta_io class is a class that I have created for Rosetta Design
Wizard.  Currently it stores the path information for the rosetta
executable, database and log files, the keys for task specification, a
simple database to store the information associated with the extra
options, and functions that make the calls to Rosetta's python
bindings or build command strings.





