• PMV Release Notes
  • What is new
  1. The TraceCommands module implements a set of commands replacing the CATraceCommands and allowing the user to chose the control and torsion points used to define the trace. This way a trace can be computed for DNA molecule forexample.
  2. viperCommand allows the integration of ViPEr (Visual Programming Environment) into PMV
  3. The buildBondsByDistance now uses bhtree to search for close atoms. This is done in C which speeds up a little loading a molecule in PMV.
  4. An alignment widget is now available in the superimposeCommands. This widget allows you to align two molecules using their sequence by inserting gaps in certain places.
  5. The displayLines now allows the user to modify the line width and to display the bond order if the bond orders have been assigned using the edit commands assign bond order.
     
  6. InteractiveCommands have been renamed PickingCommands and the ICOM level is now called PCOM level for Picking COMmand level.
  7. Regression tests have been added in a lot of package. This is still a work in progress.
  8. A first draft of a Pmv tutorial has been added to the distribution (Pmv/doc/PMVHandsout.pdf). This tutorial is not yet complete but will be hopefully soon :). It presents basic and more advanced commands as well as fundamental concepts.
  9. Some rearrangement in the menus (such as Edit, Compute, File..) have been made in order to have a better user interface.
  10. The DejaVu's color model has been modified such that the ambient component of a material is set by default to a fraction of the diffuse components. This results in more saturated colors.
  11. Geometries can now be saved as VRML2 files
  • Known Issues:
  1. problems with bondorder and displayBondorder. Such as aromatic rings are not recognized properly and some double bonds instead of being parallel to the first bond cross over.
  2. problems with the log string of extrudeTraceCommand and extrudeSecondaryStructure. When saving a session where secondary structure or trace have been extruded the session file might crash when replayed.
  3. A new module amberCommands has been added to this distribution however it relies on a platform dependent package not yet included to the distribution. This module will allow the user to do some molecular dynamics calculation.
     
  4. The meadCommands are also added to the distribution but the PYMEAD is not
  5. The superimposeCommands is really not stable at all.
• ADT Release Notes


• What is new
1. New code which allows you to do reclustering through adt (6-18):
adt can cluster docked results from one or more docking logs details:


(1) you read in all the docking logfiles (*.dlg) you are interested in clustering. This can be done one by one or using the command which reads all of the dlg in in a directory. The key is to read them all in as one Docking.
The idea of a Docking is that all results which involve the same molecules and the same origin really constitute one Docking.

(2) you can cluster the docked results by choosing 'Analyze->Conformations->Make Clusterings' which opens a gui allowing you to enter a (space separated) list of tolerances (eg '0.5 2.0 4.0') and an optional filename.
A reclustering is done at each of the listed rms tolerances. (The smaller the tolerance, the more time the clustering takes.) If a filename is specified, adt writes the clustering results which can be read in later (the convention is evolving to name these '*.clust' files). You must save the corresponding conformations if you want to do this:


'Analyze->Conformations->Write Result File' which prompts you to select the ligand name and to specify a filename.

The written format is similar to the Entropia result format and the conformations are written in a sorted order (from lowest energy up).

(3) You can visualize the clustered conformations 'Analyze->Conformations->Show Clustering States' which first prompts you to select the ligand (if more than one from Docked results is present) and which clusterer (if more than one is present) and finally which RMS Tolerance. This sequence opens an interactive bar chart which lets the user pick a cluster to examine.
Picking a cluster opens the ligand's StatesPlayerWidget (spw) which lets you play the sequence of the current cluster (forward or backward), pause, stop (which resets to conformation 0), build the current conformation, and display the rms between two conformations. At first, the displayed rms uses the initial state 0) conformation as the reference but a button 'Make rms refcoords' lets you reset the reference to the current conformation. (thus you can see the rms within a cluster or between cluster members etc etc)...

[FYI: the ligand's spw also is used to display all the states and the energy histogram binning of states. It has a current sequenceList and a current idList which are changed via the Analyze->Conformations menu. For example, if after examining the clustering results for a while you want to look at all the states, you would use 'Analyze->Conformations->Show Conformations'. Then the sequence displayed by the ligand's spw would be the unordered list of conformations as they were read in from the docking log(s). Clicking any bar in a clustering histogram graph makes that cluster's states the current sequenceList. The same is true for an energy histogram graph.]

(4) you can now cluster on binding_energy or docking_energy: When you invoke 'Make Clusterings', you choose which one to use. When you invoke 'Show Clusterings', if the docking has more than one type of clustering available, you choose which clustering you want to see.
Please note if only 1 rms is available, you won't be asked which one to show...
The written clust files have an energy_used flag in the first line. Please note, if you write a clust file, you must write the corresponding result file (in which the conformations are sorted on the appropriate energy). adt will ask which cluster to write if there are more than available.

(5) There is now a command in adt which makes allows you to make clusterings on subsets of ligand molecule atoms: (using either type of energy). This command uses sets composed of subsets of the ligand which have been named and saved previously(via Select->Save Set). It checks that all atoms in a saved set belong to the docking's ligand molecule. It appears to calculate the rms for the subset correctly.



2. Improved detection of aromatic carbons in ring structures:

adt can now detect aromatic cycles fused to non-aromatic cycles Using PyBabel's RingFinder, adt checks each separate ring in a structure of fused rings to see if each ring is aromatic or not...

3. Simplifed ligand formatting (5-15):

new one-step process includes:

• assigning appropriate charges if needed
• merging non-polar hydrogens
• merging lone pairs
• detecting aromatic carbons in cycles

details:

1. adt determines whether or not the ligand molecule is a peptide by comparing the types of residues in the ligand with the standard 20 amino acids.
2. If the ligand lacks charges OR if each charge is equal to 0., the program automatically adds Kollman charges if it is a peptide or gasteiger if it is not.
3. If the ligand has any lone-pairs, they are always automatically merged.
4. If the ligand has any non-polar hydrogens, they are automatically merged unless the userpreference 'autotors_automergeNPHS' is set to 0. (It is 1 by default).
5. adt automatically converts names of planar-cyclic carbons to 'A..' unless the user sets the userpreference 'autotors_autoCtoA' to 0. (It is 1 by default).
6. If the ligand is a peptide, aromatic carbons are detected using a look-up dictionary unless the userpreference 'autotors_useProteinAromaticList' is set to 0. (It is 1 by default). If the user chooses to not use the ProteinAromaticList, carbons in planar cycles are detected by calculating the angles between normals to adjacent atoms in the cycle. (This is a slower process but might be important if for some reason the user knows the ligand has a very distorted cycle (for example))
7. adt changes the order of the atoms as little as possible so it no longer writes CONECT records.
8. Defining a Rigid Root has been modified so that the user can specify one root per chain.
->
9. adt never adds polar hydrogens. If you want to add polar hydrogens, you can use the command found via 'Edit'->'Hydrogens'->'Add'

4. More support for nucleic acids (8-22):

We have added solvation parameters for nucleic acids. We have also added Kollman charges for nucleic acids to Pmv/qkollua.py. The charges were taken from the same amber data file as the Kollman charges for amino acids (uni.in). Like the amino acid charges, they assume that polar hydrogens are present. If all atoms are present, the sum per residue is -1.0. I have tried to include naming variants but may have missed some.

5. Miscellaneous new Commands pertaining to formatting the ligand:

1. 'Define Rigid Root'-> 'Add a chain to root'
   'Remove a chain from root'
   allow you to specify chains in a ligand which will be completely rigid.
2. 'Rotatable Bonds' -> 'Set Number of Active Torsions' allows you to interactively set the number of rotatable bonds. It requires that a root be specified first. The user chooses whether to toggle torsions moving the most atoms or those moving the fewest atoms.
3. A new button added to 'Rotatable Bonds'->'Define Rotatable Bonds' allows you to inactivate all active bonds (reversibly).

6. !!!CAUTION ONE!!!

You should be aware that the recent update has changed the order in which bonds are built.
What that means for an adt user is that ligand files that were formatted previously will differ from ligand files formatted with the new release. That is, selecting the same root and allowing exactly the same torsions will produce a file with atoms in a different order than the order found in one produced with the old version.
This will NOT affect you unless you try to cluster results based on ligands affected in this way OR if you are using a particular refrms file which was constructed with the old ordering.



7. !!!CAUTION TWO!!!

A second potential problem is that the new algorithm for building bonds will construct disulfide bonds. This can cause a problem in formatting peptide ligands. It can be prevented as described at the end of 6.

• ViPEr Release Notes
• What is New:

1. StandardNodes moved to NetworkEditor (see Compatibility Information)
2. added toolbar buttons (icons) with balloon help
3. added support to load nodes in different libraries
4. nodes are now displayed sorted by node name
5. changed showLibrary so that the user can now type the node name in the node library window and the canvas will scroll to the corresponding node
6. added regression tests

• Bug Fixes

1. fixed some problems in adding nodes to library interactively

• Compatibility Information

1. multi-threaded execution on Silicon Graphics platforms can lead to core dump. Therefore, the user can choose to run single-threaded execution which works fine on SGI.
2. moving StandardNodes to NetworkEditor breaks all existing networks Solution: edit network save-file and change the line 'from ViPEr.StandardNodes import ...'
   to
   'from NetworkEditor.StandardNodes import ...'
   

• Known Issues
1. saving networks with macro nodes does not work currently. This will be fixed as soon as possible
2. Undo is disabled since it is currently broken
3. Hyperbolic Scaling was removed from the menu since this was never working properly
4. removed show special ports entry from menu nodes as it is broken



We are happy to announce the release of the version 1.1alpha of PMV, ADT and ViPEr. (April 17th 2002)

We are happy to annouce the first "official" release of the Python based Molecular Viewing environment PMV v1.0.

Pmv is a highly customizable, extensible and scriptable environment for the visualization and manipulation of molecules. PMV has been developed on top of a number of independent Python packages. These components, each deal with a specific aspect of PMV. They have been developed independently in order to ensure their re-usability outside the context of PMV.
Some people have had access to previous/"non official" versions of PMV. We feel that this release provides a large improvement both in terms of functionality and stability of the design and fundamental concepts.
PMV's executive summary: Pmv is a molecular visualization environment mainly written using the Python programming language. PMV can handle any number of molecules and provides standard representations including, sticks, sticksAndBalls, CPK as well as molecular surfaces and ribbon diagrams. Of course we like to think that PMV is not just yet another molecular visualization program and here are some reasons why:
1. - Commands, and sets of commands can be loaded dynamically. This avoids cluttering menus with commands that are seldomly used. It also lets a user pick what set of commands he want to have loaded by default.
2. - PMV exposes the python interpreter running PMV itself. This provides scripting capabilities both over the objects in PMV and PMV itself.
3. - Commands loaded into PMV can be invoked through a Graphical User Interface (GUI) or through the Python-shell.
4. When a command runs it generates a log string. This string is a command that can be issued in the Python-shell to reproduce the effect of the command. This log string is echoed into a text window for the user and saved into a session file which can be edited and re-played later on.
5. - Most commands can be undone
6. - A light weight command mechanism called Macros makes it possible for any Python function to be run as a command.
7. PMV has been designed specificaly to let users create new commands. It provides an incremental pathway to writting a command. First a macro can be written which when working properly can be turned into a full-fledged command.
8. - Commands operate on a "current selection" and PMV provides by default a wide variety of selection commands.
9. - Many commands can be used in interactive mode where the command get's bound to a picking even. So for instance it is possible to assign the displayCPK command to a Pick event and undisplayCPK to SHIFT-Pick events. The command will be carried out on picked objects.
10. - PMV runs under windows and posix/OpenGL capable machines.
11. - And maybe the most important point is that PMV is built on a set of re-usable components. For instance, the data structures used to represent the molecules in PMV is encapsulated in a separate Python package called MolKit. The 3D visualization capabilities are implement in a Python package called DejaVu. These packages have been developed independently in order to be fully re-usable in any other Python-based application.
WARNING: we still reserve the right to modify the API in some of the components.


I- What is new in PMV version 1.0 from a user point of view:
________________________________________________________

Interactive Commands (ICOMS):
Concept:

1. Any command for which the only required argument is a bunch of atoms, residues, chains or molecules can be bound to a picking event.
2. The ICOM level (Atom, Residue, Chain, Molecule) defines the level to which the selection gets expanded before the command is carried out.
3. A new command call setICOM can be used to assign interactive commands to picking events.
4. Apply this command to multiple subsets of atoms.

Undo:
Support for un-doing commands has been added to the Command base class and most of the basic commands have been made un-doable. PMV maintains a stack of undo commands. The undo command is bound to the CTRL-Z keyboard event. This will undo the last command on the stack.
The name of the next command that could be un-done appears under the File menu. "Undo xxxxx".
A user-preference called "Number Of Undo" enable to set the maximum depth of this stack.
A user preference let's you specify how many undo commands should be stored. Setting this value to -1 specifies unlimited undo, 0 let's you save the price of setting up the undo. The default value of this parameter is 100.
When a molecule is deleted, The delete commands warns you that ths action would reset the undo command stack. You can choose the continue, cancel ot simply keep the molecule in the viewer but hide it.

Customize:
It is now possible to customize the GUI of PMV:

• 'change fonts': modify the font used.
• 'show/hide gui sections': show/hive parts of the GUI.
• 'bind action to mouse button...':allow the user to bind different action to different button. This command is very useful when having only a 2 buttons mouse.
• bind commands to key combinations

New commands architecture:
The __call__ and guiCallback methods call now a doitWrapper method.

doitWrapper in turn:

1. calls the beforeDoit method
2. try to execute the doit method, if doit succeeds log the command automatically, add the undo commands to the undo stack.
3. calls the afterDoit method.

With this new architecture:

• Loging of commands is now fully automatic, although there is a hook for a command to change the way the log argument string is built.
• Commands implementing a negate keyword are automatically undoable
• Loging of DejaVu Geometry instance is now done correctly.
• Commands can take new keyword arguments:
  topCommand: (0 or default=1) a top command is a command that logs itself, toggles the busy leds when it starts, and tried to setup and Undo command
  busyIdle: (0/1) when 1, the command will turn the busy led red when it starts and green when it stops. This flag is set to 1 for topCommands. setupUndo: (0/1) when 1, the command will add the undo command to the undo command stack
  
• setupUndoBefore(), setupUndoAfter(): these methods are called with the same arguments than doit. They can call the addUndoCall method to build the command that will undo the action of the command that is executed currently. The undo command is only added to the stack if the command is successful.

Macros:
Macro commands are now executed like commands using a doitWrapper mechanism. A macro is basically any Python function. The framework calls it as a real command who's doit method is the macro function. Therefore macros log themselves, they turn the busy led on and off, and they get executed within a try except statment.

mgllab, February 2001, (mgltools@scripps.edu)