Arcade_setup (050801)
arcade_setup <option>
The arcade option allows the user to modify how one treats text that is entered in the 3D window. Until O version 9, if the user enters text in this widow, it is always parsed just as if the text were entered in the terminal window. If the arcade option is set to ON, the character string is parsed as a non-keyboard input event. The input events that can be generated in this way are DIAL_** (to create input from dials 01 to 20), GRAB_ROT_* (for grab rotations around X, Y, Z), and keyboard arrows ARROW_* (U, D, L, R)
The mapping between input character and action is controlled by an entry in the user’s DB. This is best illustrated by an example from the distribution

O > read arcade_keyboard.odb
O > arcade
New> Option [ON] :
New> Defined codes : 16
O > $ cat $ODAT/arcade_keyboard.odb
q GRAB_ROT_X -3.00000
w GRAB_ROT_X 3.00000
a GRAB_ROT_Y -3.00000
s GRAB_ROT_Y 3.00000
z GRAB_ROT_Z 3.00000
x GRAB_ROT_Z -3.00000
e DIAL_05 -.200000
r DIAL_05 .200000
d DIAL_06 .200000
f DIAL_06 -.200000
c DIAL_07 .200000
v DIAL_07 -.200000
1 DIAL_04 -1.00000
2 DIAL_04 1.00000
3 DIAL_08 -1.00000
4 DIAL_08 1.00000

Now when the user activates a grab command, such as grab_build, hitting the q & w keys cause a rotation about the X-axis (the horizontal), while a & s rotate about the vertical axis, and z & x rotate about the axis perpendicular to the screen. Similarly, neighboring keys have been allocated to act as virtual dials to control zoom (characters 1,2), slab (3,4), and translations (characters e,r,d,f,c,v).
The controlling ODB is a text datablock, with one line per mapping. The first item in the line must be a single printing character (not space), the second item is one of the logical events, the third item is a generated value.
Arcade mode is needed when using input devices such as the X-Arcade and Belkin N52 devices. Both devices can be reprogrammed to generate particular characters for particular actions. If they have a default setting that generates a non-printing character or tab, this setting at least must be re-programmed.
Note that the Griffin Technology PowerMate does not need to be used with the arcade option.

The PowerMate can be programmed to generate key codes that correspond to left and right arrows. In use, therefore, the user keeps open the ‘Fake-Dial’ pull-down, clicks on a desired entry and starts turning the dial of the PowerMate. Here is a screen shot of the required settings under OSX.
Belkin N42 and PowerMate.The PowerMate is rather small, and suitable for a crowded desk. The N52 is larger but has more input options. The N52 has a sophisticated applet that gives a great deal of control over the key actions.
The X-Arcade comes in two sizes; one with a pair of joysticks, the other with just one. Both have an array of buttons. The X-Arcade joysticks generate single events whatever their settings. Although rather large, both X-Arcades are very well built
No system is complete without iTunes.

Applets for the PowerMate and N52 are only available under OSX and Windows XP. Plugging a Powermate into my Sony VGN-S3VP laptop running Linux generates no useful key events. An interface to O has been made, however, by ....

The N52, out of the box, generates 11 useable events from the 14 available keys, as well as the 4 arrow movements from the thumb control. An informed Linux user can, no doubt, do better.

asa_display <object> <style>
This command creates something like an accessible surface. It uses all of the atoms in the specified atomic object in the calculation. These atoms would not normally include water molecules nor ligands. The style can be solid (default) or transparent. The O DB .cpk_radii must be present in the user's database (the O data directory comes with 2 sets of radii ODBs: one for atomic radii is called cpk_radii.o and the other for small radii is called radii.o USE the atomic radii values!).
O> asa_display
Util> Which atomic object? aall
Util> Solid surface or tranparent ?[S]
A FastMap slider is generated with the name ASA. The slider controlling the level is actually the probe radius added to the atomic radii. For a solvent accessible surface, the radii should be 1.2 A. The calculation of the surfaqce takes place in real time.
Here is an example of a surface after rendering with MOLRAY (Harris & Jones, 2001)

The picture shows the active site tunnel of the cellulase Cel6A. The original TIFF image has been reduced in size (x2 in each direction) and converted to JPG format with some loss of quality
angle_define <id three atoms>
The angle between 3 identified atoms is calculated and displayed. The atoms can be identified from a macro with the Term_id command.
arith_db <A> <B> <op> <C>
A=B op C Apply + - / * operators between datablocks B and C, storing results in A

Auto_2ry (120919)
auto_2ry <map> <skeleton object> <Y/[N]>

This command attempts to generate a framework for identifying secondary structures elements from an experimental electron density map in one pass. This implementation is 1-2 orders of magnitude faster than the first attempt at this (Kleywegt & Jones, 1997; Acta Cryst. D53 179-185) and is faster, more quantitative, and otherwise more successful then the Sprout commands that have been available in O since ~2003 (Jones, 2004; Acta Cryst. D60 2115-2125). The command produces a new electron density map (called 2ry in the FastMap system) which is usually much easier to interpret than the input map. This map is skeletonized at an arbitrary value of 2.5 units to produce a new Bones molecule also called 2ry. Since these are standard maps and molecules, the map can be re-skeletonized at a different level set by the user. The skeleton can, of course, be edited with the usual tools. As a byproduct of the calculation, helical and strand segments are built from 5-mers and 3-mers respectively and added to the TRACE molecule. This command can also be activated from a pop-up in the 'Auto build'-blind of the Skeleton-Mast-Menu system that is called 'Make 2ry framework'.
O > Auto_2ry
New> What map? [AV]:
New> Skeleton object: av_mc
New> Do you want to use the existing TRACE (Y/[N]):
New> TRACE is saved in the Undo system.
New> Backup made of trace_residue_trace
Nothing in TRACE

In this example, the existing TRACE is zapped before starting the calculation. In the first pass, long helices are built from an SST that corresponds to an alpha 5-mer. All potential a5-mers are calculated at each skeleton atom that roughly fit to the locally connected skeleton atoms. The 5-mer with the best geometric fit is then fitted to the electron density as a rigid body via a local rotation/translation search. This results in coordinates for the best fitting 5-mer at each skeleton atom in the object. These are then merged in order of best ED fit, using only the better scoring 5-mers. An explicit check is made for pairs of helices that can be combined by bridging small gaps of 0, 1 and 2 residues. In this example, only a single helix is built, and this contains 8 residues:
New> Build long helices ....
New> Top score 2.78
New> Low score 2.16
New> Average score 2.56
New> RMS score 0.21
New> Statistics on segments.
Segment 1 8 2.65408278 2.76166177

The actual score function is the average of the usual electron density sum function used in O, and a function that measures how broken the density is within the SST. The second step, essentially repeats the process with shorter SSTs of length 3 residues for a-helices and b-strands in turn. However, in this case, every SST that satisfies the geometric fit to the skeleton, undergoes a real-space density fit. These are ordered by the scoring function and merged into what has already been built. Helices and strands are not allowed to fuse. The best fitting 3-mers at each skeleton atom in the object are then used to create a calculated electron density on an orthogonal 0.7 Å grid using a Gaussian atomic profile with peak height 1 unit. The alpha-helices produced in the first pass are included in the map generation, overwriting anything built from the 3-mers. SInce every potential 3-mer fit to the skeleton is checked with a local real-space refinement, this second step takes a little longer, and a little 'patience is a virtue' text is printed,
New> Build strands, short helices and 2ry map ....
Patience, % 18.5873604
Patience, % 37.1747208
Patience, % 55.7620811
Patience, % 74.3494415
Patience, % 92.9368057
New> Top score 3.37
New> Low score 1.31
New> Average score 2.50
New> RMS score 0.35

The map built from these 3-mers now shows where the secondary structure, and indeed most of the protein main-chain, is located. It is named 2ry in the FastMap system, and is skeletonsed and used to make a molecule and an object called 2ry. The skeleton has been calculated with a base level of 2.5 units.
New> Statistics on 2RY map.
New> Min, max, RMS ...... 0.00000 17.48705 1.11989
New> Unable to copy symmetry operators from map
New> Skeleton done ....
New> Clean up the 2ry skeleton.
New> 2RY skeleton has been cleaned up.
Fm> Symmetry operators not stored

The skeleton is cleaned up to remove branch points. The latter can result from extended, well-defined side chains, and hydrogen bond connections between beta-strands. The whole process is fast, with the run-time depending on the number of skeleton atoms in the object and their degree of connectivity. but of order 5 seconds-10 minutes. The 2ry map has no crystallographic symmetry operators associated with it, but the 2ry skeleton has the symmetry and cell constants of the original skeleton molecule. Here is the result of skeletonizing the averaged P2 myelin map (distributed with O) at 2.0 RMS, and then generating the secondary structure framework with Auto_2ry (this took 53 seconds on my iMac)

The 2ry map can also be displayed since it is in the FastMap system. In the following images, it has been displayed at 4.5 units and since the 2ry skeleton atoms were generated at 2.5 units, some atoms do not appear to be in density. For example, density in the area connecting the 2 helices is weaker, and the skeleton is broken (lower left corner of the image).

The features corresponding to the very long side chains and fatty acid ligand that are present in the experimental map are cleaned up. There is a remnant of one Arg side chain that is not connected to the main-chain connections:

There are no branch points in the 2ry skeleton since they are removed as part of the clean-up operation.
Here are the TRACE segments that are generated:

Auto_build (120919)

Heavily debugged in the Ov14 (Buteo) release.

This command tries to build a protein, of known sequence, in an electron density map. It only works on proteins, and requires a map where peptide bumps are visible. The user needs to generate a skeleton around the molecule (or molecules) and to have already used SST_setup with ALPH5 and BETA5 fragments. The user can, of course, have already edited the skeleton, to improve the connectivity or atom assignments. The user can also have worked with the SST system in O to generate an initial TRACE molecule which could then be extended by Auto_build.

A complete set of ODB entries for the molecule getting built must be present in the user’s database. These entries are usually generated from the sequence with the Build_init or Sam_init command. The TRACE ODB entries must also be loaded into the user’s database.

The various steps in this command try to build and extend portions of the poly-alanine TRACE molecule. The final TRACE could be a large number of small fragments if unsuccessful or a smaller number of larger fragments. The end result of running this option is that the molecule is built starting from the longest fragments. If a smaller fragment is found to have a best fit to a portion of the sequence that has already been built, it does not get incorporated into the new structure. The user has the option of saving the complete poly-alanine TRACE molecule that is generated, or just the portions that are not merged into the new structure. A mosaic PDB file is generated at the end, which contains the parts of the molecule with known sequence, parts of the unused TRACE, and water molecules placed in unaccounted electron density.

The following is an automatic run on the structure Rv0130 (Johansson et al., 2006, visit the RAPID part of my site for more information on this structure). The output has been edited for brevity, and is the second cycle of auto-building (i.e. the first model was auto-built in the experimental map, refined with Refmac, and used for a new map calculation).

If the unknown structure has NCS and the operators are known, this can be used in the auto-building.

O > aut_b
New> What map? [F21]:
New> Skeleton molecule [S1]:
New> Number of atoms in skeleton  8510
New> New structure getting built [?]: m2
New> Number of residues in molecule   300
New> Do we have NCS symmetry (Y/[N]) ? [N]: y
New> O will try to locate and/or use NCS
New> Specify an O NCS operator name (if you have one): []: q
New> Specify an O NCS operator name (if you have one): []:
New> Number of NCS OPS  1
New> Number of chains    2
New> Each of  150 residues
New> Zap the TRACE ([Y]/N) ? [Y]:
New> Backup made of trace_residue_trace
New>  TRACE is zapped
New> Save the complete TRACE at the end ([Y]/N) ? [Y]: n
New> Just the unused segments of the TRACE will be saved at the end
level  0.4849288 
New>  Build at ~      48.5      13.7      41.3

In the above, I have specified that I will use the NCS symmetry when auto_building and that the operator for the dimer is stored in O as part of the lsq-system named q. This implies an ODB entry .lsq_rt_q exists. Note that the sequence of the dimer has been used to make the entries associated with the molecule M2. The TRACE has been zapped before auto-building. The electron density in the Fm-slider system has been set at an appropriate level, and is used as part of the rotamer calculations. I have also centred roughly on the middle of the molecule. This has some influence on how the fragments coalesce into the final asymmetric unit.

In Step 1, the first TRACE is made. The 5-mers are fitted into the density, best fitting ones first. Close 5-mers are extended and the ends of each remaining fragment are cropped.

New> ***************************Step 1: make a TRACE
New> ***This is done with short a5, b5 templates***
New> ***************************Add a5 and b5 templates
New> ***************************Optimize their fit
New> ***************************Filter by ED level
New> ***************************Filter by skeleton proximity
New> ***************************Join close a5s
New> ***************************Extend close a5s
New> ***************************Extend close b5s
New> ***************************Crop ends

In Step 2, the TRACE is extended by building from free ends of the fragments and by trying to connect close segments. The extension process forces good fit to the density and no bad clashes. The skeleton connectivity is used to decide how to extend segments. If there are branch points, the direction of the main-chain will be used. If the branches are all main-chain, each one gets checked in turn. If more than one path is possible after applying the rejection criteria, the extension stalls. As the segments get built, the skeleton gets cleaned up. Symmetry merging and compaction also takes place.

New> ***************************Step 2: extend TRACE
New> ***Use short connections, tough criteria***
New> ***************************Cleanup skeleton
New> ***************************Connect close segments
New> ***************************Symmetry merge

New> ***************************Compact segments
New> ***************************Filter overlap
New> ***************************Cleanup skeleton
New> ***************************Connect close segments
New> ***************************Cleanup skeleton
New> ***************************Extend at N-termini
New> ***************************Cleanup skeleton
New> ***************************Extend at C-termini

New> ***************************Compact segments
New> ***************************Filter overlap
New> ***************************Cleanup skeleton
New> ***************************Connect close segments
New> ***************************Cleanup skeleton
New> ***************************Extend at N-termini
New> ***************************Cleanup skeleton
New> ***************************Extend at C-termini
New> ***************************Compact segments

In Step 3, the TRACE is extended with less stringent rejection criteria.

New> ***************************Step 3: extend TRACE
New> ***Less tough criteria***
New> ***************************Cleanup skeleton
New> ***************************Connect close segments
New> ***************************Cleanup skeleton
New> ***************************Compact segments
New> ***************************Filter overlap
New> ***************************Cleanup skeleton
New> ***************************Symmetry merge
New> ***************************Filter overlap
New> ***************************Tidy-up segments
New> ***************************Assign NCS if present
New> ***************************Tidy-up segments
New> ***************************Save segments in TRACE

In Step 4, the TRACE will get decorated to find where the sequence matches the density.The longest segment is tested first, and each segment is tested in turn (generating a lot of output).If the optimal path of each segment has not been built yet, it is merged into the molecule, and side-chains are added.

New> ***************************Step 4: decorate TRACE
New> ***Each segment is checked, longest first***
New> ***************************YASSPA the TRACE

New> ***************************Decor_guess each segment
New> ***************************Merge TRACE into <mol>
New> ***************************Decor_guess each segment
New> ***************************Merge TRACE into <mol>

In Step 5, the results of the auto-building are produced. In this example, 234 of the 300 residues in M2 have been built, and no bits of TRACE are left over. 706 water molecule are needed to fill the unaccounted electron density in the asymmetric unit. Therefore, in this example the mosaic model auto.pdb contains just parts of the molecule and solvent.

New> ***************************Step 5: output the results
New> ***The results consist of 3 parts
New> ***The molecule getting built - in the ODB
New> ***Any TRACE segments not incorporated
New> ***A mosaic molecule saved as a PDB file
New> ***************************These residues are built:
New> ***************************Make a pool of water
New> ***************************Make mosaic PDB file
New> File auto.pdb generated.
New>  There were    234 built residues.
New>  There were      0 trace residues.
New>  There were    706 solvents.
New> Only unused segments of the TRACE are saved
New> ***************************Done

The output matrix of 1/0 shows which parts of M2 have been built. The user can now continue with a round of refinement of the mosaic molecule, or can use the Grab_build tools in O to complete the structure.

Here is the Ca of Rv0130 at this stage, looking down the 2-fold axis:

Here is a close up with the auto-built structure having yellow carbons and the final, fully refined coordinates with white carbons. Note how well they fit, except for a PHE side chain at bottom left:

h is is worth looking at in more detail:

The side-chain density is not continuous with the main-chain, and so the rotamer fitting did not work. However, there is density for the ring and so the mosaic molecule has 4 water molecules fitted into it.

Here is a piece of the structure where auto-building failed to generate a main-chain (something to do this summer):

The complete run of Auto_build took less than 20 minutes on my Apple Macbook Pro laptop.

Disclaimer: I have used this one only 2 structures (Rv0130 & Rv0216). These are the only structures my co-workers and I have worked on recently where carbonyl bumps were visible. Things worked very well on both. If things do not work for you, I’d be interested in knowing more.

Backup the user Database to another disk file. The name of the backup file is stored in the text datablock File_O_Backup.
baton <mol> <start residue> <direction> <manipulate Baton>
This command is used to build a Ca trace. It uses a measuring stick in the form of a di-peptide which can be moved around and can be pivoted about one end. The baton is actually a di-peptide from which the user must make an object of a single bond between the Ca atoms before using this command. When the command is activated, the di-peptide object appears at the current screen centre and consists of a single split coloured bond. The dial set can be used to translate the di-peptide object, and to pivot the object around the green atom. When Yes is activated, the coordinates of the red residue are taken and written into the molecule that is being contructed. The baton jumps to this new postion and the process can be repeated until the command is cleared with No. If an object called CA exists, it will be updated after each Yes command.
This command overcomes one of the problems associated with using the Bone_Ca _Id command where long or short inter-Ca separations can be produced. After ~5 pivots of the Baton, it may be necessary to use the translation dials again to get the di-peptide and the density back in register. The command can be used to build the whole structure, but is particularly useful for building difficult loopy bits that the other Trace commands have had problems with. Since the di-peptide is in fact a poly-alanine, the Slider_lego command can be used to check-out side chain sizes.
Before using the command, information for the di-peptide must be in the user’s database. A database file di.o is supplied and can be added by
O> read di.o
The user must then create the di-peptide object by
O> mol di ca ; end
The Baton command can then be used. For convenience in switching between translating the Baton and rotating it, it may be convenient to have Dial_next and Dial_previous commands on the User menu.
The position and orientation of the di-peptide can be changed by the Baton_mode command when Baton_build is active. When the No or Clear_flag commands are activated, this option no longer activates lego_auto_mc and lego_auto_sc to construct both main and side chains from the Ca trace that has been generated. These commands now need to be activated by the user.
baton_mode <option>
This command controls the orientation and position of the di-peptide when Baton_build is active. If the mode setting is alpha, the coordinates of the last 4 CA atoms are taken and a least squares comparison made with a regular a-helix. The di-peptide is then placed in the position of the 4th and 5th residues of the helix. If the mode is beta, the comparison is made with residues from a regular b-strand. If the mode is 2ry, a comparison is made with both a and b structures, and the one closest to the last 4 residues is used to position the di-peptide. In all three modes, if 4 residues have not been built, the mode defaults to a 'standard' orientation for the peptide. This can also be achieved by defining mode ? or any other non-recognized character string. The option may also be a skeleton molecule. The program uses the current connectivity of this molecule to place one end of the di-peptide on a line joining 2 bones atoms, if these atoms exist. If more than one pair of atoms exists, the program creates a list of suggestions. Multiple calls to this command cause the peptide to be placed at different positions within this list. The order of items in the list is determined by the bones status of the pair of skeleton atoms; pairs of class 1 atoms first, followed by pairs of non-class 2, followed by mixed 2/other etc, and by the direction of building.
This option, therefore, makes it easy to follow a skeleton or to build standard secondary structure elements, or anything in-between.
Ring a bell on the terminal. Used in macros to wake up the user.
bond_break <id 2 atoms>
Break all bonds between 2 identified atoms. The 2 atoms must not form a closed connection. The new connectivity must be saved by the user with Save_DB or Stop. Do not make a lot of changes without hitting Save_DB.
bond_make <id 2 atoms>
Add a new bond between 2 atoms. The new connectivity must be saved by the user with Save_DB or Stop
Bones Overview
This group of commands allows the user to display and manipulate a skeletonized electron density ("Bones atoms"). A basic set of commands are available via the Bones pull-down menu system to control the creation of simple skeleton objects. More commands are available to the user via the O line interpreter. The skeleton offers a suitable data structure that is usefull in the preliminary tracing of a new structure in an electron density map. Tactics for making the first trace are discussed elsewhere.
The O skeleton is like a regular molecule but with some extra data blocks. Each skeleton, therefore, has an associated molecule name. One special datablock is a set of status codes or levels that can be changed by the user with the Bone_redefine command. Another datablock defines the connectivity of the skeleton. The skeleton can be edited by making and breaking bonds between skeleton atoms (Bond_make, Bond_break commands).
The skeleton is produced from an electron density map by running the Skeleton command. Atoms recieve a level code of 2 or 3 if they are assigned to be side chain or main atoms, respectively, that get mapped to colours. This assignment is dependent on a number of parameters that the user must define when generating the skeleton. The skeletonization algorithm is my own, though like Greer's, it depends on the setting of a base level density value and a step size. The step value is usually the RMS value of the map, but the base can vary somewhat. Suitable values for the base may be betweeen 1.25-1.5 the RMS. If the value is too low, the skeleton will contain too many atoms and appear too connected. If the value is too high, there will be too few and look rather sparse. The assignment of side or main-chains depends on how connected the skeleton is. Short branch points get classified as side-chain, and longer ones as main-chain.
Once the skeleton is made, the user is free to use any system of code assignments that may be applicable to the problem. Normally, in a simple system , one would assign level 1 to be the correct main chain trace.
The colour associated with each level is defined in the datablock .bones_colour and can be any of the possible X-windows colours. If this ODB does not exist or is deleted, the following defaults are taken:

O > db_kill *bone*colour
Heap> Deleted .BONES_COLOUR
Heap> Making default Bones colours
Heap> An ODB is missing, it is updated with a default.

The skeleton can be used to create an envelope for use with O's averaging options, NCS-commands, by associating radii to skeleton atoms making up an object.
Skeletons can also be used with the Decorate & Trace commands in O but require a starting map of excellent quality, or some preliminary editing of the skeleton.
Bone_Ca_ID (101014)
bone_pick_Ca <mol> <start_residue> <direction> <id>i

This command works with Bone_repeat and Bone_skip to build a rough representation of a molecule by identifying skeleton atoms as C(entral)A(toms) atoms. The command now works with the residue ‘central atom’ (defined for each residue in the stereo_chem.odb dictionary) rather than protein CA atoms and can, therefore, be used to build proteins or nucleic acids. When activated you must specify where you wish to start in the sequence and if you wish to go forward or backward through the sequence.

O > bon_ca_id
Bone> What molecule [TRACE ]? p2
Bone> Start residue : a8
Bone> Backwards or Forwards (B/[F])?

You can then pick any atom and its coordinates get associated with the CA atom of the current residue shown in the prompt window. The identified atom is usually a skeleton atom but can in fact be any kind of atom. As the molecule is developed, a text object is generated to show what has been built (residue name & 1 letter code at each CA), and the <mol>_CA object gets updated as you work. It is not recommend for ab initio model building, but if the Decor system has a problem with building a poorly defined loop, say, this command could be used to produce a rough initial CA-model, before improving it with the Loop commands.
The command can be paused by setting a variable in the ODB to a non-zero value (via Db_Set_data .bones_integer 12 12 1), and re-activated by setting the same variable back to zero (via Db_Set_data .bones_integer 12 12 0).
The program halts when it recognizes a terminus of the molecule or with Clear_flag

bone_ca_zone <Id 2 atoms> <molecule> <start residue> <direction>
This command is intended to help in the construction of Ca traces. It would normally be used after using the bone_prune command to create something that looks like a trace. All atoms between the identified atoms are taken to be Ca atoms of the molecule being constructed. The identified atoms cannot be joined in a circular connection. It is only necessary to specify the start residue of the molecule under construction. The direction can be forwards or backwards in the chain. If an object CA has been constructed, it will be redrawn.

It is of historical interst only and has been superceded by the Decor commands

bone_branch <Id an atom>
An atom will be added to the object of the identified atom, connected to this atom but displaced (0.5, 0.5, 0.5) Å. It will be given the status code 2 (which usually specifies a side-chain) and will initially appear as a white bond (this will change to the users specified colour when the next object is created). This command is useful to indicate the desired position for a Ca atom when a branch point is lacking. It can also be used to extend a skeleton from a loose end (via repeated bond_branch and grab_atom commands).
Extract and draw the skeleton atoms on the screen using current parameters.
bone_excise <Id 2 atoms>
All bonds connecting the 2 identified atoms are broken, and replaced by a single direct bond. The atoms must be in the same skeleton molecule.
bone_mask <molecule> <codes> <radii>
This command is used to make a datablock called <molecule>_mask that contains coordinate and radii information for use in making a molecular mask. The option requests a set of skeleton codes and the associated radii. Only the specified coded skeleton atoms are used in making the mask datablock. Use the Bone_redefine command to set the desired codes. Computer programs are available to read the mask datablock and generate masks suitable for the A programs (Jones (1992)) or the newer RAVE programs (Kleywegt & Jones,never to be published).
bone_prune <Id 2 atoms>
This command attempts to create a tentative Ca trace. It modifies the connectivity of all atoms linking the 2 identified atoms, to more closely resemble a Ca trace. The two end-point atoms are kept, as are all atoms containing a branch. Connections from other/to other atoms are removed if the distance to the last tentative Ca atom is < 3.8Å. When an atom is found to be > 3.8Å from the last tentative Ca, it is shifted to make a more exact separation. Any remaining short separations between tentative Ca atoms are flagged in an object called warn.
bone_redefine <id 2 atoms> <new level>
Redefine the 'bone level' of a set of connected Bones atoms. Must not be in a circular connection. The objects are redrawn with the new colours. NOTE: you can put any text up on the screen menu, so if you are doing skeleton editing, you might want to put the characters 1 2 3 as separate menu items.
Backtrack one position in the sequence for Bone_Ca_ID.Depending on the choice of direction,you may be going forwards or backwards.
Bones_sc_set (050801)

bone_set_sc <skeleton molecule <number of links>

This command reassigns skeleton side-chain/main-chain classes, based on connection lengths from the closest branch point. The command is useful after a user has made lots of changes to the connectivity of a skeleton, without making any reassignments to the skeleton class codes.

O > bo_sc_set
New> Skeleton [CAT ]: av
New> Number of linked bonds from a branch [15]: 20

In the following P2 myelin example, some of the skeleton connections in the middle of the molecule are broke, and the command activated
The previously assigned main-chain atoms are reclassified as side-chain, and the skeleton object is updated with the new codes.

The user must specify Yes/No to accept the new assignments or not.

bone_setup <mol> <object> <radius> <level>
Setup necessary parameters. These define the skeleton molecule, the object name being created, the radius within which to display atoms, and what levels to use.
Move forward (or backward, depending on choice of direction) one residue in the sequence for Bone_Ca_ID
This command restores the connectivity prior to the last bond_break or bone_prune operation. Only one level of undo is maintained. Any objects that may exist will have to be remade by the user.
Build Commands (020329)

The Build commands aim to be completely general, and should work with any kind of residue provided there is a description in the stereochemical dictionary used by O.
Some of these commands are used during the initial stages of map interpretation. Others are intended for use during the rebuilding stage of crystallographic refinement. Those commands that use electron density maps (Build_ed_*) are integrated with the F(ast)M(ap) system used in O.
There are currently 12 Build commands available

O > build
Heap> BUILD is not a unique keyword.
Heap> Build_molecu is a possibility.
Heap> Build_residu is a possibility.
Heap> Build_rotame is a possibility.
Heap> Build_slider is a possibility.
Heap> Build_ed_rot is a possibility.
Heap> Build_ed_loo is a possibility.
Heap> Build_ed_to is a possibility.
Heap> Build_ed_res is a possibility.
Heap> Build_ed_gro is a possibility.
Heap> Build_nucleu is a possibility.
Heap> Build_init is a possibility.
Heap> Build_altern is a possibility.
Heap> BUILD is not a visible command.

Build_altern(ate) 050802

build_alt <ID an atom> or <mol res atom>

This command creates an alternative conformation for the specified residue.
In O, alternate conformations are created by generating molecules with these conformations. The name of the molecule containing alternates is derived from the parent molecule of single conformations. For example, if a molecule is called P2 in O, the molecule of alternates would be called P2B. Every residue in P2B would also exist as a residue in P2, but their conformations would usually differ. If a residue should have 3 alternate conformations of at least one residue, a third molecule P2C would exist. The molecule of third alternate conformations must only contain residues that exist in P2B, and P2.
The number of alternate molecules that exist are kept in an ODB called <mol>_alternates. If this DB does not exist, there are no alternates present for the molecule. O makes use of this ODB when the user wishes to create a PDB file, using PDB_write.
In the following example, there is a molecule in the O database called P2, with no alternate conformations. We wish to make alternate conformations for residues A8 and A10, initially.


there are no such entries to begin with.

O > buil_alt p2 a8 ca
New> P2 A8 CA BIT
New> Alternates not present
New> Occupancies are fixed at the PDB_write stage
New> P2 molecule name for zapping
Sam> Database compressed.
Sam> Using existing residue names.
Sam> There are 1 residues, 14 atoms.
Sam> This atom has the potential for an incorrect Z: CA
Sam> 14 atoms
Sam> 14 updated.
Mol> Database compressed.
Mol> Created connectivity Db for P2B

A new molecule has been created, P2B, with just a single residues in it, called A8 and it is a TRP. An object called BIT has been drawn for this residue, and the side-chain has the most likely rotamer conformation.
Now make an alternate conformation at residue A10.

O > buil_alt p2 a10 ca
New> P2 A10 CA BIT
New> Contains alternate locations
New> 2 molecules of alternates
New> Occupancies are fixed at the PDB_write stage
New> P2 molecule name for zapping
Mut> There are 1 mutations
Mut> This atom has the potential for an incorrect Z: CA
Mut> Molecular connectivity deleted.
Mut> Stereochemistry entries deleted
Mut> Delete_objec BIT ;
Sam> 8 atoms
Sam> 8 updated.
Mol> Database compressed.
Mol> Created connectivity Db for P2B

The output is different because there now exists a molecule called P2B. AFter this second alternate, the P2B molecule contains 2 residues.

O > dir p2b*
Heap> P2B_ATOM_XYZ R W 66
Heap> P2B_ATOM_B R W 22
Heap> P2B_ATOM_WT R W 22
Heap> P2B_ATOM_Z I W 22
Heap> P2B_ATOM_NAME C W 22
Heap> P2B_BOND_ANGLE I W 130

P2B is a normal O molecule, so the user can make objects, build new conformations etc. However, we now have a P2_ALTERNATES entry in the ODB:

O > wri p2_alternates ;;
P2_ALTERNATES I 1 (40(1x,i1))

When an alternate residue is created by O, all atoms in the residue are included. This allows the user to use all relevant O commands on this new residue.

When the user creates a PDB file, the alternates will be included.

O > pdb_wr
Util> PDB file name: m1.pdb
Util> What molecule [P2B ]: p2
Util> Residue range [all molecule]:
Util> Define cell constants [ 91.80 99.50 56.50 90.00 90.00 90.00]:
Util> Write out only selected atoms? [No]:
Util> SEGIDs not present
Util> Contains alternate locations
Util> 2 molecules of alternates
Util> Anis Us not present
Util> Use the B-factor? [Yes]:
Util> Use the occupancy? [Yes]:
Util> 1076 atoms written out

A warning is given that the molecule contains alternates and the new PDB file will contain two conformations for A8 and A10. If the user had specified P2B in the above, only the molecule of alternates would have been written out.

Alternate molecules should not be mutated by the user. If you really have to make mutations, making a mutate_replace in an alternate molecule will produce problems in PDB_write. Never mutate_delete a residue if it is the only one in the molecule. So if you make the first alternate conformation and then change your mind, use db_kill to get rid of the alternate molecule and then delete the relevant <mol>_alternates entry

Build_ED_Group (050802)

build_ed_group <ID atom in skeleton > <ID atom in group>

The ID’ed skeleton atom is taken as the pivot point for a full 3-D rotational search of a group of connected atoms. The group of connected atoms are a defined as all atoms that have a connection to the second ID’ed atom. The group is translated so that the ID’ed atoms are superimposed. The goodness of fit is to the map defined in the Density pull-down. The command requires a group of coonected atoms, a skeleton, and a FastMap electron density.

Any group of coonected atoms can be defined with this command. To illustrate the use of this command, I shall build an ADP molecule. The ADP is first built at the screen centre, roughly where we have some denisty. The Build_residue command requres that we have a stereochemical description of the ADP (i.e. it is described in the stereo_chem.odb, and refi_init/refi_gener have been used)

O > bui_res
Mnp> Molecule getting built [M6A]: adp
Mnp> Residue : [?]: a501
Mnp> Build direction ([F]/B/C): [F]: c
O > z ; end ! adenine ring separated from the ribose via Bond_break
O > bu_ed_gr ! skeleton and N9 atom ID'ed
New> Score: 0.873
New> Fm_rsr_group ! activated from the Pull-down, N9 ID'ed
Fm> Score: 1.135

The adenine ring is first separated from the ribose ring (using Bond_break) to form a group
Build_ed_group is then activated and a skeleton atom roughly where the N9 atom is to be placed, and the N9 in the group are identified. The adenine then moves as a rigid body to fit the density, and can be further optimized with the Fm_rsr_group command (also accessible from the Density/E.D.Fit pull-down)

The adenine ring can now be used as the nucleus to create the rest of the ADP, see Build_nucleus.

Build_ed_loo (020329)

Build_ed_loo <molecule name><from residue> <to residue> <skeleton molecule>

This generates coordinates for all residues after the 'from' residue and before the 'to' residue in the molecule that is being built. The algorithmuses the main-chain connectivity of the specified skeleton molecule to make theinitial placement of the 'central atom' of each residue (CA in proteins, P in nucleic acids). The inter-residue distance is then updated to take into account the spacing along the skeleton, a new placement is made, the main-chain database is used to build the loop, side-chains are then fitted to the densityin a rotamer conformation, the loop is regularized. The final goodness of fit will depend on the quality of the electron density and the quality of the skeleton.
The stereochemistry for the molecule being built must exist in the O database, i.e. the commands refi_init / refi_gener must have been used. The Lego_setup must correctly specfiy the location of the main-chain database. The electron densitymust have been loaded into the O F(ast)M(ap) system and is specified by the Density pull-down (Density option).

O > bu_ed_l
New> Map used is MIR
New> Molecule being built [P2 ]:
New> Residue from where to build: a22
New> Residue to which we want tobuild: a29
New> Skeleton [SKL ]:
New> Reading proteins db
New> The protein DB is now being loaded.


The main-chain database is loaded the first time it is needed.
This command is activated automaticall by the decor_guess command to fill in the loops between secondary structures once the user is happy with the sequence decoration.
Build_ed_res(idue) (050803)

build_ed_res <ID an atom>

This command builds the main- and side-chain of an amino-acid into the specified electron density. The identified atom could be in a skeleton, TRACE or any other molecule, and should correspond to the desired position of the CA atom. The main chain coordinates are determined by carrying out separate 3-D rotational searches of CA-CO-N-CA groups for the preceding and current peptide planes. The best fitting rotamer is then automatically added (using Build_ed_rot).
The residue that gets fitted is the current residue in the Sequence slider pull-down

We wish to build residue 230, a tyrosine. The map and skeleton clearly show good density for this residue. Note that the peptide bump is clearly defined.

The map has been specified in the Density pull-down. The residue to be built has been highlighted in the Sequence pull-down

Build_ed_res has been activated, and a skeleton atom close to the branch point has been identified
Fm_rsr_zone has been used to slightly improve the fit.

The coordinates defining the peptide plane must be in the user database (this can be done with ‘read pep.odb’ at some earlier stage), the residue to be built must be specified in the sequence slider pull-down (Build_mol, and then setting up the pull-down), the stereochemistry of the residue getting built must exist to allow rotamer calculations (refi_ini/refi_gen must have been run).

This command is only useful in good resolution maps that clearly show peptide bumps.

.Build_ed_rot (020329)

Build_ed_rot <ID zone > or <molstart end object>

This command carries out a rotamer-based optimization to an electron density for a zone of residues. The stereo-chemistry for the molecule being built must exist in the O database, i.e. the commands refi_init / refi_gener must have been used. The electron density must have been loaded into the O F(ast)M(ap) system and is specified by the Density pull-down (Density option).
The results are accepted with the Yes command or rejected with No. The fitting algorithm generates a mask into which the side-chain is optimized. The side-chain is allowed to pivot around the central atom of each residue. The mask is generated using the current level in the slider of the density, and makes use of the centre atom as a nucleus for mask formation, and the connected main-chain atoms (N and C for proteins) to limit the mask. The point of using a mask is to prevent the side-chain from moving into abutting density.
In the following example, the molecule is P2, the zone is A17 to A19 and the object to be refreshed is BIT.

O > bu_ed_rot p2 a17 a19 bit
New> P2 A17 A19 BIT
New> Map used is MIR

Build_ed_to (050806)

build_ed_to <molecule> <from residue> <direction [F]/B> <ID skeleton end point>

This command extends a molecule from the defined residue along a skeleton. The direction can be forward or backwards in the sequence. The skeleton must be continuous from the closest skeleton atom to the CA of the identified residue, to the ID'ed skeleton atom (the connectivity of the skeleton object is used not the connectivity of the skeleton molecule). If the pair of skeleton atoms are not connected or have too many connections, the command is terminated. This is a simple dropping off of CA atoms along the skeleton roughly at 3.8 Å. The main-chain is then built with the main-chain database.

It is a fast but inaccurate way of building the chain.

O > bui_ed_to
New> Map used is AV
New> Molecule being build [P2 ]: m17
New> Residue from where to build: a16
New> Direction of growth ([F],B):
New> Number of connections 59
New> Reading proteins db
New> The protein DB is now being loaded.
New> A binary file
New> There were 103 ODBs in the file.
New> Loading data for chain:HCAC
.... New> There were 7 ODBs in the file.
New> Rotamers not fitted

Build_init (101014)

build_init <new molecule> <protein/nucleic acid> <file name of text>

This command generates an empty O molecule from a text file containing the protein or nucleic acid sequence as a single-letter code. If a character in the text file does not correspond to a one letter code, the user is prompted for a 3 letter equivalent code. One-letter codes are taken from the residue keywords in the stereo_chem.odb dictionary and since both proteins and nucleic acids can use the same letter (e.g. A can be an alanine or an adenosine), O prompts the user when there is any confusion. If a 1-letter code does not exist in th dictionary, O will prompt for a 3-letter code.
The first residue in the molecule will be named 1, the next one 2 etc. Use Sam_rename if these names are not suitable. Coordinates are all set to (1500,1500,1500), temperature factors to 20, and occupancies to 1. Use Db_set_* commands to set them to some other value.

O > build_init
New> This WILL initialise certain datablocks.
New> Molecule name ([] to exit): p2m
New> <=100 characters per line, SVP.
New> File of sequence in 1-letter code: p2_1let_seq
New> Number of residues 131
New> There were 19 different residues
New> There were 4 problems in conversion
New> Specify 3 letter code for G : gly
New> Specify 3 letter code for T : thr
New> Specify 3 letter code for A : ala
New> Specify 3 letter code for C : cyh
Sam> Database compressed.
Sam> Making residue names.
Sam> There are 131 residues, 1038 atoms.
Sam> This atom has the potential for an incorrect Z: CA...
Sam> This atom has the potential for an incorrect Z: CA
O > $ cat p2_1let_seq
O > dir p2m*
Heap> P2M_ATOM_NAME C W 1038
Heap> P2M_ATOM_XYZ R W 3114
Heap> P2M_ATOM_B R W 1038
Heap> P2M_ATOM_WT R W 1038
Heap> P2M_ATOM_Z I W 1038
Heap> P2M_ATOM_SELECT I W 1038
Heap> P2M_RESIDUE_CG R W 524

Build_molecule (020709)

build_molecule <molecule name>

The user specifies which molecule will be used for the Build commands

O > build_mol
Mnp> Molecule getting built [A]:

Most Build commands require that the stereochemistry entries exist for this molecule. These entries are generated by refi_init & refi_gener commands.

Build_nucleus (050803)

build_nucleus <ID atom>

This command assumes that a part of a residue has been disconnected from the rest of the atoms in the residue, and now forms a group of connected atoms. Normally this so-called nucleus will have been fitted to the electron density, while the rest of the residue is separated, and positioned somewhere else in space. The Build_nucleus command uses the known stereo-chemistry of the residue to ‘grow back’ the disconnected atoms onto the nucleus group. The sterero-chemistry for the residue must have been created (refi_ini/refi_gener).
All objects associated with the molecule are deleted, a new stereochemistry calculation is made (@stereo_chem gets activated), and a new object (BIT) is generated of the residue. The user accepts the new coordinates and connectivity with Yes; No restores the original.

The adenine ring has been fitted to the density and seoparated from the rest of the ADP (see Build_ED_group above)
Build_nucelus has been activated and an atom in the ring ID'ed. The rest of the ADP has been generated from the stereochemistry.

In the case of an ADP, once the adenine nucleus has been fitted, the rest of the residue can be fitted to the density in a single round of extending the nucleus, followed by torsion RSR. This is illustrated in the following series of pictures

The adenine ring has been used as a nucleus to build the rest of the ADP using Build_nucleus

The the C2*-C3* bond in the ribose ring has then been broken.

Fm_rsr_tor has been used with the largest allowed number of connected bonds, from C8 in the adenine to PA, to give a roughly fitting ADP
Fm_rsr_zone has been used to optimize the fit

If the residue has too many connected torsion angles to use Fm_rsr_tor directly, it can be trimmed back to make a new, larger nucleus that can be fitted with Fm_rsr_tor. After fitting, this larger group can then be extended with Build_nucleus, and the process repeated, if necessary. Once a complete, roughly fitting residue has been built, it can be optimized to the density with Fm_rsr_zone.

build_residue <molecule name> <residue name> <option [F]BC>
This command generates atomic coordinates from the stereochemistry dictionary that is used by O's Refi system. The bond lengths, angles and torsion angles must be sufficient to allow O to actually build the residue. If the user chooes the F option, the resodues is built in the forward direction in the sequence, with B ackwards, with C at the current screen centre.
O > bu_res
Mnp> Molecule getting built [A]:
Mnp> Residue : [?]: a22
Mnp> Build direction ([F]/B/C):


build_rotamer <molecule name> <residue> <rotamer number>
This generates coordinates for a possible rotamer. The rotamer must be defined in the stereochemical dictionary that is used by O's Refi system
O> Buil_rot
Mnp> Molecule getting built [A]:
Mnp> Residue : [?]: a22
Mnp> Rotamer number: 2
Mnp> No rotamers found for ALA
In the above example, the residue is an alanaine and does not have a rotamer.
Build_slider (020329)

Build_slider <guess> <molecule to be built>
Build_slider <guesses> <gap size(s) between guesses><molecule to be built>
Build_slider ; <molecule to be built> <zone>

This commands allows one to see how the sequence matches a part ofthe framework. If no guess is specified, the user defines the zone over which to apply the operation. The sequence window specifies which part of the sequence is tobe associated with the guess framework. Moving through the sequence window,updates the side-chains drawn on the framework. If multiple guesses aredefined, one must also define initial estimates for the gap size between theframework templates. If one specifies 2 guesses, only one gap needs to bedefined, etc. As one changes the sequence, for multiple guesses, the gapsize(s) is (are) used to decide the sequence to be drawn. If specified, the gapcan be changed via dial input. Another dial input (Toggle) controls if theside-chains appear as the first rotamer, or if they are first real-spacefitted. Changes in the sequence window will result in an immediate response ifthe first rotamer option is active. The real-space fitting option, will take afew seconds to produce a response.
Here is an example using just one gap:

O > bui_slider
New> Map used is AVER
New> Slider guesses in DB : G1
New> Slider guesses in DB : G2
New> Slider guesses in DB : G3
New> Slider guesses in DB : G4
New> Slider guesses in DB : G5
New> Slider guesses in DB : G6
New> Slider guesses in DB : G7
New> Slider guesses in DB : G8
New> Slider guesses in DB : G9
New> Slider guesses in DB : G10
New> Slider guesses in DB : G11
New> Slider guesses in DB : G12
New> Slider guesses in DB : G13
New> Slider guesses in DB : G14
New> What guesses ? g14
New> Molecule being built [P2 ]:

One dial input ('Toggle') is now active, to toggle between the 2 side-chain fitting options. In the following figure, the correct sequence is drawn with the most common rotamer in the left image:

The first three residues ASP, GLU and TYR are not in the density to begin with, left image. After applying the alternative side-chain fitting option, the residues fit in the density as rotamers. The LYS residue has no clear density associated with it.

The displayed coordinates are accepted with YES, orrejected with NO.
ca_zone <res1 res2>
Add a Ca zone to the current open object. A blank input specifies all residues in the molecule. Entering just one residue name, specifies only that residue.

Centre_atom (050803)

centre_atom [<mol>] <res> [<atom>]

This command centres on the defined atom The macro @on_centre is activated. The distributed version of this macro causes contouring of the electron density defined in the Density pull-down with the current slider setting.

O > ce_atom
New> Define molecule [P2], residue, and atom [CA]: a98

Centre_build (050803)

centre_build [<mol>] <res> [<atom>]

This command centres on the defined atom, and then activates activating Grab_build for this residue. The macro @on_centre is activated. The distributed version of this macro causes contouring of the electron density defined in the Density pull-down with the current slider setting. New Centre_build commands can be activated when Grab_build is active

O > ce_buil
New> Define molecule [P2], residue, and atom [CA]: a98
O > ce_bui
New> Define molecule [P2], residue, and atom [CA]: p2 a8

The user can, however, choose to keep using Grab_build .

Centre_ID (020801)
The next identified atom becomes the screen centre. Atoms can be identified by picking at the screen or by using the Terminal_id command. The macro @on_centre is activated. The distributed version of this macro causes contouring of the electron density defined in the Density pull-down with the current slider setting.
centre_next <property> <operator> <value>
Move from the currently centred atom to the next atom or residue along the sequence that fullfill the criteria of the logical expression. A sister command, Centre_prev, moves in the backward direction. Examples:
centre_next atom_name = ca
sets the current active centre at next C-alpha position.
centre_next residue_type = lys
centres on next lysine residue.
centre_next residue_rsfit < 0.8
Centres on next residue with a rsfit correlation coefficient worse than 0.8
The macro @on_centre is activated. The distributed version of this macro causes contouring of the electron density defined in the Density pull-down with the current slider setting.
centre_prev <property> <operator> <value>
Same as Centre_next, but moves backwards in the sequence. The macro @on_centre is activated. The distributed version of this macro causes contouring of the electron density defined in the Density pull-down with the current slider setting.
centre_xyz <x y z>
Define the '.active_centre' by entering a coordinate value at the terminal. The macro @on_centre is activated. The distributed version of this macro causes contouring of the electron density defined in the Density pull-down with the current slider setting.
centre_zone <id two atoms> or <mol res1 res2>
The picture centre is redefined as the centre of gravity of the defined zone. The macro @on_centre is activated. The distributed version of this macro causes contouring of the electron density defined in the Density pull-down with the current slider setting.
If the user wishes to centre on the centre of gravity of the molecule, just define the molecule without the zone. For example, typing 'cen_zone m1' will centre on the centre of gravity of molecule M1.
Clear all flags. This command cancels all active commands. If atomic coordinates are being changed, e.g. by Lego_side_chain, the command issues a No.
Remove ID text from all molecular objects.
Connect_code (050803)

connect_code <code>

The atomic connectivity used by O is calculated for skeleton molecules, but generated from connectivity definitions for atomic models. These definitions are kept with the stereochemical information for each residue in the stereo_chem.odb file. The distribution file contains connectivity codes ALL, MC, SC for the usual residue types. For a valine residue, for example, the connectivity records are as follows:

connect_sc - CA +
connect_mc - N CA C +
connect_mc C O

To make atomic objects showing all atoms, therefore, one would use the ALL code as follows:

O > co_code
Mol> Connectivity code: [sc]: all
Mol> Maximum linkage distance = 2.00
Mol> There were 49 residues.
Mol> 380 atoms.

When the next atomic object is created, the current database entry <mol>_connectivity will be deleted and a new molecular connectivity will be generated. Residues that lack connectivity records will have intra-residue bonds drawn according to a distance criterion, and no connections to adjacent residues in the sequence.
The connectivity associated with the ALL code will show bonds between all atoms in the residue and connections to the previous and next residue. The MC code, shows just the main-chain atoms, while SC shows the side-chain atoms and links between the CA atoms.
The differences are shown in the following pictures:

Connectivity code ALL
Connectivity code SC
Connectivity code MC

Continue_no (050803)


Many commands in O are controlled by the Yes/No flags. Some O commands assume that the user will activate other commands when active. For example, Fm_water_peak and Trace_grow are normally used with other commands active that might be dependent on the Yes/No flags. Such commands, therefore, are controlled by the Continue_yes/Continue_no flags.

Continue_yes (050803)


Many commands in O are controlled by the Yes/No flags. Some O commands assume that the user will activate other commands when active. For example, Fm_water_peak and Trace_grow are normally used with other commands active that might be dependent on the Yes/No flags. Such commands, therefore, are controlled by the Continue_yes/Continue_no flags.

copy_db <A> <B>

A = B. Copy B on to A. Can be used to make a backup of coordinates, for example, prior to a drastic rebuilding session. The command Backup_DB can also be used for this purpose, but this will save the entire database to a file, Copy_Db only copies a single data block within the database.

cover_sphere <res atom> <radius>
Add the residues in contact with an atom or to whole residue. Define either an explicit atom (i.e. a residue and an atom) to choose atoms around an atom, or define just a residue to define atoms covering a residue. If one atom from a residue is within the cover radius, all atoms in that residue get chosen.

CPK_object <object> <mode> <cleanup>

Make a CPK object out of a molecular object. Specify molecular object name, and the kind of balls (fast or slow), and whether to clean-up an intermediate datablock.
On some machines, the fast option generates a rough approximation to a sphere, while the slow option is an excellent sphere.
This option uses datablock .cpk_radii to associate ball radii with atom types. Two example files are provided in odat/cpk_radii.o and odat/radii.o, for large and small balls. The option generates a set of drawing instructions in .object_cpk_<object> that can be written out and edited on a standard text editor if necessary. This datablock gets deleted if the default cleanup option is taken.