End_object

End the current open object and display it. The atomic colouring codes in the atom property datablock <mol>_atom_colour are used for bond drawing. If the user has not issued colouring commands (see the Paint major menu) default values are taken: carbons yellow, nitrogens blue, oxygens red, sulphurs green, phosphorous pink etc.

Error_exit (101014)
This command is used to control error handling in macros. Some commands in O (including Molecule_name, Water_add, Water_peak, Water_profile, HKL commands, NCS_average, NCS_Sphere) set internal flags on facing an error condition. The Error_exit command will recognize such an event and immediately exit from a macro, popping all other nested macros in the process. The command is widely used in the master-menu system, e.g. a macro in the rebuild menu:

@rebuild_ca_rainbow t 4 72
mol $rebuild_mol error_exit @pt_red_blue
mol $rebuild_mol object ${rebuild_mol}_ca ca ; end
vis * off
vis ${rebuild_mol}_ca on
!

If the symbol for the molecule getting rebuilt has not been defined, or if the molecule no longer exists in the user's ODB, O will exit from the macro before trying to colour and draw objects.


EZD_draw

ezd_draw <level> <colour>

The command contours the last read in EZD file at the desired level, creating an object with lines of the desired colour. All of the EZD map is contoured. The contour level is in the
s level of the map. The following example would contour at the s level, creating a blue object

O > ezd_dr 1. sky_blue
 
EZD maps can also be drawn with the F(ast)m(ap) commands.

EZD_map

ezd_map <keyword data>i

This is a formatted electron density file. The keywords define the origin, extent, grid, cell constants, scaling, and the density. The order is not important, but the values must be on the same line, except for the density data. The density is read/written by a block matrix operation (((ed(i,j,k),i=1,nx),j=1,ny),k=1,nz) with 7 density values on a line. The density is divided by the scale constant. SInce the density file includes the O keyword, this command is always actived as if the file were a macro
Example
 
% cat chop.ezd
EZD_map
! Created by ODALISQUE V-920917/2.5
! At Mon Sep 21 13:21:16 1992
CELL 40.090 47.390 69.340 90.000 90.000 90.000
ORIGIN 42 -21 -11
EXTENT 33 27 17
GRID 80 80 80
SCALE 1000.000
MAP
35. -122. -293. -340. -245. -138. -135.
-210. -248. -175. -26. 108. 162. 124.
16. -123. -244. -289. -215. -43. 131.
200. 126. -36. -202. -311. -322. -210.
....
....
-426. -73. 486. 779. 483. -208. -687.
-504. 160. 666. 600. 218. 127. 557.
1074. 1081. 487. -223. -556. -472. -273.
-169. -112. -18. 30. -107. -380.
END
 
In O, this map would be read in

O > @chop.ezd

Flip_peptide
 
Flip_peptide <id an atom> or <mol res atom>
 
This is an easy but dirty way to flip peptides, since the peptide group simply is rotated 180° around the Ca - Ca direction. After the flip, the geometry of the peptide group of the current and adjacent residues are slightly distorted. The operation should therefore be followed by a regularization or a database fragment fit. This is an immediate action command, there is no need to accept/reject the new coordinates. If you regret the flip, simply activate the command once more.
You must identify any atom in the residue whose carbonyl oxygen gets flipped. A number of people have identified the nitrogen atom N of the next residue, thinking that will define the peptide. They are surprised to see the 'next' oxygen flip!
F(ast)m(ap) Commands Overview (080109)
 
These are a group of commands that work with electron density maps. They differ from the map_* and rsr_* commands from older version of O in what they do and how they do it. When a user works with these commands, the electron density maps is kept in computer memory, and will remain there until it is explicitly removed, or the program stops. If the user defines the space group, and provides a crystallographic asymmetric unit, (s)he can work anywhere in space, i.e(s)he is not limted to be within the volume of defined by the map envelope.
On program restarts, the user usually needs to redefine the file being worked with (command Fm_file) and, in the case of contouring, the parameters being used could be defined (Fm_setup). This can be done with the on_startup macro, for example.
Some of the Fm-commands are used for real time contouring of elctron densities, some for real-space refinement of models into density, and one assists in determining the chain directionality. All modern O commands that make use of the electron density, use the FastMap system. You will usually be prompted for the name associated with the map. Residue based goodness of fit indicators, for example, are calculated with the RS_fit command.
There is a new pull-down called 'Density' where there is a separate pane for contouring each of the possible 5 maps. These , in turn, allow the user to control real-time contouring by changing the radius, level(s), colour(s) via a set of sliders.
The FastMap contouring commands should, in general, replace contouring with the Map_* and Qmap_* commands. They are controlled by a series of sliders that allow one to set the contour level, radius and colour (in RGB). The contour level can be in absolute units (electrons/Å3) or in what is usually called sigma units.
Crystallographers have a fixation with the latter and, at the time of writing (080109), I feel partly to blame for encouraging this in all implementations of O from V6 to V11. The units are more correctly called root-mean-square of the electron density within the 3D volume element of the electron density, i.e. the square root of the sum of the squares of all the density points in the map. From now on, I will use RMS instead of sigma. It has NO physical (or mystical, for that matter) meaning. It is a particularly unfortunate way of looking at, and describing (|Fo|-|Fc|) maps. For example, suppose you are looking at the first such map calculated during the refinement of a structure, but before adding water molecules. Now look at the density for a nice water molecule, and take the peak height in RMS units. Do not add it to your next model, or add it with 0.0 occupancy. Now check the peak height in RMS units for the same water molecule during subsequent rebuilds. This value will shoot up as the maps become flatter, and by the end of the refinement it will seem to be a huge peak in RMS-units. It isn't; it's the same starting water molecule. If you use absolute units, you'll not be fooled.
You don't have to follow my advice, O allows you to use either mode, and the default is stored in the user's database so it can be changed (see Fm_mode for details). Also remember that in your first experimental map, you are working in arbitrary density units. If you have a complete unit cell, the RMS value is as good a place as any to start working. You might want to scale such maps (Fm_mult) to make the RMS value equal to 1.0
The Fm RSR commands do not subtract neighbouring atoms from the density before refinement.
Here are those starting with Fm:

Fm_file - to define and read in an external file of electron density
Fm_setup - to define parameters for electron density contouring
Fm_draw - to contour a loaded map at the current screen centre
Fm_mode - set the slider electron density units mode (absolute or RMS)
Fm_multiply - apply a multiplicative scale constant to a loaded map.
Fm_zap - to remove a loaded density from computer memory
Fm_rsr_zone - real space refinement of a zone of residues to a density
Fm_rsr_rotamer - finds the best fitting rotamer, carrying out a roational search about Ca
Fm_rsr_torsion - does a stepped torsional search real-space refinement.
Fm_local_av - local average allows one to enhance the alpha helix Christmas tree affect
Fm_draw
 
This command contours a defined map with the current settings for that map
 
O > fm_draw
Fm> What map? [MIR]:
Fm> Symmetry operators not stored
Fm_file
 
fm_file <file> <name> <space_group>
 
This command defines which electron density file is to be read in. The program can read in the usual binary format used in the map_* commands (O style maps), CCP4, CNS, TNT, EZD formats. I have not tested all of them. Note that the O style maps still have an advantage in terms of size. If you frequently use other maps, the reading time is improved by having them in x fastest, then y , then z (ie. z-sections)
Here is what happens:
 
O > fm_file
Fm> File name? []: ano1.map
Fm> Name of this map? [Q1]: mir
Fm>
Fm> Map type is O
Fm>
Fm> Parameters as read from the map file:
Fm> Grid ................. 76 82 48
Fm> Origin ............... 0 0 0
Fm> Extent ............... 77 83 49
Fm> Fast, medium, slow.... X Y Z
Fm> Cell axes ............ 91.80 99.50 56.50
Fm> Cell angles .......... 90.00 90.00 90.00
Fm> No reslicing of map necessary
Fm> Prod ................. 20.00
Fm> Plus ................. 0
Fm> Min, max, sigma ...... 0.00000 8.35000 0.95545
Fm> Scale ................ 1.000
Fm> Symmetry information may be used
Fm> Space group? [Do not use]: p212121
Fm> O-style symm-ops for spacegroup P212121
Fm> Database compressed.
Fm> 4 symmetry operators
 
The symmetry operators are assumed to be in the O-data directory in the sub-directory symm in a file named according to the spacegroup name. In the above example, a datablock mir_map_operators is created that contains the crystallographic symmetry operators to associate with the map. To disable the application of crystal symmetry, just delete this entry or enter just a <CR> at the space group prompt.
Fm_local_a(verage)
 
An important stage in the tracing of a new structure is when the crystallographer is able to determinine the chain's directionality. One way of doing this is to locate alpha helices and note how the side chain 'hang', pointing towards the N-terminus of the helix. I call this the Christmas tree affect. With this command the user specifies an electron density and then identifies 2 atoms to define a zone. The command builds up an electron density (LOCAV) that can be displayed with the density pull down menu. If the zone of atoms is an alpha helix, the density will show an enhanced Christmas tree affect that will in turn help in defining the directionality of the chain.
This is an example from one of the helices in the P2 myelin example. Notice how the CB atom of the central residue is pointing clearly into the denisty.
 

Fm_rsr_group (971204)
 
fm_rsr_group <ID atom>
 
This command is the first of a new generation of real-space refinement commands in O. Unlike the RSR_* commands, I now use a much simpler goddness of fit indicator (Buerger's Sum Function and more like Essens). This makes it faster.
 
O > fm_rsr_group
In group 35
0 1 621.6002
0 2 626.0002
0 3 667.3000
0 4 680.8501
1 5 689.8000
0 1 689.8000
0 1 689.8000
 
The program cycles through a local rotation and translation search for all atoms in the fragment of the identified atom. The score is an indicator of how well the fragment fits the map defined in the last fm_setup, fm_draw, or F(ast)m(ap) slider.
The group of atoms is defined by all of the atoms that can be linked to the IDed atom.
This command is used by the Template system in O to fit SST units.
Fm_rsr_rotamer (020709)
 
This command is one of a new generation of real-space refinement commands in O. Unlike the RSR_* commands, I now use a much simpler goddness of fit indicator (Buerger's Sum Function and more like Essens). This makes it faster.
This command works with FastMap densities. It uses the map specified by the Density/Density pull-down. After identifying an atom, the option generates a side-chain mask based on the current contouring level in the FastMap slider for the map, and the coordinates of the Ca, N, C atoms for proteins (C1*, O4* and C2* for nucleic acids). Only electron densities within this mask are used in the goodness-of-fit calculation, and therefore reduces the risk of moving into density meant for some other group of atoms. Each rotamer for the residue is generated and then a rotational search pivoting around the CA atom is evluated. The rotamer with the best score after the pivot search is drawn and can accepted. This command can only be used with residues that have rotamers deined in the stereo-chemistry library used by O.
 
O > fm_rsr_rot
Fm> Score for TRP rotamer 7 2.12115 1.79625
 
The scores are indicators of how well the rotating atoms fit the map, for all atoms being pivoted (including N, Ca, C for proteins) and for just the side-chain atoms.
Fm_rsr_torsion (020709)
 
This command is one of a new generation of real-space refinement commands in O. Unlike the RSR_* commands, I now use a much simpler goddness of fit indicator (Buerger's Sum Function and more like Essens). This makes it faster.
This command works with FastMap densities. It uses the map specified by the Density/Density pull-down. The option carries out a stepped torsion rotational search (30 degree stepping interval) around the bonds defined between 2 identified atoms. These atoms cannot be connected by a ring. If one defined N and CD1 of a PHE residue, for example, this command would vary the CHI1 and CHI2 angles. The command uses the connectivity on the screen to decide what atoms are affected in the torsional rotation. Note that the order of identification determines which atoms get rotated (the first atom IDed does not rotate).
 
Fm> Fm_rsr_torsi
Fm> Score: 2.025
 
The score is an indicator of how well the rotating atoms fit the map .
Fm_rsr_zone (041228)

fm_rsr_zone <id two atoms> or <mol res1 res2 object>

This real-space refinement option also uses the simplified scoring function. Each residue is defined as a series of groups in the stereo_chemistry.odb dictionary. These groups undergo local rotational and translational shifts to optimize their fit to the density but are prevented to move too far from other groups containing the same atoms. For example, a tryptophan residue is split into 3 groups:

fragment_rsr_1 CA C O N+ CA+
fragment_rsr_2 N CA CB C
fragment_rsr_3 CB CG CD1 CD2 NE1 CE2 CE3 CZ2 CZ3 CH2

The first two groups share the CA and C atoms and so these atoms are restrained to be close together when the groups are moved to optimize their fit to the density. Similarly the third group shares the CB atom with the second group and so the position of this atom will also be restrained during group optimzation.  This command should only be used at a resolution where the atomic groups are well defined.  At lower resolution, the Build_ed_rot command is to be preferred, where the side-chain conformation is restricted to rotamers.

pd_ed_fit.tiff This command is also available from the pull-down menu system for a zone or a single residue


Fm_setup (020709)

 
This command defines which map you want to contour and what parameters are to be used. The map must have been read in with the fm_file command. The user can choose 3 levels to work with.
 
O > fm_setup
Fm> What map? [MIR]:
Fm> Radius [ 15.0]:
Fm> Line type [solid]:
Fm> Number of levels [1]:
Fm> Level 1? [ 1.000]:
Fm> Colour? [maroon]:
Fm> MIR_1
Fm> Symmetry operators not stored
 
Line types can be solid, dashed, dotted, dot_dash, surface or transp. The latter two types specify solid and semi-transparent surfaces.
If space group symmetry had been specified in the fm_file step, the last line of the above listing would have been absent.
 

Fm_mode (080110)

fm_mode <map> <slider_mode>

This command allows the user to modify how the level is defined in the FastMap slider window. The user can choose to work in absolute units (electron/cubic Å) or in RMS-units. The default value is the current mode.


O > Fm_mode
New> What map? [F21]:
New> Slider mode ([Absolute]/RMSD): r

The slider will then change in style from

to:

Only the 'Level' slider is affected, and in this case was reset to RMS=1.0.

The default value that is used when the map is read into or created in O is controlled by the second item in the .fm_real ODB vector. The default value can, therefore, be changed by the user with the Db_set_d command

O > dir .fm*
Heap> .FM_REAL R W 2
O > wr .FM_REAL ;;
.FM_REAL R 2 (10(1x,f7.5))
0.80000 0.00000

The following will set the default to RMS units:
O > d_s_d .fm_real 2 2 1.

while the following sets the mode back to absolute units:
O > d_s_d .fm_real 2 2 0.

If the ODB .fm_real is deleted, the default mode is set to use absolute units


Fm_multiply (080110)

fm_multiply <map> <value>

This command allows you to apply a multiplicative scale constant to a FastMap that has been read or created in O. It can be used to set the RMS of the map to unity.

O > Fm_multiply
New> What map? [F21]:
New> Min, max, RMS ...... -1.43633 4.53619 0.50280
New> Multiplication constant to apply to map [ 1.99]:
New> Min, max, RMS ...... -2.85669 9.02194 1.00000


Fm_zap (971204)
 
This command clears the desired map from computer memory
 
O > fm_zap
Fm> Zzzzap what map? [MIR]:
 
Linux Gampads with O (020618)
 
From O v8.0.9 USB Gamepads are support by the Linux version of O.
I have tested 2 gamepads: Microsft Sidewinder and Logitech Wingman RumblePad. Gamepads usually differ in detail but have some common features. The Sidewinder has a 'thumb' type joystick, for example, while the Wingman has 2 little, real joysticks.
Here are a couple of pictures of my Sidewinder:
 
The above view shows the 2 shooter buttons on the Sidewinder.
 
 
Below is the WingMan:
 
 
This gamepad also has a thumb joystick, but the numbers that it spits out are wierd, so I'm not using it.
As well as the shooters, both gamepads have 6 buttons called A, B, C, X, Y and Z, and another one close to the thumb joystick (I call it the thumb button).
This is how O uses gamepad inputs:
Joystick 1: controls the X- and Y- viewing, or the Z-viewing. The thumb button acts as a toggle, between these controls. If a grab command is active, this joystick controls the grab X- and Y-rotations.
Joystick 2: controls the Z-viewing if present. If a grab command is active, this joystick controls the grab Z-rotation.
Buttons A/X: control the zoom
Buttons B/Y: control the clipping
Buttons C/Z: change the 'active dial', just like the up/down arrows on the keyboard.
Shooter buttons: generate inputs from the 'active dial'
All other gamepad inputs are ignored.
Overview of Grab Commands (020709)
 
The Grab commands allow the user to change a model by moving bits of it around. These commands differ from the Move commands in that they do not use dials (whether real or fake ones) to control the movement of the affected atoms. Instead, the mouse and keyboard control all manipulations. The translation that is applied to the atom(s) is also different. In the Grab commands, the mouse pointer is the position to which the affected atom(s) is/are moved. The Grab_atom command, for example, requires that an atom is first identified. If the mouse button is kept depressed near this atom and the mouse then moved, the identified atom will follow the moving mouse pointer until the mouse button is released. The rotational component (if present) is also controlled by the mouse, but requires that the keyboard Ctrl-key is also depressed. Mouse movement with right button and Ctrl-key depressed is then mapped into horizaontal and vertical rotations (as for the viewing transformation). Depressing the middle and right mouse buttons with the Ctrl-key depressed is mapped into a rotation around an axis perpendicualr to the screen.
Under Apple OS-X, a single mouse button can be used to control the rotational components by using the <ALT> key.
Under Linux, a Gamepad can be used to control the rotational component. The precise controls depend on which gamepad is being used.
There is no Grab_zone command, just break a few bonds and use Grab_group.
The Grab_build is of special interest, since it captures many functionas in one useful window.

Grab_atom
 
grab_atom <id>
 
This command allows the user to move an atom around in space. All movement is controlled by the mouse. The atom must be identified, and the left mouse button must be kept down. As the mouse moves, so will the atom. When the mouse is released, the atom stops moving. The same atom or another atom can then be identified and moved around. Activating No, returns the present moving atom to its position when it was last identified. The command can be cleared with the Yes or Clear_flag commands.
To be more specific about the use of the No flag, lets say that there is an atom at point A. It is identified, the mouse left button kept down, and moved so that the atom is moved to point B. The mouse is now released, and lets say that the view is changed (to see what has happened). The same atom is now ID'ed again, and moved to point C. If the No command is now activated, the grabbed atom goes back to point A. Now lets say we move it from, A to C via a mouse release at B. Then we release the mouse and grab a different atom. After a while we come back to our starting atom and grab it again, shifting it to point D. What happens when we say No? It goes back to point C.
Grab_build (020709)
 
grab_build <mol> <residue> or <ID>
 
This command allows a user to rebuild an existing residue, or to extend a growing chain. The user must specify a molecule and the name of the starting residue. A special window is then displayed that controls all of the funcionality associated with the command :
Clicking on the first line clears the command and in the process accepts any changes that might have been made. Two objects are made; one corresponds to the zone of residues that are built with the command, while the other object shows the residues that are close to the last residue being built. The former object (called BIT) begins as just the first residue specified and then grows as the command is used. The latter object is called <mol>sph and uses the current sphere radius.
The current, 'active' residue can be moved around under the control of the mouse. Clicking on an atom with the left button and sliding the mouse causes a translational shift. Pressing the keyboard <Ctrl> and the right button causes a pivot on the central atom of the residue. If one identifies aa different atom in the residue, it then becomes the pivot point.
The second line shows the sequence as a one letter code; the current residue is in the middle (a W in the above). The < & > symbols allow the user to move backwards and forwards in the sequence/structure. As this occurs a new residue is either read in or gets its coordinates calculated. This, however, depends on the current 'grow mode' setting, controlled on the fifth line. If this mode is 'As is', the residue gets drawn with its current atomic coordinates. If the mode is '2ry struc.', the coordinates have the conformation defined in line four, with the side-chain of the most frequent rotamer.. If the grow mode is 'Auto 1', the program attempts to create a conformation that fits thedensity. The algorithm makes use of the currently defined skeleton, the main-chain fit to the density, and a match to the main-chain database. The latter mode is specific for proteins.It is optimised for low resolution tracing.
The third line allows one to change the rotamer for the side-chain using the < & > symbols to view the different possibilities. The rotamer information must exist in the .bonds_angles ODB for the particular residue. Clicking on the text, draws the currently defined rotamer.
The fourth line in the window allows one to specify different residue conformers. This information also needs to be defined in the .bonds_angles ODB. In the default library, protein residues, for example, can be buildt as a-helices or b-strands. Clicking on the < or > symbols shows what conformers are available, but nothing dramatic happens unless one is in grow mode '2ry struc.'. The next residue to be built will then take on the conformation that is defined. Alternatively, the current residue will take on this conformation if the text in line 5 ('grow mode') is clicked.
The fifth line controls the 'grow mode'. If the user tries to fit the residue but does not like the result, clicking on the text will restore the coordinates using the current 'grow mode' setting. The starting, default mode is 'As is', and the residue takes the current coordinates. Other modes are '2ry struc.' and 'Auto 1', see above.The 'Auto 1' will only work for protein residues.
The sixth, seventh and eighth lines are actions that can be applied to the residue. The < & > symbols allow you to change the action, clicking on the text then activates the action. Current actions are:
 
RSR rotamer: to rotamer real space fit the side-chain (Fm_rsr_rotamer) to the 'current' map (Density/Density pull-down)
Regularize: to restore stereochemically sensible bond lengths and angles. The zone is the complete section that has been built/rebuilt. There is no restore capability, other than clicking on line five again.
Flip: flips over the peptide oxygen in the linkage between the current residue and the 'previous' one.
Torsion: activates torsional rotations, as defined in the .bonds_angles ODB for that particular residue. There is no restore capability, other than clicking on line five again.
Build to : build to the identified skeleton atom (see Build_ed_to command)
 
It must be empahasized that the usual Yes/No flags have no affect on this command, nor on the actions.
Grab_fragment (050913)
 
grab_fragment <id>
 
This command allows the user to move a fragment of connected atoms around in space as a rigid body. From O version 10.0.1, the atoms making up the fragment are defined in the database entry .bonds_angles for that particular residue type. The ODB file stereo_chem.odb MUST have been loaded into the user's database.
This command makes use of the same fragments as the Fm_rsr_zone command, selecting the largest fragment containing the identified atom. For example, the records that are relevant for a PHE residue define three fragements
 
fragment_rsr_1 CA C O N+ CA+
fragment_rsr_2 N CA CB C
fragment_rsr_3 CB CG CD1 CD2 CE1 CE2 CZ

 
Identifying any atom in the phenol ring would allow one to move the whole ring. IF the CB atom is identified, there are 2 possible fragments, but he phenol ring still moves since it is the largest fragment containing a CB atom. Likewise identifying the CA atom would allow one to grab the atoms defining the peptide plane to the next residue.
All movement are controlled by the mouse. An atom must be identified, and if the left mouse button is kept down., the fragment of connected atoms will be translated as the mouse is moved. If the <Ctrl>-key is depressed, then pressing the right button will rotate the fragment. Pressing the middle and right buttons with <Ctrl>-key depressed, rotates the fragment clockwise/anti-clockwise about an axis perpendicualr to the screen. The identified atom is the pivot point for the rotations. When the mouse is released, the group of atoms stops moving. The command stays active so that when another atom is identified it is used to define a new fragment. This atom becomes the pivot point. Only atoms within the fragment are affected.
Activating No, returns the moving fragment to its position when it was first identified. The command can be cleared with the Yes or Clear_flag commands.
Like the grab_atom command, if another atom is identified, a new moving fragment of atoms is defined.
Grab_group (020709)
 
grab_group <id>
 
This command allows the user to move a group of connected atoms around in space as a rigid body. All movement are controlled by the mouse. An atom must be identified, and if the left mouse button is kept down., the group of connected atoms will be translated as the mouse is moved. If the ctrl-key is depressed, then pressing the right button will rotate the fragment. Pressing the middle and right buttons with ctrl-key depressed, rotates the fragment clockwise/anti-clockwise about an axis perpendicualr to the screen. The identified atom is the pivot point for the rotations. When the mouse is released, the group of atoms stops moving. The command stays active so that when another atom in the fragment is identified, this atom becomes the pivot point. Only atoms within the fragment are affected.
Activating No, returns the moving group to the position when it was first identified. The command can be cleared with the Yes or Clear_flag commands.
Unlike the grab_atom command, if an atom not in the moving group is identified, a new moving group is not defined.
Groups can be created by changing the connectivity with the Bond_break or Bond_make commands, or by making suitable objects. The new bonds do not have to make chemical sense but are just used to create a suitable group of connected atoms
If the group corresponds to just Ca atoms, the rest of the atoms in the zone are not affected.
Grab_guide (080112)

grab_guide <ID start residue> <ID end residue>

This command allows the user to manipulate a small zone of residues using O's main-chain database. It is best used with the the MasterMenu system which provides the user with simple access to the various options as well as the possibility of restoring backups of the coordinates.


After activating the command with 'Grab a CA zone' from the menu, the user is prompted to define the start and end residues for the zone. Two objects are then created; CA contains the central atom object of the zone and SEQ will contain the sequence/residue names. If the user wishes to make use of the existing CA coordinates, one should now click on 'Set mode all CA's'. If one now clicks on an atom and grabs it, the zone will get updated with main-chain fragments as you move the atom. The SEQ object containing the sequence-related text will also get updated as you move the atom around. Click on 'Accept changes' when you are happy or 'Undo changes' to return the start coordinates.


If the starting coordinates are very poor, you can have a little bit more fun. The basic idea is that the atom you grab, as well as the start/end atoms in the zone, are guide points for the database search, and the other residues in the zone are not. This is the default mode of working with the command. If you identify a CA it will be drawn in magenta to indicate it is a guide atom. The strategy, therefore, is to decide that the CA of a particular residue is associated with a particular piece of density and then move it there. Everything else will jiggle around to accomplish this. Next, select where another CA is to go and move it. The first guide atom, stays (roughly) where it was. When you have finished guiding things, you might want to switch mode back to the 'Set mode all CA's' to make the final placement. Alternatively, if you find that you have generated too many guide atoms, you can click on 'Set mode alternate points' to generate more freedom for the database search.


The various macros in MasterMenu that are associated with this command, merely set new values in the database for .grab_integer with values 0, 1, 2, 3 for modes guide points, all CA's, alternate points, and accept changes, respectively


Grab_residue
 
grab_residue <id>
 
This command allows the user to move atoms in one residue around in space as a rigid body. All movement are controlled by the mouse. An atom must be identified, and if the left mouse button is kept down., the group of connected atoms will be translated as the mouse is moved. If the <Ctrl>-key is depressed, then pressing the right button will rotate the fragment. Pressing the middle and right buttons with <Ctrl>-key depressed, rotates the fragment clockwise/anti-clockwise about an axis perpendicualr to the screen. The identified atom is the pivot point for the rotations. When the mouse is released, the group of atoms stops moving. The command stays active so that when another atom in the residue is identified, this atom becomes the pivot point. Only atoms within the residue are affected.
Activating No, returns the moving residue to its position when it was first identified. The command can be cleared with the Yes or Clear_flag commands.
Unlike the grab_atom command, if an atom not in the moving resdiue is identified, a new moving resdiue is not define
Hbonds_all
 
hbonds_all <id two atoms> or <mol res1 res2>
 
The hydrogen bonds between all atoms within the desired zone are drawn as dotted lines. The bond is made according to a trigonometric calculation. The donor-acceptor atoms must be closer than 3.25Å and an angular cut-off of 90°. This option requires that the user database contains a definition of what atoms can act as H-bond acceptors or donors. This is not included in the $ODAT/startup.odb file, and must be read from $ODAT/old/residue_dict.odb.
Hbonds_mc
 
hbonds_mc <id two atoms> or <mol res1 res2>
 
The hydrogen bonds between main chain atoms within the desired zone are drawn as dotted lines. The bond is made according to a simple energy term defined by Kabsch & Sander (1983) Biopolymers 22, 2577-2637. The cutoff values are 3.5Å in length and &SHY;0.5 Kcal/mol in energy. The minimum separation is 3 residues.
Help

help
 
O's help facilities are supported via the World Wide Web and via the o-info service
 
O > help
As2> O help is supported via the World Wide Web.
As2> Set your browser to http://xray.bmc.uu.se/alwyn

HKL commands (080215)

These commands use the diffraction data directly. Commands are available to read the list of reflections into O, to calculate structure factors based on either a map or a model, and to calculate an electron density. When used with the NCS commands, the user can carry out cyclic averaging.

O > hkl

 New>  HKL          is not a unique keyword.

 New>  HKL_read     is a possibility.

 New>  HKL_SF_map   is a possibility.

 New>  HKL_Fourier  is a possibility.

 New>  HKL_SF_model is a possibility.

 New>  HKL_SF_expli is a possibility.

 New>  HKL_SF_chop  is a possibility.

 New>  HKL_chop_Fou  is a possibility.

 New>  HKL_upd_Four  is a possibility.

 New>  HKL          is not a visible command.

The structure factor and Fourier calculations are made using the Cooley-Tukey Fast Fourier Transform algorithm with code kindly proved by Lynn Ten Eyck.

All structure factor calculations will make use of NCS-operators if present as a chain entry.

An entry in the O database called .HKL_INTEGER controls 2 important parameters. The first one is the amount of scratch space used in the Fourier calculation, the other the temperature factor (scaled by a factor 100) added to the atomic B’s in HKL_SF_model command. The defaults values are 1,000,000 and 20.0 Å 2 :

 O > wr .HKL_INTEGER ;;

.HKL_INTEGER              I          2 (10(1x,i7))                            

 1000000    2000

People working with very large unit cells might need more scratch space. If the average B-factor in your model is very high, it might be a good idea to increase the added B-value a bit. Read LTE’s papers to see what this is about.

The O reflection file format is a simple text file with a few required lines defining things like space group, unit cell information that are read in under the control of keywords, and free format. The control lines are then followed by the diffraction data. Each reflection is contained on one line and consists of values for h, k, l, Fobs, SigmaFobs. The line is readunder Fortran format control. Unless the user changes things, the default format is (3i5, 2f15.5). CCP4 users may find it easiest to use mtz2various and select the 'Convert MTZ to TNT format' option:


In the following example, we have generated a TNT-style reflection data-set and then added the extra keywords needed by O using a text editor.

short_name NATI
cell 70.15 67.81 85.00 90.0000 107.72 90.0000
space_group P21
form (4x,3i4,2f8.0)
sf_field Fo SigF
HKL -36 0 4 31.0 15.5 0.0 0.0000 1.
HKL -36 0 5 39.4 18.4 0.0 0.0000 1.
HKL -36 0 6 43.0 18.5 0.0 0.0000 1.
HKL -36 0 7 61.3 21.7 0.0 0.0000 1. ....

The CCP4 output is already formated, and can be read into O with the indicated statement.

The reflection data are not stored in the user's ODB. O allocates memory on the fly as it is needed for most HKL-related activities. There are no limitations on the number of reflections that can be handled other than the user's virtual address space assignments.



HKL_chop_Fou(rier) (080219)
This command allows the user to remove the contributions of selected atoms from the most recently calculated phases and to calculate a Fourier around these atoms. There is a 5 Å padding around the space containing the atoms. Both structure factor and Fourier calculations are made with explicit, trigonometric terms (i.e. not using the FFT). If the selection is just restricted to a single residue, for example, this makes the calculation very fast.

In the following example, I select a chop Fourier around a single residue and since there are only 14 atoms (and symmetry related copies), the calculation is essentially instantaneous.

O > sel_off
Sel> What molecule [1OGM ]:
Sel> Residue range [all molecule]:
O > sel_on
Sel> What molecule [1OGM ]:
Sel> Residue range [all molecule]: x541 x541
O > HKL_chop_Fou
New> What molecule? []: 1ogm
New> What hkl project? [NATI]:
New> Resolution [ 1.80]:
New> Fourier Coefficients a*|Fo|-b*|Fc| [1 1]: 1 1
New> New map: []: chop11
New> Grid points along cell axes [ 180 204 84]:
8.000000 Ang. lower resolution mods to coefficients

The new map appear in the FastMap system.

This command is also available from the master-menu Rebuild menu where it allows you to generate a chopped |Fo|-|Fc| Fourier for a zone or a single residue. The new map is called CHOP11 and the FastMap slider is opened and positioned at the bottom centre of the screen.



HKL_Fourier (050426)

This command is used to calculate an electron density map from a set of structure factor amplitudes and phases. The user is able to control which amplitudes are used in the Fourier calculation. The resulting map becomes part of the O FastMap system.

 O > hkl_fou

 New> What hkl project? [NATI]:

 New> Fourier Coefficients a*|Fo|-b*|Fc|: 1 1

 New> Resolution [2.5]: 1.8

 New> New map: []: f11

 New> Grid points along cell axes [   180   204    84]:

 New> Min, max, sigma ......  -1.57960   2.07567   0.24386

In the above example, a map is calculated with |Fo|-|Fc| amp l itudes and model phases. In the FastMap system, the map has the name F11 and can be controlled by the usual O slider system.

The grid is calculated at ~1/3 of the resolution, suitable for use with LTE’s FFT routines. For cyclic averaging, a finer grid may be appropriate. If O does not like the grid supplied by the user, you will be told.

At the moment, no weighting is applied to the Fourier coefficients. The Fo and Fc data are scaled in resolution shells. The low resolution data, however, often scale poorly because of the solvent contribution. In maps where the absolute value of (a-b) is > 0.1 (2|Fo|-|Fc| maps, for example), O uses |Fo| and calculated phases for low resolution terms. Otherwise, the low resolution reflection is skipped.


HKL_read (101013)

This command allows the user to load reflection data into O from the external file system. This data is not stored in the user's O database, and as such it is best read in from the on_startup macro.

 O > hkl_read

 New> HKL reflection file name : nati.hkl

 New> Getting reflection count

 New> Number of reflections  56267

 New> HKL project name : [NATI]:

 New> Reading cell and space group info...

 New>  O-style symm-ops for spacegroup P21212

 New>  Database compressed.

In the above example, the external file nati.hkl looks like this:

Short_name Nati

Cell    103.670   115.516    50.040    90.000    90.000    90.000

Space_group  P21212

SF_field Fo SigF Fc PhiC

hkl     0    0    3     1042.70320       21.35019     1923.24020      180.00001

hkl     0    0    4      239.20133        4.77582      672.92940        0.00000

hkl     0    0    5      739.09470       11.14824     1663.80600      180.00001

hkl     0    0    6      108.29800        9.91356      491.62040        0.00000

hkl     0    0    7      617.38494        9.61245      433.17780      180.00001

hkl     0    0    8      854.39910       12.70748     1279.51100        0.00000

hkl     0    0    9      256.52813        8.69932      308.32882        0.00000

hkl     0    0   10     2363.87600       34.43382     2788.15130      180.00001

....

hkl    57    8    1       81.25087       32.56689      163.01560      311.40802

hkl    57    9    0       68.22990       43.17918      110.47620        0.00004

Each line begins with a code-word that is almost self-explanatory. The space group name is the one used within O. All records are parsed with free format input. The diffraction data must be already scaled and merged. If you use CCP4, for example, you could write out the (h,k,l) , Fobs, Sigma (Fobs) reflection data with format (‘hkl’, 3i5, 2f15.5), or as a TNT-style reflection file (see the HKL Overview, above). You would then need edit in the other bits-and-pieces with your favourite editor.

The SF_Field keyword specifies the names to be associated with the data in each column.

The user can specify an explicit format for the structure factor data with the form keyword, followed by an explicit Fortran format statement instead of the default (4x, 3i5, 2f15.0) . Structure factors are recognized by either 'HKL ' or a single space at the start of each line


HKL_SF_chop (050520)

This command is used to remove the effect of a group of atoms from the current phases and to then calculate a new electron density map. The atoms are removed from the phases by explicit summations of the trigonometric terms making up the structure factor equations. The map is made with the FFT at the moment, but this will e ventually be changed to make an explicit calculation around the atoms  that are removed from the phases.

The atoms are specified using the O selection system. Those atoms in the molecule that are select ON, are removed. In the following example, a zone of 3 residues are used to generate a chopped Fourier.

 O > sel_off

 Sel> What molecule [1OGM  ]:

 Sel> Residue range [all molecule]:

 O > sel_on ; x349 x351

 O > hkl_sf_chop

 New> What molecule? []: 1ogm

 New> What hkl project? [NATI]:

 New> Resolution [2.5]: 1.8

 New> Fourier Coefficients a*|Fo|-b*|Fc|: 1 1

 New> New map: []: chop11

 New> Grid points along cell axes [   180   204    84]:

 New> Min, max, sigma ......  -1.57437   4.51231   0.25020

In the above example, a map is calculated with |Fo|-|Fc| amp l itudes and chopped model phases. In the FastMap system, the map has the name CHOP11 and can be controlled by the usual O slider system.


HKL_SF_Explicit (050429)

This command is used to calculate structure factors from an O molecular model. All atoms in the molecule are used in the calculation. Each atom type must have Forsyth & Wells (1959, Acta Cryst. 12, 412-415)) form factors in the O database. Parameters for the most common atom types (C, N, O, P, S) are included in the menu.odb file.

This command uses explicit summations of the trigonometric terms making up the structure factor equations. It is, therefore, much slower than the HKL_SF_model command which works by generating an electron density  and then taking a Fourier transform using the FFT algorithm. The following calculation took 240 seconds while HKL_SF_model took only 10 seconds.

 O > hkl_sf_exp          

 New> What molecule? []: 1ogm

 New> What hkl project? [NATI]:

 New> Resolution [2.5]: 1.8

 read F&W for  7

 read F&W for  6

 read F&W for  8

 read F&W for  16

 number of atoms of type  6  2777

 number of atoms of type  7  734

 number of atoms of type  8  1402

 number of atoms of type  16  18

 Percentage done  10

 Percentage done  20

 Percentage done  30

 Percentage done  40

 Percentage done  50

 Percentage done  60

 Percentage done  70

 Percentage done  80

 Percentage done  90

 Percentage done  100

 New> R-factor =     0.1913

This is the usual linear R-factor. The Forsyth & Wells constants look like these ODB entries:

 O > dir *f&w*

 Heap>  .F&W_6                    R W         5

 Heap>  .F&W_7                    R W         5

 Heap>  .F&W_8                    R W         5

 Heap>  .F&W_15                   R W         5

 Heap>  .F&W_16                   R W         5

for carbon, nitrogen, phosphorous and sulphur, for example.


HKL_SF_Map (050426)

This command is used to calculate structure factors from an electron density. It would be used, for example, as part of a cyclic averaging procedure. If the input map does not contain a complete unit cell, it is expanded on the fly, provided an asymmetric unit is defined.

 O > hkl_sf_map

 New> What map? [AV]:

 New> What hkl project? [NATI]:

 New> Resolution [2.5]: 2.2

 New> R-factor =     0.2893

The map must be a part of the O FastMap system.


HKL_SF_Model (050426)

This command is used to calculate structure factors from an O molecular model. All atoms in the molecule are used in the calculation. Each atom type must have Forsyth & Wells (1959, Acta Cryst. 12, 412-415)) form factors in the O database. Parameters for the most common atom types (C, N, O, P, S) are included in the menu.odb file.

 O > hkl_sf_model

 New> What molecule? []: 1ogm

 New> What hkl project? [NATI]:

 New> Resolution [2.5]: 1.8

 read F&W for  7

 read F&W for  6

 read F&W for  8

 read F&W for  16

 number of atoms of type  6  2777

 number of atoms of type  7  734

 number of atoms of type  8  1402

 number of atoms of type  16  18

 New> R-factor =     0.1936

This is the usual linear R-factor. The Forsyth & Wells constants look like these ODB entries:

 O > dir *f&w*

 Heap>  .F&W_6                    R W         5

 Heap>  .F&W_7                    R W         5

 Heap>  .F&W_8                    R W         5

 Heap>  .F&W_15                   R W         5

 Heap>  .F&W_16                   R W         5

for carbon, nitrogen, phosphorous and sulphur, for example.



HKL_upd_Four(ier) (080219)
This command is still being worked on. It didn't prove as useful as I expected in it's current form so ...


If_yes_no
 
if_yes_no @<macro1> @<macro2>
 
This command allows one to do a very simple if statement. The first macro will be activated if YES is set, the second one if NO is set.

Job_submit (080221)

This allows a user to submit a job into the O ‘job system’. This system makes user of a number of template files that describe a shell script, a start macro (that gets activated before the shell script, and is therefore used to prepare files for the script), and a second macro that is used to load in the results from running the script. The template files are stored in a directory defined by the OJOB environment variable, and all files that are generated are put in directory defined by the OTMP variable. The templates are built according to a naming convention that is best explained by example. There is a script called lsq_brute that uses Gerard Kleywegt’s LSQMAN program with the so-called BRUTE option to align a pair of molecules. There are 2 macro templates associated with this example that are called lsq_ brute_1st.omac and lsq_brute_2nd.omac . Of these, lsq_ brute_1st.omac is a template for the macro that gets run before the shell script starts, and lsq_ brute_2nd.omac is the template for the macro that gets run when the user wishes to see the result of running the script. The first macro MUST indicate that it is completed by setting the Continue_Yes flag. O’s job system also has a command to check what scripts are finished (Job_check ), and this is accomplished by creating a so-called done-file at the end of the script. Submitted scripts that have not been ‘done’, are stored in the ODB entry .job_scripts , while macros that have not yet been activated are stored in .job_macros . As the job system gets used, a counter gets incremented and appended to the templates that are produced. These files will end up in the OTMP directory which should be periodicallt cleared of old files.

Template files will usually contain symbols that need expanding by the user. The user will be prompted for all symbols before the script gets started. If a symbol already has a value, it’s current value will be offered as the default.

Here is what happens when you run the brute script:

O > jo_su
 New> Define the template file: lsq_brute
 New> There is no data in the JOB system
 New> New symbol to expand <A molecule> : 1295
 New> New symbol to expand <B molecule> : 1uim
 Util> SEGIDs will be written out
 Util> Alternates not present
 Util> Anis Us not present
 Util>       5177 atoms written out.
 Util> SEGIDs will be written out
 Util> Alternates not present
 Util> Anis Us not present
 Util>       5472 atoms written out.
 New> Script started
STOP ... Toodle pip ... statement executed

Here you just need to specify a reference  molecule (1295) and the molecule to be moved onto it (1uim). The first macro, then writes out the 2 PDB files, and then the script gets started. The last line in the above is from LSQMAN

Here is the contents of the lsq_brute script:

#!/bin/csh -f
cd `PRINTENV OTMP`
~/USF/dejavu_osx/osx_lsqman << EOF > q
re a job_a.pdb
re b job_b.pdb
brute a a b a 50 25 50
sa a b job_b_to_a.odb .lsq_rt_b_to_a
quit
EOF

grep 'atoms have an RMS distance of' q > lsq_brute_##JOB_ID##.done

and here is the first macro:

! macro to align 2 PDB files using LSQMAN Brute option
pdb_wr ##OTMP##job_a.pdb ##A molecule## ;;;;;
pdb_wr ##OTMP##job_b.pdb ##B molecule## ;;;;;
mol ##A molecule## obj  ##A molecule##ca ca ; end
mol ##B molecule## obj  ##B molecule##ca ca ; end
con_yes

The symbol JOB_ID is maintained by the job-system, getting incremented each time a script is submitted. Note that the script extracts output from LSQMAN’s listing to make the done-file. Also note that the start script creates 2 molecular objects, CA objects of each molecule which will be manipulated by the 2nd macro, as follows:

! macro to align 2 PDB files using LSQMAN Brute option
! second macro
read ##OTMP##job_b_to_a.odb
lsq_imp b_to_a ##A molecule## ; ##B molecule## ;; b_to_a
lsq_obj b_to_a ##B molecule##ca
print ----------------------------------------------------
print A new LSQ operator called B_TO_A has been made
print It has been applied to the object ##B molecule##ca
print ----------------------------------------------------

This macro reads in the result of the super-positioning, does an improve, and then applies the operator to the CA object of the second molecule. How this macro gets activated is described under Job_Check.


Job_Check (050317)

Once a job has been submitted, and run it MUST create a done-file. O keeps a list of jobs to check for such files. The Job_check command looks for completed jobs in this list, and if present updates the Jobs pull-down menu to add the appropriate macro. Clicking on any entry in this menu will then start the second macro associated with the relevant script.

The first entry in the Job pull-down will start Job_check :

pd_jobs_no_jobs.tiff

Clicking on ‘Check’ produces :

 As2>  Done file made /Users/alwyn/o/temp/lsq_brute_2.done
 As2>  The    292 atoms have an RMS distance of    0.691 A

within O, indicating the result of running the script. The pull-down also gets updated:

pd_jobs_checked.tiff

with the macro associated with the script. Clicking on this macro produced (truncated output):

 Heap>  Created by LSQMAN V. 050218/9.6 at Thu Mar 17 08:31:08 2005 for alwyn
 Heap>  Database compressed.
 Lsq > Least squares match by Semi Automatic Alignment.
 Lsq > Number of atoms in A/B to look for alignment   698  700
 Lsq > 0Search for connected fragments.
 Lsq > A fragment of   184 residues located.
 Lsq > A fragment of   181 residues located
.....
 Lsq > A fragment of    35 residues located.
 Lsq > A fragment of    15 residues located.
 Lsq > A fragment of     4 residues located.
 Lsq >  Loop =    4 ,r.m.s. fit =     1.056 with   683 atoms
 Lsq >  x(1) =     0.1489*x+    0.7738*y+    0.6158*z+  -51.2760
 Lsq >  x(2) =     0.7953*x+   -0.4637*y+    0.3904*z+   27.3965
 Lsq >  x(3) =     0.5876*x+    0.4316*y+   -0.6844*z+    1.9302
 Lsq > The transformation can be stored in O.
 Lsq > A blank is taken to mean do not store anything
 Lsq > The transformation will be stored in .LSQ_RT_ Lsq > Here are the fragments used in the alignment
 Lsq >     A13 PGVIAAYRDRLPVGDDWTPVTLLEGGTPLIAATNL    A47
 Lsq >         |  |  ||  |||        |||| ||||
 Lsq >      A3 PPLIERYRNLLPVSEKTPVISLLEGSTPLIPLKGP    A37
 Lsq >
....
 Lsq > Number of identical residues   401
 As4> ----------------------------------------------------
 As4> A new LSQ operator called B_TO_A has been made
 As4> It has been applied to the object 1uimca
 As4> ----------------------------------------------------

On the screen, the 2 CA objects will be superimposed.



Job_reset (080221)
job_reset

This command resets all ODB entries associated with O’s JOB system. It also deletes all files of type .done in the OTMP directory, and clears the job menu.



Job Script REFMAC (080222)
This script provides an interface between O and the crystallographic refinement program REFMAC5 from the CCP4 system. The script is also dependent on a number of symbols used by the rebuild-menu (REBUILD_MOL, REBUILD_F21, REBUILD_F11, HKL_PROJ, HKL_RESOL), from which the script can be activated.

The job-script assumes that an environment variable CCP4 has been defined so that the REFMAC5 program is present in $CCP4/bin/refmac5. If this assumption does not apply, the script needs to be edited. This script may need more editing if you need something a little more exotic. It has place-holders for the MTZ file, the resolution, and the various MTZ label fields FP, SIGFP, and FREE. The symbols are used in the O macro that reads in the PDB file output by REFMAC5.

If the script is activated with Job_submit, the user will be prompted to specify the location of the CCP4 MTZ file (in full, and must be <= 72 characters), the MTZ labels, the resolution, and the molecule. If activated from the rebuild-menu, these values are added automatically. When the script is running the user can continue working within O. When completed, the user gets some statistics from the run in the done file. When the job macro is activated, the name of the molecule defined by the REBUILD_MOL symbol is incremented, and F21 & F11 maps are recalculated.

If the user does not like the results of the refinement run, the molecule should be deleted from the ODB (pdb_kill $REBUILD_MOL), and the the REBUILD_MOL symbol redefined to the earlier model (Symbol_defin $REBUILD_MOL ...)

The done file lists the RMSDs to bond distance and angle restraints during the course of running the script, as well as the crystallographic R-factor.

Repeated runs will start to generate numerous files in the OTMP directory, so do a periodic clean-up (and a Job_reset) to keep things tidy.

O > job_su
New> Define the template file: refmac
New> There is no data in the JOB system
New> New symbol to expand <MTZ file> : /Users/smith/O/1ogm/1ogm.mtz
New> New symbol to expand <Resolution> : 1.8
New> New symbol to expand <FP label> : FP
New> New symbol to expand <SIGFP label> : SIGFP
New> New symbol to expand <FREE label> : FREE
New> New symbol to expand <Molecule> : 1ogm
Util> SEGIDs will be written out
Util> Chain & SEG IDs not concatenated.
Util> Contains alternate locations
Util> 2 molecules of alternates
Util> Anis Us not present
Util> 4938 atoms written out.
New> Script started
O > job_ch
New> Done file made /Users/smith/o/temp/refmac_1.done
New> Bond distances: refined atoms 4525 0.010 0.022
New> Bond distances: refined atoms 4525 0.011 0.022
New> Bond distances: refined atoms 4525 0.011 0.022
New> Bond distances: refined atoms 4525 0.011 0.022
New> Bond distances: refined atoms 4525 0.011 0.022
New> Bond distances: refined atoms 4525 0.011 0.022
New> Bond angles : refined atoms 6187 1.374 1.921
New> Bond angles : refined atoms 6187 1.236 1.921
New> Bond angles : refined atoms 6187 1.237 1.921
New> Overall R factor = 0.1503
New> Overall R factor = 0.1492
New> Overall R factor = 0.1498
New> Overall R factor = 0.1499
New> Overall R factor = 0.1499
New> Overall R factor = 0.1499
New> Macro list created in the JOB system
As2> Symbol has new value: m2
Util> Database compressed.
Util> Space for 9583958 atoms
Util> Space for 100000 residues
Util> Element information at end of line
Util> Chain name >X<
Util> Chain name >C<
Util> Molecule M2 contained 1112 residues and 4931 atoms
Util> Alternative conformations result in 2 molecules
Util> O-style symm-ops for spacegroup P21212
Util> Database compressed.
Util> Skipped Hs 0
Util> SEGID :
Util> Database compressed.
Util> Space for 9575701 atoms
Util> Space for 100000 residues
Util> Element information at end of line
Util> Chain name >X<
Util> Molecule M2B contained 1 residues and 7 atoms
Util> O-style symm-ops for spacegroup P21212
Util> Database compressed.
Util> Skipped Hs 0
Util> SEGID :
Util> @on_stereo_chem will be activated
Mol> Database compressed.
Mol> Created connectivity Db for M2
New> R-factor = 0.1960
8.000000 Ang. lower resolution mods to coefficients
New> Multi-scale R-factor = 0.1816
New> Min, max, RMS ...... -1.24588 4.85430 0.47400
8.000000 Ang. lower resolution mods to coefficients
New> Multi-scale R-factor = 0.1816
New> Min, max, RMS ...... -0.74374 0.87733 0.08583
As4> The refined coordinates are loaded into molecule m2


Job Script REFMAC chop (080222)
This script provides an interface between O and the crystallographic refinement program REFMAC5 from the CCP4 system. The script is also dependent on a number of symbols used by the rebuild-menu (REBUILD_MOL, REBUILD_F21, REBUILD_F11, HKL_PROJ, HKL_RESOL), from which the script can be activated.

The script differs from the REFMAC script in that the user is only interested in a small zone of residues which may be absorbed into the O molecule upon refinement.

The job-script assumes that an environment variable CCP4 has been defined so that the REFMAC5 program is present in $CCP4/bin/refmac5. If this assumption does not apply, the script needs to be edited. This script may need more editing if you need something a little more exotic. It has place-holders for the MTZ file, the resolution, and the various MTZ label fields FP, SIGFP, and FREE. The symbols are used in the O macro that reads in the PDB file output by REFMAC5.

If the script is activated with Job_submit, the user will be prompted to specify the location of the CCP4 MTZ file (in full, and must be <= 72 characters), the MTZ labels, the resolution, start and end residues, and the molecule. If activated from the rebuild-menu, these values are added automatically. When the script is running the user can continue working within O. When completed, the user gets some statistics from the run in the done file.

When the job macro is activated, the user will be taken back to the zone of interest, a map will be generated (using O's HKL-system and the current HKL project), and the refined structure in the zone will be displayed. The user can merge this portion into the working molecule by Yes, or ignore it with No.

The macros assume that the start/end residues that get merged at the end are the main conformers if there are multiple conformers. If the user is interested in minor conformers, use Clear_flags to reset the If_yes_no flag, and then explicitly merge them from the CHOP molecule into the working molecule.

The done file lists the RMSDs to bond distance and angle restraints during the course of running the script, as well as the crystallographic R-factor.

Repeated runs will start to generate numerous files in the OTMP directory, so do a periodic clean-up (and a Job_reset) to keep things tidy.

O > jo_su
New> Define the template file: ccp4_refmac
New> There is no data in the JOB system
New> New symbol to expand <MTZ file> : /Users/smith/O/r1ogmsf.mtz
New> New symbol to expand <FP label> : FP
New> New symbol to expand <SIGFP label> : SIGFP
New> New symbol to expand <FREE label> : FREE
New> New symbol to expand <Resolution> : 1.8
New> New symbol to expand <Start residue> : x349
New> New symbol to expand <End residue> : x351
New> New symbol to expand <Molecule> : 1ogm

Util> SEGIDs will be written out
Util> Chain & SEG IDs not concatenated.
Util> Contains alternate locations
Util> 2 molecules of alternates
Util> Anis Us not present
Util> 4938 atoms written out.
New> Script started

The job is now running. The user can click on the job-menu to check the status and, when completed, activate the macro to see the results of the refinement.

As2> Done file made /Users/smith/o/temp/refmac_chop_1.done
As2> Bond distances: refined atoms 4525 0.010 0.022
As2> Bond distances: refined atoms 4525 0.011 0.022
As2> Bond distances: refined atoms 4525 0.011 0.022
As2> Bond distances: refined atoms 4525 0.011 0.022
As2> Bond distances: refined atoms 4525 0.011 0.022
As2> Bond distances: refined atoms 4525 0.011 0.022
As2> Bond angles : refined atoms 6187 1.374 1.921
As2> Bond angles : refined atoms 6187 1.236 1.921
As2> Bond angles : refined atoms 6187 1.237 1.921
As2> Overall R factor = 0.1503
As2> Overall R factor = 0.1492
As2> Overall R factor = 0.1498
As2> Overall R factor = 0.1499
As2> Overall R factor = 0.1499
As2> Overall R factor = 0.1499
As2> Macro list created in the JOB system
Util> Database compressed.
Util> Space for 9583958 atoms
Util> Space for 100000 residues
Util> Element information at end of line
Util> Chain name >X<
Util> Chain name >C<
Util> Molecule CHOP contained 1112 residues and 4931 atoms
Util> Alternative conformations result in 2 molecules
Util> O-style symm-ops for spacegroup P21212
Util> Database compressed.
Util> Skipped Hs 0
Util> SEGID :
Util> Nothing marked for deletion, so no compression.
Util> Space for 9575679 atoms
Util> Space for 100000 residues
Util> Element information at end of line
Util> Chain name >X<
Util> Molecule CHOPB contained 1 residues and 7 atoms
Util> O-style symm-ops for spacegroup P21212
Util> Database compressed.
Util> Skipped Hs 0
Util> SEGID :
Util> @on_stereo_chem will be activated
Mol> Database compressed.
Mol> Created connectivity Db for CHOP
As4> x349
As4> x351
As4> 1.8
As4> No object defined.
As4> Centering on zone from X349 to X351
As4> SF calculation
New> R-factor = 0.1960
As4> Making the map
8.000000 Ang. lower resolution mods to coefficients
New> Multi-scale R-factor = 0.1816
New> Min, max, RMS ...... -1.24588 4.85430 0.47400
As4> Yes or No to accept or not


The molecule is centred on the area of the chopped residues and O is now waiting for the user to Yes/No the results.

O > no
As4> Cleaning up
New> Deleted CHOP_ATOM_XYZ
New> Deleted CHOP_ATOM_B
New> Deleted CHOP_ATOM_WT
New> Deleted CHOP_ATOM_Z...
New> Deleted CHOP_CONNECTIVITY
New> Deleted CHOP_ATOM_COLOUR
As4> ----------------------------------------------------
As4> Done: Not Merged
As4> ----------------------------------------------------



Job script eds_fetch (051010)
This script, written by Gerard Kleywegt, provides an interface between O and the Uppsala Electron Density Server (EDS). The user needs to specify the PDB code of the desired EDS entry to start downloading a complete EDS package. This package is copied into the directory specified by the environment variable OTMP.

O > jo_su
New> Define the template file: eds_fetch
New> There is no data in the JOB system
New> New symbol to expand <PDB code> : 1ogm
As4> Fetching EDS entry 1ogm for you ...
As4> ...
As4> IMPORTANT ... Make sure that there is room for *at least*
As4> *two* fm_maps (e.g., by using fm_zap on existing maps)
As4> ...
New> Script started
As2> Done file made /Users/smith/o/temp/eds_fetch_1.done
As2> 9408 -rw-r--r-- 1 alwyn staff - 4813069 Oct 10 16:48 1ogm.tar.gz
As2> Macro list created in the JOB system



The downloaded EDS entry is now in the OTMP directory. Activating the associated macro, loads the EDS package into the O session.

If the PDB code does not exist, error messages will appear when trying to load the respective files.


Lego Overview
 
This approach allows a user to build a structure with help from a 'database'. Some of the commands are available from the pull-down menu system (Rebuild/Database). O can access both a main chain database (Jones et al, 1992; Jones and Thirup,1986) and side-chain rotamer database (Kleywegt & Jones, 1998).
The main chain database consists of 32 protein structures that have been refined at high resolution and are the same ones that I selected in 1985. The nucleic acid database consists of 11 structures selected by Morten Kjeldgaard at the end of 1999. The program uses the main-chain database that is appropriate for the structure. The side-chain rotamers are based on an analysis of high resolution structures that was made by Gerard Kleywegt. I have deliberately removed the low frequency conformations.
My main idea for using databases early in modelling was to prevent the crystallographer over-interpreting the electron density. Since I showed that I could build an exisiting model from just short fragments, I thought it would be easier to pick the right fragment than the right local conformation. Combining the database approach with a skeletonised representation of the density, allowed one to construct a model using this 'Lego (TM)' approach. The same idea is used in O's template based SST system, but the fragments are larger, taking the form of secondary structure elements.
The main-chain database files are loaded from the O data area when first used in the session. They go into the user's O database but are not written back to disk when the database is saved because they have a status of 'R' (readonly). If the user's database is full, it may not be possible to load the main-chain database, in particular, and a series of warnings will be issued. The user will then have to make space by deleting existing entries.
The rotamer database is encoded as entries in O's stereochemical library and must be loaded before the relevant commands can be used. An alternative set of rotamers has been made available (The "Penultimate Rotamer Library" from Lovell, Word, Richardson and Richardson; Proteins 40:389-408, 2000) and is available at
http://kinemage.biochem.duke.edu/databases/rotamer.html
This database has a more extensive number of confomations for each amini-acid, in particular arginine and lysine residues.

Lego_Auto_MC
 
lego_auto_mc <id two atoms> or <mol res1 res2>
 
Automatically build the main chain for a zone of atoms, using the database. This option goes along the chain searching for the best fitting pentapeptide, keeping the main chain atoms of the middle 3 residues and overlapping with the next pentapeptide. This means that the first and last residues are not changed. The option requires coordinates for the Ca or P atom of each residue.
Lego_Auto_SC
 
lego_auto_sc <id two atoms> or <mol res1 res2>
 
Move along the chain and automatically build side chain by choosing the most frequent rotamer from the database. This requires the coordinates for N, CA, C atoms for proteins or C1*, O4* and C2* for nucleic acids, for each residue. Because ALA and GLY residues have no rotamers, they will cause a warning that can be ignored.
Since this command does not make use of any electron density fitting, it may be appropriate to optimise the fit later, either by inspection or automatically with the Build_ed_rot command.
Lego_bones
 
lego_bones <id>i
 
This command is meant for use with skeleton Bones atoms but is not enforced by the program. Identify atoms to be taken as guide Ca's. End by specifying Yes. Use Yes / No to pick best fit to Id'ed (Ca equivalent) atoms. I do not recommend using this option anymore.
Lego_Ca
 
Lego_Ca <id two atoms> or <mol res1 res2>
 
Look through the fragment database to find similar pieces of structure. A dial becomes activated to pass through the top 20 best fits. The rms fit, protein and sequences are shown on the prompt window. The user is also able to specify any particular protein in the data base. Use Yes / No to pick the best matching main chain fit to one's own Ca atoms. Only the main chain atoms are extracted from the database. The coordinates of the first and last residues in the user's zone are not affected
Here is an example:
 
Lego> Lego_ca a a5 a10
Lego> Reading proteins db
Lego> The protein DB is now being loaded.
Lego> A binary file
Lego> There were 103 ODBs in the file.
Lego> Loading data for chain:HCAC
Lego> A binary file
Lego> There were 15 ODBs in the file.
Lego> Loading data for chain:PA
Lego> A binary file
....(lines deleted)
Lego> There were 7 ODBs in the file.
Lego> Loading data for chain:TLN_3
Lego> A binary file
Lego> There were 7 ODBs in the file.
Lego> DGNL> Top matches
Lego> Protein Start Res. Score Sequence
Lego> sga_2 161 0.233 GGTTFY
Lego> pa 173 0.275 EGIYKV
Lego> pa 57 0.289 EGIYKV
Lego> app_2 87 0.322 TDSVTV
Lego> rhd_1 137 0.351 GHPVTS
Lego> app_2 160 0.378 QQPGVY
Lego> pcy_1 77 0.399 KGEYSF
Lego> fb4_1 84 0.399 ESDYYC
Lego> tln_3 37 0.404 DGIFTY
Lego> ins_1 8 0.441 TSICSL
Lego> ins_1 59 0.460 TSICSL
Lego> pa 80 0.461 EHAEVV
Lego> ptn_2 133 0.462 DVLKCL
Lego> hcac 82 0.477 DGTYRL
Lego> act_2 130 0.502 YQPVSV
Lego> sga_2 17 0.502 GFNVSV
Lego> cpa_5 10 0.504 ATYHTL
Lego> pa 196 0.512 EHAEVV
Lego> tln_3 19 0.514 NINTTY
Lego> app_2 207 0.520 GFSGIA
 
The top matches show the protein, internal number of start residue, RMS fit of CA atoms, protein sequence.
Lego_Loop
 
lego_loop <id two atoms> or <mol res1 res2>
 
Make a Ca data base search for a zone but only use atoms that have been selected with select_on or select_off . After accepting the new coordinates, the selection datablock is not changed so sometime remember to use select_on again. Otherwise, when you eventually write out the coordinates you might not get what you expected.
In the following example, an extra residue is inserted into a molecule (called a28) after residue 100. The new residue is called 100A and is a leucine. Only the main- and side-chain databases are used, so the modellingis only a rough approximation of the likely truth.
 
mutate_insert a28 100 100a leu ;
sel_on a28 ;
sel_off a28 100 101
leg_loop a28 98 103
yes
sel_on a28 ;
leg_auto_sc a28 100 101
yes
 
The loop chosen is the best fit to the CA coordinates of residues 98 99 102 and 103 (i.e. ignoring each residue next to the insertion). The new leucine and abutting residues have the most common rotamer conformation.
Lego_setup
 
Lego_setup
<Ca_trace>
<colour_ramp>
<protein_main_chain_database>
<rna_main_chain_database>
<database_directory>
<rotamer_database>
 
Define necessary parameters for the main-chain databases. The rotamer database is only used by the Slider_lego command. All other rotamer based commands used the stereochemical library deffinition.
This command allows the user to select an option to show or not show Ca traces, the colour codes to be used to display them, a file with the definition of the precalculated Ca diagonal distance matrix, the directory where this database is kept, the equivalent files for the nucleic acid main-chain DB, and the file with the side-chain rotamer database.
Most of the values will be correct by default, but it is necessary to define these parameters the first time the Proleg commands are used with a given database file.
Here is an example where the defaults are restored:
 
O> db_kill .dgnl*
Heap> Deleted .DGNL_TEXT
Heap> Deleted .DGNL_INTEGER
Heap> TRACE
O> lego_setup
Lego> Define LEGO paramaters.
Lego> Drawing of Ca traces ([on]/off):
Lego> Good-bad fit colour ramping [ 120 40]:
Lego> File of Protein Diagonal Distances [D:/Alwyn/o/data/dgnl.o]:
Lego> File of RNA Diagonal Distances [D:/Alwyn/o/data/dgnl_rna.o]:
Lego> Directory Main-chain Database [D:/Alwyn/o/data/]:
Lego> File of side chain rotamers[D:/Alwyn/o/data/rsc.odb]:


Lego_Side_Chain
 
lego_side_chain <id an atom> or <mol res atom>
 
Pick a side chain rotamer for a specified residue from the library of preferred side chain conformations. A residue is specified by identifying any atom in the residue. A dial becomes activated to change the rotamer. This requires the coordinates for N, CA, C atoms for proteins or C1*, O4* and C2* for nucleic acids, for each residue. Because ALA and GLY residues have no rotamers, they will cause a warning that can be ignored.
Use Yes to choose the rotamer you want, No to end without changing the coordinates.
Rotamers are defined in O's stereochemical library.

Loop Overview (101019)
Loop commands allow the user to quickly access non-secondary structure portions of their protein. The commands are best used in the master-menu skeleton system since they easily allow one to rebuild the complete loop from CA guide atoms.
When building a model in an experimental map, it is not unusual for local regions of the structure to be difficult to difficult to interpret. It might be necessary to change one’s idea of how the chain is placed, and essentially want to rip apart the model and start again. The user is able to do this in a number of ways in O (e.g. Grab_build works), but these commands are meant to work with a simplified representation of the loop - just a CA object - where Grab_atom is used to make major changes. A text object showing the sequence as a 1-letter code helps the user to focus on when should get built and where. Often, but not always, these regions correspond to the connections between secondary structures, hence the name Loop-commands. If the user has built the model using the Decor-system, there may be too many or too few residues in any particular loop of the TRACE that arise because of the sequence threading that has been used. O will try to build these loops following the skeleton with the number of residues that are needed to fit the threading, but they may need manual rebuilding; hence the Loop-commands:

O > loop
New> LOOP is not a unique keyword.
New> Loop_setup is a possibility.
New> Loop_text is a possibility.
New> Loop_next is a possibility.
New> Loop_define is a possibility.
New> LOOP is not a visible command.

If a loop is incorrect because of out-of-register errors, other O commands may be more useful (e.g. Build_slider). Smaller errors can be fixed in Grab_build while very large errors may requirw returning to working with skeletons. The Loop-commands are meant to be used for in-between cases. These commands are more relaxing to work with than the Grab_guide command.


Loop_define (101019)
This command allows the user to define a 'loop'. This is useful if the badly built bit of structure that you want to tear apart is larger than a loop, or if it is just a small part of a longer loop.

O > loop_def
New> Molecule to be used [P2 ] :
New> Loop zone [A10 to A12 ] : a8 a12


The symbols are updated accordingly.


Loop_next (101019)
Move forward to the next loop in the molecule. Start-end residues in each loop correspond to the end or start of secondary structure unless the loop is at the start/end of the molecule or we have non-AA/NA. The loop zone symbol is updated accordingly. Here is the second loop for P2 myelin (in this case just one residue, valine A11, between the end of the first strand and the start of the next one):




Loop_setup (101019)
The command decides where the loops are located in the model by making multiple YASSPA runs to localize a-helices and b-strands. It then makes an object of the first loop in the structure called LOOP, makes another object of the complete model <mol>_CA, decorates the LOOP object with residue information (name and 1-letter code), and makes 2 symbols (.LOOP_MOL and .LOOP_ZONE) that are used by the other Loop-commands.

O > loop_set
New> Molecule to be used [P2 ] :
New> Running YASSPA .....
Heap> Deleted P2_RESIDUE_2RY_STRUC
Util> Template size : 5 residues.
Util> There were 17
Util> Template size : 5 residues.
Util> There were 83
O > Symbol_list *loop*
New> .LOOP_MOL P2
New> .LOOP_ZONE A1 A7

Here is the YASSPA-coloured CA object that gets drawn (in this case called P2_CA):



and the LOOP object(from the N-terminus to the start of the first secondary structure element):



Loop_text (101019)
This command refreshes the object containing residue text information (residue name and type as the 1-letter code) within the user defined loop; default is the loop zone
O > loop_text
New> Molecule to be used [P2 ] :
New> Loop zone [A1 to A7 ] :


LSQ Overview
 
This major menu is designed for looking at similar 3-D structures. It can determine the transformation operator between 2 structures either by explicitly defining pairs of atoms for a least squares calculation, or given a transformation, it can produce an improvement both in the matrix and in the set of matched atom pairs. Afterwards the transformation can be applied to an object or to the coordinates of a molecule in the database. The operators can also be used for carrying out electron density averaging within O (NCS_average) or with Gerard Kleywegts's RAVE programs that were developed from my A programs. These programs assume that the NCS has improper symmetry. If you have operators that have exact proper symmetry, O and RAVE will not complain. If you want to force approximate improper operators to have exact proper symmetry, you can use the Lsq_proper command.
 
The LSQ commands use and create a number of different DB entries:
 
.lsq_integer
1 Defines a distance cutoff limit for Lsq_improve, default of 38 corresponds to 3.8Å.
2 Defines smallest fragment size for Lsq_improve, default 3.
3 Defines the colour of the vector between paired atoms, default red.
 
Each transformation saved by the program creates 4 data blocks.
If the user saved a transformation under the name 'rbp_to_p2', for example, then the following entries would be created:
.lsq_rt_rbp_to_p2
This is the transformation matrix, as the following 12 real numbers
x = R1 x + R4 y + R7 z + R10
y = R2 x + R5 y + R8 z + R11
z = R3 x + R6 y + R9 z + R12
This data block can be used to specify operators that are applied to 3-D objects such as maps (command Rot_tran_obj), objects (command Lsq_obj) or molecular coordinates (command Lsq_mol).
 
.lsq_mm_rbp_to_p2
Holds the names of the two molecules being compared.
 
.lsq_mn_rbp_to_p2
Holds the paired set of atoms from each molecule.
 
.lsq_vp_rbp_to_p2
A description of the vectors between paired atoms in the O graphics object descriptor language. This is a large entry and should be deleted if not needed.

LSQ_axis (080223)

lsq_axis <chain_operator>

This command draws a line representing the location the rotation axis associated with an O rotation-translation (RT) operator. The user needs to define the the operator(s) of interest. O is able to work with a group of operators, usually associated with oligomer of multiple chains or with single operators. In the following example, the structure is ClpP1 protease from Mycobacterium tuberculosis, Rv2461c, refined at a resolution of 3 Å with tight NCS restraints but no enforcement of proper symmetry.  The crystal has two rings, each of 7 chains, in the asymmetric unit. The various operators have been determined with the lsq_explicit command.

O > lsq_axis
Lsq > There is a chain-operator called 2C8T
Lsq > Which chain operator ? 2c8t
Lsq > RT-operator b
Lsq >  Rotation      51.07
Lsq >  Rossmann & Blow angles      86.21    169.79     51.07
Lsq >  Euler angles                -8.68    -50.21     -0.98
Lsq >  Translation along rotation axis     -1.08
Lsq >  Point 1 on rotation axis    -46.92      1.13     27.04
Lsq >  Point 2 on rotation axis    -86.87      3.82     19.85
Lsq > -------------------------------------------------------
Lsq > RT-operator c
Lsq >  Rotation    -103.20
Lsq >  Rossmann & Blow angles     -84.90    -10.02   -103.20
Lsq >  Euler angles               -17.52   -101.04     -7.16
Lsq >  Translation along rotation axis     -0.45
Lsq >  Point 1 on rotation axis    -46.44      0.34     26.74
Lsq >  Point 2 on rotation axis    -86.65      3.99     19.63
Lsq > -------------------------------------------------------
Lsq > RT-operator d
Lsq >  Rotation     152.92
Lsq >  Rossmann & Blow angles      94.29    -10.53    152.92
Lsq >  Euler angles               -41.48   -145.85    -32.74
Lsq >  Translation along rotation axis      0.39
Lsq >  Point 1 on rotation axis    -86.95      4.15     19.68
Lsq >  Point 2 on rotation axis    -46.96      1.09     27.12
Lsq > -------------------------------------------------------
Lsq > RT-operator e
Lsq >  Rotation    -153.81
Lsq >  Rossmann & Blow angles      83.66    169.29   -153.81
Lsq >  Euler angles                32.00    146.37     44.89
Lsq >  Translation along rotation axis      0.28
Lsq >  Point 1 on rotation axis    -46.62     -0.42     27.16
Lsq >  Point 2 on rotation axis    -86.92      4.13     19.54
Lsq > -------------------------------------------------------
Lsq > RT-operator f
Lsq >  Rotation    -256.58
Lsq >  Rossmann & Blow angles      83.37    170.90   -256.58
Lsq >  Euler angles              -175.45   -101.63   -162.03
Lsq >  Translation along rotation axis     -0.96
Lsq >  Point 1 on rotation axis    -45.52     -0.46     26.32
Lsq >  Point 2 on rotation axis    -86.08      4.32     19.82
Lsq > -------------------------------------------------------
Lsq > RT-operator g
Lsq >  Rotation      53.00
Lsq >  Rossmann & Blow angles     -85.88     -7.52     53.00
Lsq >  Euler angles                -0.43     52.51      7.88
Lsq >  Translation along rotation axis      0.62
Lsq >  Point 1 on rotation axis    -45.08      0.99     25.07
Lsq >  Point 2 on rotation axis    -85.42      3.91     19.74
Lsq > -------------------------------------------------------
Lsq > RT-operator h
Lsq >  Rotation     177.04
Lsq >  Rossmann & Blow angles     110.58     82.16    177.04
Lsq >  Euler angles                18.38    -43.91    158.43
Lsq >  Translation along rotation axis      1.98
Lsq >  Point 1 on rotation axis    -45.56     -0.60     23.37
Lsq >  Point 2 on rotation axis    -39.98    -15.98    -17.18
Lsq > -------------------------------------------------------
Lsq > RT-operator i
Lsq >  Rotation     -50.42
Lsq >  Rossmann & Blow angles     -81.87     -9.38    -50.42
Lsq >  Euler angles               -12.58    -49.71      3.90
Lsq >  Translation along rotation axis     -0.62
Lsq >  Point 1 on rotation axis     -5.25     -4.29     35.35
Lsq >  Point 2 on rotation axis    -45.19      1.50     28.76
Lsq > -------------------------------------------------------
Lsq > RT-operator j
Lsq >  Rotation     101.94
Lsq >  Rossmann & Blow angles      83.00    169.73    101.94
Lsq >  Euler angles               -19.43    -99.74     -5.20
Lsq >  Translation along rotation axis     -0.76
Lsq >  Point 1 on rotation axis     -5.98     -4.14     35.36
Lsq >  Point 2 on rotation axis    -45.89      0.84     28.13
Lsq > -------------------------------------------------------
Lsq > RT-operator k
Lsq >  Rotation    -153.92
Lsq >  Rossmann & Blow angles     -83.35    -10.55   -153.92
Lsq >  Euler angles               -44.90   -146.66    -31.37
Lsq >  Translation along rotation axis     -0.88
Lsq >  Point 1 on rotation axis     -6.23     -4.29     35.36
Lsq >  Point 2 on rotation axis    -46.13      0.44     27.93
Lsq > -------------------------------------------------------
Lsq > RT-operator l
Lsq >  Rotation    -154.64
Lsq >  Rossmann & Blow angles      96.42    -11.77   -154.64
Lsq >  Euler angles                35.46    145.63     48.57
Lsq >  Translation along rotation axis     -0.74
Lsq >  Point 1 on rotation axis    -46.77      0.26     27.16
Lsq >  Point 2 on rotation axis     -6.86     -4.33     35.47
Lsq > -------------------------------------------------------
Lsq > RT-operator m
Lsq >  Rotation     104.40
Lsq >  Rossmann & Blow angles      81.84    167.33    104.40
Lsq >  Euler angles                 7.28    100.94     23.99
Lsq >  Translation along rotation axis     -0.81
Lsq >  Point 1 on rotation axis     -6.73     -4.76     35.27
Lsq >  Point 2 on rotation axis    -46.76      1.12     26.27
Lsq > -------------------------------------------------------
Lsq > RT-operator n
Lsq >  Rotation     -52.00
Lsq >  Rossmann & Blow angles      80.74    169.10    -52.00
Lsq >  Euler angles                -4.22     51.02     14.62
Lsq >  Translation along rotation axis     -0.84
Lsq >  Point 1 on rotation axis     -5.65     -5.24     35.06
Lsq >  Point 2 on rotation axis    -45.71      1.41     27.35
Lsq > -------------------------------------------------------

I have input a chain-operator that specifies the operators  between the different chains. In the above, the A chain in one ring has operators to BCDEFG and the H chain, in the other ring, to IJKLMN. For each operator, O outputs the rotation angle around each axis, its orientation in the spherical polar angles definition used by Rossmann & Blow (1961), and in Euler angles. Two points,one at each end of the line are also given.

One clearly sees in the figure that the rotation axes are not collinear, nor exactly parallel.
The chain operator is a text ODB containing the names of the relevant operators like this:

.lsq_ncs_rt_2c8t t 8 25
.lsq_rt_ident
.lsq_rt_b
.lsq_rt_c
.lsq_rt_d
.lsq_rt_e
.lsq_rt_f
.lsq_rt_g
.lsq_rt_h
!done

In this example, I have 7 operators describing the chains in one ring, and an eighth operator to describe the transformation between rings.

If the user calculates the chain operator with lsq_chain_op or has loaded a PDB file containing MTRIX records to describe the NCS restraints, the information describing which molecules are related by the RT-operators will be missing. In this case, the user will be prompted to desecribe the NCS molecule, zone and atom as follows for this M. tuberculosis glutamine synthetase structure which consists of two rings of hexamers:

O > lsq_ax
Lsq > There is a chain-operator called NCS1
Lsq > Which chain operator ?
Lsq > No RT chain-operators in ODB.
Lsq > There is an RT-operator called IDENT
Lsq > There is an RT-operator called NCS1_1
Lsq > There is an RT-operator called NCS1_2
Lsq > There is an RT-operator called NCS1_3
Lsq > There is an RT-operator called NCS1_4
Lsq > There is an RT-operator called NCS1_5
Lsq > There is an RT-operator called NCS1_6
Lsq > There is an RT-operator called NCS1_7
Lsq > There is an RT-operator called NCS1_8
Lsq > There is an RT-operator called NCS1_9
Lsq > There is an RT-operator called NCS1_10
Lsq > There is an RT-operator called NCS1_11
Lsq > There is an RT-operator called NCS1_12
Lsq > Which RT operator ? NCS1_7
Lsq > Molecule names missing for RT-operator
Lsq > You need to identify the NCS asyymetric unit
Lsq > NCS molecule (<cr> to exit): ncs1
Lsq > Zone [all molecule]:
Lsq > Atom [CA]:
Lsq > Rotation 179.99
Lsq > Rossmann & Blow angles 90.02 91.20 179.99
Lsq > Euler angles 90.87 2.40 89.11
Lsq > The object name of the axis is truncated
Lsq > Translation along rotation axis -0.49
Lsq > Point 1 on rotation axis 0.86 -0.07 14.06
Lsq > Point 2 on rotation axis -0.34 -0.08 -42.96


LSQ_chain_op(erators) (101013)

lsq_chain_op <molecule>

This command is used to create a so-called chain operator which is a set of O-style LSQ operators linking one chain to a set of NCS-related chains. Once this chain operator has been generated, it can be used in O's averaging system. The user can decide to create a new molecule of just the NCS-asymmetric unit with associated chain operators.

The specified molecule must contain a set of separate chains with different chain identifier letters (A,B etc). The first chain is taken as the reference for least-squares calculations. In the following example, the chains have been refined with strict NCS-symmetry

O > lsq_chain
Lsq > Create chain LSQ ops from a molecule of chains.
Lsq > Molecule name [NCS1]: m1
Lsq > Reference chain is A
Lsq > Chains A and B , RMSD = 0.0 , on 475 CA atoms.
Lsq > Chains A and C , RMSD = 0.0 , on 475 CA atoms.
Lsq > Chains A and D , RMSD = 0.0 , on 475 CA atoms.
Lsq > Chains A and E , RMSD = 0.0 , on 475 CA atoms.
Lsq > Chains A and F , RMSD = 0.0 , on 475 CA atoms.
Lsq > Chains A and G , RMSD = 0.0 , on 475 CA atoms.
Lsq > Chains A and H , RMSD = 0.0 , on 475 CA atoms.
Lsq > Chains A and I , RMSD = 0.0 , on 475 CA atoms.
Lsq > Chains A and J , RMSD = 0.0 , on 475 CA atoms.
Lsq > Chains A and K , RMSD = 0.0 , on 475 CA atoms.
Lsq > Chains A and L , RMSD = 0.0 , on 475 CA atoms.
Lsq > 12 NCS operators are stored.
Lsq > O can make a molecule from just the reference chain ID
Lsq > Hitting a <return> for the name, skips this action
Lsq > Name of new single chain molecule:

In the above, I have elected not to create a new molecule in O for the NCS-asymmetric unit.

The command generates an LSQ O-style rotation/translation operator for each chain, including a unit operator for the reference chain. It then creates the chain operator which is an O text ODB entry, containing the names of all the separate chain operators. The chain operator is called .lsq_ncs_rt_<mol> , M1 in this example.

O > dir .lsq*m1*
Heap> .LSQ_RT_M1_1 R W 12
Heap> .LSQ_RT_M1_2 R W 12
Heap> .LSQ_RT_M1_3 R W 12
Heap> .LSQ_RT_M1_4 R W 12
Heap> .LSQ_RT_M1_5 R W 12
Heap> .LSQ_RT_M1_6 R W 12
Heap> .LSQ_RT_M1_7 R W 12
Heap> .LSQ_RT_M1_8 R W 12
Heap> .LSQ_RT_M1_9 R W 12
Heap> .LSQ_RT_M1_10 R W 12
Heap> .LSQ_RT_M1_11 R W 12
Heap> .LSQ_RT_M1_12 R W 12
Heap> .LSQ_NCS_RT_M1 T W 252

O > wr .LSQ_NCS_RT_M1 ;;
.LSQ_NCS_RT_M1 T 12 20
.lsq_rt_m1_1
.lsq_rt_m1_2
.lsq_rt_m1_3
.lsq_rt_m1_4
.lsq_rt_m1_5
.lsq_rt_m1_6
.lsq_rt_m1_7
.lsq_rt_m1_8
.lsq_rt_m1_9
.lsq_rt_m1_10
.lsq_rt_m1_11
.lsq_rt_m1_12

If I had elected to generate an NCS-asymmetric unit, O would have written out a scratch PDB file (called o_scr_ncs.pdb) for a single chain with strict NCS, and then read it in again to generate a new molecule with the name specified by the user. Sometimes the starting molecule might have the NCS-asymmetric unit spread throughout the entries of the input molecule, e.g.we could have a molecule that is ordered protein chain A, protein chain B, water chain A, water chain B, ligand chain A, etc... O will do its best to group together all the relevant parts of chain A in the new molecule.

Lsq_explicit
 
lsq_explicit <mol_A> <mol_B>
<<res1 res2 [atom]>A <res1 [atom]>B>i
< >
<result>
 
Least squares comparison of 2 structures via explicit paired atoms. The user must specify two molecules, for example, A and B. The transformation is then applied to B to bring it onto A. No wild cards are allowed when defining the atoms. If no atom name is specified for molecule A, then Ca is implied. If no atom name is specified for molecule B, then the atom name specified for molecule A is chosen. The number of atoms chosen must be identical in the two groups. The result of the comparison can be stored in the database. The user supplied name is appended to various names defined by the program, creating 4 datablocks for each comparison.
Here is an example:
 
O > lsq_exp
Lsq > Least squares match by explicit definition of atoms.
Lsq > Given 2 molecules A, B the transformation rotates B onto A
Lsq > What is the name of A (the not rotated molecule)? a
Lsq > What is the name of B (the rotated molecule)? b
Lsq > Now define what atoms in A [=A] are to be matched to B [=B]
Lsq > Defining 3 names in A implies a zone and an atom name.
Lsq > Defining 2 names in A implies a zone and CA atoms.
Lsq > Defining 1 name in A implies the CA of that residue.
Lsq > Molecule B just requires the start residue and atom name.
Lsq > A blank line terminates input.
Lsq > Define atoms from A (the not rotated molecule): a1 a131
Lsq > Define atoms from B (the rotated molecule): b1
Lsq > Define atoms from A (the not rotated molecule):
Lsq > The 131 atoms have an r.m.s. fit of 0.614
Lsq > xyz(1) = 0.3866*x+ 0.0907*y+ 0.9178*z+ -16.9494
Lsq > xyz(2) = 0.1155*x+ 0.9825*y+ -0.1458*z+ 25.7535
Lsq > xyz(3) = -0.9150*x+ 0.1624*y+ 0.3694*z+ 66.9963
Lsq > The transformation can be stored in O.
Lsq > A blank is taken to mean do not store anything
Lsq > The transformation will be stored in .LSQ_RT_b_to_a
O > dir *b_to_a*
Heap> .LSQ_RT_B_TO_A R W 12
Heap> .LSQ_MN_B_TO_A T W 4847
Heap> .LSQ_MM_B_TO_A T W 13
Heap> .LSQ_VP_B_TO_A T W 8246
 
The command generated four entries oin the ODB.
Lsq_improve
 
Lsq_improve <old_result>
<[mol_A]> <[res1 res2]>A
<[mol_B]> <[res1 res2]>B
<[atom]>
<new_result>
 
This command can improve on a given transformation. The command employs an algorithm involving a search for structure fragments that can be aligned within a given cutoff limit, and tries to improve the transformation and the matched atoms. The user must specify which transformation currently stored in the database is to be improved. The user specifies which part of molecule A is to be matched with B. The improved transformation operator can be stored in the database (with the same name as the start matrix or as a new entry). The algorithm cycles until either the same set of atoms are selected or until 10 cycles are made.
The algorithm has been published (G J Kleywegt & T A Jones (1997) 'Detecting folding motifs and similarities in protein structures.' Methods in Enzymology 277, 525-545), and also implemented in GJK's computer programs. Roughly speaking, it works by first locating the longest matching fragments between the two molecules where each pair of atoms in a fragment fits better than a set value, using these pairs to calculate a new operator, and then repeating the process.
In the following example, I make a deliberate mistake with lsq_expl and then improve the operator
 
O > lsq_e
Lsq >Lsq definition defaults are taken.
Lsq >Least squares match by explicit definition of atoms.
Lsq >Given 2 molecules A,B the transformation rotates B onto A
Lsq >What is the name of A (the not rotated molecule) ? a
Lsq >What is the name of B (the rotated molecule) ? b
Lsq >Now define what atoms in A are to be matched to B.
Lsq >Defining 3 names in A implies a zone and an atom name.
Lsq >Defining 2 names in A implies a zone and CA atoms.
Lsq >Defining 1 name in A implies the CA of that residue.
Lsq >The B molecule requires just the start residue.
Lsq >A blank line terminates input.
Lsq >Define atoms from A (the not rotated molecule) : a1 a125
Lsq >Define atoms from B (the rotated molecule) : b5
Lsq >Define atoms from A (the not rotated molecule) :
Lsq >The 125 atoms have an r.m.s. fit of 11.038
Lsq >xyz(1) = 0.2809*x+ 0.0037*y+ 0.9597*z+ -8.7543
Lsq >xyz(2) = 0.2134*x+ 0.9747*y+ -0.0662*z+ 16.6426
Lsq >xyz(3) = -0.9357*x+ 0.2234*y+ 0.2730*z+ 69.5881
Lsq >The transformation can be stored in O.
Lsq >A blank is taken to mean do not store anything
Lsq >The transformation will be stored in .LSQ_RT_ b_to_a
O > lsq_i
Lsq >Least squares match by Semi Automatic Alignment.
Lsq >There is an alignment called B_TO_A
Lsq >Given 2 molecules A,B the transformation rotates B onto A
Lsq >What is the name of molecule A [A ]?
Lsq >Zone to look for alignment [all molecule A] :
Lsq >What is the name of molecule B [B ]?
Lsq >Zone to look for alignment [all molecule B] :
Lsq >What atom [CA] ?
Lsq >Number of atoms in A/B to look for alignment 131 131
Lsq >Search for connected fragments.
Lsq >A fragment of 131 1 1 residues located.
Lsq >Loop = 1 ,r.m.s. fit = 0.614 with 131 atoms
Lsq >x(1) = 0.3866*x+ 0.0907*y+ 0.9178*z+ -16.9487
Lsq >x(2) = 0.1155*x+ 0.9826*y+ -0.1458*z+ 25.7526
Lsq >x(3) = -0.9150*x+ 0.1624*y+ 0.3694*z+ 66.9966
Lsq >Search for connected fragments.
Lsq >A fragment of 131 1 1 residues located.
Lsq >Loop = 2 ,r.m.s. fit = 0.614 with 131 atoms
Lsq >x(1) = 0.3866*x+ 0.0907*y+ 0.9178*z+ -16.9487
Lsq >x(2) = 0.1155*x+ 0.9826*y+ -0.1458*z+ 25.7526
Lsq >x(3) = -0.9150*x+ 0.1624*y+ 0.3694*z+ 66.9966
Lsq >The transformation can be stored in O.
Lsq >A blank is taken to mean do not store anything
Lsq >The transformation will be stored in .LSQ_RT_ b_to_a
Lsq >Here are the fragments used in the alignment
Lsq > A1 SNKFLGTWKLVSSENFDEYMKALGVGLATRKLGNLAKPRVIISKKGDIIT
Lsq > B1 SNKFLGTWKLVSSENFDEYMKALGVGLATRKLGNLAKPRVIISKKGDIIT
Lsq > A51 IRTESPFKNTEISFKLGQEFEETTADNRKTKSTVTLARGSLNQVQKWNGN
Lsq > B51 IRTESPFKNTEISFKLGQEFEETTADNRKTKSTVTLARGSLNQVQKWNGN
Lsq > A101 ETTIKRKLVDGKMVVECKMKDVVCTRIYEKV A131
Lsq > B101 ETTIKRKLVDGKMVVECKMKDVVCTRIYEKV B131
 
See it worked
Lsq_molecule
 
Lsq_molecule <transformation_name> <mol>
 
Apply a transformation to a molecule or to part of a molecule. This option will change the coordinates of the atoms in the database. If you are frequently working with 2 or more molecules it might often be better to apply a transformation to the whole molecule, but remember to have a reverse transformation in the database to restore the coordinates to the correct place. Entering a <cr> at either prompt, terminates the option. If a transformation is defined, a vector .lsq_rt_<transformation_name> must exist in the database.
Here is an example:
 
O > lsq_mol
Lsq > Apply a transformation to an existing molecule.
Lsq > There are these transformations in the database
Lsq > B_TO_A
Lsq > Which alignment [<CR>=abort operation] ? b_to_a
Lsq > There these molecules in the database
Lsq > B AV5 START BEAD1 BETA ALPHA
Lsq > DI A TRACE BETA7 BETA5 ALPH7
Lsq > ALPH9 SKL Q
Lsq > Which molecule? [<CR>=abort operation]: b
Lsq > Define a zone in which to apply the tranformation [all]:

The coordinates of molecule B have now been transformed. Any objects that were made will have to be remade.
Lsq_object
 
Lsq_object <object> <transformation_name>
 
Apply a transformation to an existing molecular object. Typing just <CR> instead of the transformation, removes an operator that is being applied to the object.
If a transformation is to be applied, a vector .lsq_rt_<transformation_name> must exist in the database.
No changes are made to the coordinates of the atoms making up the object. This can affect the behaviour of a number of commands. For example, if you try to move an atom occurring in a transformed object, the moving atom cross comes up at the actual coordinates of the atom. Grabbing an atom is even more confusing.
Here is an example:
 
O > lsq_obj
Lsq >Apply a transformation to an existing object.
Lsq >There is an alignment called B_TO_A
Lsq >Which alignment [<CR>=restore a transformed object] ? b_to_a
Lsq >There is an object called A
Lsq >There is an object called SPH_A
Lsq >There is an object called B
Lsq >Which object ? b
O > lsq_obj ; b
 
That removed the transformation.
Lsq_paired_a
 
Lsq_paired_atoms <transformation> <on/off>
 
Display or remove vectors between a set of atoms that were used in a LSQ'ed operation. The Lsq_explicit / Lsq_improve commands create a data structure of the paired atoms used in the alignment. The command draws a vector from the set in molecule A and the transformed set in molecule B.
Here is an example:
 
O > lsq_pair
Lsq >There is an matched pair called B_TO_A
Lsq >Object state ([ON],OFF) : on
 
We now see little arrows between matched atoms.
LSQ_proper (080112)

lsq_proper <mol> <zone> <operator> <proper symmetry>

The averaging program A (Jones, 199x) and the developments made by Gerard Kleywegt in the program RAVE treat proper and improper non-crystallographic symmetry in the same way. The tools we have provided over the years do not force improper symmetry, even if it is present. So for example, if a structure is made up of a dimer where one chain is related to the other by a rotation of 178º, the crystallographer has at least three problems: is it really 180º, how do I make it 180º and how do I prove it should be 180º. The Lsq_proper command is a tool to solve the second of these problems. The user needs the NCS operators that are required to describe the improper symmetry (including the identity operator) in O-style rotation-translation ODB entries. The names of these operators are stored in the ODB in a chain-operator entry, i.e. as a set of names of the actual operator entries. The ODB describing the proper symmetry must also be in the user’s database, except for the rotational N and N2 proper symmetries, where N is an N-fold rotation. So for example, if we have 32 symmetry, we need to have an ODB called .ncs_proper_32 in the database describing all of the 32 symmetry operators. The order of operators that is defined by the user MUST match the order defined in the proper symmetry ODB.

This command is very easy to use if you have simple rotational N or N2 symmetry. For other proper symmetries, you must have the complete set of symmetry operators exactly describing the proper symmetry. I only supply the operators for 32 symmetry in the file proper_ncs.odb in the O data directory. Even if you have this symmetry, the order of operators in my file, must match the order in your chain-operator.

The following example is ClpP1 protease from M. tuberculosis, which has 2 rings, each of 7 chains. I will input a chain-operator that specifies the operators  between the different chains in one ring. In this example, the A chain in one of the rings has operators to chains BCDEFG. These operators have been previously calculated with Lsq_explicit and are stored in the ODB with names like qb, qc,... qg. They have been grouped into a chain-operator called ring_1 as follows:

O > dir *ring_1
Heap>  .LSQ_NCS_RT_RING_1        T W       182
O > wr .LSQ_NCS_RT_RING_1  ;;
.LSQ_NCS_RT_RING_1        T          7         25
.lsq_rt_ident           
.lsq_rt_qb              
.lsq_rt_qc              
.lsq_rt_qd              
.lsq_rt_qe              
.lsq_rt_qf              
.lsq_rt_qg
   

where each line in the chain operator is the full name of an O-style rotation/translation operator. The chain-operator could be generated by reading in a PDB file that has the strict NCS MTRIX cards, or could be generated from a molecule of separate chains using the Lsq_chain_op command, or by creating the ODB in the file system with your favourite editor and then reading it into O.

We will specify this group of operators in Lsq_proper. Note that we need to define a zone of resides. This zone corresponds to the set of chains that are related by the operators, i.e. just the one ring in this case, and is required to calculate the centre of gravity.

O > lsq_prop
Lsq > Which molecule [2C8T  ] ?
Lsq > Define the zone [all]: a15 g194
Lsq > There is a chain-operator called 2C8T
Lsq > There is a chain-operator called RING_1
Lsq > There is a chain-operator called RING_1_PROPER
Lsq > There is a chain-operator called RING_2
Lsq > There is a chain-operator called RING_2_PROPER
Lsq > Which chain operator ? RING_1
Lsq > RT-operator ident
Lsq > RT-operator qb
Lsq > RT-operator qc
Lsq > RT-operator qd
Lsq > RT-operator qe
Lsq > RT-operator qf
Lsq > RT-operator qg
Lsq >  There were       7 operators
Lsq > Which proper symmetry ? n
Lsq > What is N [2]? 7
Lsq >  There can be       7 molecules
This is ODL to show the axes
Cut and paste to a file if you want to see the NCS axes
Draw the object with the draw command
begin_object axes
colour red
move 0. 0. 0.
line   24.55015      -1.652470       4.422621   
text   24.55015      -1.652470       4.422621               2
move 0. 0. 0.
line   24.52091      -2.221831       4.334579   
text   24.52091      -2.221831       4.334579               3
move 0. 0. 0.
line   24.51015      -1.872190       4.554955   
text   24.51015      -1.872190       4.554955               4
move 0. 0. 0.
line   24.41472      -2.759208       4.616064   
text   24.41472      -2.759208       4.616064               5
move 0. 0. 0.
line   24.52011      -2.885434       3.929191   
text   24.52011      -2.885434       3.929191               6
move 0. 0. 0.
line   24.72095      -1.795472       3.263613   
text   24.72095      -1.795472       3.263613               7
colour green
move 0. 0. 0.
line -1.0927847E-06 -1.0927847E-06   25.00000   
text -1.0927847E-06 -1.0927847E-06   25.00000               2
move 0. 0. 0.
line -1.0927847E-06 -1.0927847E-06   25.00000   
text -1.0927847E-06 -1.0927847E-06   25.00000               3
move 0. 0. 0.
line -1.0927847E-06 -1.0927847E-06   25.00000   
text -1.0927847E-06 -1.0927847E-06   25.00000               4
move 0. 0. 0.
line -1.0927847E-06 -1.0927847E-06   25.00000   
text -1.0927847E-06 -1.0927847E-06   25.00000               5
move 0. 0. 0.
line -1.0927847E-06 -1.0927847E-06   25.00000   
text -1.0927847E-06 -1.0927847E-06   25.00000               6
move 0. 0. 0.
line -1.0927847E-06 -1.0927847E-06   25.00000   
text -1.0927847E-06 -1.0927847E-06   25.00000               7
end_object
Lsq > RMS at 25 A is   0.62
Lsq > Centre of gravity is  -67.02    2.08   23.29
Lsq > Operators are created with 'new' appended.

O types out an ODL that you might cut and paste to see how the improper and proper operators are oriented relative to one-another. The RMS refers to how well the rotation axes are superimposed. The vectors representing each axis are shifted to the origin and a superposition made of the improper and proper groups, after the unit vectors are scaled to a length of 25 Å. The proper set are then translated to pass through the centre of gravity of the chains.

The command generates a new set of RT operators with the text 'new' appended to the names:

O > dir .lsq*rt*new
Heap> .LSQ_RT_QBNEW R W 12
Heap> .LSQ_RT_QCNEW R W 12
Heap> .LSQ_RT_QDNEW R W 12
Heap> .LSQ_RT_QENEW R W 12
Heap> .LSQ_RT_QFNEW R W 12
Heap> .LSQ_RT_QGNEW R W 12

NB if you want to see the orientation of the proper-axes with LSQ_axis, there is a problem. Lsq_axis needs ALL the results generated by Lsq_exp or Lsq_improve, not just the operators. I choose not to duplicate all this extra information. You’ll therefore have to write out the new operators and edit the names back to the whatever they were when you ran Lsq_exp, qa, qb etc in this case. If you just want the operators for averaging or for applying to objects, there is no need to do this edit step.

Here is what happened before and after running Lsq_proper. First you can see the axes from Lsq_exp on each chain in ring 1, then ring 2:


The operator rotation axes are clearly not co-linear, nor when viewed down the axes (ring 1 axes only):


After creating the proper operators, the axes are co-linear (6 lines are drawn here, honest)