YUP Tutorial Module 4: Force Field Assembly

1. Introduction

This is a discussion of issues that might come up as you implement a new class of model in YUP. There are no exercises, but you should study the YUP modules that are highlighted.
Sections

1. Introduction
2. Setup
3. The Prepare Module
4. The FFA Module
5. The Calculate Module
6. The Analyze Module
7. Miscellaneous
8. Finally

Traditional force field assembly

Traditional molecular mechanics programs such as Amber, CHARMM and X-PLOR, assemble models from a library of monomer definitions. The monomers or residues are specified with a data description language that ranges from the barely recognizable in Amber to the X-PLOR language which is an almost complete programming language. Molecules are assumed to be linear polymers although simple cross-links can be made. This scheme has worked well for all-atom models.

However, the conventional scheme fails for reduced representation models. For instance:
  1. The reduced model of RNA (rrRNA) represents each nucleotide with a single extended atom (the phosphate group) and incorporates secondary structural features such as explicit helices. If we define a residue to contain a single extended atom, we will have a linear polymer but we then have to construct the secondary structures by making many complicated cross-links. Alternatively, we can define residues to encompass entire helices, but we will then have to put a non-linear polymer together. The data description languages in conventional programs are not up to the task of making the complicated linkages in either case.
  2. Closely bonded atom pairs are excluded from non-bond interactions: atom pairs that are separated by one, two or three bonds are not considered or are evaluated with attenuated force constants. A simple rule based on bonding proximity can be applied to conventional models because bond lengths and van der Waals radii do not vary greatly over the range of atom types in these models. A reduced DNA (rrDNA) model may have an exclusion distance equivalent to four to 15 bonds depending on the atom types of the excluded atoms (therefore making it necessary to examine each of these atoms). One rule (out of several) for the rrRNA model is to exclude atom pairs in which one atom is at the end of a helix and the other atom is at either end of all other helices (a criterion that cannot be simplified into a rule based on the number of intervening bonds). The calculations for either example cannot be expressed with the data description languages of conventional programs.

Force field assembly in Yammp 1

The problems with building reduced representation models were not solved for Yammp 1. Instead, the burden was passed to the originator of each model type who has to write a program to construct and save models to a descriptor file (equivalent to a parmtop file in AMBER). Any programming language can be used. Two problems with this approach are:
  1. The programmer has to deal with a lot of low level details like formatting data and writing them in the correct order and keeping track of atom numbers. Many of the details are the same for all model types.
  2. Programs are written in C, FORTRAN and Perl which is a factor in isolating them ("islands of code"). There is hardly any code sharing which means that there is a lot of duplicated effort. This leads to large programs that are correspondingly hard to maintain.
Modules

0. Preparations
1. Model Construction and Simulations
2. Programming with YUP Part 1
3. Programming with YUP Part 2
 4. Force field Assembly
5. Developing Potential Energy Terms

Force field assembly in YUP

Yammp 2 (YUP) extends Python, a standard programming language, with data types that are necessary for molecular modeling (AtomMap, AtomVector, Energy, etc). One set of extensions provide model construction commands ("add atom", "add bond", "exclude pair", "modify parameter", etc). To implement a new class of model:
  1. Create a Python package analogous to the traditional library of monomers. For instance, residue definitions might be implemented as functions. Unlike in Yammp 1, there is no need to deal with low-level details, and as in traditional modeling programs, models can be built at a higher level of abstraction using the construction commands.
  2. The programmer has a full (and powerful) programming language to code any unusual routines that might be needed. Being unconventional, reduced representation models are bound to have unusual needs.
There are additional advantages to using Python:
  1. Python serves as the scripting language for YUP.
  2. Users learn to use a standard programming language, a skill that can be used to solve other programming problems.
  3. Python is used to program much of YUP. As a high level language, Python is much easier to use than older languages like C.
  4. There is no need to maintain a home grown language.
 Resources

Yammp Under Python
The Harvey Laboratory

Python Home
Python Tutorial

(new browsers)
Prev | Top | Next