• Data Flow and Design
• Creating a Simulated Target Map for Validation
• Preliminary Rigid-Body Registration
• Vector Quantization of the High-Resolution Structure with quanpdb
• Vector Quantization of the Low-Resolution Map with quanvol
• Flexible Fitting using Interpolation
  
• Visualization (Actin)
• Introduction to Skeletons
• Vector Quantization of the High-Resolution Structure
• Assigning Corresponding Vectors and Distance Constraints
• LBG Vector Quantization of the Low-Resolution Map
• Flexible, Skeleton-Based Docking with Interpolation
• Visualization (RNA Polymerase)
• Visualization (2D Projections)
  

Schematic diagram of flexing related routines. Major Situs components (blue) are classified by their functionality. The main work flow is indicated by brown arrows. The advanced modeling of distance constraints for the motion capture skeleton is shown in dark blue. Visualization (orange) for the rendering of the data requires a molecular graphics viewer (we use here the VMD graphics program, Chimera and Sculptor also support Situs format). 

Standard EM formats are supported and are converted to cubic lattices in Situs format. This is done with the map2map utility. Subsequently, the data is inspected and, if necessary, prepared for the vector quantization using a variety of visualization and analysis tools. Atomic coordinates in PDB format can be transformed to low-resolution maps, if necessary, and vice versa. During vector quantization of the high-resolution structure, distances can be learnt that are sent to the vector quantizer of the low-resolution structure to enable skeleton-based fitting. After the vector quantization, the high-resolution structure is flexibly docked by the qplasty tool to the low-resolution density by the corresponding codebook vectors.

First we create a simulated EM map from a known atomic structure for later validation. We lower the resolution of the target structure to 15 Å with the pdb2vol kernel convolution utility. Enter at the shell prompt:

The program projects the atomic structure to the lattice, computes the Gaussian kernel, and carries out the real-space convolution, writing the resulting volumetric map to the file 1_actin_target.situs.

Before we start fitting the original actin structure to the target structure, it is important to roughly align the atomic structure and the target map by rigid-body fitting.

Alternatively, an automated rigid-body fitting procedure can also be employed, e.g. using colores, collage, or matchpt as explained in other tutorials. It is a good idea to export a number of best-scoring rigid body fits, and to explore the alignment of these fits by eye, before selecting one for subsequent flexible fitting.

Now, we perform the vector quantization of the rigid fitted structure with the quanpdb utility.

and select mass-weighting (enter 2), ignore the B-factor cutoff (enter 1). Next, enter the number of codebook vectors: 4 (one for each of actin's subdomains). Watch the program compute a number of datasets for statistical averaging. The file 2_actin_orig_dock_target.qpdb now contains the four new codebook vectors, their rms variability, and the effective radius of their Voronoi cells, in PDB format. Finally, the user is asked whether nearest-neighbor connectivities should be learnt, or whether the Voronoi cells should be saved. Here we twice enter 1 (don't save the connectivities or Voronoi cells). See also run_tutorial.bash.

For the vector quantization of the volumetric dataset with the quanvol utility we use the previous quanpdb codebook vectors as start positions. After entering

the user is prompted to enter the density cutoff value. We enter 100 which is an appropriate surface value for this map. Subsequently, the program asks whether we wish to optimize the data. or analyse it only. We enter 1 for LBG optimization. Next, the program asks if the users wishes to use distance constraints, we enter 1 (No). Finally, the user is asked whether nearest-neighbor connectivities should be learnt. For now we enter 1 (No). The file 3_actin_target.qvol now contains the codebook vectors.

The flexible docking is approximated, based on the sparsely sampled displacements from the above quanvol and quanpdb codebook vectors, by interpolation with qplasty. This is sufficient for carbon alpha level accuracy. We use here the default parameters for qplasty. For more information on the algorithm see Rusu et al., 2008.

To start the flexing, enter at the shell prompt:

The flexed structure has been written to file 4_flexed_to_target.pdb.

The above example using four feature points is very elementary. To improve the stereochemical quality of the flexing, it is possible to constrain the distances between the features to reduce the effect of noise and experimental limitations on the codebook vector positions. This "skeleton" based approach, as described on the Vector Quantization page, is related to 3D motion capture technology used in the entertainment industry and in biomechanics. 

In principle, the resolution of flexible fitting of an atomic structure to a low-resolution map could be improved by increasing the number of codebook vectors. However, one cannot increase the level of detail indefinitely. If there are experimental limitations (e.g. noise, missing parts) not all vectors converge towards equivalent features in the two data sets at a higher level of detail. The solution to this problem is to freeze longitudinal degrees of freedom, and to impose distance constraints on the vectors. 

We consider here an interesting case, the flexible fitting of the closed RNA polymerase structure to a (simulated) open form at low resolution. Inspection of this file reveals that an isocontour value of 50 units is appropriate.

Important: Before we start the flexing, it is again mandatory to roughly align the atomic structure and the target map by rigid-body fitting. This can be done "by eye" or with one of our Situs tools, as described above. Here the structures are already sufficiently aligned, but it isn't always the case.

Now, we perform the vector quantization of the roughly aligned atomic structure with the quanpdb utility.

Here is the output of the entire quanpdb calculation:

We now have codebook vectors and the distance information for the atomic structure. To proceed with the flexible docking, two problems must be solved:

• We need to generate low-resolution vectors that are in correspondance with the atomic ones, i.e. here we must form 15 pairs of vectors that will be used as refinement parameters.

• Modeling of the skeleton. The distance connectivity file 5_rnap1.qpsf contains connectivity information about adjacent high-resolution vectors. This file is only a starting point. E.g. enforcing all of these constraints would make the structure rather rigid, so we must select a sparse set of non-redundant distances, i.e. a skeleton, that enables flexible fitting.
  

(click images to enlarge)

Then toggle the display of molecule 0_rnap1.pdb (in the VMD Molecule menu) so that only the blue connectivities remain. Don't rotate the molecule. Under the 'Mouse' menu select 'Add/Remove Bonds'. Remove any "red" bonds shown above by clicking on both end points. Then add the "green" bonds the same way. You should have a proper balance between freedom of motion and stability of the skeleton. This takes some experience, trial and error. The blue connectivities give a reasonable fit that can be improved later. The edited connectivity can then be saved into a PSF file from the VMD command console (assuming your connectivity molecule is still 'top'):

Now that the skeleton connectivities have been determined, the skeleton distances can be enforced with the local LBG optimization algorithm of the quanvol utility. After entering

(click image to enlarge)

Below is the output of the entire quanvol LBG calculation. LBG is an iterative "gradient descent" method that converges slowly, whereas TRN (without the second argument as start vectors) uses a prespecified number of calculations. The additional SHAKE statements describe the convergence of the distance constraints:

To start the qplasty optimization, enter at the shell prompt

The flexed structure will be written to the file 8_flexed_rnap.pdb.

Don't forget to hit "enter" after the last line!  The final result should look like this: 

The resulting projections (.dat files) can be inspected with a plotting program such as MATLAB. The final result should look like this: