Welcome to Adobe GoLive 6


ASA_display

asa_display <object> <style>

This command creates something like an accessible surface. It uses all of the atoms in the specified atomic object in the calculation. These atoms would not normally include water molecules nor ligands. The style can be solid (default) or transparent. The O DB .cpk_radii must be present in the user's database (the O data directory comes with 2 sets of radii ODBs: one for atomic radii is called cpk_radii.o and the other for small radii is called radii.o USE the atomic radii values!).

O> asa_display Util> Which atomic object? aall Util> Solid surface or tranparent ?[S]

A FastMap slider is generated with the name ASA. The slider controlling the level is actually the probe radius added to the atomic radii. For a solvent accessible surface, the radii should be 1.2 A. The calculation of the surfaqce takes place in real time.
Here is an example of a surface after rendering with MOLRAY (Harris & Jones, 2001)


The picture shows the active site tunnel of the cellulase Cel6A. The original TIFF image has been reduced in size (x2 in each direction) and converted to JPG format with some loss of quality
Angle_define

angle_define <id three atoms>

The angle between 3 identified atoms is calculated and displayed. The atoms can be identified from a macro with the Term_id command.
Arith_Db

arith_db <A> <B> <op> <C>

A=B op C Apply + - / * operators between datablocks B and C, storing results in A
Auto_build (070606)
Backup_DB

Backup the user Database to another disk file. The name of the backup file is stored in the text datablock File_O_Backup.
Baton_build

baton <mol> <start residue> <direction> <manipulate Baton>

This command is used to build a Ca trace. It uses a measuring stick in the form of a di-peptide which can be moved around and can be pivoted about one end. The baton is actually a di-peptide from which the user must make an object of a single bond between the Ca atoms before using this command. When the command is activated, the di-peptide object appears at the current screen centre and consists of a single split coloured bond. The dial set can be used to translate the di-peptide object, and to pivot the object around the green atom. When Yes is activated, the coordinates of the red residue are taken and written into the molecule that is being contructed. The baton jumps to this new postion and the process can be repeated until the command is cleared with No. If an object called CA exists, it will be updated after each Yes command.
This command overcomes one of the problems associated with using the Bone_Ca _Id command where long or short inter-Ca separations can be produced. After ~5 pivots of the Baton, it may be necessary to use the translation dials again to get the di-peptide and the density back in register. The command can be used to build the whole structure, but is particularly useful for building difficult loopy bits that the other Trace commands have had problems with. Since the di-peptide is in fact a poly-alanine, the Slider_lego command can be used to check-out side chain sizes.
Before using the command, information for the di-peptide must be in the user’s database. A database file di.o is supplied and can be added by

O> read di.o

The user must then create the di-peptide object by

O> mol di ca ; end

The Baton command can then be used. For convenience in switching between translating the Baton and rotating it, it may be convenient to have Dial_next and Dial_previous commands on the User menu.
The position and orientation of the di-peptide can be changed by the Baton_mode command when Baton_build is active. When the No or Clear_flag commands are activated, this option no longer activates lego_auto_mc and lego_auto_sc to construct both main and side chains from the Ca trace that has been generated. These commands now need to be activated by the user.
Baton_mode

baton_mode <option>

This command controls the orientation and position of the di-peptide when Baton_build is active. If the mode setting is alpha, the coordinates of the last 4 CA atoms are taken and a least squares comparison made with a regular a-helix. The di-peptide is then placed in the position of the 4th and 5th residues of the helix. If the mode is beta, the comparison is made with residues from a regular b-strand. If the mode is 2ry, a comparison is made with both a and b structures, and the one closest to the last 4 residues is used to position the di-peptide. In all three modes, if 4 residues have not been built, the mode defaults to a 'standard' orientation for the peptide. This can also be achieved by defining mode ? or any other non-recognized character string. The option may also be a skeleton molecule. The program uses the current connectivity of this molecule to place one end of the di-peptide on a line joining 2 bones atoms, if these atoms exist. If more than one pair of atoms exists, the program creates a list of suggestions. Multiple calls to this command cause the peptide to be placed at different positions within this list. The order of items in the list is determined by the bones status of the pair of skeleton atoms; pairs of class 1 atoms first, followed by pairs of non-class 2, followed by mixed 2/other etc, and by the direction of building.
This option, therefore, makes it easy to follow a skeleton or to build standard secondary structure elements, or anything in-between.
Bell_ring

Ring a bell on the terminal. Used in macros to wake up the user.
Bond_break

bond_break <id 2 atoms>

Break all bonds between 2 identified atoms. The 2 atoms must not form a closed connection. The new connectivity must be saved by the user with Save_DB or Stop. Do not make a lot of changes without hitting Save_DB.
Bond_make

bond_make <id 2 atoms>

Add a new bond between 2 atoms. The new connectivity must be saved by the user with Save_DB or Stop
Bones Overview
This group of commands allows the user to display and manipulate a skeletonized electron density ("Bones atoms"). A basic set of commands are available via the Bones pull-down menu system to control the creation of simple skeleton objects. More commands are available to the user via the O line interpreter. The skeleton offers a suitable data structure that is usefull in the preliminary tracing of a new structure in an electron density map. Tactics for making the first trace are discussed elsewhere.
The O skeleton is like a regular molecule but with some extra data blocks. Each skeleton, therefore, has an associated molecule name. One special datablock is a set of status codes or levels that can be changed by the user with the Bone_redefine command. Another datablock defines the connectivity of the skeleton. The skeleton can be edited by making and breaking bonds between skeleton atoms (Bond_make, Bond_break commands).
The skeleton is produced from an electron density map by running the Skeleton command. Atoms recieve a level code of 2 or 3 if they are assigned to be side chain or main atoms, respectively, that get mapped to colours. This assignment is dependent on a number of parameters that the user must define when generating the skeleton. The skeletonization algorithm is my own, though like Greer's, it depends on the setting of a base level density value and a step size. The step value is usually the RMS value of the map, but the base can vary somewhat. Suitable values for the base may be betweeen 1.25-1.5 the RMS. If the value is too low, the skeleton will contain too many atoms and appear too connected. If the value is too high, there will be too few and look rather sparse. The assignment of side or main-chains depends on how connected the skeleton is. Short branch points get classified as side-chain, and longer ones as main-chain.
Once the skeleton is made, the user is free to use any system of code assignments that may be applicable to the problem. Normally, in a simple system , one would assign level 1 to be the correct main chain trace.
The colour associated with each level is defined in the datablock .bones_colour and can be any of the possible X-windows colours. If this ODB does not exist or is deleted, the following defaults are taken: O > db_kill *bone*colour Heap> Deleted .BONES_COLOUR Heap> Making default Bones colours Heap> An ODB is missing, it is updated with a default. O > wr .BONES_COLOUR ;; .BONES_COLOUR T 10 20 yellow red cyan blue salmon spring_green orange_red turquoise gold blue_violet O>
The skeleton can be used to create an envelope for use with O's averaging options, NCS-commands, by associating radii to skeleton atoms making up an object. Skeletons can also be used with the Decorate & Trace commands in O but require a starting map of excellent quality, or some preliminary editing of the skeleton.
Bone_Ca_ID (101014)

bone_pick_Ca <mol> <start_residue> <direction> <id>i This command works with Bone_repeat and Bone_skip to build a rough representation of a molecule by identifying skeleton atoms as C(entral)A(toms) atoms. The command now works with the residue ‘central atom’ (defined for each residue in the stereo_chem.odb dictionary) rather than protein CA atoms and can, therefore, be used to build proteins or nucleic acids. When activated you must specify where you wish to start in the sequence and if you wish to go forward or backward through the sequence. O > bon_ca_id Bone> What molecule [TRACE ]? p2 Bone> Start residue : a8 Bone> Backwards or Forwards (B/[F])? You can then pick any atom and its coordinates get associated with the CA atom of the current residue shown in the prompt window. The identified atom is usually a skeleton atom but can in fact be any kind of atom. As the molecule is developed, a text object is generated to show what has been built (residue name & 1 letter code at each CA), and the <mol>_CA object gets updated as you work. It is not recommend for ab initio model building, but if the Decor system has a problem with building a poorly defined loop, say, this command could be used to produce a rough initial CA-model, before improving it with the Loop commands. The command can be paused by setting a variable in the ODB to a non-zero value (via Db_Set_data .bones_integer 12 12 1), and re-activated by setting the same variable back to zero (via Db_Set_data .bones_integer 12 12 0). The program halts when it recognizes a terminus of the molecule or with Clear_flag
Bone_Ca_zone

bone_ca_zone <Id 2 atoms> <molecule> <start residue> <direction>

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

Bone_branch

bone_branch <Id an atom>

An atom will be added to the object of the identified atom, connected to this atom but displaced (0.5, 0.5, 0.5) Å. It will be given the status code 2 (which usually specifies a side-chain) and will initially appear as a white bond (this will change to the users specified colour when the next object is created). This command is useful to indicate the desired position for a Ca atom when a branch point is lacking. It can also be used to extend a skeleton from a loose end (via repeated bond_branch and grab_atom commands).
Bone_draw

bone_draw

Extract and draw the skeleton atoms on the screen using current parameters.
Bone_excise

bone_excise <Id 2 atoms>

All bonds connecting the 2 identified atoms are broken, and replaced by a single direct bond. The atoms must be in the same skeleton molecule.
Bone_mask

bone_mask <molecule> <codes> <radii>

This command is used to make a datablock called <molecule>_mask that contains coordinate and radii information for use in making a molecular mask. The option requests a set of skeleton codes and the associated radii. Only the specified coded skeleton atoms are used in making the mask datablock. Use the Bone_redefine command to set the desired codes. Computer programs are available to read the mask datablock and generate masks suitable for the A programs (Jones (1992)) or the newer RAVE programs (Kleywegt & Jones,never to be published).
Bone_prune

bone_prune <Id 2 atoms>

This command attempts to create a tentative Ca trace. It modifies the connectivity of all atoms linking the 2 identified atoms, to more closely resemble a Ca trace. The two end-point atoms are kept, as are all atoms containing a branch. Connections from other/to other atoms are removed if the distance to the last tentative Ca atom is < 3.8Å. When an atom is found to be > 3.8Å from the last tentative Ca, it is shifted to make a more exact separation. Any remaining short separations between tentative Ca atoms are flagged in an object called warn.
Bone_redefine

bone_redefine <id 2 atoms> <new level>

Redefine the 'bone level' of a set of connected Bones atoms. Must not be in a circular connection. The objects are redrawn with the new colours. NOTE: you can put any text up on the screen menu, so if you are doing skeleton editing, you might want to put the characters 1 2 3 as separate menu items.
Bone_repeat

bone_repeat

Backtrack one position in the sequence for Bone_Ca_ID.Depending on the choice of direction,you may be going forwards or backwards.
Bones_sc_set (050801)

bone_set_sc <skeleton molecule <number of links>

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

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


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

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

bone_setup <mol> <object> <radius> <level>

Setup necessary parameters. These define the skeleton molecule, the object name being created, the radius within which to display atoms, and what levels to use.
Bone_skip

bone_skip

Move forward (or backward, depending on choice of direction) one residue in the sequence for Bone_Ca_ID
Bone_undo

bone_undo

This command restores the connectivity prior to the last bond_break or bone_prune operation. Only one level of undo is maintained. Any objects that may exist will have to be remade by the user.
Build Commands (020329)
The Build commands aim to be completely general, and should work with any kind of residue provided there is a description in the stereochemical dictionary used by O. Some of these commands are used during the initial stages of map interpretation. Others are intended for use during the rebuilding stage of crystallographic refinement. Those commands that use electron density maps (Build_ed_*) are integrated with the F(ast)M(ap) system used in O. There are currently 12 Build commands available
O > build Heap> BUILD is not a unique keyword. Heap> Build_molecu is a possibility. Heap> Build_residu is a possibility. Heap> Build_rotame is a possibility. Heap> Build_slider is a possibility. Heap> Build_ed_rot is a possibility. Heap> Build_ed_loo is a possibility. Heap> Build_ed_to is a possibility. Heap> Build_ed_res is a possibility. Heap> Build_ed_gro is a possibility. Heap> Build_nucleu is a possibility. Heap> Build_init is a possibility. Heap> Build_altern is a possibility. Heap> BUILD is not a visible command.
Build_altern(ate) 050802

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

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

O > dir P2_ALTERNATES

there are no such entries to begin with.

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

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

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

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

O > dir p2b* Heap> P2B_MOLECULE_TYPE C W 2 Heap> P2B_MOLECULE_CA C W 1 Heap> P2B_MOLECULE_CA_MXDST R W 1 Heap> P2B_ATOM_COLOUR I W 22 Heap> P2B_ATOM_XYZ R W 66 Heap> P2B_ATOM_B R W 22 Heap> P2B_ATOM_WT R W 22 Heap> P2B_ATOM_Z I W 22 Heap> P2B_ATOM_SELECT I W 22 Heap> P2B_ATOM_VISIBLE I W 22 Heap> P2B_ATOM_BUILT I W 22 Heap> P2B_ATOM_NAME C W 22 Heap> P2B_RESIDUE_TYPE C W 2 Heap> P2B_RESIDUE_NAME C W 2 Heap> P2B_RESIDUE_POINTERS I W 4 Heap> P2B_RESIDUE_CG R W 8 Heap> P2B_BOND_DISTANCE I W 96 Heap> P2B_BOND_ANGLE I W 130 Heap> P2B_TORSION_FIXED I W 96 Heap> P2B_TORSION_FLEXIBLE I W 24 Heap> P2B_CONNECTIVITY I W 31
P2B is a normal O molecule, so the user can make objects, build new conformations etc. However, we now have a P2_ALTERNATES entry in the ODB:

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

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

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

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

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

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

Build_ED_Group (050802)

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

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

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

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

The adenine ring is first separated from the ribose ring (using Bond_break) to form a group

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

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

Build_ed_loo (020329)
Build_ed_loo <molecule name><from residue> <to residue> <skeleton molecule>
This generates coordinates for all residues after the 'from' residue and before the 'to' residue in the molecule that is being built. The algorithmuses the main-chain connectivity of the specified skeleton molecule to make theinitial placement of the 'central atom' of each residue (CA in proteins, P in nucleic acids). The inter-residue distance is then updated to take into account the spacing along the skeleton, a new placement is made, the main-chain database is used to build the loop, side-chains are then fitted to the densityin a rotamer conformation, the loop is regularized. The final goodness of fit will depend on the quality of the electron density and the quality of the skeleton. The stereochemistry for the molecule being built must exist in the O database, i.e. the commands refi_init / refi_gener must have been used. The Lego_setup must correctly specfiy the location of the main-chain database. The electron densitymust have been loaded into the O F(ast)M(ap) system and is specified by the Density pull-down (Density option).
O > bu_ed_l New> Map used is MIR New> Molecule being built [P2 ]: New> Residue from where to build: a22 New> Residue to which we want tobuild: a29 New> Skeleton [SKL ]: New> Reading proteins db New> The protein DB is now being loaded. …..
The main-chain database is loaded the first time it is needed.
This command is activated automaticall by the decor_guess command to fill in the loops between secondary structures once the user is happy with the sequence decoration.
Build_ed_res(idue) (050803)

build_ed_res <ID an atom>

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

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

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

Build_ed_res has been activated, and a skeleton atom close to the branch point has been identified

Fm_rsr_zone has been used to slightly improve the fit.

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

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

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

Build_ed_to (050806)

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

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

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

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

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

O > build_init New> This WILL initialise certain datablocks. New> Molecule name ([] to exit): p2m New> <=100 characters per line, SVP. New> File of sequence in 1-letter code: p2_1let_seq New> Number of residues 131 New> There were 19 different residues New> There were 4 problems in conversion New> Specify 3 letter code for G : gly New> Specify 3 letter code for T : thr New> Specify 3 letter code for A : ala New> Specify 3 letter code for C : cyh Sam> Database compressed. Sam> Making residue names. Sam> There are 131 residues, 1038 atoms. Sam> This atom has the potential for an incorrect Z: CA... Sam> This atom has the potential for an incorrect Z: CA O > $ cat p2_1let_seq SNKFLGTWKLVSSENFDEYMKALGVGLATRKLGNLAKPRVIISKKGDIIT IRTESPFKNTEISFKLGQEFEETTADNRKTKSTVTLARGSLNQVQKWNGN ETTIKRKLVDGKMVVECKMKDVVCTRIYEKV O > dir p2m* Heap> P2M_RESIDUE_TYPE C W 131 Heap> P2M_RESIDUE_NAME C W 131 Heap> P2M_ATOM_NAME C W 1038 Heap> P2M_ATOM_XYZ R W 3114 Heap> P2M_ATOM_B R W 1038 Heap> P2M_ATOM_WT R W 1038 Heap> P2M_ATOM_Z I W 1038 Heap> P2M_ATOM_SELECT I W 1038 Heap> P2M_ATOM_VISIBLE I W 1038 Heap> P2M_RESIDUE_POINTERS I W 262 Heap> P2M_RESIDUE_CG R W 524
Build_molecule (020709)
build_molecule <molecule name>
The user specifies which molecule will be used for the Build commands
O > build_mol Mnp> Molecule getting built [A]:
Most Build commands require that the stereochemistry entries exist for this molecule. These entries are generated by refi_init & refi_gener commands.

Build_nucleus (050803)

build_nucleus <ID atom>

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

The adenine ring has been fitted to the density and seoparated from the rest of the ADP (see Build_ED_group above)

Build_nucelus has been activated and an atom in the ring ID'ed. The rest of the ADP has been generated from the stereochemistry.

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

The adenine ring has been used as a nucleus to build the rest of the ADP using Build_nucleus
The the C2*-C3* bond in the ribose ring has then been broken.

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

Fm_rsr_zone has been used to optimize the fit

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

build_residue <molecule name> <residue name> <option [F]BC>

This command generates atomic coordinates from the stereochemistry dictionary that is used by O's Refi system. The bond lengths, angles and torsion angles must be sufficient to allow O to actually build the residue. If the user chooes the F option, the resodues is built in the forward direction in the sequence, with B ackwards, with C at the current screen centre.

O > bu_res Mnp> Molecule getting built [A]: Mnp> Residue : [?]: a22 Mnp> Build direction ([F]/B/C):

build_rotamer <molecule name> <residue> <rotamer number>

This generates coordinates for a possible rotamer. The rotamer must be defined in the stereochemical dictionary that is used by O's Refi system

O> Buil_rot Mnp> Molecule getting built [A]: Mnp> Residue : [?]: a22 Mnp> Rotamer number: 2 Mnp> No rotamers found for ALA

In the above example, the residue is an alanaine and does not have a rotamer.
Build_slider (020329)
Build_slider <guess> <molecule to be built> or Build_slider <guesses> <gap size(s) between guesses><molecule to be built> or Build_slider ; <molecule to be built> <zone>
This commands allows one to see how the sequence matches a part ofthe framework. If no guess is specified, the user defines the zone over which to apply the operation. The sequence window specifies which part of the sequence is tobe associated with the guess framework. Moving through the sequence window,updates the side-chains drawn on the framework. If multiple guesses aredefined, one must also define initial estimates for the gap size between theframework templates. If one specifies 2 guesses, only one gap needs to bedefined, etc. As one changes the sequence, for multiple guesses, the gapsize(s) is (are) used to decide the sequence to be drawn. If specified, the gapcan be changed via dial input. Another dial input (Toggle) controls if theside-chains appear as the first rotamer, or if they are first real-spacefitted. Changes in the sequence window will result in an immediate response ifthe first rotamer option is active. The real-space fitting option, will take afew seconds to produce a response. Here is an example using just one gap:
O > bui_slider New> Map used is AVER New> Slider guesses in DB : G1 New> Slider guesses in DB : G2 New> Slider guesses in DB : G3 New> Slider guesses in DB : G4 New> Slider guesses in DB : G5 New> Slider guesses in DB : G6 New> Slider guesses in DB : G7 New> Slider guesses in DB : G8 New> Slider guesses in DB : G9 New> Slider guesses in DB : G10 New> Slider guesses in DB : G11 New> Slider guesses in DB : G12 New> Slider guesses in DB : G13 New> Slider guesses in DB : G14 New> What guesses ? g14 New> Molecule being built [P2 ]:
One dial input ('Toggle') is now active, to toggle between the 2 side-chain fitting options. In the following figure, the correct sequence is drawn with the most common rotamer in the left image:


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

ca_zone <res1 res2>

Add a Ca zone to the current open object. A blank input specifies all residues in the molecule. Entering just one residue name, specifies only that residue.

Centre_atom (050803)

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

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

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

Centre_build (050803)

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

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

O > ce_buil New> Define molecule [P2], residue, and atom [CA]: a98 O > ce_bui New> Define molecule [P2], residue, and atom [CA]: p2 a8The user can, however, choose to keep using Grab_build .

Centre_ID (020801)

The next identified atom becomes the screen centre. Atoms can be identified by picking at the screen or by using the Terminal_id command. The macro @on_centre is activated. The distributed version of this macro causes contouring of the electron density defined in the Density pull-down with the current slider setting.

Centre_next

centre_next <property> <operator> <value>

Move from the currently centred atom to the next atom or residue along the sequence that fullfill the criteria of the logical expression. A sister command, Centre_prev, moves in the backward direction. Examples:

centre_next atom_name = ca

sets the current active centre at next C-alpha position.

centre_next residue_type = lys

centres on next lysine residue.

centre_next residue_rsfit < 0.8

Centres on next residue with a rsfit correlation coefficient worse than 0.8

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

Centre_prev

centre_prev <property> <operator> <value>

Same as Centre_next, but moves backwards in the sequence. The macro @on_centre is activated. The distributed version of this macro causes contouring of the electron density defined in the Density pull-down with the current slider setting.

Centre_XYZ

centre_xyz <x y z>

Define the '.active_centre' by entering a coordinate value at the terminal. The macro @on_centre is activated. The distributed version of this macro causes contouring of the electron density defined in the Density pull-down with the current slider setting.

Centre_zone

centre_zone <id two atoms> or <mol res1 res2>

The picture centre is redefined as the centre of gravity of the defined zone. The macro @on_centre is activated. The distributed version of this macro causes contouring of the electron density defined in the Density pull-down with the current slider setting.
If the user wishes to centre on the centre of gravity of the molecule, just define the molecule without the zone. For example, typing 'cen_zone m1' will centre on the centre of gravity of molecule M1.

Clear_flags

Clear all flags. This command cancels all active commands. If atomic coordinates are being changed, e.g. by Lego_side_chain, the command issues a No.

Clear_Id

Remove ID text from all molecular objects.

Connect_code (050803)

connect_code <code>

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

connect_sc - CA + CONNECT_sc CA CB CG1 CONNECT_sc CB CG2 CONNECT_ALL - N CA C + CONNECT_ALL CA CB CG1 CONNECT_ALL CB CG2 CONNECT_ALL C O connect_mc - N CA C + connect_mc C O
To make atomic objects showing all atoms, therefore, one would use the ALL code as follows:

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

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

	Connectivity code ALL
	Connectivity code SC
	Connectivity code MC

Continue_no (050803)

continue_no

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

Continue_yes (050803)

continue_yes

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

Copy_Db

copy_db <A> <B>

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

Cover_sphere

cover_sphere <res atom> <radius>

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

Cpk_object

CPK_object <object> <mode> <cleanup>

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

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

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

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

	We wish to build residue 230, a tyrosine. The map and skeleton clearly show good density for this residue. Note that the peptide bump is clearly defined. The map has been specified in the Density pull-down. The residue to be built has been highlighted in the Sequence pull-down
	Build_ed_res has been activated, and a skeleton atom close to the branch point has been identified
	Fm_rsr_zone has been used to slightly improve the fit.

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

	The adenine ring has been used as a nucleus to build the rest of the ADP using Build_nucleus The the C2-C3 bond in the ribose ring has then been broken.
	Fm_rsr_tor has been used with the largest allowed number of connected bonds, from C8 in the adenine to PA, to give a roughly fitting ADP
	Fm_rsr_zone has been used to optimize the fit