YUP is a molecular mechanics program offering such methods as Monte Carlo, Molecular Mechanics and Energy Minimization. The program provides a scripting interface and more importantly, exposes much of its internal data structures to the user. Therefore, the existing molecular mechanics methods can be used in many different ways and may even be used in any combination. YUP has no force field of its own. Instead it offers a collection of potential energy terms, from which the user can pick and choose whatever terms he needs for his model. In addition, the user has to provide the force field parameters and force field assembly routines to specify the connectivity of their particular molecular model. Some standard force field parameters and assembly routines will be provided.

[About Taro and Yammp]

YUP uses Python as a programming and scripting language. (Python is an interpreted object-oriented scripting language available for nearly all computer systems.) This provides the power of a complete programming language to the user. At the same time, we do not have to design, program and maintain our own control language, which would not be as complete or as expressive as Python anyway.

A programming language (whether it is C, FORTRAN or Python) has several simple data types such as integer and floating point scalars and more complicated data types such as arrays (collection of simpler data types) and character strings. YUP extends the Python language by adding new data types that are useful in molecular mechanics calculations. These are Atom Maps, Atom Vectors and numerous Energy types such as Bonds, Angles, Torsions, VanderWaalsX and so on. These extensions are written in the C Language and compiled as shared objects. Thus, the computationally intensive parts of a molecular mechanics calculation can be carried out efficiently. New Energy terms can be written entirely in Python and if the performance is poor, as is likely, rewritten in the C Language and compiled into shared objects.

Much of the program is in fact written in Python using our extension types. The initial task of a molecular mechanics calculation is to specify the connectivity and parameters for a molecular model. This is done by calling a force field assembler routine appropriate for the molecule class (whether it is an all-atom protein, an all-atom carbohydrate, or a reduced representation nucleic acid, etc). Force field assembler routines are written in Python. Atoms are represented and organized as linked Atom Map objects. The appropriate Energy objects are created and the interactions among the atoms are added to the Energy objects. The assembler then bundles the various Atom Maps, Atom Vectors and Energy objects into a single higher order Model object and returns it.

The user can visualize the Model object or apply a molecular mechanics method such as Monte Carlo or Molecular Dynamics to the object. Molecular mechanics methods are written in Python and they all require the evaluation of the energy and frequently also of the gradients. Each term of the potential energy function is evaluated by the appropriate Energy object and the objects operate on the coordinates and gradients which are represented as Atom Vectors. The molecular mechanics routines also operate on the coordinates and gradients. These calculations can be carried out efficiently as long as they use operations provided in the Atom Vector extension. Future molecular mechanics methods may well require operations that are not available in Atom Vectors. These can be implemented initially in Python and if that is not fast enough, then the Atom Vector object must be extended with the required operations.

Since YUP merely extends the Python language, YUP is highly programmable. This can lead to some interesting (though not necessarily correct) calculations. The connectivity of the molecular model can be modified on the fly and the values of the force field parameters can also be adjusted. [More]

The graphical user interface (GUI) will be written in Python using Tkinter which is glue module to the graphical toolkit Tk. This has the advantage that we can code the GUI once and it will run unchanged on any platform that supports Python and Tk. However, for the moment YUP is available only for Linux.

[Why Python and not C]

There are three groups of documentation:

• The end-user would run the standard molecular mechanics calculations interactively through the graphical user interface. They should consult the User Manual.
• More advanced users may want to take advantage of the programmability of YUP and write scripts to control complex models and calculations. Other users may want to create an entirely new class of molecular model; they would create a parameter library and write force field assembly routines for the new model. Users may also want to write programs to carry out new molecular mechanic methods. All these users should consult the Technical Documentation.
• The Programming Manual documents the program design and the source code. This would be of interest to someone who wishes to implement a new term of the potential energy function.