Neighbour_at(om)
Neighbour_at <id an atom> or <mol res atom>
 
Show neighboring atoms to identified atom. The calculation is repeated so that the contacts of moving atoms get flagged. The distance cut-off is kept in the database in .trig_real . Contacts within the same residue are not calculated

How to work with the NCS Commands (080218)

These commands are used to improve electron densities by non-crystallographic averaging as follows:


To carry out averaging, one requires an electron density that has been calculated on a suitably fine grid, a set of operators that move the reference molecule to each NCS-related molecule in turn, and a mask defining the NCS-reference molecule. The grid spacing of the electron density must be at least a third of the resolution, or finer. The mask must be on the same grid as the electron density. The mask can be made outside O, using Gerard Kleywget’s programs, for example. There are also 2 commands that can be used from within O to make masks. One command, NCS_mask_mak , takes a density in the FastMap system, smears it, and constricts within a box (see below). The other command, NCS_mask_sph ,  takes an atomic objects, and then creates a mask by placing spheres of a particular radius at each atom in the object. The object can be from a molecule or a skeleton. NCS_mask_sph is the more useful command. The masks generated from either command will need editing with the NCS_mask_lay and or NCS_mask_edi commands.

When we have a structure with strict NCS, the user may have a PDB file containing just one chain and a set of NCS-operators or a series of identical but separate chains. The crystallographic refinement program REFMAC5 is unable to handle strict NCS and users are forced to refine with tight NCS-restraints. In this situation the separate chains will be similar but not identical. A series of separate chains can be converted into a single chain plus operators by first using the Lsq_chain_op command to generate the operators, then PDB_write to create the file (the user needs to specify that O wishes to use the chain operator, see the desciptions of the commands for details). This file will contain a single chain plus a set of MTRIX records. Once read back into O (PDB_read), the NCS-related chains can be viewed or generated with the NCS_instance or NCS_sphere commands.

If the density is calculated from atomic models (i.e. as a result of molecular replacement), it is vital that there is no mistake in the calculation of the operators. In O v12, I introduced the concept of the chain operator where the group of ODB entries associated with a single chain are grouped together in one ODB entry. This is described in more detail in the Lsq_chain_op command. The user is still able to work with separate operators that relate the reference molecule to the other NCS-realted molecules, however. If the molecule contains 4 chains, A, B, C and D , and if chain A is the reference molecule then the four operators are:

• the unit operator that moves molecule A onto itself

• the operator that moves A to B, determined using lsq_explicit where the non-moving molecule is B, and the rotated molecule is A

• the operator that moves A to C, determined using lsq_explicit where the non-moving molecule is C, and the rotated molecule is A

• the operator that moves A to D, determined using lsq_explicit where the non-moving molecule is D, and the rotated molecule is A

If the map to be averaged is based on experimental phases, the operators have to be determined by other means. If a set of heavy atom coordinates are available where equivalent heavy atoms have been identified in each chain, then the same LSQ commands can be used in O to get the first estimate of the operators. However, there have to be at least 3 matching pairs of heavy atoms for the calculation of each NCS-operator.

If there are not sufficient heavy atoms, the operators can be determined directly in O. First make a skeleton of the whole asymmetric unit or cell. In the following, I shall use the experimental map from P2 myelin protein ( ano1.map ).

 O > skel

 Qm> What map? [MIR]:

 Qm> All map [Y]/N?

 Qm> Base level [1.25]: 1.5

 Qm> Skeleton name [SKL]: mir

Make an object of the whole thing:

O > bon_set

 Bone> Skeleton molecule name [MIR   ]:

 Bone> Object name [ALL   ]:

 Bone> Sphere radius [ 1000.0 ]:

 Bone> What bone levels? [ 3 ]:

 O > bo_draw

Now evaluate where you see one molecule that will be used as our reference molecule, and make a main-chain object centred on it with a radius that covers it. I have chosen skeleton 5553 and a radius of 20 Å.

ncs_mir_a.tiff

I have coloured the object magenta to make it clearer when superimposing it. This reference molecule will be referred to as the A molecule.

Now centre in the ALL object where you think the centre of the first NCS-related molecule, the B molecule

ncs_mir_b.tiff

I have centred on 7438. Now I start this command to get the operator that moves A to B:

O > ncs_op

 New> What map? [MIR]:

 New> Object name [QQ]: mcmir

 New> Step search width [3]:

 New> Number of atoms in object   507

 New>  Belongs to molecule MIR

 New> Pivot coordinates in object [ 51.33 65.71 33.17]:

 New> This takes some time ...

 New>  Starting     1 of     3

 New>  Starting     2 of     3

 New>  Starting     3 of     3

 New>  Best score:      1.924

A translational grid search is carried out around this identified atom, and the atoms in the skeleton object are pivoted in a full 3-D search. The default search width is +/3 steps, each 1 Å wide around the ID’d atom. The score is the average density at each point in the rotated skeleton for the best fitting translation/orientation. The value here will depend on the map and on how well the command has been able to find th e correct operator. The standard deviation in the MIR map was listed when it was read in:

 Fm> Min, max, sigma ......   0.00000   8.35000   0.95545

The command has generated a new entry in the O DB with the operator to take you from the A to the B molecule:

 > dir .lsq_*rt*

 Heap>  .LSQ_RT_IDENT             R W        12

 Heap>  .LSQ_RT_BEST              R W        12

The first operator is the identity operation, taking A to itself. Now we can see how good the A molecule fits on the B molecule using the Lsq_obj command. This command takes a rotation-translation operator and applies it to an atomic object. The coordinates in the object are not affected by this command.

 > lsq

 Heap>  LSQ          is not a unique keyword.

 Heap>  Lsq_explicit is a possibility.

 Heap>  Lsq_improve  is a possibility.

 Heap>  Lsq_object   is a possibility.

 Heap>  Lsq_molecule is a possibility.

 Heap>  Lsq_Paired_a is a possibility.

 Heap>  LSQ          is not a visible command.

 > lsq_obj

 Lsq > Apply a transformation to an existing object.

 Lsq > There are these transformations in the database

 Lsq > IDENT            BEST

 Lsq > Which alignment [<CR>=restore a transformed object] ? BEST

 Lsq > There is an object called MCMIR

 Lsq > There is an object called ALL

 Lsq > Which object ? mcmir

Here is how it looks

ncs_mir_b_a.tiff

You can see that I did not judge the centres very well, but it worked. This is a first approximation to the A->B operator and will be improved later. If we are happy with the result, we want to give it a name that makes some sense

cop .LSQ_RT_b .LSQ_RT_BEST

Now lets find the operator to move A onto the C molecule. This is harder because the density for this molecule is not so well defined.

ncs_mir_c.tiff

O > ncs_op

 New> What map? [MIR]:

 New> Object name [MCMIR]:

 New> Step search width [3]:

 New> Number of atoms in object   507

 New>  Belongs to molecule MIR

 New> Pivot coordinates in object [ 51.33 65.71 33.17]:

 New> This takes some time ...

 New>  Starting     1 of     3

 New>  Starting     2 of     3

 New>  Starting     3 of     3

 New>  Best score:      0.910

 O > cop .LSQ_RT_c .LSQ_RT_BEST

 O > lsq_obj c mcmir    

The result is not impressive, so we try again with a bigger search grid

 O > ncs_op

 New> What map? [MIR]:

 New> Object name [MCMIR]:

 New> Step search width [3]: 5

 New> Number of atoms in object   507

 New>  Belongs to molecule MIR

 New> Pivot coordinates in object [ 51.33 65.71 33.17]:

 New> This takes some time ...

 New>  Starting     1 of     5

 New>  Starting     2 of     5

 New>  Starting     3 of     5

 New>  Starting     4 of     5

 New>  Starting     5 of     5

 New>  Best score:      1.535

 O > cop .LSQ_RT_c .LSQ_RT_BEST

 O > lsq_obj c mcmir

This is a better score and the fit of the objects is much better. It took longer to do the calculation though.    

ncs_mir_c_a.tiff

We now have rough values for both operators, but they might not be good enough for averaging. Instead of wasting our time finding out, it is best to improve them before starting the averaging. O does not have a command to do this so we’ll use one of the RAVE programs written by Gerard Kleywegt and Alwyn Jones. This program needs a starting operator and a mask. At this stage the mask does not have to be particularly fancy, and we’ll just make a simple spherical one that is centred at the middle of our reference molecule.

First make an object centred on the reference molecule with only a few skeleton atoms in it.

O > bon_set

 Bone> Skeleton molecule name [MIR   ]:

 Bone> Object name [MCMIR]: 1

 Bone> Sphere radius [   20.0 ]: 2.

 Bone> What bone levels? [ 3 ]:

 O > bon_dr

Now convert this object into a mask using the NCS_mask_sph command, and save it in the file system.

 O > ncs_mask_sph

 New> What map (for cell, grid units only)? [MIR]:

 New> Object name [1]:

 New> Atomic radii [3.0]: 22.

 New> Mask name [MASK]: sphere

 New> Number of atoms in object     2

 New>  Belongs to molecule MIR

 O > ncs_mask_wri

 Mask> What map? [MIR]: sphere

 Mask> Mask file name? [sphere.mask]:

The mask is actually a map in the F(ast)M(ap) viewing system but contains just 0’s and 1’s. It can be inspected using the usual map slider system:

ncs_mask_sphere.tiff

Now we are ready to run the imp program using the O JOB system. Here is the A-> B operator

 O > jo_su

 New> Define the template file: ncs_imp

 New> Old symbol to expand <NCS-operator > to <b >

 New> Old symbol to expand <Mask > to <sphere >

 New> Old symbol to expand <CCP4 map file > to </Users/alwyn/o/work_o/NCS/ano1.E

 New> Old symbol to expand <ODAT > to </Users/alwyn/o/data/ >

 New> Old symbol to expand <O Symmetry Operator > to <p212121 >

 New> Script started

STOP ... Toodle pip ... statement executed

I now use the Jobs pull-down to activate the macro.

 As2>  Done file made /Users/alwyn/o/temp/ncs_imp_4.done

 As2>  Predicted Correlation Coefficient =     0.568816

 As2>  Predicted Correlation Coefficient =     0.568741

 As2>  Predicted Correlation Coefficient =     0.568751

 As2>  Predicted Correlation Coefficient =     0.568744

 Heap>  Database compressed.

 As4> ----------------------------------------------------

 As4> The operator has been improved.

 As4> Try it

 As4> ----------------------------------------------------

This script shows how the correlation coefficient improves . The final value is 0.569.

Now the A->C operator

 O > jo_su

 New> Define the template file: ncs_imp

 New> Old symbol to expand <NCS-operator > to <b >c

 New> Old symbol to expand <Mask > to <sphere >

 New> Old symbol to expand <CCP4 map file > to </Users/alwyn/o/work_o/NCS/ano1.E

 New> Old symbol to expand <ODAT > to </Users/alwyn/o/data/ >

 New> Old symbol to expand <O Symmetry Operator > to <p212121 >

 New> Script started

STOP ... Toodle pip ... statement executed

I now use the Jobs pull-down to activate the macro.

 As2>  Done file made /Users/alwyn/o/temp/ncs_imp_5.done

 As2>  Predicted Correlation Coefficient =     0.469587

 As2>  Predicted Correlation Coefficient =     0.471927

 As2>  Predicted Correlation Coefficient =     0.472368

 As2>  Predicted Correlation Coefficient =     0.472538

 As2>  Predicted Correlation Coefficient =     0.472600

 As2>  Predicted Correlation Coefficient =     0.472633

 As2>  Predicted Correlation Coefficient =     0.472632

 Heap>  Database compressed.

 As4> ----------------------------------------------------

 As4> The operator has been improved.

 As4> Try it

 As4> ----------------------------------------------------

The correlation coefficient is a bit worse, but still OK.

The jobs have read in the new operators to the database, so now we can average with good operators and a poor mask.

 O > ncs_av

 New> What map? [SPHERE]: mir

 number SPG ops  4

 New> What mask? [?]: sphere

 New> New averaged map: 1stav

 New> Define an NCS operator .lsq_rt_ident

 New> Define an NCS operator .lsq_rt_b

 New> Define an NCS operator .lsq_rt_c

 New> Define an NCS operator .lsq_rt_

 New>  Average.

   130410  26894  0  0

 New> Min, max, sigma ......  -0.29636   5.71056   0.38887

This has created a new F(ast)M(ap) call 1stav that can now be viewed or used for other O commands. Notice that the sigma in the map is only 0.38887 while the original MIR map has a sigma of .988. This map is already rather nice, so you might want to save it.

 O > ncs_map_wr

 New> What map to write out ? [1STAV]:

 New> Whatfile name ? [ave]: 1stav

 New> /Users/alwyn/o/work_o/NCS/1stav.ezd

and we can skeletonize it:

 O > skel

 Qm> What map? [1STAV]:

 Qm> All map [Y]/N?

 Qm> Base level [1.25]: 4.5

 Qm> Skeleton name [SKL]: 1stav

Note the high level for the base level - this is in multiples of sigma.

1stav_mc.tiff

There are a few skeleton connections on the left still, and these need to be removed with the Bond_break command and a new skeleton drawn:

1stav_mc_edit.tiff

This can now be used to make a new, more complex mask where we associated a radius around each atom of 3 Å.

 O > NCS_mask_sph

 New> What map (for cell, grid units only)? []: mir

 New> Object name [MC1STA]:

 New> Atomic radii [3.0]:

 New> Mask name [MASK]: 2nd

 New> Number of atoms in object   341

 New>  Belongs to molecule 1STAV

This mask will have holes and clefts in it that have to be smoothed out:

1stav_mask_1.tiff

 O > NCS_mask_lay

 New> What mask ? [MIR]: 2nd

 New> Expand layer (+), or peel it (-)? [+]: +

In the above, adding the first  extra layer improved things, but it was still not perfect

1stav_mask_2.tiff

There are still a few buried holes, so I added another layer to fill them in, and then removed it (to keep it slim).

 O > NCS_mask_lay 2nd +

 O > NCS_mask_lay 2nd -

1stav_mask_3.tiff

This mask is now good enough for cyclic averaging, so save it.

 O > NCS_mask_wri

 Mask> What map? [2ND]:

 Mask> Mask file name? [2ND.mask]: 2nd.mask



NCS_add_maps (080218)
ncs_add_maps <map1> <map2> <map3>

This command adds <map1> and <map2> to produce <map3>. The maps to be added must have the same grid and extent. This command is useful for some complicated averaging script. Suppose, for example, that you have a case of 2 rings where each ring has a number of subunits having proper rotational symmetry. One may force proper symmetry on each ring, and find that the symmetry axes are not identical. It might then be easiest to average each ring (with expansion), and then add the two maps topgether.

O > NCS_add_maps
New> First map: []: ring1
New> Second map [?]: ring2
New> New map: both
New> Min, max, RMS ...... -59.48718 71.28205 15.16168

The maps must have the same grid and extent.

O > NCS_add_maps
New> First map: [f21]:
New> Second map [?]: mir
New> New map: both
New> Sorry, maps have different grids, abort.





NCS_instance (080218)

This command allows a user to make an instance of a molecular object that makes use of NCS symmetry. The molecule concerned must have a chain operator defining the NCS-operators. Note that the instance of the object contains just a set of lines and atoms cannot be identified (use NCS_sphere instead).

This example is from Satellite Tobacco Necrosis Virus (PDB entry 2BUK) which was the first virus to be refined, and contains 60 chains related by icosahedral symmetry.

O > NCS_instance
Sym> Molecular objects name? [A]: 2bukca
Sym> NCS object name? [ncs]:
Sym> Sphere radius [10.0]: 1000
Sym> Molecule c.g. = 46.50 48.97 -7.00
Sym> Radius = 37.77
Sym> Number of NCS operators = 60




NCS_sphere (080218)

This command allows a user to generate molecules from a reference molecule containing NCS symmetry. The reference molecule must have a chain operator defining the NCS-operators. Note that the newly generated molecules are real molecules as far as O is concerned so that atoms can be identified (use NCS_instance instead if you just want to see the NCS).

This example is from Satellite Tobacco Necrosis Virus (PDB entry 2BUK) which was the first virus to be refined, and contains 60 chains related by icosahedral symmetry.

O > NCS_sph
Sym> Molecule name? [GS]: 2buk
Sym> NCS molecule name? [ncs]:
Sym> Sphere radius [10.0]: 1000
Sym> Molecule c.g. = 46.50 48.97 -7.00
Sym> Radius = 37.77
Sym> Number of NCS operators = 60
Sym> NCS chain 2
Sym> NCS chain 3
Sym> NCS chain 4
Sym> NCS chain 5
Sym> NCS chain 6
Sym> NCS chain 7.....
Sym> NCS chain 58
Sym> NCS chain 59
Sym> NCS chain 60

Full atomic objects are generated for each chain.




NCS_average (050425)

We can average the electron density once we have good operators and a mask. For non-cyclic averaging, the mask can be a simple sphere that is big enough to cover completely the reference molecule. For cyclic averaging, the mask should be as good as you can make it.

 O > ncs_av

 New> What map? [SPHERE]: mir

 number SPG ops  4

 New> What mask? [?]: sphere

 New> New averaged map: 1stav

 New> Define an NCS operator .lsq_rt_ident

 New> Define an NCS operator .lsq_rt_b

 New> Define an NCS operator .lsq_rt_c

 New> Define an NCS operator .lsq_rt_

 New>  Average.

 New> Min, max, sigma ......  -0.29636   5.71056   0.38887

 New> Expand into a complete cell? [Y]: n

This has created a new F(ast)M(ap) call 1stav that can now be viewed or used for other O commands. Notice that the sigma in the map is only 0.38887 while the original MIR map has a sigma of .988. It will, therefore, have to be viewed with a much larger level (around 4 sigma) than the original MIR map.

In the final prompt, n was entered, so the NCS-averaged asymmetric unit has not been expanded to fill the complete unit cell. If this were part of a cyclic averaging procedure, an expansion would have been required and a complete unit cell would have been generated.

 New> Expand into a complete cell? [Y]:

 New> Min, max, sigma ......  -1.14902   5.71055   1.08863

Note that the sigma value is now quite different!


NCS_map_writ (050323)

An averaged mask may look so good that you want to keep it. This command writes a F(ast)M(ap) system map as an EZD formatted file into the computer’s file-system.

 O > NCS_map_writ

 New> What map to write out ? [AV]:

 New> Whatfile name ? [ave]: 1st_av

 New> /Users/alwyn/o/work_o/NCS/1st_av.ezd

 map_write_ezd

The map can be read into O again at a later stage using the Fm_file command.


NCS_mask_edi (050323)

This command allows a user to edit a mask stored in the O FastMap system. The user needs to define a radius that controls which pixels are reset around identified atoms. The mask is expanded around the identified atom if Yes is set, and constricted if No is set.

 O > NCS_mask_edi

 Mask> What mask? []: 2nd

 Mask> Radius [3.]:

In the following example, the mask is too close to an abutting molecule, represented in part by a few skeleton atoms:

ncs_mask_edi_1.tiff

With Yes set, the result is as follows:

ncs_mask_edi_2.tiff

This has made the matter worse, by expanding the mask into the wrong volume. Setting No , and identifying a few of the skeleton atoms produced a slightly shaved mask in this region:

ncs_mask_edi_3.tiff


NCS_mask_lay (050323)

The first mask that you make is not likely to be perfect. This mask will, almost certainly, have holes and clefts in it that have to be smoothed out:

1stav_mask_1.tiff

 O > NCS_mask_lay

 New> What mask ? [MIR]: 2nd

 New> Expand layer (+), or peel it (-)? [+]: +

In the above, an extra outer layer has been added to the mask. Although adding this first  extra layer has improved things, but it was still not perfect

1stav_mask_2.tiff

There are still a few buried holes, so I would add another layer to fill them in, and then remove the outer layer (to keep it slim).

 O > NCS_mask_lay 2nd +

 O > NCS_mask_lay 2nd -

Note that adding/removing layers tends to smoothen the outer layer of the mask.


NCS_mask_mak (050323)

This command makes a mask out of a density in the FastMap system. The user needs to specify a volume within which the input map is smeared. The FastMap slider for the mask is then used to control a level and radius until the user sets Yes or No. If Yes is set, the current volume being display (i.e. at the current level and radius) is used as the mask. The smeared density is converted to 0 and 1 below and above the contouring level in the slider. The slider setting is then reset to this new range of values. The mask is padded by 10 pixels in each direction.

 O > ncs_mas_ma

 Mask> What map? [AV]: mir

 Mask> All map [Y]/N? n

 Mask> Radius around active_centre [50.]: 22

 Mask> Radius to average [3.]: 6

 Mask> Mask name [MASK]:

 Mask> This takes some time ...

 Mask>  Done   10 levels of   38

 Mask>  Done   20 levels of   38

 Mask>  Done   30 levels of   38

 Mask> Done

The following snapshot shows a smeared P2 myelin MIR map, prior to accepting the level and radius:

ncs_mask_make_1.tiff

After setting Yes, the mask is quite similar but is now defined as 0/1’s

ncs_mask_make_2.tiff

and no longer has any symmetry associated with it.

Clearly this is a very rough mask and will need lots of editing.


NCS_mask_sph (050323)

This is a very convenient way to make a mask in O’s NCS-system. You just have to make an atomic object, and then you create a mask by placing a sphere at each atom in the object. In a molecular replacement solution, one of the chains can be used to make a very nice mask. If one uses a sphere of say 3 Å around each atom, there will be holes and cavities in the mask, but these are easy to remove with the NCA_mask_lay command. A mask can also be made out of a skeleton object.

Remember that an averaged map has no density outside the mask. Therefore, in cyclic averaging it is a good idea to keep the last un-averaged map from the last cycle of phase refinement.

 O > ncs_mask_sph

 New> What map (for cell, grid units only)? [MIR]:

 New> Object name [1]:

 New> Atomic radii [3.0]: 22.

 New> Mask name [MASK]: sphere

 New> Number of atoms in object     2

 New>  Belongs to molecule MIR

The mask becomes part of the F(ast)M(ap) system and can be viewed with the map slider interface. S i nce the mask contains just 0’s and 1’ s , there is nothing to view above a level of 1.0


NCS_map_writ (050323)

An averaged mask may look so good that you want to keep it. This command writes a F(ast)M(ap) system map as an EZD formatted file into the computer’s file-system.

 O > NCS_map_writ

 New> What map to write out ? [AV]:

 New> Whatfile name ? [ave]: 1st_av

 New> /Users/alwyn/o/work_o/NCS/1st_av.ezd

 map_write_ezd

The map can be read into O again at a later stage using the Fm_file command.


NCS_operator (050323)

If the map to be averaged is based on molecular replacement solution, determining the NCS-operators is very easy using lsq_explicit . However, if the map is produced from experimental phases, the operators have to be determined by other means. If a set of heavy atom coordinates are available where equivalent heavy atoms have been identified in each chain, then the same LSQ commands can be used in O to get the first estimate of the operators. However, there have to be at least 3 matching pairs of heavy atoms for the calculation of each NCS-operator.

If there are not sufficient heavy atoms, the operators can be determined directly in O. First make a skeleton of the whole asymmetric unit or cell. Then make another object which corresponds to the reference molecule. The NCS_oper command allows you to find the operator that place this object on other NCS-related molecules in the skeleton. The user is prompted to identify an atom that is roughly in the middle of an NCS-related molecule.

O > ncs_op

 New> What map? [MIR]:

 New> Object name [QQ]: mcmir

 New> Step search width [3]:

 New> Number of atoms in object   507

 New>  Belongs to molecule MIR

The user is prompted to ID an atom roughly in the middle of the NCS-related molecule

 New> Pivot coordinates in object [ 51.33 65.71 33.17]:

 New> This takes some time ...

 New>  Starting     1 of     3

 New>  Starting     2 of     3

 New>  Starting     3 of     3

 New>  Best score:      1.924

A translational grid search is carried out around this identified atom, and the atoms in the skeleton object are pivoted in a full 3-D search. The default search width is +/3 steps, each 1 Å wide around the ID’d atom. The score is the average density at each point in the rotated skeleton for the best fitting translation/orientation. The value here will depend on the map and on how well the command has been able to find th e correct operator. The standard deviation in the MIR map was listed when it was read in:

 Fm> Min, max, sigma ......   0.00000   8.35000   0.95545

The command has generated a new entry in the O DB with the operator to take you from the reference molecule to an NCS-related molecule:

 > dir .lsq_*rt*

 Heap>  .LSQ_RT_IDENT             R W        12

 Heap>  .LSQ_RT_BEST              R W        12

The first operator is the identity operation, taking the refernce molecule to itself. One can see how good theoperator is by using the Lsq_obj command. This command takes a rotation-translation operator and applies it to an atomic object. The coordinates in the object are not affected by this command.

If the user has just a single heavy atom per NCS-subunit, it may be worth making the reference object centred on a heavy atom site. In this case, ID the heavy atom in the NCS-molecule to define roughly the NCS-centre.


Neighbour_re(sidue)
 
Neighbour_re <id an atom> or <mol res atom>
 
Show neighboring atoms to all atoms in the residue of the identified atom. The calculation is repeated so that the contacts of moving atoms get flagged. The distance cut-off is kept in the database in .trig_real Contacts within the same residue are not calculated.
No
 
Set the No flag on, the Yes flag off. See the description of Yes.
Note Overview
 
The Notes major menu contains a number of commands that enable the user to maintain three-dimensional notes in the database. Such notes are useful is for tracing a new structure when one often wants to record ideas of where one may be in a structure, for introducing reminders during refinement, or for taking pictures.Each note has an associated name, and can contain an arbitrary number of text elements. Any number of objects can be generated from the notes. The colour and size of the text elements can be adjusted (SGI machines don't support different text character sizes). A text string can be added next to an ID'ed atom, or at a specific coordinate in orthogonal Ångström coordinates. When created, a text string will be added to the currently open note name and note object. However, to avoid the screen from getting cluttered with a large number of 3D text strings, that also degrade the performance of the graphics system, the display of notes can be restricted to those within a given radius from the active centre. Presently, note objects are not recreated when the program is started.
Note_id_add
 
Note_id_add <identify atom> <text string>
 
Add note at a picked atom or bone atom. The text string is added to the current note and note object.
Note_name
 
Note_name <name>
 
Change the name of the "active note". If a note of this name does not exist, a new one is created.
Note_object
 
Note_object <name>
 
Change the object name of the displayed note.
Note_setup
 
Note_setup <col> <size> <font>
 
Set the colour, size and (not yet used) font of the next text element.
Note_sphere
 
Note_sphere <radius>
 
Create an object from the current note, with a name defined by Note_object, displaying all notes within the given radius. To display all your notes, simply specify a very large radius.
Note_xyz_add
 
note_xyz_add <x y z> <text string>
 
Add note at the given orthogonal Ångström coordinate. The text string is added to the current note and note object.
O Descriptor Language (080219)

Overview
ODL is a means for O and/or the user to generate simple objects. The drawing instructions must be in an O text datablock in the user’s database or a text file in the computer file-system. The instructions can be parsed with the draw_object command.
ODL instructions can be used to create very simple objects (e.g. text at a particular point in space), or more complicated things (e.g. given a set of NCS operators, one can reconstruct a whole spherical virus from the object of a single capsid protein).

Syntax
begin_object <name> - start an object with a given name. The object name associated with the ODL when drawn in O, is the name of the last defined object. The following file illustrates how this can be used:

begin_object text_red
colour red
text 55 72 30 AAAAAA
end_object

begin_object text_yellow
colour yellow
text 55 72 35 BBBBBB
end_object

begin_object text
instance text_red
instance text_yellow
end_object

When drawn in O, the object that you see is called ‘text’ and appears to be red A’s and yellow B’s

end_object - end the current object

colour <value> - define the colour to be used with the drawing instruction that follow. The <value> can be text (e.g. ‘red’) or a packed integer (e.g. 16711680 is red, 65280 is green)

line_type <type> - specify how to draw lines, and can have the following values solid, dashed, dotted, dash_dot.

move <x y z> - specify the start coordinates of a line.

line <x y z> - specify the coordinates for drawing a line from the current point in space to the new position.

dot <x y z> - draw a dot at the specified coordinates

move_atom <mol res atom> - specify the start of a line by the coordinates of an atom in the O database.

line_atom <mol res atom> - specify the coordinates for drawing a line from the current point in space to the new position by the coordinates of an atom in the O database.

text <x y z string> - place the text contained in the string at the desired coordinates

text_colour <value> - define the text colour to be used with the drawing instruction that follow. The <value> can be text (e.g. ‘red’) or a packed integer (e.g. 16711680 is red, 65280 is green)

poly <number of vertices> <xyz vertex> - draw a polygon with current colour. Each coordinates can be on a new line.

poly_colour <value> - define the text colour to be used with the drawing instruction that follow. The <value> can be text (e.g. ‘red’) or a packed integer (e.g. 16711680 is red, 65280 is green)

instance <object> <ODB entry> - object to be instanced with optional RT operator. This is useful if you want to apply operators to an atomic object to build a virus particle, for example. E.g.

begin_object icos
instance aca .lsq_rt_sym1
instance aca .lsq_rt_sym2
instance aca .lsq_rt_sym3
......
end_object

Here is a more complicated example (5 different chains) from Jorge Navaza’s group:



where the multiple copies of the separately coloured CA objects are instances of the originals.

sphere_atom <mol res atom radius colour> - draw a sphere at the coords of an atom

sphere_xyz <x, y, z, radius> - draw a sphere at the specified point

stick <mol res atom> <mol res atom> <radius> - draw a stick between a pair of atoms

stick_xyz <x1, y1, z1> <x2, y2, z2> <radius> - draw a stick between 2 points

mode <solid/line> - set drawing mode

cell <cell params.> - set cell for following 3 commands

fmove <x, y, z> - moveto in fractional coords.

fline <x, y, z> - lineto in fractional coords.

ftext <x,y,z, string> - place text , coords. in fractional units

bubbles <mol1 res1 atom1 mol2 res2 atom2 radius1 radius2> draw small spheres (AKA bubbles) between a pair of atoms. The bubbles are of radius value <radius2> and roughly <radius1> apart. Here is an example from the distributed P2 myelin structure:

begin_object bubbles
mode solid
colour cyan
bubbles a a132 o1 a a106 nh1 .4 .15
colour red
bubbles a a132 o1 a a106 nh2 .9 .15
colour green
bub a a132 o2 a a126 nh1 .2 .3
end_object

and the resulting figure:

 
 


O_setup
 
1.Control of echoing commands on the terminal that come from indirect files.
2.Control logging of command line input to a file 'o_log.fmt' . This is useful to create templates for macros.
3.Control logging of terminal listing to a file 'o_log.lst'. This option can be used to keep track of the output from complicated operations, such as the lsq commands. The listings of O output in this manual were created using this option.
Object_name
 
Object_name <name>
 
Define the name of a new molecular object. In the current version of O, the name can be up to 6 characters long.
Paint Overview
 
The paint commands affect the colour properties of molecules or molecular objects. Each molecule has an associated atomic property called <mol>_atom_colour, and each molecular object has a property called .obj_col_<object_name>. These are integer arrays of colour values. The difference between these two lists of colours is subtle, but it is important that the difference between them is understood. If you make a molecular object, for example using the command Zone or Ca, the current colour property of the molecule is copied to the object colour array. Therefore, you can make an object of a molecule coloured according to element type, with carbons white, oxygens red etc. Now, for example, you could change the colours associated with each atom, to represent the magnitude of their temperature factors, and make another object. There would now be two objects, representing the same molecule. However, the colours of the first object you created (the one with atom colouring) did not change when you changed the colour property of the molecule, because they are saved in the O database along the description of the object.
 
Some of the commands in the Paint menu change the colour property of the objects. These are Paint_object, Paint_obj_zone and Paint_obj_atom, and can be used to colour objects with the current active colour, set by Paint_colour. The molecular colours have to be set according to some atom or residue property. There is a selection of commands for doing this in different ways, namely Paint_property, Paint_ramp, Paint_case and Paint_zone.
 
O makes use of the RGB (Red-Green-Blue) colour scheme, where the relative intensities of the three major colour components are set, using numbers between 0.0 and 1.0. Thus, red is (1,0,0), blue is (0,0,1) and so on. In the program, these 3 numbers are converted to 3 eight bit numbers between 0 and 255, and packed into a 32 bit integer word. These numbers are extremely strange when written out in decimal format, and are not understandable by normal human beings. Unless you're really into changing certain datablocks in the database, you should never have to deal with these strange integer numbers. The normal way to specify colours in O is by typing the name of a colour. In the default startup.o and colour_default.o files, there are 71 colours to choose from and are the colours defined in X-windows. These are
 
O > pai_col ?
Paint>Available colors:
Paint> aquamarine black blue
Paint> blue_violet brown cadet_blue
Paint> coral cornflower_blue cyan
Paint> dark_green dark_olive_green dark_orchid
Paint> dark_slate_blue dark_slate_gray dark_slate_grey
Paint> dark_turquoise dim_gray dim_grey
Paint> firebrick forest_green gold
Paint> goldenrod gray green
Paint> green_yellow grey indian_red
Paint> khaki light_blue light_gray
Paint> light_grey light_steel_blue lime_green
Paint> magenta maroon medium_aquamarine
Paint> medium_blue medium_forest_green medium_goldenrod
Paint> medium_orchid medium_sea_green medium_slate_blue
Paint> medium_spring_green medium_turquoise medium_violet_red
Paint> midnight_blue navy navy_blue
Paint> orange orange_red orchid
Paint> pale_green pink plum
Paint> red salmon sea_green
Paint> sienna sky_blue slate_blue
Paint> spring_green steel_blue tan
Paint> thistle turquoise violet
Paint> violet_red wheat white
Paint> yellow yellow_green
 
If this is not enough for you, the program will in most places accept 3 numbers for the RGB value when the colour prompt comes up. To get the list of colour names, type a question mark (?) as argument to the Paint_colour command. When specifying a colour name, you are allowed to abbreviate to a unique set of letters.
 
Paint_case
 
paint_case <property> <#values> <values> <colours>
 
Colour residue or atomic properties according to discrete values, all in one go. The default is <mol>_atom_z. The following commands will colour the current molecule according to atom name:
 
paint_case atom_name 5 c* n* o* s* p* white blue red yellow green
z ; end
 
Notice that for the specification of character value properties such as atom names or residue types, you can use the wildcard character '*' in the specification. Thus, for residue types, T* could be Tyr, Thr or Trp. This is not the case in command, property or colour specification.
 
Another way to paint atoms according to the type of atom is to use the element number property:
 
pa_ca atom_z 3 6 7 8 white blue red z ; end
 
This will colour atoms with Z = 6 (carbon) white, atoms with Z = 7 (nitrogen) blue and atoms with Z = 8 (oxygen) red. The zone containing the whole molecule will be drawn. In fact this way of colouring according to atom type is faster, because there is less computation involved in the comparison, than is the case for character properties like atom_name. Now let us try to paint according to the charges on residues. To do this, you need to load the residue table containing the charges:
 
db_table_res charge i table_charge
paint_case residue_charge 3 -1 0 1 red white blue z ; end
 
The latter line could be abbreviated even further:
 
p_ca r_c 3 -1 0 1 re whi blue z ; end
Paint_colour
 
paint_colour <colour>
 
Select the current colour. The colour is be given as a colour name. There are 71 standard colours to choose from, and the list of colour names can be listed by answering with a question mark (?) in response to the prompt. The colour name is converted internally to a mysterious integer code. The current colour code is stored in the datablock .active_colour, the name of the current colour is stored in the datablock .active_colour_name. If an unknown colour input is given, the current colour remains unchanged. It is also possible to specify a colour directly using the RGB triple.
Example:
 
O > p_col
Paint> Colour? [green]: red
O > dir *act*
Heap> .ACTIVE_COLOUR I W 1
Heap> .ACTIVE_COLOUR_NAME T W 21
Heap> .ACTIVE_CENTRE R W 3
Heap> .DENSITY_TEMPACT T W 1071
O > wr .active_colour ;;
.ACTIVE_COLOUR I 1 (8(1x,i8))
16711680
O > wr .active_colour_name ;;
.ACTIVE_COLOUR_NAME T 1 20
red
O >

Paint_map
 
paint_map <map_object>
 
This command is an attempt to allow real time colour cdefinition for the old style Map commands. Three dials are allocated to allow one to set the RGB values.
Use F(ast)M(ap)!

Paint_obj_at(om)
 
paint_obj_at <id an atom> or <mol res atom object>
 
The user can either identify an atom to get painted with the current colour, or the atom can be defined by typing the information on the same line, e.g.
pa_obj_at m14 90 cb ca

Paint_obj_zo(ne)
 
paint_obj_zo <id two atoms> or <mol res1 res2 object>
 
The user is required to identify a zone in an object, which gets painted with the current colour. Useful for interactively making a picture where for example a-helices are one colour, and b-strands another. The object can be specified by identifying two atoms in the object or by by typing on the same line , e.g.
 
pa_obj_z m14 90 110 ca
 
Paint_object
 
paint_object <id an atom> or <object>
 
The user is required to identify an object, which is painted with the current colour. The object can be specified by identifying an atom in the object or by typing the name on the same line , e.g.
 
pa_obje sph
Paint_property
 
paint_property <property> <operator> <value> <colour>
 
Paint according to the residue or atomic property. For example, paint all phenylalanine residues blue and all tryptophanes violet:
 
paint_prop residue_type = phe blue
paint_prop residue_type = trp violet
z ; end
 
Or, colour the first 15 residues red, the remaining yellow:
 
paint_prop residue_name < A16 red
paint_prop residue_name >= A16 yellow
z ; end
Paint_ramp
 
paint_ramp <property> <min_value max_value> <start_colour> <end_colour>
 
Colour ramp according to the individual value of the property. The default property is the residue internal number, stored as a datablock with a residue property <mol>_residue_irc. If this property does not exist, it is created. The minimum and maximum values are those in the specified property vector.
 
This option can be used make pretty Ca drawings where the colour changes as one goes from N-terminal to the C-terminal:
 
paint_ramp ; ; red blue ca ; end
 
We could also ramp according to temperature factors, so that the smallest values are blue and the highest values are red:
 
paint_ramp atom_b ; violet red zone ; end
 
or we could colour the real space residue fit from salmon pink to cyan:
 
paint_ra res_rsfit ; salmon cyan z ; end
paint_z ; a1 a23 green ca ; end
Paint_select
 
paint_select
 
Paint a selection. See the section on the Select commands for examples.
Paint_zone
 
paint_zone <mol> <start end> <colour>
 
Paint a zone of a molecule a particular colour. The following command will paint residues A1 to A23 of the current molecule green, and draw all the Ca's :
 
Patterson

These commands allow one to solve Patterson functions interactively or to check out the results from an automatic system.The proposed heavy atom sites must exist as a molecule in O, together with unit cell and symmetry (see Symm_setup). The atom selection property <mol>_atom__select is used to switch on or off the use of a particular atom to the cross vector calculation. It can be defined with the Select menu.
A molecule PATT must exist and have enough entries to satisfy the number of cross vectors that are generated. It can be made with Patt_setup or Water_init. Before using these commands, it is helpful to have an object displaying the unit cell, and map objects of Harker sections and 3-d volume elements in the Patterson function.
 
Patt_cross

patt_cross <heavy_atom_molecule_name>
<xmin xmax ymin ymax zmin zmax>

This creates an object of all of the desired heavy atoms within the selected volume. The volume must be defined in fractional unit cell units. The cross vectors are put as atoms in molecule PAT (which must exist) and an object created. The command remains active. If a heavy atom position is being changed with patt_move the cross vector coordinates and object are updated. If a cross vector is identified, the residue type field gives the from/to heavy atom.

Patt_move

patt_move <id an atom> or <mol res atom>
The moving atom moves along the orthogonal axes of structure space and not of display space. This means if you change the x-dial it moves along the molecule x-axis not the screen x-axis.

Patt_setup

patt_setup
This generates a molecule in O called PATT that contains 1000 cross vectors. The command is actually a call to water_init so the cross vector atom have solvent names. If you want more (or less) vectors then type the following, for example
water_init patt 100 1

PDB_kill (050805)

pdb_kill <molecule>

This command removes all objects and ODB entries associated with a molecule.
.
O > pdb_kill
New> Delete all entries and objects associated with a molecule
New> Wild cards (*) are allowed in name.
New> Warning: typing 'a*', is like 'db_kill a*_*'
New> For this example, do 'dir a*_*' first
New> What molecule? [no default] : m17
New> Deleted M17_ATOM_XYZ
New> Deleted M17_ATOM_B
New> Deleted M17_ATOM_WT
New> Deleted M17_ATOM_Z
.....


PDB files (101013)
 
O can read or write a number of external coordinate formats.The only format that is widely used today is the Protein Data Bank format. Since O 7.0 there have been PDB_read and PDB_write commands, while previously external coordinates were read and written with sam_atom_in and _out. The newer commands are closer to the PDB definition, and can also read in X-PLOR or CNS files that contain SEGIDs. If the molecule has strict NCS-symmetry and the PDB file has the corresponding MTRIX records, O will store the operators as a so-called chain operator (see PDB_read for more detais). I strongly adivise the use of the new commands.
O can read a number of external coordinate formats using the Sam_atom_in command. If the coordinates file type ends in .pdb , O will assume it is PDB format and then prompt for a 5 letter molecule name.The program saves various information that might be in the file, including cell constants, space group name etc. It does NOT store anisotropic temperature factors, nor does it handle multiple conformations cleverly. Files with unexpected endings are prompted for the coordinate type.
O supports writing out a number of different coordinate formats using the Sam_atom_out command. The user can write out just those that are selected, if he/she so wishes. The program decides on which format to write out by recognizing the file type. For PDB style coordinates the type should be .pdb If the type is not recognized, the program prompts for the file type.
More details on the Sam commands are provided elsewhere.

The PDB format defines residue names with a single letter insert code, 4 letter numeral and an insert code. Up to the Ov13 release, therefore, residue names (things like 101, or A101) have been restricted to 6 characters. Time marches on, and our community now tackles structures that break this limit. The PDB have come up with a solution for the problem where they split the structure into separate files. I think this is silly and have no plans to support this solution. Axel Brunger and colleagues have been using 4 characters (in ‘rows’ 73-76 of the ATOM ‘card’, long live the IBM 29 card punch - Google it) for what is essentially chain information for many years, the so-called SEGID. In an attempt to satisfy people working with many chains, recent versions of O can also use SEGID information as a part of the residue name. If this data exists in a PDB file, PDB_read can now combine it with the usual 6 PDB defined characters for a so-call long residue name. This is best shown by example, and these are from a PDB file provided  by Martin Laurberg of a 70S ribosome crystal structure that contains 2 complete particles in the asymmetric unit (I include a character count line in case you want details):
12345678901234567890123456789012345678901234567890123456789012345678901234567890
ATOM  A2WU0  O2' CYT   273E    -63.885 -33.385 122.373  1.00168.55      B23S O
This atom would be in residue B23S_273E in O, while
ATOM  A3FLO  P   GUA  1400       1.086 -53.745  23.230  1.00115.09      B23S P
is in residue B23S_1400

Changing the size of the residue name has a large number of consequences. I’ve modified the code of my ‘core’ routines to check if I’m accessing them with the wrong length variable. If you get ‘ET call home’ warnings like this:
New> Residue length warning in resinf, call Alwyn
New> getseq length warning in zonatm, call Alwyn
please let me know. The long residue names will be unscrambled correctly by PDB_write.
PDB_read (101013)
 
This command more closely follows the PDB standard than does the sam_atom_in command. Alternate conformations result in mutiple molecules being produced. They are named with 'B' added to the user defined name if there is only one one extra conformation, 'C' if at least one residue has 3 conformations etc. The user is able to strip hydrogens as the coordinates are read. For CNS/X-PLOR users, the SEGIDs can be stored, becoming new residue properties. Note that if SEGIDs are used to encode alternate conformations, there can be residues appearing within a molecule that have the same name.
A macro is activated to generate stereo-chemical data. The macro assumes only one chain (it just does a refi_init & refi_gener) . The macro also centres on the centre of gravity of the molecule.
Here is an example of reading in a file where two residues have 3 different alternate atom locations:
 
O> pdb_read
Util> PDB file : 2nlr.pdb
Util> O associated molecule name: 2nlr
Util> Remove hydrogens ? [y]/n :y
Util> Save CNS/XPLOR SEGIDs ? [y]/n :n
Util> EXPDTA X-RAY DIFFRACTION
Util> Molecule 2NLR contained 495 residues and 1966 atoms
Util> 1509 hydrogens were skipped
Util> Alternative conformations result in 3 molecules
Util> Now get the Aniso Us for this molecule
skipped Hs 1509
Util> Molecule 2NLRB contained 71 residues and 249 atoms
Util> 174 hydrogens were skipped
Util> Now get the Aniso Us for this molecule
skipped Hs 174
Util> Molecule 2NLRC contained 2 residues and 17 atoms
Util> 3 hydrogens were skipped
Util> Now get the Aniso Us for this molecule
skipped Hs 3
 
Three molecules have been created:
 
Util> dir 2nlr*xyz
Heap> 2NLR_ATOM_XYZ R W 5898
Heap> 2NLRB_ATOM_XYZ R W 747
Heap> 2NLRC_ATOM_XYZ R W 51
 
The molecule 2NLRA contains all of the residues for which there is a second conformation (71 in this case), while 2NLRC contains all residues for which there are 3 conformations (only 2 residues). Note that the user has to take care in issuing names to molecules when there are multiple conformations. O molecule names are only 5 letters long, including any that might get added.
ANISOU cards are recognised.

In the next example, the molecule has been refined with strict NCS and contains 12 sets of MTRIX records that together describe the NCS. Note that the PDB file does not contain the space group information, which forces an extra prompt.

O > pdb_read
Util> PDB file : gs_a.pdb
Util> This mols DB entries that already exist will be deleted!
Util> O associated molecule name: a1
Util> Remove hydrogens ? [y]/n :
Util> Save CNS/XPLOR SEGIDs ? [y]/n : n
Util> Database compressed.
Util> Space for 9536776 atoms
Util> Space for 100000 residues
Util> Element information at end of line
Util> Chain name >A<
Util> Molecule A1 contained 476 residues and 3790 atoms
Util> File containing datablock of space group symmetry [symm/p1]: symm/p212121.sym
Util> O-style symm-ops for spacegroup P212121
Util> Database compressed.
Util> 12 NCS operators are stored.
Util> Skipped Hs 0
Util> SEGID :
Util> @on_stereo_chem will be activated
Mol> Created connectivity Db for A1
O > dir *rt*a1*
Heap> .LSQ_RT_A1_1 R W 12
Heap> .LSQ_RT_A1_2 R W 12
Heap> .LSQ_RT_A1_3 R W 12
Heap> .LSQ_RT_A1_4 R W 12
Heap> .LSQ_RT_A1_5 R W 12
Heap> .LSQ_RT_A1_6 R W 12
Heap> .LSQ_RT_A1_7 R W 12
Heap> .LSQ_RT_A1_8 R W 12
Heap> .LSQ_RT_A1_9 R W 12
Heap> .LSQ_RT_A1_10 R W 12
Heap> .LSQ_RT_A1_11 R W 12
Heap> .LSQ_RT_A1_12 R W 12
Heap> .LSQ_NCS_RT_A1 T W 252
O > writ .LSQ_NCS_RT_A1 ;;
.LSQ_NCS_RT_A1 T 12 20
.lsq_rt_A1_1
.lsq_rt_A1_2
.lsq_rt_A1_3
.lsq_rt_A1_4
.lsq_rt_A1_5
.lsq_rt_A1_6
.lsq_rt_A1_7
.lsq_rt_A1_8
.lsq_rt_A1_9
.lsq_rt_A1_10
.lsq_rt_A1_11
.lsq_rt_A1_12

A chain operator is created for the molecule, as well as operators describing each NCS-relationship. The operators can be used by many commands in O (see NCS*, LSQ* etc for more details). Note, however, that the Lsq_explicit and Lsq_improve commands generate 4 entries in the ODB for each operator. These other entries describe the molecules and matching sets of atoms.

The next example is todemonstrate how to load in a molecule with so many chains that one has to use long residue names.
O > pd_read
Util> PDB file : 70S_RF1_final.pdb
Util> This mols DB entries that already exist will be deleted!
Util> O associated molecule name: rf1
Util> Remove hydrogens ? [y]/n :
Util> Save CNS/XPLOR SEGIDs ? [y]/n :
Util> Combine SEGID & residue name ? y/[n] : y
Util> Database compressed.
Util> Space for 9598271 atoms
Util> Space for 100000 residues
Util> Element information at end of line
Util> Molecule RF1 contained 24071 residues and 300255 atoms
Util> O-style symm-ops for spacegroup P212121
Util> Skipped Hs 0
Util> SEGID : AL02
Util> SEGID : AL03
Util> SEGID : AL04 ....
Util> Number of different SEGIDs 115
Util> SEGIDs are part of the residue name
Util> They are not stored as a residue property
Util> Checking for name duplications. ...
Util> There are no duplicate residue names in this molecule
Util> @on_stereo_chem will be activated
Util> Screen centre set to centre-of-gravity of molecule....

Residue names in this molecule are now 12 characters wide and are formed by concatenating the segment ID with the usual PDB residue name. The following is a clipping from the above file, showing where we pass the 99999 atom limit in the original PDB definition.


If we identify the atom equivalent to the one on line A0005, we now see it corresponds to O2’ of residue A16S_157


The whole molecule slows down my state-of-the-art (101013) iMac and makes my Macbook Air shudder when I try to rotate it.


My special thanks to Martin Laurberg for making his RF1 70S ribosome crystal structure available to me ahead of publication.


PDB_write (101013)
 
PDB files can be created from a molecule (or molecules in the case of a structure with multiple conformations) in the O database. If the structure originally had multiple conformations, they will be regenerated into a single file. SEGIDs and ANISOUs will also be written out if present. If the residue names are 12 character long, they will be split into CNS-style SEGIDs and the usual PDB-style residue names.
 
O> pdb_write
Util> PDB file name: q.pdb
Util> What molecule [ ]: 2nlr
Util> Residue range [all molecule]:
Util> Define cell constants [ 65.96 65.96 88.74 90.00 90.00 120.00]:
Util> Write out only selected atoms? [No]:
Util> SEGIDs not present
Util> Contains alternate locations
Util> 3 molecules of alternates
Util> Aniso Us are present and will get written out
Util> Use the B-factor? [Yes]:
Util> Use the occupancy? [Yes]:
Util> 2232 atoms written out.

In the following example, the molecule has been refined and rebuilt in O with strict NCS and contains 12 sets of NCS-related chains. The presence of chain operator is detected and O reacts accordingly.

O > pdb_wr
Util> PDB file name: a2.pdb
Util> What molecule [A1 ]:
Util> Residue range [all molecule]:
Util> Define cell constants [ 134.74 203.24 229.42 90.00 90.00 90.00]:
Util> Write out only selected atoms? [No]:
Util> SEGIDs not present
Util> Alternates not present
Util> Anis Us not present
Util> Use the B-factor? [Yes]:
Util> Use the occupancy? [Yes]:
Util> This molecule has strict NCS.
Util> Keep the strict NCS in one chain ([Y],N)?
Util> RT-operator A1_1
Util> RT-operator A1_2
Util> RT-operator A1_3
Util> RT-operator A1_4
Util> RT-operator A1_5
Util> RT-operator A1_6
Util> RT-operator A1_7
Util> RT-operator A1_8
Util> RT-operator A1_9
Util> RT-operator A1_10
Util> RT-operator A1_11
Util> RT-operator A1_12
Util> 3790 atoms written out.

The new PDB file, a2.pdb, contains 12 sets of MTRIX records describing the NCS. If the user had elected to relax the strict NCS, the following output would have been generated:

Util> Keep the strict NCS in one chain ([Y],N)? n
Util> Strict NCS will be expanded.
Util> Chain IDs are of form A, B, C ....
Util> 45480 atoms written out.

If the molecule has 12 character, long residue names, they are split into CNS-style segment information and the usual PDB residue name:

O > pd_wr
Util> PDB file name: m2.pdb
Util> What molecule [RF1 ]:
Util> Residue range [all molecule]:
Util> Define cell constants [ 210.13 454.39 616.45 90.00 90.00 90.00]:
Util> Write out only selected atoms? [No]:
Util> Chain & SEGIDs are concatenated.
Util> SEGIDs will be written out
Util> Alternates not present
Util> Anis Us not present
Util> Use the B-factor? [Yes]:
Util> Use the occupancy? [Yes]:
Util> 7954 atoms written out.

Pep_flip
 
pep_flip <id two atoms> or <mol res1 res2>
 
This command allows the user to locate peptide conformations that are unusual. The technique has been described by Jones et al (1991) and will not be repeated here. If the main-chain database of structures has not been loaded, then it will be loaded before carrying out the calculation. It must, therefore, be properly defined in Lego_setup . The command makes a residue property called <mol>_residue_pepflip
Example:
O > pep_flip a a1 a20
Util> Calculating zone A1 to A20 in molecule A , object C
Util> The DB is now being loaded.
Util> Loading data for protein:HCAC
Util> Loading data for protein:PA
... (lines deleted)
Util> Loading data for protein:TLN_3
Util> Residue A3 has a pep_flip r.m.s. value of 1.43
Util> Residue A4 has a pep_flip r.m.s. value of 0.41
Util> Residue A5 has a pep_flip r.m.s. value of 2.54
Util> Residue A6 has a pep_flip r.m.s. value of 1.56
Util> Residue A7 has a pep_flip r.m.s. value of 0.54
Util> Residue A8 has a pep_flip r.m.s. value of 0.69
Util> Residue A9 has a pep_flip r.m.s. value of 0.40
Util> Residue A10 has a pep_flip r.m.s. value of 0.70
Util> Residue A11 has a pep_flip r.m.s. value of 0.83
Util> Residue A12 has a pep_flip r.m.s. value of 0.50
Util> Residue A13 has a pep_flip r.m.s. value of 0.96
Util> Residue A14 has a pep_flip r.m.s. value of 0.97
Util> Residue A15 has a pep_flip r.m.s. value of 1.96
Util> Residue A16 has a pep_flip r.m.s. value of 1.53
Util> Residue A17 has a pep_flip r.m.s. value of 0.67
Util> Residue A18 has a pep_flip r.m.s. value of 0.33
Util> Residue A19 has a pep_flip r.m.s. value of 0.81
Util> Residue A20 has a pep_flip r.m.s. value of 0.23
O > dir a_*pep*
Heap> A_RESIDUE_PEPFLIP R W 132
O >
Phi_Psi
 
phi_psi <id an atom> or <mol res atom>
 
The phi and psi values for the residue containing each identified atom get displayed in the message window. The command is only applicable to protein molecules. The command stays active so that information about other residues can be obtained by identifying an atom in the residue. It can be reset with Clear_flags.
Plotting Overview
 
O does not generate plots. O does, however, allow you to generate meta-files that can be plotted by other programs. The Plot commands allow you to generate an O descriptor language description of the objects that have been created in O. together with keywords describing scale and orientation information. These may require fine tuning before making the final plots.
These commands are usually used in conjunction with a macro that draws the various objects that you want plotted. A Plot_on is issued before and a Plot_off issued after the macro has been activated
Ray-traced images can be generated from the meta-file using the Molray system (M. Harris & T.A. Jones 'Molray- a web interface between O and the POV-Ray ray tracer' (2001) Acta Cryst. D57, 1201-1203) on our server (see http://xray.bmc.uu.se/alwyn and links)
The plot meta-file can also be converted into a POSTSCRIPT file using the program oplot written by Morten Kjeldgaard.
Plot
 
Creates a plot meta file from molecular objects, and/or the last defined electron density object (all Map files)
Plot_off
 
Switch off plotting.
Plot_on
 
Switch on plotting. All graphics instructions that afterwards get activated, will create something in the plot file. The dials are not active while plot_on is selected.
Plot_setup
 
plot_setup root_name plot_number <plot the menu Y/N>
<plot in stereo Y/N>
 
Setup for the plotting menu. Define the root name of the plot file, and the plot number. The root name is a template used to generate a unique name for each file to be plotted. The plot number will be incremented for each file created, and the plot number inserted into the file name template. The position of the plot number in the template is indicated by character %. For example, defining crbp_%%%.plt as the template and a plot number of 1 would result in the first file being crbp_001.plt, the next one crbp_002.plt etc. Defining crbp.plt as a template would result in the file being overwritten after each plot. The user is also prompted to plot the menu and whether to make the final plot in mono or stereo.

Pop-up (120904)
pop-up <pop-up descriptor>

This command activates a pop-up descriptor that must exist as an ODB entry or as an external file.
O > Pop-up
New> Open a pop-up menu.
New> Pop-up descriptor:popup_skel_2ry
New> message [prompt [ Make 2ry framework] colour_prompt [lime_green]] m
New> ap [ prompt [ED map: ] default [$skel_map] colour_prompt [magenta] col
New> our_focus [yellow] return_value [value_1] ] text [ prompt [Skeleton ob
New> ject: ] default [${skel_mol}_mc] colour_prompt [magenta] colour_focus
New> [yellow] return_value [value_2] ] text [ prompt [Use the existing Trac
New> e? (Y/N): ] default [N] colour_prompt [magenta] colour_focus [yellow]
New> return_value [value_3] ] macro [ prompt [Activate macro ] colour_promp
New> t [red] colour_focus [yellow] macro [ Auto_2ry #value_1# #value_2# #va
New> lue_3# vis * off vis trace on vis 2ry* on fm_set 2ry 30. ;; 4.5 red f
New> m_draw 2ry ] ]

The output text is the contents of the descriptor to be activated. A number of pop-up descriptors are distributed in the O data directory in the ODB file popup.odb . This file is read in my the Master-menu system when the user activates a command that activates a pop-up. Here is a listing of the pop-ups that areThe distributed on 120913:
O > dir popup*
Heap> POPUP_REBUILD_MOL_SYMBOLS T W 1752
Heap> POPUP_REBUILD_HKL_SYMBOLS T W 1679
Heap> POPUP_REBUILD_REFMAC_SYMB T W 2628
Heap> POPUP_SKEL_OBJ_SYMBOLS T W 2117
Heap> POPUP_SKEL_DOIT_SYMBOLS T W 2847
Heap> POPUP_SKEL_DOIT_RAD T W 2993
Heap> POPUP_SKEL_DOIT_ALL T W 2336
Heap> POPUP_REBUILD_WATER_ADD T W 1314
Heap> POPUP_SKEL_2RY T W 2263
Heap> POPUP_SKEL_SEQ T W 1898

The user is free to design his/her own pop-up, of course. Here is the pop-up that is activated to calculate a secondary structure framework (Auto_2ry command) from an experimental map via the Master-menu system:
O > wr POPUP_SKEL_2RY ;;
POPUP_SKEL_2RY T 31 72
message [prompt [ Make 2ry framework] colour_prompt [lime_green]]
map [
prompt [ED map: ]
default [$skel_map]
colour_prompt [magenta] colour_focus [yellow]
return_value [value_1]
]
text [
prompt [Skeleton object: ]
default [${skel_mol}_mc]
colour_prompt [magenta] colour_focus [yellow]
return_value [value_2]
]
text [
prompt [Use the existing Trace? (Y/N): ]
default [N]
colour_prompt [magenta] colour_focus [yellow]
return_value [value_3]
]
macro [
prompt [Activate macro ]
colour_prompt [red] colour_focus [yellow]
macro
[ Auto_2ry #value_1# #value_2# #value_3#
vis * off
vis trace on
vis 2ry* on
fm_set 2ry 30. ;; 4.5 red
fm_draw 2ry
]
]

This is what gets drawn in the 3D window:



The first line is a prompt, and the fifth line activates a macro to do the calculation. Symbols are used in this example to describe the electron density map and the skeleton that will be used. In the pop-up descriptor, the current value of the symbol skel_map is taken as the map, and the main-chain object generated from the skeleton described by the symbol skel_mol is the object used by the Auto_2ry command. The fourth line allows the user to indicate if an existing TRACE molecule is to be used. These actions (as well as colours, prompt text etc) are encoded in the pop-up descriptor.
If you change your bind, just click on the little red square in the top right corner of the pop-up window.
The user makes changes by clicking on a line that accepts input, and starts typing text to append to the current text. The <delete> key removes the last text character. At the moment, left and right arrows keys are not recognized by pop-up widgets, they enter values to the 'Dial Menu' window. Up and down arrow keys, move within the widget.
Each pop-up descriptor has a series of key words that can, in turn, call sub-commands. All commands are delineated by left and right square brackets [ ], respectively. Level 1 commands are: message, map, molecule, text, macro. Level 2 key words depend on the calling level 1 command as follows:
message :- prompt, colour_prompt
map :- prompt, default, colour_prompt, colour_focus, return_value
mol :- prompt, default, colour_prompt, colour_focus, return_value
macro :- prompt, default, colour_prompt, colour_focus, macro
Input text can be associated with a local variable via the return_value level 2 command, and variables can be used to generate (part of) the activated macro. In the example above, the 3 variables that may have been changed by the user, are used to define input to the Auto_2ry command, while the rest of the macro modifies object visibility and draws an object from the new map created by Auto_2ry.


Print
 
Print a message on the terminal. Used in macros.

QDS Overview (121023, 170116)
Quick and Dirty Sketcher contains a number of O commands to generate coordinates for small molecule ligands with a point and click interface. QDS also generates restraint entries for bonds, angles and torsion angles as the ligand is made. This means the user is able to use the Refi commands as the molecule is produced. One QDS command also generates the relevant entries for using Tor_residue. This means that the full strength of the Grab_build system can be used for electron density fitting and for general  modeling.

The amount of knowledgeable chemistry in QDS is rather small. It might, therefore, be necessary to edit the dictionaries that are generated by the system. Once you are happy with the dictionary, you might want to add it to your stereo_chem.odb file, or not.

QDS includes its own menu system, part of the new so-called Master-menu system (see below).

To use QDS, you will also need to load the latest menu.odb file as well as the specific qds.odb database entry into O. To use the Master-menu system, you will need all menu_*.odb files in your ODAT directory, and to load menu_master.odb into your running O database.

QDS is the first O feature to have an explicit undo capability. I don’t apologize for not having an undo capability in other commands, since almost all of the commands available within O work by accepting or not the results of a user’s input. QDS does not, it does what you tell it, and then you have a chance to undo the action. There are 5 levels of undo. Perhaps there should be more. I implement the undo feature by writing out all ODB entries associated with the molecule to an O binary database file. The molecule name is part of the file name, as is an integer in the range 1-5. For example, if the ligand is called LIG, the undo feature will generate up to 5 files with names like backup_lig_<value>.o where <value> is 1, 2, 3, 4 or 5. The files are stored in the OTMP directory.

Here are the current set of QDS commands

O > qds
Mnp>  QDS          is not a unique keyword.
Mnp>  QDS_setup    is a possibility.
Mnp>  QDS_extend   is a possibility.
Mnp>  QDS_atom     is a possibility.
Mnp>  QDS_ring     is a possibility.
Mnp>  QDS_write    is a possibility.
Mnp>  QDS_undo     is a possibility.
Mnp>  QDS_extrac   is a possibility.
Mnp>  QDS          is not a visible command.

Here is the QDS user menu in the Master-menu system.

A QDS molecule has a few extra ODB entries in it and MUST be made with the QDS_setup (which is used by 'Make new QDS molecule' in the Master-menu) or QDS_extract commands. If you want to return to an old QDS molecule, it is best accomplished with the Master-menu command 'Use existing QDS molecule' to redefine the QDS molecule and residue type. This information is actually stored in the database in ODB .qdsc entries 2 and 3.

At any moment, QDS is working with a defined atom type. This type can be set or changed with the QDS_atom command. Every recognized atom type has entries in qds.odb for relevant bond lengths, angles, branching torsion angles, fixed and flexible torsion angles. The user must first generate the relevant ODB entries associated with the ligand and the QDS system by using the QDS_setup command. The QDS menu has a macro to activate this command, which also defines a symbol for the molecule name used by the other menu commands. The small molecule is actually generated with repeated calls to the QDS_extend command. The first QDS_extend places a single atom of the desired type at the current screen centre, the second time it’s used results in a bonded pair of atoms, and the third time makes 3 linked atoms at a defined angle. Subsequently, the user must identify the atom to which the new atom is bonded. Sometimes, QDS will be unable to this without getting more information from the user; for example, chiral centres may be introduced or the new bond between the two atom types could be of different lengths. QDS_ring allows one to create rings, and the user simply identifies the 2 atoms that need to be connected for ring closure. The stereo-chemical information needed for O’s regularization system are generated in real time, while the information needed to define torsion angles for Tor_residue are made as part of QDS_write. Click on 'Undo action' if you make a mistake. There are 5 levels of undo.

The default torsion angle that is used when adding a new atom, can be changed to 180, 0, +/- 60, or +/-90 degrees by clicking on one of the cyan coloured items as appropriate.

Define the type of atom you want for the first atom in your new residue BEFORE initialising the new molecule. A small aromatic molecule will be constrcted in the following example. Therefore, the 'C aromatic bond' was clicked first to define the atom type needed to build the phenyl group.

Here is how one starts the process from the terminal interface:

O  > QDS_setup
New> This WILL initialise certain datablocks.
New> Molecule name ([] to exit): new
New> Residue type [QDS]:
New> This action can be undone.
New>  Database compressed.

This could also have been achieved by activating 'New molecule' in the menu. Such an action forces the user to define the necessary symbols.

O  > You most type something at the prompt
New> This WILL initialise certain datablocks.
New> Prompt> QDS molecule :new
New> Prompt> QDS residue type : qds
New>  Database compressed.


A single atom now appears at the screen centre.


Clicking on 'Extend from ID' now draws a bond of length 1.40 Å which is appropriate for a bond between a pair of C_aromatic atoms (the current atom type, at the time & listed on the Prompt line in the 3D window)


Another 'Extend from ID' produces 3 connected atoms that subtend an angle of 120º which is also appropriate (and defined in qds.odb):


The next 'Extend from ID', however, forces one to identify where QDS should extend the molecule by an atom, and I’ve done it 3 more times to produce this extened molecule:


To make these 6 atoms form a ring, use 'Make ring' and identify C1 and C6 to define where the ring needs to be closed:

Note that C1 is no longer at the screen centre. In fact, this structure has been regularized, and fixed torsion angle restraints have been defined to force the flat ring (outliers are listed on the terminal, as usual).


Now I want to add a hydroxyl group at C3, so I change the atom type to 'O single bond' in the menu, then 'Extend from ID', and then ID C3:


Next, I want to make another ring branch, a tetrahedral carbon (C single bond) from C5 and then attach 3 fluorine atoms to this carbon.


Adding the C single bond and the first F bond are simple uses of Extend from ID, but the QDS_extend command will prompt for help on adding the 2nd and 3rd fluorine atoms:

New> More than one branch is possible
New>  Option     1C_SING F_SING   120.000
New>  Option     2C_SING F_SING  -120.000
New>  Which one [1] :
New> This action can be undone.
New> C_SING angle needed
New> More than one branch is possible
New>  Option     1C_SING F_SING   120.000
New>  Option     2C_SING F_SING  -120.000
New>  Which one [1] : 2

To generate the necessary ODB dictionary entries requires QDS_write (also available from the menu). This actually generates a new ODB entry as well as a file in the computer file-system:

O > qds_write
New> Write out the restaints associated with NEW
New> File name [qds_stereo_chem.odb]:
New> Stereo-chem dictionary created in ODB for residue type: QDS
O > dir qds*
Heap>  QDS_BONDS_ANGLES          T W      3650

You could use the file to update your stereo_chem.odb entry to include your new ligand, but remember to upgrade the line count indicator in the header line. However, you don't have to since the Refi_gener command will search in your ODB for an entry < restyp > _bonds_angles if the residue is not described in the stereo_chem.odb file and .bonds_angles ODB entry.

At this stage, the new ligand has the following entries associated with it:

O > dir new*
Heap>  NEW_RESIDUE_NAME          C W         1
Heap>  NEW_RESIDUE_TYPE          C W         1
Heap>  NEW_ATOM_NAME             C W       200
Heap>  NEW_ATOM_XYZ              R W       600
Heap>  NEW_ATOM_B                R W       200
Heap>  NEW_ATOM_WT               R W       200
Heap>  NEW_ATOM_Z                I W       200
Heap>  NEW_ATOM_TYPE             C W       200
Heap>  NEW_ATOM_SELECT           I W       200
Heap>  NEW_ATOM_VISIBLE          I W       200
Heap>  NEW_ATOM_BUILT            I W       200
Heap>  NEW_RESIDUE_POINTERS      I W         2
Heap>  NEW_RESIDUE_CG            I W         4
Heap>  NEW_MOLECULE_TYPE         C W         2
Heap>  NEW_MOLECULE_CA           C W         1
Heap>  NEW_MOLECULE_CA_MXDST     R W         1
Heap>  NEW_ATOM_COLOUR           I W       200
Heap>  NEW_TORSION_FLEXIBLE      I W         6
Heap>  NEW_CONNECTIVITY          I W        21
Heap>  NEW_BOND_DISTANCE         I W        44
Heap>  NEW_BOND_ANGLE            I W        80
Heap>  NEW_TORSION_FIXED         I W        54

Note that the atom names contain the element and a counter. There is a maximum of 200 atoms in the residue, and only one residue in the molecule.


The Tor_residue command in O requires the definition of each torsion angle, and a list of the atoms that are affected by changes in the angle. How should one do this for the case of a general ligand? QDS assigns a torsion angle to be fixed or flexible, and only allows you to change flexible angles. One is not allowed to change torsion angles in closed rings. QDS decides which atoms are affected by counting the number of atoms that change in either of the 2 possible directions, and selecting the angle that changes the lower number. This prevents the tail from wagging the dog.

In the above ligand, for example, there are 4 flexible torsion angles. The angle between C2 and C3 could be defined so that only 2 atoms move, or 9, so QDS chooses to change only 2 by defining TOR_1 to be C4-C3-C2-C1. Rotations around the C3-C4 bond could change 4 or 7 atoms, so TOR_2 is defined by C5-C4-C3-C2. Changing TOR_4, however, rotates the ring because only 5 atoms are affected while 6 would be affected in the other direction.

If you are unhappy with the dictionary, you can, of course, write it to the file system, modify it by hand, and then read it in again.



QDS_atom (080219)
qds_atom <atom type>

This command redefines the default atom type for the QDS system. This will be the atom type of the next atom added with qds_extend. The user will be prompted for allowed atom types.

O > qds_atom
New> Here are the possible atom types
C_SING C_DOUB C_TRIP C_AROM N_SING N_DOUB
O_SING O_DOUB S_SING S_DOUB P_SING F_SING
CL_SIN BR_SIN I_SING
New> Atom type [C_single]: o_double


QDS_extend (080219)
qds_extend <ID atom>

This command extend the ligand by one atom. The new atom will be of the current default type. After 3 atoms have been built, the user must identify where the atom is to branch from. If QDS thinks there are alternate branch pints, the user will be prompted to decide.

O > qds_atom c_single
O > QDS_extend
New> This action can be undone.
New> C_SING angle needed
New> More than one branch is possible
New> Option 1C_SING C_SING 120.000
New> Option 2C_SING C_SING -120.000
New> Which one [1] : 2


QDS_ring (080219)
qds_ring <2 IDs>

This command forces a ring closure between the two identified atoms


QDS_setup (080219)
qds_setup <mol> <residue type>

This command begins the creation of a new ligand. An existing molecule of the same name will be overwritten. QDS will create space for 200 atoms and all of the usual ODB entries associated with a molecule in O. QDS also creates a special atom property <mol>_atom_built which indicates the atoms that have been built by QDS (value 1 means built, 0 not built).

O > qds_atom c_double
O > qds_setup
New> This WILL initialise certain datablocks.
New> Molecule name ([] to exit): fa
New> Residue type [FA ]: fa
New> This action can be undone.
New> Database compressed.


QDS_undo (080219)
qds_undo <mol>

This command reads in the last undo backup file for a particular molecule, and recreates the object of the ligand.

O > QDS_undo
New> Molecule name [FA ] :
New> A binary file
New> Database compressed.
New> Database compressed.
....
New> There were 22 ODBs in the file.


QDS_write (121023)
qds_write <file name>

This command generates a file containing the information that O needs when working with this residue type. This includes connectivity information, torsion definitions, and stereochemistry data in the form of bond lengths and angles, as well as fixed and flexible torsion angles in the format used by the Refi-commands. No rotamer information gets generated. The file is an ODB, since it includes a header and can therefore be read into any O session. However, a text ODB (called <residue_type>_bonds_angles) containing the same information is also directly generated in the O database of the user.

O > qds_write
New> Write out the restaints associated with FA
New> File name [fa_stereo_chem.odb]:
New> Stereo-chem dictionary created in ODB for residue type: FA
O > $ cat fa_stereo_chem.odb
FA_BONDS_ANGLES T 26 72
residue FA
centre C1
atom C1 C2 C3 C4 O5 \
O6 C7
torsion tor_1 C1 C2 C3 C4 \
C3 C4 C7
torsion tor_2 C3 C2 C1 O5 \
C1 O5 O6
connect_all C1 C2
connect_all C1 C2
connect_all C2 C3
connect_all C3 C4
connect_all C1 O5
connect_all C1 O6
connect_all C3 C7
bond_distance C1 C2 1.220 0.02
bond_distance C1 C2 1.500 0.02
bond_distance C2 C3 1.540 0.02
bond_distance C3 C4 1.540 0.02
bond_distance C1 O5 1.420 0.02
bond_distance C1 O6 1.220 0.02
bond_distance C3 C7 1.540 0.02
bond_angle C1 C2 C3 110.0 1.0
bond_angle C4 C3 C2 110.0 1.0
bond_angle O5 C1 C2 120.0 1.0
bond_angle O6 C1 C2 120.0 1.0
bond_angle O6 C1 O5 120.0 1.0
bond_angle C7 C3 C2 110.0 1.0
bond_angle C7 C3 C4 110.0 1.0
torsion_flexible C4 C3 C2 C1 180.0 20.0
torsion_flexible O5 C1 C2 C3 180.0 20.0
torsion_fixed O6 C1 C2 O5 180.0 2.0
torsion_fixed C7 C3 C2 C4 -120.0 2.0


Quick map commands have been superceded by the FastMap system.
Quit
 
Stops the current session without saving. The <ESC> key accomplishes this too.