Coordinate reading/writing .... the Sam commands

****** Superceded by the PDB_* commands ********

If all you want to do is read and write PDB files, use the pdb_read and pdb_write commands

This menu was named Sam for old times sake. It is associated with commands that control the retrieval and storage of structural data in and out of the O database. The commands generate the datablocks from the entire molecular data structure. They therefore differ from the Read_formatted and Write_formatted commands, that are general commands which can be used with any O datablocks.The Sam commands are the link between the O database and external program systems such as the Prolsq package.

When reading or writing coordinate files, the program attempts to identify the kind of coordinates by checking the file type. Recognized file types are :

.rd	Dr. Robert Diamond style files. These are usually in Å 's along the unit cell axes. This style is used by PROTEIN for FC calculations, where the atom type field is used to describe formfactors.
.wah	Dr. Wayne Arthur Hendrickson style files as used in PROLSQ.
.pdb	the format used at the Protein Data Bank at Brookhaven.
.xpl	X-plor style PDB files where column 73 is used as a chain ID.
.bud	Furey's PHASES coordinate format.
.xyz	FRODO binary files, DSN2 format to some. Only works on Vax/VMS.
.o	are binary O database files.

When reading PDB files, the program keeps the unit cell values and the space group. When creating PDB files, the program also writes out the extra records SCALEn, CRYST1 and ORIGx needed by some programs.
The program generates a time of creation record <mol>_date when it reads a coordinate file.

---

Sam_atom_in

Read atomic coordinates from an external file and give them an O associated 5 character name. If the file name does not end with a recognised file type, the user is prompted to describe the kind of coordinates.

Superceded by PDB_read

---

Sam_atom_out

Write atomic coordinates in one of the standard formats. The user can write out those atoms that have been 'selected'.
For .rd files, one usually wants coordinates in Å units along the cell axes. This requires that one defines the cell constants as 1., 1., 1., alpha, beta, gamma.

Superceded by PDB_write

---

Sam_init_db

Create the initial datablocks required to describe a molecule. A datablock entry describing the sequence (e.g. A_RESIDUE_TYPE for a molecule named A) MUST exist in the database. If an entry describing the residue name also exists ( in this case A_RESIDUE_NAME), it will be used. Otherwise the first residue is called '1', the next '2' etc. The sequence can be entered (in 3 letter code) as a formatted O datablock. All coordinates get the value (1500.,1500.,1500.) so do not be surprised if you get some strange looking bonds.

---

Sam_list_sequ

List the sequence on the terminal.

---

Sam_rename

sam_rename <molecule> <res1 res2> <first_residue_name>

Change the residue name of a given zone of residues. Residue names are generated from the first residue name supplied. Entering A1, for example, generates names like A1, A2 etc.
Suppose you have 2 molecules in the asymmetric unit and they have residue names in the ranges 1-200 and 201-400. The following commands may be used to call them molecules A and B with names in the range 1-200:

 

sam_rename m23 1 200 a1
sam_rename m23 201 400 b1

---

Save_DB

 

Save the O database in a previously assigned file. The first time the command is activated, the user is prompted to decide the file where the database is to be written. The name of this file is stored in the database in the text datablock 'file_O_save' and can be changed as follows:

 

O > wr file_o_save ;;
FILE_O_SAVE T 1 72
p2.o
O > db_kill file_o_save
Heap> Deleted FILE_O_SAVE
O > save
As1> File_O_save is not defined.
As1> Enter file name [binary.o]: new_p2.o

Here is a save_as macro:

 

print save_as macro
db_kill file_o_save
save #New file name#
print file saved

The Save_DB command should be activated every time you have made any important modifications in the database!

---

Screen_colour

 

screen_colour <colour>

 

Set the colour of the screen background. This is useful when taking pictures of solids.

---

Select Overview

 

These commands are used to select atoms on the basis of properties. After the selection of a set of atoms, different actions can be performed on the selection; most commonly they are displayed or coloured. The Select commands act on an atomic property <mol>_atom_select.If this property does not exist for a given molecule, it is created.

Several commands make use of the 'selected' atoms, for example: PDB_read, Sam_atom_out, Paint_select, Lego_loop & Patt_cross. When used for display purposes, the selection can be used to create an additional filter in determining which atoms are to be displayed. This filter is made with the atomic property <mol>_atom_visible. Bonds will only be drawn when the value of this property for each atom is 'on'. This atomic property is best manipulated with the Select menu, first defining which atoms are to be selected, and then copied to the correct datablock with Select_visible.

Several O commands make use of the 'visibility filter' datablock feature behind the user's back. For example, in Move_fragment, the atoms in the moving fragment are marked to be visible. The visibility datablock is then 'inverted' and the drawing routine called again to create the rest of the object.

Examples:
Select_property can be used to create more complicated molecular objects for display. The following commands will create a Ca-trace with all tyrosine sidechains. The final Zone command specifies the whole molecule since no input is given but only the 'visible' atoms are drawn. It is wise to reset both the selection and visible data blocks after making the object:

 

obj ca_tyr
conn o.dat
sel_off ;;
sel_prop atom_name = ca on
sel_prop residue_type = tyr on
sel_vis
z ; end
sel_on ;; sel_vis

 

Note that the connectivity file is o.dat and not all.dat . Using the latter would cause small crosses to be drawn at non-tyrosine residues.

In the next example, we display the poly-Gly backbone:

 

obj poly_g
conn all.dat
sel_off ;;
sel_prop atom_name = n on
sel_prop atom_name = ca on
sel_prop atom_name = c on
sel_prop atom_name = o on
sel_vis
z ; end

 

Now, display all residues with bad rms Pep_flip values:

 

obj flip
sel_prop residue_pepflip > 2.5 on
sel_vis
z ; end

In this last example, the residue property called residue_pepflip must have been calculated in advance by the Pep_flip option.

---

Select_invert

Select_invert

The select datablock is inverted, that is 1's become 0's and vice versa.

---

Select_object(080219)
select_object <object> <on or off>
This command allows one to set the selection state (on or off) of all atoms making up an atomic object. This can be useful if one wants to write out the coordinates of atoms close to a point in space, for example. In this case, one would centre on the point, make an object, select all atoms off, select atoms in the object on, write out the PDB file using the ‘Use selection’ option. For example, here i want to make a PDB file from the atoms close to the fatty acid in the P2 myelin demo structure (named M1). The logic is straightforward: specify the centre, make a sphere object, set selection to off, select the atoms in the object to off, make the PDB with the selection option specified. Easy:

O > mol m1 c_at a132 c1
O > obj m1sph sph 10 end
O > sel_off
Sel> What molecule [M1    ]:
Sel> Residue range [all molecule]:
O > sel_obj      
Sel>  Molecular Objects = M1CA   M1ALL  M1SPH
Sel> Object name: m1sph
Sel> Select on or off [on] ?
O > pd_wr
Util> PDB file name: q.pdb
Util> What molecule [M1    ]:
Util> Residue range [all molecule]:
Util> Define cell constants [ 1.00 1.00 1.00 90.00 90.00 90.00]:
Util> Write out only selected atoms? [No]: y
Util> SEGIDs will be written out
Util> Alternates not present
Util> Anis Us not present
Util> Use the B-factor? [Yes]:
Util> Use the occupancy? [Yes]:
Util>        490 atoms written out.
 
 
 

---

Select_off

Select_off <mol> <res1> <res2>

The residues given are removed from the selection. Atoms outside the zone are not affected. If no input is given, all residues in the current molecule are un-selected. This command is often used to clear the selection property, like this:

Sel_off ;;

---

Select_on

Select_on <mol> <res1> <res2>

The residues given are selected. The selection values of atoms outside the zone are not affected. If no input is given, all residues in the current molecule are selected.

---

Select_property

Select_property <property> <op> <value> <on/off>

Select atoms or residues according to property. The property can be of type real, integer or character. The operator must be one of the following: <, >, <=, >=, =, != (means 'not equal') .

---

Select_visible

Select_visible

The select datablock of the current molecule is copied to the visibility datablock of that molecule. The latter datablock acts as a filter in the drawing of new objects. Bonds will appear between atoms that are set 'on'.

---

Skeleton (080213)

 

This command allows one to skeletonize an electron density that has been loaded into the FastMap system. The user can wither skeletonize the whole map, or within a specified radius of the current screen centre. Like all FastMap commands, this optin is able to work anywhere in space provided that the space group operators are associated with the map, and that the map has sufficient volume of space.

Atom assignments are made according to the length of the connections and branch points. Main-chain skeleton atoms are given a code of 3, side-chain of 2.

Here are 2 examples:

 

O > skel
Qm> What map? [AV]:
Qm> All map [Y]/N? y
Qm> Base level in RMS units [1.25]: 2.
Qm> Skeleton name [SKL]: av
O > skel
Qm> What map? [AV]:
Qm> All map [Y]/N? n
Qm> Radius around active_centre [50.]: 20
Qm> Base level in RMS units [1.25]: 2.
Qm> Skeleton name [SKL]:

The first run makes a skeleton of the complete volume of the input map AV, and creates a skeleton molecule called AV. The second run makes a skeleton of all points 20 A from the current screen centre, and calls the molecule SKL. Both runs use a base level of twice the RMS of the map.

---

 

Sketch Overview

 

The Sketch major menu is a menu to draw different stylized pictures of macromolecules. Much functionality is available from the Display/Sketch pull-down menu.

The Sketch menu works similarly to the Draw_mol commands: first an object is opened, by giving it a name. The Sketch_object command is used to do this. Then a series of drawing instructions can be given to add to the currently open sketch object, using the Sketch_add command. Unlike the Zone command, used to draw molecular objects (which are pickable, sketch objects are not), Sketch_add allows you to define the zones by picking start and end residues on the screen. (Of course, you can only do this if you have a molecular object displayed).

The 'current sketch type' is set by the Sketch_type command. The options available in the current version of O are:

tapeworm A worm made up of little rectangles in the peptide planes, in the style of Arthur Lesk (1986). Works for protein only, as the atoms forming the peptide plane are needed by the algorithm.

ribbon The classic ribbon representation, as described by Carson (1988). A set of cubic b-spline curves is drawn using the central atoms of the molecule atoms as control points. Works for protein molecules only.

cylinder This sketch type draws a cylinder, coaxial to an alpha helix. Works for protein molecules only.

spiral The classic a-helix style made popular by Jane Richards. This sketch type is not suited for b-strand regions, but looks good for RNA structures, when using P or C1* as central atoms.

arrow The classic b-strand style made popular by Jane Richards. Only suited for protein b-strand. The arrows do not look good when drawn in a-helical regions.

rattler Also known as the tube. Draw a smooth looking rattle snake through the central atoms. Very suitable for loop regions of a protein when creating a cartoon.

 

The command Sketch_add uses the current definition of what type of sketch you want, and for each type, the characteristic parameters. These parameters are set by Sketch_setup. Normally, once and for all, you would settle for a set of parameters that appeal to you, and only rarely change them.

The colours of the sketches are taken from the current colour of the central atom of the molecule. For proteins, this is normally the Ca atom, but the user can define the central atom in the <mol>_molecule_ca datablock. For tRNA, it often looks good to use the C1* atom as the central atom, instead of P.

The program can also apply two particualr sketch operations to whole objects. These can be used to make objects of balls (Sketch_cpk) or of sticks (Sketch_stick).

Several different types of sketches can be mixed in the same object. If you begin the definition of a new sketch without defining another object name, the old sketch will be overwritten.

Examples:

Draw tapeworms from residues A1 to A10 and A100 and A120, and connect these by a ribbon:

 

sketch_obj x

sk_set tape line 1.5

sk_add a1 a10

sk_add a100 a120

sk_typ ribbon

sk_add a10 a100

 

Make a ball-and-stick object of an object x :

 

obj x sphe 10 end

ske_stick x

read radii.o

ske_cpk x

 

---

Sketch_add

 

Sketch_add <id two atoms> or < [mol] res1 [res2]>

 

Add a zone, with the current setup parameters, to the currently open sketch descriptor. Input can be given by picking on the display, or by entering the zone from the terminal. The sketch element appears immediately on the screen.

---

Sketch_auto

 

Sketch_auto <mol> <zone> <Y/N>

 

This command allows you to generate a cartoon of the type invented in Uppsala, but popularized by Jane Richardson and made more accurately using computer graphics by Arthur Lesk and Karl Hardman. Sketch_auto uses the output of a previous Yasspa run, and generates and executes a macro called @cartoon. This macro is stored as a text data block in the O database, and it uses the current setting as defined in Sketch_setup. Therefore, if you do not like the appearance of the cartoon, you can change the parameters and run the macro again:

@cartoon

The types used for the secondary structures are defined in the cartoon section of Sketch_setup.

The user is prompted for using the secondary structure colouring scheme (the default, with helices red, strands green, and rest yellow) or the current atomic colouring. If you like rainbow colouring, use Paint_ramp to first define the colours, then specify aom colouring:

O > pai_ramp
Paint> Colour-ramp a property in molecule P2
Paint> Property [residue_irc] :
Paint> Minimum and maximum value of property [1 132] :
Paint> First colour [red] :
Paint> Second colour [blue] :
O > sk_auto
Sketch> What molecule [P2 ]:
Sketch> Residue range [all molecule]:
Sketch> Making cartoon from A1 to A132
Sketch> Use the secondary stucture colouring scheme? [Yes]: n

---

Sketch_cpk

 

sketch_object <id an atom> or <object>

 

Converts an atomic object of bonds into a CPK object. This is essentially identical to CPK_object but without the options. It uses the same datablock .cpk_radii to obtain atomic radii for the spheres. It can, therefore, be used to construct 'real' CPK objects or in the creation of ball-and-stick objects by reading in suitable atomic radii. Two example files are provided in odat/cpk_radii.o and odat/radii.o, for large and small balls. Both this command and Sketch_stick keep the atomic colouring used in the defined object.CPK models can be drawn in line, solid or the computer's generic mode.Creating a spacefilling model of the entire molecule is likely to make most workstations go totally dead if you try to turn the dials. The best way to take a photo is to find the orientation first with a normal vector drawing, turn off everything, and then create the spacefilling model.

---

Sketch_lighting

 

sketch_lighting

 

This command allows you to modify the lighting properties of solid surfaces. Use Yes/No to keep the new valuesIf you are not satisifed with your results later, just:

 

db_kill .ogl_light

 

and you will get my default values for the kind of system you are using.

---

Sketch_object

 

Sketch_object <object>.

 

Begin the definition of a new sketch object. This command is equivalent to the Object command for molecular objects.

---

Sketch_setup

 

Sketch_setup <option> <parameters>

 

Set up parameters for the different sketch options. After issuing the Sketch_setup command, you have to specify the sketch type for which to set up parameters; this also sets the current sketch type (same as Sketch_type). The number of parameters vary according to type. Default values are given in brackets.

 

· Tapeworm

Solid or line mode [solid]

Width of tapeworm in Å [1.5].

 

· Ribbon. Only available in line mode.

Width of ribbon in Å [1.5]

Number of lines in ribbon [7]. This parameter determines how many parallel curves are drawn along the polypeptide chain.

Number of segments per peptide [5]. This is the number of points that are generated on the curve between successive Ca's. Five segments gives a nice reasonable compromise between a smooth looking curve, and not too many vectors on the display.

Smoothness [2]. A value of 1 for the smoothness generates a Cardinal spline instead of a b-spline.

 

· Cylinder. The zone chosen to define a cylinder must be > 4.

Rendering mode [solid]. For cylinders, the rendering mode can be line, solid or smooth. Both solid and smooth modes generate solid cylinders, but in the former mode the cylinders are built up using polygons.

Radius [2.5]. This is the approximate radius of an a-helix.

Number of edges [24]. The number of facets on the polygonal approximation to the cylinder.

 

· Arrow.

Rendering mode [ solid]. For arrows, this can be line or solid.

Width of arrow in Å [2.5].

Thickness of arrow in Å [0.5].

Width of arrow head in Å [3.75]. This is the width at the base of the arrowhead. The default is actually 1.5 · the width of the arrow.

Number of segments ns [2]. This parameter determines how each segment of the arrow is subdivided.

Number of lines on face & side [7 3]. These parameters are used only in line mode. They can be used to give the arrows a solid look.

Smoothness s [2]. The s parameter determines the degree of interpolation of the central atom curve. This is done in order to give a smooth appearance of the arrow. The number of extra points inserted between two atoms is equal to 2s-1 where s is the smoothness parameter. Each of the 2s-1 segments are then subdivided into the number sub-segments defined by the 'number of segments' parameter ns. The number of polygons drawn depend very heavily on the two parameters s and ns. For picture taking, you might want a very smooth looking sketch, but when speed is important, a more coarse representation will probably do. The total number of polygons used to render an arrow of length N residues is

8(N-1) · (2s-1)ns + 5

 

· Spiral

Rendering mode [ solid]. For spirals, this can be line or solid.

Width of spiral in Å [2.5].

Thickness of spiral in Å [0.5].

Width of spiral termini in Å [0.5]. This parameter determines how wide the spiral is at the termini, where it normally joins up with other sketch elements.

Number of segments ns [2]. As for the arrow.

Number of lines on face & side [7 3]. As for the arrow.

Smoothness s [2]. As for the arrow.

The number of polygons used to draw a spiral of length N residues is:

8N · (2s-1)ns

 

· Rattler

Rendering mode [ solid]. For rattlers, this can be line or solid.

Radius of rattler [0.5].

Number of edges ne [7]. This parameter sets the number of facets.

Smoothness s [2]. As for the arrow.

Experimenting with the parameters may result in many interesting looking representations.

In solid rendering mode, the rattler is made up of tiny polygons. There can be quite a large number of polygons forming a rattler, and the performance of the computer my degrade considerably. If the length of the rattler is N, the number of polygons used in the rendering will be:

2N (2s-1) ne

 

· Stick

Rendering mode [ generic]. For sticks, this can be line, solid or generic.

 

· Sphere

Rendering mode [smooth]. For spheres, this can be line, solid or smooth.

Thesselation number [2].

In solid or line mode, O will generate spheres made of polygons. This is useful when making plots, since the current version of the plotting program oplot can't handle spheres yet. The thesselation number n determines how close an approximation to a sphere is made. The number of polygons is 2 · 4 (n+1) and is thus a vary rapidly growing function.

 

· Cartoon

Alpha helix: sketch type [spiral], colour [red], template name [ALPHA]

Beta strand: sketch type [arrow], colour [blue], template name [BETA]

Loop: sketch type [rattler], colour [yellow], template name [].

Other sketch types that could be chosen instead of the defaults are for example: cylinder for alpha helix, and tapeworm for loop regions. If the special colour 'molecule' is chosen, the sketch will be coloured according to the molecule's colour for each residue.

---

Sketch_stick

 

sketch_stick <id an atom> or <object>

 

Unlike most of the other sketch commands, this is object oriented. Can be used to draw cylinders around the bonds of an object. If the real datablock .stick_radius exists, it's value is used for the radius of the cylinder. In this way, Sketch_stick can also be used to 'stickify' a C-alpha trace with thick cylinders. Both this command and Sketch_cpk keep the atomic colouring used in the defined object.Sticks can be drawn in line, solid or the computer's generic mode. Stick drawings, if they are complicated, don't rotate in real time on most workstations.

---

Sketch_type

 

Sketch_type <option>

 

Set the current sketch type (arrow, rattler, etc.).

---

Sketch_undo

 

Sketch_undo

 

Undo the action of the last Sketch_add command. Repeating the command results in the removal of the sketch elements, with the most recent ones being removed first, i.e. you cannot undo an undo command.

---

Slider Overview

****** Superceded by the Decor system ********

 

This menu is an aid to map interpretation. It allows one to make an estimate of what amino acid is to be associated with some electron density. The user enters a guess of the sequence based on the shape and position of the density that is then compared to the actual sequence via a look up table that must have been read into the users database. The guess may be accepted and may be entered into the database as a named entity. A number of guesses can later be combined together.

The guesses entered are one letter codes that usually appear to be the 20 amino acids. However, any one letter can be entered but it must exist in the 'slider matrix' that converts the entered symbol into a score relative to each of the 20 amino acids. The user is free to modify the file supplied in $ODAT/slider.o - it is NOT based simply on matching the size of the sequence to the guess.

Datablocks Used

.slider_integer, .slider_real, .slider_matrix should not be of interest to anyone.

The slider matrix is read in as a formatted T type data block. The first line contains the one letter symbolic names, then each following line scores how the amino acids are matched to the symbolic residue name.

The interactive commands can be used with the qualitative Decor_guess command

 

---

Slider_combine

 

Normally one enters a number of guesses into the system and then tries to combine them in some way. The order in which guesses are specified to be combined is vital since this implies that the first guess comes before the second one in the sequence, and so on. When combining them, one specifies a maximum size gap between guesses. These values are important since they act as constraints in forming the scores.

In the following examples, a few more guesses are added to the system. Small beta-strand fragments have been built with the template system and trimmed to the desired length. The first guess is actually starting at residue A38 and has quite a worse fit when compared to the top score:

 

O > sl_gues

Slid> There are 132 residues in molecule.

Slid> Estimated sequence: vavvlv

Slid> Average= 0.54,rms= 0.16

Slid> VAVVLV

Slid> Fit 1 0.883 A82 STVTLA

Slid> Fit 2 0.833 A80 TKSTVT

Slid> Fit 3 0.783 A23 LGVGLA

Slid> Fit 4 0.767 A38 PRVIIS

Slid> Fit 5 0.733 A122 VVCTRI

Slid> Fit 6 0.733 A89 GSLNQV

Slid> Fit 7 0.717 A81 KSTVTL

Slid> Fit 8 0.717 A83 TVTLAR

Slid> Fit 9 0.717 A120 KDVVCT

Slid> Fit 10 0.717 A25 VGLATR

Slid> Fit 11 0.717 A88 RGSLNQ

Slid> Fit 12 0.717 A48 IITIRT

Slid> Fit 13 0.700 A100 NETTIK

Slid> Fit 14 0.700 A123 VCTRIY

Slid> Fit 15 0.700 A45 KGDIIT

Slid> Fit 16 0.683 A98 NGNETT

Slid> Fit 17 0.683 A11 VSSENF

Slid> Fit 18 0.683 A37 KPRVII

Slid> Fit 19 0.683 A73 TTADNR

Slid> Fit 20 0.667 A27 LATRKL

Slid> Do you want to associate with a residue ([Y],n)?

Slid> Molecule and residue name : trace 11

Slid> Forwards or backwards ([F],b)?

Slid> g2

O > no

 

This has been called guess g2. Now the next strand is added, the correct answer is fit 12, residue A48:

 

O > sl_gues

Slid> There are 132 residues in molecule.

Slid> Estimated sequence: vltfal

Slid> Average= 0.52,rms= 0.15

Slid> VLTFAL

Slid> Fit 1 0.817 A90 SLNQVQ

Slid> Fit 2 0.767 A83 TVTLAR

Slid> Fit 3 0.750 A61 EISFKL

Slid> Fit 4 0.750 A22 ALGVGL

Slid> Fit 5 0.733 A63 SFKLGQ

Slid> Fit 6 0.717 A85 TLARGS

Slid> Fit 7 0.717 A92 NQVQKW

Slid> Fit 8 0.700 A114 VVECKM

Slid> Fit 9 0.700 A103 TIKRKL

Slid> Fit 10 0.700 A29 TRKLGN

Slid> Fit 11 0.683 A5 LGTWKL

Slid> Fit 12 0.683 A48 IITIRT

Slid> Fit 13 0.683 A123 VCTRIY

Slid> Fit 14 0.667 A7 TWKLVS

Slid> Fit 15 0.667 A81 KSTVTL

Slid> Fit 16 0.650 A11 VSSENF

Slid> Fit 17 0.650 A59 NTEISF

Slid> Fit 18 0.650 A99 GNETTI

Slid> Fit 19 0.650 A54 ESPFKN

Slid> Fit 20 0.633 A24 GVGLAT

Slid> Do you want to associate with a residue ([Y],n)?

Slid> Molecule and residue name : trace 17

Slid> Forwards or backwards ([F],b)?

Slid> g3

O > no

 

Now they can all be combined, or in pairs:

 

O > sl_com

Slid> Slider guess : G1

Slid> Slider guess : G2

Slid> Slider guess : G3

Slid> Enter which ones : g2 g3

Slid> There will be a search for 2

Slid> Enter gap sizes : 4

Slid> Fit 1 = 0.850 82 90

Slid> Fit 2 = 0.825 80 90

Slid> Fit 3 = 0.800 82 92

Slid> Fit 4 = 0.767 81 90

Slid> Fit 5 = 0.767 83 90

Slid> Fit 6 = 0.742 23 29

Slid> Fit 7 = 0.725 84 90

Slid> Fit 8 = 0.725 73 83

Slid> Fit 9 = 0.725 38 48

Slid> Fit 10 = 0.717 82 88

Slid> Fit 11 = 0.717 83 92

Slid> Fit 12 = 0.708 82 89

Slid> Fit 13 = 0.708 55 61

Slid> Fit 14 = 0.708 82 91

Slid> Fit 15 = 0.700 55 63

Slid> Fit 16 = 0.700 80 86

Slid> Fit 17 = 0.692 53 61

Slid> Fit 18 = 0.692 89 99

Slid> Fit 19 = 0.692 80 88

Slid> Fit 20 = 0.683 80 89

O > no

 

Because of the relatively poor guessing, the correct answer is a little way down the list at position 9.

Lets add some more, the next strand. The error message 'Residue FA not in matrix.' comes because the A molecule includes a fatty acid that is not in the slider matrix.

The guess is a good one, the top score is correct.

 

O > sl_gues

Slid> There are 132 residues in molecule.

Slid> Estimated sequence: siqlqf

Slid> Residue FA not in matrix.

Slid> Residue FA not in matrix.

Slid> Residue FA not in matrix.

Slid> Residue FA not in matrix.

Slid> Residue FA not in matrix.

Slid> Residue FA not in matrix.

Slid> Average= 0.53,rms= 0.15

Slid> SIQLQF

Slid> Fit 1 0.833 A59 NTEISF

Slid> Fit 2 0.817 A90 SLNQVQ

Slid> Fit 3 0.783 A114 VVECKM

Slid> Fit 4 0.750 A67 GQEFEE

Slid> Fit 5 0.750 A12 SSENFD

Slid> Fit 6 0.733 A89 GSLNQV

Slid> Fit 7 0.717 A91 LNQVQK

Slid> Fit 8 0.717 A14 ENFDEY

Slid> Fit 9 0.717 A50 TIRTES

Slid> Fit 10 0.700 A65 KLGQEF

Slid> Fit 11 0.700 A92 NQVQKW

Slid> Fit 12 0.700 A63 SFKLGQ

Slid> Fit 13 0.700 A124 CTRIYE

Slid> Fit 14 0.700 A13 SENFDE

Slid> Fit 15 0.683 A10 LVSSEN

Slid> Fit 16 0.683 A61 EISFKL

Slid> Fit 17 0.683 A47 DIITIR

Slid> Fit 18 0.667 A123 VCTRIY

Slid> Fit 19 0.667 A82 STVTLA

Slid> Fit 20 0.667 A15 NFDEYM

Slid> Do you want to associate with a residue ([Y],n)?

Slid> Molecule and residue name : trace 25

Slid> Forwards or backwards ([F],b)?

Slid> g4

O > no

 

Now include this one and the first guess which is also well defined:

 

O > sl_com

Slid> Slider guess : G1

Slid> Slider guess : G2

Slid> Slider guess : G3

Slid> Slider guess : G4

Slid> Enter which ones : g1 g2 g3 g4

Slid> There will be a search for 4

Slid> Enter gap sizes : 40 5 5

Slid> Fit 1 = 0.782 6 38 48 59

Slid> Fit 2 = 0.764 55 82 90 99

Slid> Fit 3 = 0.759 6 37 48 59

Slid> Fit 4 = 0.755 55 82 90 101

Slid> Fit 5 = 0.755 33 38 48 59

Slid> Fit 6 = 0.750 40 82 90 99

Slid> Fit 7 = 0.750 72 82 90 99

Slid> Fit 8 = 0.750 55 80 90 99

Slid> Fit 9 = 0.750 33 73 83 90

Slid> Fit 10 = 0.750 50 82 90 99

Slid> Fit 11 = 0.750 62 82 90 99

Slid> Fit 12 = 0.745 6 50 61 67

Slid> Fit 13 = 0.745 26 38 48 59

Slid> Fit 14 = 0.741 40 82 90 101

Slid> Fit 15 = 0.741 62 82 90 101

Slid> Fit 16 = 0.741 6 38 49 59

Slid> Fit 17 = 0.741 50 82 90 101

Slid> Fit 18 = 0.741 72 82 90 101

Slid> Fit 19 = 0.741 6 23 29 40

Slid> Fit 20 = 0.741 55 80 90 101

O > no

 

The correct answer is at the top. Notice that there are clusters of correct answers in the top scores. The gap values are important since they are restraints in evaluating the scores. In the above example, we check all possibilities that are separated by less then 40 residues between guess G1 and G2; by 5 between G2 and G3, and by 5 between G3 and G4. In the next example, the gaps are all less then 200 residues, i.e. the gap restraints are not of any use (there are only 131 residues in the protein):

 

O > sl_set

Slid> Slider molecule [A ] :

Slid> Maximum number on dial for Slider_guess [20] : 30

O > sl_comb

Slid> Slider guess : G1

Slid> Slider guess : G2

Slid> Slider guess : G3

Slid> Slider guess : G4

Slid> Enter which ones : g1 g2 g3 g4

Slid> There will be a search for 4

Slid> Enter gap sizes : 200 200 200

Slid> Fit 1 = 0.836 6 82 90 114

Slid> Fit 2 = 0.823 6 80 90 114

Slid> Fit 3 = 0.814 6 82 90 124

Slid> Fit 4 = 0.809 6 23 90 114

Slid> Fit 5 = 0.809 33 82 90 114

Slid> Fit 6 = 0.809 6 82 92 114

Slid> Fit 7 = 0.805 6 38 90 114

Slid> Fit 8 = 0.805 6 82 90 123

Slid> Fit 9 = 0.805 6 82 103 114

Slid> Fit 10 = 0.805 6 23 83 90

Slid> Fit 11 = 0.800 6 82 90 99

Slid> Fit 12 = 0.800 6 23 61 90

Slid> Fit 13 = 0.800 55 82 90 114

Slid> Fit 14 = 0.800 6 82 90 122

Slid> Fit 15 = 0.800 6 82 90 108

Slid> Fit 16 = 0.800 6 38 83 90

Slid> Fit 17 = 0.800 6 82 90 112

Slid> Fit 18 = 0.800 6 82 90 103

Slid> Fit 19 = 0.800 26 82 90 114

Slid> Fit 20 = 0.800 6 80 90 124

Slid> Fit 21 = 0.795 6 23 83 114

Slid> Fit 22 = 0.795 33 80 90 114

Slid> Fit 23 = 0.795 6 80 92 114

Slid> Fit 24 = 0.795 6 23 63 90

Slid> Fit 25 = 0.795 6 38 61 90

Slid> Fit 26 = 0.791 6 23 61 114

Slid> Fit 27 = 0.791 6 82 90 125

Slid> Fit 28 = 0.791 6 38 83 114

Slid> Fit 29 = 0.791 6 23 29 59

Slid> Fit 30 = 0.791 28 82 90 114

O > no

 

Now the correct answer does not show in the top 30!

---

Slider_display

 

Allows one to reactivate a guess that has been stored in the database. A dial controls which of the scores is shown.

 

O > sl_displ

Slid> Enter which one : g1

O > no

---

Slider_guess

 

Allows one to enter a guess into the database. After getting a score, the user is asked if it should be associated with some coordinates. This allows one to first build a poly-alanine, for example, then later try to work out where one is in the sequence. Since one could have build the initial structure backwards, the program gives you the chance of associating the guess with a backwards model.

The 'slider matrix' must have been loaded.

 

O > sl_gues

Slid> There are 132 residues in molecule.

Slid> There is no slider matrix in the database.

O > read ../data/slider.o

Slid> There are 132 residues in molecule.

Slid> Estimated sequence: gvwa

Slid> Average= 0.43,rms= 0.14

Slid> GVWA

Slid> Fit 1 0.875 A6 GTWK

Slid> Fit 2 0.725 A33 GNLA

Slid> Fit 3 0.700 A84 VTLA

Slid> Fit 4 0.675 A26 GLAT

Slid> Fit 5 0.675 A55 SPFK

Slid> Fit 6 0.675 A122 VVCT

Slid> Fit 7 0.650 A99 GNET

Slid> Fit 8 0.650 A82 STVT

Slid> Fit 9 0.650 A111 GKMV

Slid> Fit 10 0.625 A28 ATRK

Slid> Fit 11 0.625 A89 GSLN

Slid> Fit 12 0.600 A62 ISFK

Slid> Fit 13 0.600 A40 VIIS

Slid> Fit 14 0.600 A72 ETTA

Slid> Fit 15 0.600 A24 GVGL

Slid> Fit 16 0.600 A50 TIRT

Slid> Fit 17 0.600 A22 ALGV

Slid> Fit 18 0.575 A102 TTIK

Slid> Fit 19 0.550 A79 KTKS

Slid> Fit 20 0.550 A73 TTAD

Slid> Do you want to associate with a residue ([Y],n)?

If you type N, the command will exit.A <CR> or Y will continue:

Slid> Molecule and residue name : trace 1

Slid> Forwards or backwards ([F],b)?

 

The best fitting sequence is now shown on the display near the molecular zone you defined. A dial controls which of the fits is displayed. The guess has been associated with a part of the TRACE molecule. This in turn was made from a 5 residue beta-strand that had been troimmed by on1residue.

If you wish to fix an out of register error, the Build_slider is a better command.

This guess will be assigned a name, starting at G1 and then incrementing. Five items will be added to the database:

 

O > dir *g1*

Heap> .SLIDER_MOL_G1 C W 3
Heap> .SLIDER_SEQ_G1 T W 4
Heap> .SLIDER_POS_G1 I W 132
Heap> .SLIDER_FIT_G1 R W 132
Heap> .SLIDER_XYZ_G1 R W 12

The command is terminated with the Yes/No flags. If you accept the sequence placement, the main-chain will be merged into your molecule, side-chains added as rotamers and then real-space fitted (Build_ed_rot) to the density (defined in the Density/Density pulldown).

---

Slider_lego

 

People are often unsure about the size of a particular amino acid. This makes it rather difficult to make guess when one sees density. Even for experts, it helps to concentrate the mind to see which ones could actually fit. It is necessary to have built at least a poly-alanine before this command works. Then the first time one ID's an atom, 2 knobs get activated so that one controls which amino acid type gets displayed and one controls the rotamer for that residue type. If the Poly-alanine does not point into the density, then the side chain will not fit into the density. Making further ID's, transfers the activity to the new residue.

This command would normally be used with a TRACE molecule built with the templatre system.

This command uses the old rotamer system.

---

Slider_setup

 

This command defines which molecule is to be worked on and how long a scoring list is to be used.

O > slider

O > SLIDER is not a unique keyword.

O > SLider_Setup is a possibility.

O > Slider_guess is a possibility.

O > Slider_show is a possibility.

O > Slider_displ is a possibility.

O > Slider_combi is a possibility.

O > Slider_lego is a possibility.

O > SLIDER is not a visible command.

O > sl_setup

Slid> Slider molecule [A ] :

Slid> Maximum number on dial for Slider_guess [20] :

---

Slider_show

 

Allows one to see on the display which guesses have been made.

---

Spawn

 

Spawn another process in the operating system. In Unix, the shell is closed by logout, exit, or <CTRL>-D if this option is enabled in your shell environment.

 

---

Sphere_centre

 

sphere_centre <radius>

 

Choose atoms in a sphere centred at the current active centre, stored in the .active_centre datablock. If an atom from a residue is within the given sphere radius, all atoms in that residue get chosen. The .active_centre datablock is set by any of the commands Centre_ID, Centre_xyz, Centre_atom, Centre_zone, or by the user directly overwriting the value stored in the database.

 

---

 

Spin

 

Set the view spinning automatically for a while. Mainly for testing purposes. Spins through 100 views.

---

Sprout overview (101020)

O > sprout
New> SPRO is not a unique keyword.
New> Sprout_sst is a possibility.
New> Sprout_auto is a possibility.
New> Sprout_setup is a possibility.
New> Sprout_CAT is a possibility.
New> Sprout_grow is a possibility.
New> Sprout_trace is a possibility.
New> Sprout_easy is a possibility.
New> SPRO is not a visible command.


The seven sprout commands are designed to quickly generate a TRACE or a CAT skeleton, for use in the SST/Decor system.

At the time of writing (101020), the map interpretation method of choice is the Decor-system. The Decor_easy command removes all of the complexity of rapidly moving from a skeleton to a TRACE, to a threading of the sequence onto the TRACE, and the construction of an atomic model for the protein of interrest. One command, Sprout_setup, is still needed for use with Auto_build, which is meant for high resolution building (the carbonyl oxygen atoms must be clearly visible). A new command, Sprout_easy, is a work in progress, and (roughly speaking) tries to do the equivalent of the Decor_easy step skeleton -> TRACE for a whole skeleton, with no user input. Use it if you wish, but please note that it is currently unfinished and generates lots of debugging output. All other commands are incorporated in Decor_easy and are only included here for historical interest.

Once the user has a skeleton object that he/she is happy with, it can be used to generate a TRACE molecule either automatically with Sprout_auto or under the control of the user with the SST commands (see below). Such a TRACE framework can then be used with the skeleton to generate the intermediate entity called the CAT (Central Atom Trace); automatically with Sprout_trace or semi-interactively with Sprout_grow. The CAT, in turn, can then be used to generate a continuous TRACE suitable for use in the Decor system (see below).

Once one has a suitable skeleton object, therefore, the steps to generate a complete TRACE for a protein are:
• Sprout_setup a-helix 5-mer (alph5)
• Sprout_setup b-strand 5-mer (beta5)
• Sprout_auto generate TRACE framework
• Sprout_trace TRACE framework + skeleton -> CAT
• Sprout_cat CAT - > continuous TRACE

---

Sprout_auto

sprout_auto <map> <skeleton> <zap TRACE>

This command builds a TRACE from pentamers; a-helix and b-strand pentamers for proteins, or RNA 5-mers for. This means that sprout_setup must have been run for both of these SSTs before sprout_auto is activated. The user is prompted for the current map, skeleton and wether the current TRACE is to be zapped before a new one is generated

O > sp_aut
Slid> What map? [AV]:
Slid> Skeleton molecule [CAT]:
Slid> Number of residues 1
Slid> Number of atoms 1587
Slid> Zap the TRACE ([Y]/N) ? [Y]: n
Slid> TRACE is not zapped

If the user elects not to zap the current TRACE, the new elements are added to what already exists. The algorithm starts by finding the next best fitting pentamer that does not clash with what has been built. All CA atoms in this pentamer and (for a protein TRACE) the point mid-way between each CA-CA vector must fit within the density at the current level of the map slider. This 5-mer is then extended towards one terminus by one residue, provided the new residue does not clash with what has already been built. This is done using overlapping 5-mers that must fit what exists to within a defined RMS cut-off, and the new CA must fit within the density level. The extension process continues until a clash occurs or until the added residue is out of density. An attempt is then made to extend towards the other terminus. Once this extension finishes, a new pentamer is tried, until none remain.
The clash conditions and the 5-mer overlap RMS are controlled by values in the ODB entry .sprout_real (default values of 3.0 and 1.0 Å, respectively)
The new trace will contain only elements that fit the density, and some of them may abut. The elements, however, should not overlap. There is no need to modify abutting elements in the TRACE since this will be correctly handled by the Trace_CA command.

The capability of not zapping the TRACE is particularly useful at low resolution, where the user may prefer to build longer a-helices using the interactive SST commands.

	The blue skeleton object has been used with Sprout_setup to calculate helical and strand 5-mer fits. Sprout_auto then generated the TRAC
	The trace and skeleton were then Sprout_trace'd to make this CAT, There is one break at the N-terminal end of the second helix.
	In this example, I built a helical 7-mer at the second helix, and then generated the rest of the TRACE automtatically with Sprout_auto etc. Here is the Decor_yasspa version of the result.

---

Sprout_CAT (050810)

sprout_cat <object> <option> <Zap TRACE>

This command generates a TRACE molecule from a skeleton, normally the CAT.
There are 3 possible building modes that can be used. The user should make the selection depending on the resolution and overall quality of the electron density. The DB mode is most suitable for low resolution maps. The connected atoms in the CAT are used to make a main-chain using the main-chain database of best fitting pentamers. WIth this mode, the user can elect to take the whole CAT object or a group of connected atoms. The definition of the from/to atoms, forces the directionality of the TRACE.
The PEP building mode should only be used at very high resolution since a peptide plane is allowed to do a complete 3-D rotational search at each position in the CAT. The SPIN mode can be used at intermediate resolution where peptide planes are visible. It places a peptide plane along each CA vector in the CAT and does a 1-D spin around this vector to find the best fit.

If the user chooses, the TRACE can be cleared before a new one is generated from the CAT. This is the default since not clearing the TRACE will add to whatever may exist and make it difficult to manipulate. Since this command either zaps or makes a major modification to the TRACE, it is a good idea to save the current TRACE before activating Sprout_CAT (easily done with 'write trace* trace_save.odb ;', for example).

O > sprout_cat
New> Skeleton object [CAT]:
New> Belongs to molecule CAT
New> Number of residues 1
New> Number of atoms 712
New> Build into the TRACE molecule
New> Number of residues 700
New> Number of atoms 3500
New> A protein
New> Here are the possible modes
New> DB PEP SPIN
New> Choose one[DB ]:
New> At the next prompt, <ret> takes the whole object.
New> Define from/to atom numbers: 25 107
New> Clear the TRACE before making a new one ([Y]/N)?
New> Backup made of trace_residue_trace
New> The TRACE is zapped

length of the trace is 122 0
New> Side-chains not rotamer fitted
Heap> Deleted TRACE_CONNECTIVITY
Mol> Database compressed.
Mol> Created connectivity Db for TRACE


Here is the result of executing the above example using the DB option. A TRACE has been generated starting at residue 1 (skeleton atom 25 in the CAT) and ending at 122 (corresponding to atom 107 in the CAT)

 

The above TRACE was used in the example shown in Decor_guess. The CAT is from the example used to describe Trace_CA.

---

Sprout_easy (101020)

This command is a work in progress. The user is prompted to identify an atom in the skeleton to be used for tracing, and then asked if the existing TRACE is to be used. If the user clicks Yes, the current TRACE is used in the generation process. Otherwise, the current TRACE is reset before generating a new one. The process uses a similar algorithm to the skeleton -> TRACE step in the Decor_easy command, making a rapid preliminary evaluation of how helical and strand 5-mers fit to the skeleton without density fitting, followed by an acceptance-growth step that includes a local optimization to the density for each 5-mer. I plan to write up this algorithm for an upcoming CCP4 meeting and I will make the text available from the O-section of my home-page. For the P2 myelin averaged map that I use in teaching, Sprout_easy creates a single chain of 126 residues in one step, which really surprised me, in less than 10 seconds on my lovely, but slow (1.8 GHz), Macbook Air!

---

Sprout_grow (050805)

sprout_grow <map> <skeleton> <mode>

This command allows the user to control the interactive generation of a CAT skeleton. In the process, all TRACE SSTs are absorbed. The user specifies an SST from which to start and the algorithm moves along the skeleton until there is a problem, placing the CAT atom according to the mode switch. At problems the user is able to make adjustments (to the skeleton, for example), and then activates Continue_Yes to carry on. Eventually, a loose end will be reached and activating Continue_No, carries on from the other end of the first SST. The command can be used for proteins and nucleic acids.

O > spr_gro
New> What map? [AV]:
New> Map used is AV
New> Skeleton used is [CAT ]: av
New> Mode 1: place CA at the right distance on skeleton
New> Mode 2: place CA near (< 1.9 A) branch on skeleton
New> Mode 3: place CA via 3D PEP rotational search,
New> : unless too far (> 1.5 A) from mode 2 result (AA)
New> Mode 4: place CA at local density peak (CCD 5 -> 7.5A)
New> : on skeleton (NA)
New> Building mode [2]:2

The following illustrate the use with a protein skeleton.

	Start skeleton and TRACE, drawn as CA. The first helix is chosen as the nucleus
	An end is reached so Con_No is activated to start from the other end of the first helix. The CAT is drawn yellow.
	This stops the process because there is a 3 way main-chain
	The skelton is redefined, and Con_yes activated
	CAT all done

This is an example of working with an RNA/protein complex. The RNA is being traced

	The skelton is drawn in cyan, the developing CAT is drawn in green. Short SSTs are absorbed
	The P-P of the strcuture, L11 (from Venki Ramakrishnan), is in yellow. The density is at a high level to indicate the position of the phosphate groups. The few errors shown here can be fixed with Grab_atom.

---

---

 

Sprout_setup

This command takes a skeleton object (or an atomic one for that matter), and then evaluates how well a secondary structure template (SST) fits a map at each skeleton point. The template is rotated around the central atom (CA for amino-acids, P for nucleic acids, but defined in the stereo-chemistry dictionary for the residue with the keyword CENTRE) and the program evaluates how well it fits the map at each orientation. The goodness of fit indicator is a sum of how well each rotated atom in the template fits the density. The latter is merely the sum of the 8 nearest neigbour points in the density. This goodness indicator is rougher than those used in the old RSR_* commands, and is more like the indicator used in ESSENS (Kleywegt & Jones, Acta Cryst.(1997) D53, 179-185)
So far I have made templates for b-strands containing 5&7 residues (beta5 and beta7), a-helices of 5, 7 & 9 residues (alph5, alph7 and alph9), and helical RNA of 5 residues (RNA5). The Sprout_auto option requires running Sprout_setup with 5-mers; alph5 and beta5 for proteins, rna5 for RNA.
Running this option generates a number of new datablocks that can later be further processed by the Sprout_sst command:

O > sprout_setup
Fm> What map? [ANO]:
Fm> Object name [MCSTAR]:
Fm> Secondary Structure [alph9]: beta7
Fm> Number of residues 7
Fm> Number of atoms 35
Fm> Number of atoms in object 325
Fm> Belongs to molecule START
2.24321 2283 49.526 57.032 40.021
2.19321 4127 44.695 72.806 31.781
2.17089 2300 54.358 60.672 37.667
2.12947 4122 42.279 74.019 32.958
2.08553 4557 47.110 46.111 40.021
2.07661 4123 43.487 74.019 31.781
2.06268 2305 48.318 57.031 34.135
2.05732 2226 42.279 57.031 34.135
2.03607 2329 55.566 61.885 32.958
2.03000 2306 48.318 55.818 34.135
2.02821 2288 51.942 58.245 41.198
2.02179 2325 51.942 57.031 30.604
2.02089 4558 45.902 46.111 41.198
1.99696 4119 41.071 74.019 36.490
1.98679 2304 49.526 58.245 35.313
1.97857 2302 51.942 58.245 37.667
1.97518 2328 54.358 60.672 32.958
1.97250 3684 38.655 69.166 35.313
1.96232 2289 53.150 58.245 42.375
1.96000 4556 48.318 44.897 38.844

The top 20 scores are listed. The score is the average density for the template (high is good). Here are the 3 database entries that get generated:

Heap> START_BETA7_SCORE R W 325
Heap> START_BETA7_INDEX I W 325
Heap> START_BETA7_XYZ R W 975

---

Sprout_SST

sprout_sst <F(ast)M(ap)> <skeleton molecule name> <SST> <number to be built>

This command is used to generate an SST framework for more detailed, later evaluation. The command works with a F(ast)m(ap) that has been loaded, and a skeleton after a run through the SST_build command with a particular SST. The user specifies how many of the best fitting templates are to be used The SST is allowed to flex at its centre.

This command has been, to some extent, superceded by the new implementation of Sprout_auto.

The user should run Sprout_setup with different length SSTs and then cycle through them, starting with a few of the longest ones, then moving on tot he shorter ones:

O > sprout_sst
Slid> What map? [ANO]:
Slid> Skeleton molecule [START]:
Slid> Number of residues 1
Slid> Number of atoms 6653
Slid> Secondary Structure [alpha]: beta7
Slid> Number of residues 7
Slid> Number of atoms 35
Slid> How many shall we build? 10
Slid> Density fitting score 2.2432
Slid> Density fitting score 2.1932
Slid> Density fitting score 2.1709
Slid> Density fitting score 2.0855
Slid> Density fitting score 2.0361
Slid> Density fitting score 1.9259
Slid> Density fitting score 1.8862
Slid> Density fitting score 1.8770
Slid> Density fitting score 1.8437
Slid> Density fitting score 1.7652
Slid> All SSts built
Slid> Macro in database.
Heap> Deleted TRACE_CONNECTIVITY
Heap> Mol> Database compressed.
Mol> Created connectivity Db for TRACE

The TRACE molecule gets the specified number of new SSTs added (10 in the example above), and is displayed in the TRACE object.
The trust that the user puts into the directionality of each SST depends on the resolution and quality of the phasing. At lower resolution, thelocal averaging procedure can be used with a helical SST to determine thedirectionality (Display pull-down/Helix_tree option)
The template fragments can be merged into the molecule that is beingbuilt with the Sequence pull-down (Display / Sequence). They can also be usedwith the Slider system, some of the Build commands and the Decor-system.

---

Sprout_tra(ce_CA) (050805)

sprout_tra <skeleton molecule> <carbonyl bumps Y/N> <use crystal symmetry to trim CAT Y/N>

This command generates a CAT trace from a skeleton, absorbing TRACE SSTs in the process. It is multi-step process described in the listing:

O > spro_tr
New> Skeleton [AV ]:
New> Any carbonyl bumps [N]/Y?
New> Short branches will not be trimmed
New> Use crystal symmetry ([N]/Y)?
New> Crystal symmetry NOT used to trim the CAT
max branches 3
New> The TRACE will be absorbed
New> Step 1: Make initial set of connects
New> Step 2: Remove short singles & potential SS
New> Step 3: Analyse & remove carbonyl bumps
New> Step 4: Remove multiple branch points (>=3)
New> Step 5: Remove single connects<= CA-CA
New> Step 6: Merge close or linked connects
New> Step 7: Expand connects into linked CAs
New> Step 8: check if any CAs are too close
New> Step 9: remove crystallographic duplicates
New> No cell information, skipped
New> Done: Look at the CAT!

The absorption of the SSTs by the skeleton can result in breaks in the CAT which must be joined before using Sprout_CAT. At this editing stage, CAT atoms may need to be adjusted as in the example

	The skeleton has been slightly edited and a framework of SSTs generated with the Sprout and SST commands
	The CAT generated by Sprout_Trace has one break in it at the start of the second helix
	The skeleton and SST do not gel well here so the CAT is changed slighlt using Grab_atom and a an extra bond is drawn
	Now it looks fine. It doe snot matter that the CAT atoms are not incremental, it is the start end connection in Sprout_CAT that is important.

The user can elect to use crystallographic symmetry to trim the CAT. For this option to have any affect, the skeleton molecule must contain crystallographic unit cell and space group data (defined with Symm_setup). A final step is then carried out to remove crystallographic equivalents in the CAT. This is Rv0216 from MTB with the skeleton I used to trace the chain:

---

SST Overview (050805)
This can be traced back to one of the methods I described in 1982 (Jones, 1982) for how to trace a structure in a map using Frodo. It consisted then of recognizing secondary structure elements (helices and strands), building short templates of them, placing them in the density by a least squares fit to guide points, and filling in the bits and pieces by fixing guide points for Ca atoms. The new implementation makes use of interactive real-space refinement (Jones & Liljas, 1984) to quickly fit the so-called secondary structure templates (SSTs) to the density, and database fragment building (Jones & Thirup, 1986) to combine them together, if one wishes. The building of a secondary structure framework is an important step in the creation of a continuous TRACE molecule that can be later decorated with the sequence of the molecule being solved (Jones, 2004), see the Decor commands.
The SST commands allow one to modify the TRACE framework interactively. SSTs can, for example, be added to an existing framework, trimmed at either end, flipped, reversed, merged into the structure being built. Most importantly, they can be used to generate or optimize a disconnected set of SSTs that can be merged with a skeleton to form the so-called CAT (see Trace_CA). This is part of the process of creating an improved continuous TRACE (see Sprout_CAT) for use with the Decor system of commands.
An a-helical SST can be used to determine chain directionality using the Christmas tree affect. This is most easily available from the Display pull-down option 'Helix tree' to activate Fm_local_averaging.
The TRACE molecule must not be mutated (actually you can't).
Although the TRACE molecule has most of the properties of a regular molecule, there is one aspect of regular molecules that has got lost in the trace molecule. In a regular molecule there is a sequence, and that implies one residue comes before another. In the TRACE molecule, this is true locally within a template but is then lost between templates. This may sound a bit esoteric, but it is an important difference.

---

SST_build

 

sst_build <map> <SST> <ID>

 

This command allows you to rapidly fit one of the template molecules to a density. The user must have loaded in the secondary structure templates (SSTs) and the TRACE molecule. For proteins, the SSTs are short helices and strands and the TRACE is a polyalanine. For RNA, the SST is a short helix and the TRACE is poly-rC

 

O > read trace.odb
Heap> A poly-alanine molecule of 700 residues for SST commands
Heap> 980520 Taj
O > dir trace_*
Heap> TRACE_RESIDUE_TYPE C W 700
Heap> TRACE_RESIDUE_NAME C W 700
Heap> TRACE_ATOM_NAME C W 3500
Heap> TRACE_ATOM_XYZ R W 10500
Heap> TRACE_ATOM_B R W 3500
Heap> TRACE_ATOM_WT R W 3500
Heap> TRACE_ATOM_Z I W 3500
Heap> TRACE_ATOM_SELECT I W 3500
Heap> TRACE_ATOM_VISIBLE I W 3500
Heap> TRACE_RESIDUE_POINTERS I W 1400
Heap> TRACE_RESIDUE_CG R W 2800
Heap> TRACE_RESIDUE_TRACED I W 700
Heap> TRACE_RESIDUE_TYPE C W 700
Heap> TRACE_RESIDUE_NAME C W 700
Heap> TRACE_ATOM_NAME C W 3500
Heap> TRACE_ATOM_XYZ R W 10500
Heap> TRACE_ATOM_B R W 3500
Heap> TRACE_ATOM_WT R W 3500
Heap> TRACE_ATOM_Z I W 3500
Heap> TRACE_ATOM_SELECT I W 3500
Heap> TRACE_ATOM_VISIBLE I W 3500
Heap> TRACE_RESIDUE_POINTERS I W 1400
Heap> TRACE_RESIDUE_CG R W 2800
Heap> TRACE_RESIDUE_TRACED I W 700

O > read trace_2ry.odb
Heap> trace_2ry.odb contains SST and related molecules
Heap> 031030 Taj, PEP containing CA,C,O,N+,CA+ for use by some O commands
Heap> 980520 Taj, contains 4 SST molecules (beta5, 7 & alph7, 9)

 

The TRACE molecule is a standard polyalanine or poly-rC, except for the extra residue property trace_residue_trace This is used to keep track of what bits in the molecule are currently being used .

 

The user defines which template is to be used.

 

O > sst_build

Fm> What map? [MIR]:

Fm> Secondary Structure [alpha]: beta7

Fm> Number of residues 7

Fm> Number of atoms 35

 

and can then identify an atom in the skeleton being worked on. The best fit of the template (after a complete rotational search) is then shown, together with all of the current trace segments. Here is the output

 

Fm> Starts at resdiue 19

Fm> Macro in database.

Heap> Deleted TRACE_CONNECTIVITY

Mol> No connectivity Db for TRACE

Mol> Database compressed.

mol connectivity is 5590

 

The program draws the trace segments by activating the macro on_trace_draw that is inlcuded in the menu.odb file

 

O > write @ON_TRACE_DRAW ;;

@ON_TRACE_DRAW T 6 50

mol trace

sel_off trace ;

sel_prop residue_traced = 1 on

sel_vis

db_kill trace_connectivity

zon ; end

 

The command is most easily used with the Density/Pulldown window.

---

SST_combine (000104)

 

sst_combine <id end of one group> <id start of a different group>

 

This command is used to combine 2 separate SST groups in a TRACE molecule into one larger group of residues. The user is able to specify interactively how many residues are to exist between the end of the first group and the start of the second group. Coordinates for any inserted residues are extracted from the closest stretch of residues in the main-chain database. The new group is accepted with Yes, or the old groups are restored with No.

This command can be activated from the Density/Template pull-down menu.

---

SST_extend (050805)

sst_extend <ID end of SST> <ID skeleton point>

This command extends the end of a TRACE template along a skeleton. The skeleton must be continuous from the closest skeleton atom to the CA of the identified SST, to the ID'ed skeleton atom (the connectivity of the skeleton object is used not the connectivity of the skeleton molecule). If the pair of skeleton atoms are not connected or have too many connections, the command is terminated. This is a simple dropping off of CA atoms along the skeleton roughly at 3.8 Å. The main-chain is then built with the main-chain database.It is a fast but inaccurate way of building the TRACE.

IT HAS BEEN SUPERSEDED BY THE TRACE_CA COMMAND.

---

SST_flip (050805)

sst_flip <id>

If the template building process is carried out at low resolution, many units will appear running in the wrong direction in the TRACE molecule (i.e. the N-terminal residue of the group is where the C-terminus should be and vice versa). This command will reverse the unit, by carrying out a least squares fit that matches the N-terminus to the C-terminus etc. It should only be applied to SST units. Longer stretches of a TRACE should be reversed with SST_reverse.

This command can be activated from the Density/Template pull-down menu

---

SST_merge (000104)

 

sst_merge <id>

 

This command is used in conjunction with the sequence pulldown. The group of residues containing the identified atom in the TRACE molecule are merged into the target molecule used in the active sequence pull-down such that the Id'ed residue merges to the active residue of the sequence pull-down. Since this imjplies that the user now knows where he/she is in the sequence of the target protein, the side chains are added using the lego_auto_sc comman.The TRACE residues are removed from the trace object and the zone of the target molecule is drawn with the side-chains included.

This command can be activated from the Density/Template pull-down menu

---

SST_reverse (050805)

 

sst_reverse <id>

 

If the template building process is carried out at low resolution, many units will appear running in the wrong direction in the TRACE molecule (i.e. the N-terminal residue of the group is where the C-terminus should be and vice versa). If the portion of the TRACE to be reversed is an SST unit, it can be done with SST_flip. For longer sections where TRACE elements have been combined, flipping is not what is needed. SST_reverse places the CA of first residue in the TRACE element to last, second to last but one and so on until the last is put at the CA of the first. The element is then auto-built with the main-chain database.

This command can be activated from the Density/Template pull-down menu

---

SST_trim (000104)

 

sst_trim <id>

 

This command is used to reduce the N- or C-terminus of a secondary structure template in the TRACE molecule by 1 residue.This is usefull when building long a-helices, for example, where separate units might overlap.

This command can be activated from the Density/Template pull-down menu

---

SST_zap (050805)

sst_zap

This command clears the complete TRACE molecule, and deletes the TRACE object.