Contents
Previous
DESCRIPTION
"alias" allows you to bind a commonly used command to a single word
USAGE
alias name, command-sequence
PYMOL API
cmd.alias(string name,string command)
EXAMPLES
alias go,load "test.pdb"; zoom (i;500); show sticks,(i;500 a;4)
go
SEE ALSO
extend
DESCRIPTION
"alter" changes one or more atomic properties over a selection
using the python evaluator with a separate name space for each
atom. The symbols defined in the name space are:
name, resn, resi, chain, alt, elem, q, b, segi,
type (ATOM,HETATM), partial_charge, formal_charge,
text_type, numeric_type, ID
All strings must be explicitly quoted. This operation typically
takes several seconds per thousand atoms altered.
WARNING: You should always issue a "sort" command on an object
after modifying any property which might affect canonical atom
ordering (names, chains, etc.). Failure to do so will confound
subsequent "create" and "byres" operations.
USAGE
alter (selection),expression
EXAMPLES
alter (chain A),chain='B'
alter (all),resi=str(int(resi)+100)
sort
SEE ALSO
alter_state, iterate, iterate_state, sort
DESCRIPTION
"alter_state" changes the atomic coordinates of a particular state
using the python evaluator with a separate name space for each
atom. The symbols defined in the name space are:
x,y,z
USAGE
alter_state state,(selection),expression
EXAMPLES
alter 1,(all),x=x+5
SEE ALSO
iterate_state, alter, iterate
DESCRIPTION
The PyMOL Python Application Programming Interface (API) should be
accessed exclusively through the "cmd" module (never "_cmd"!). Nearly
all command-line functions have a corresponding API method.
USAGE
from pymol import cmd
result = cmd.<command-name>( argument , ... )
NOTES
Although the PyMOL core is not multi-threaded, the API is
thread-safe and can be called asynchronously by external python
programs. PyMOL handles the necessary locking to insure that
internal states do not get corrupted. This makes it very easy to
build complicated systems which involve direct realtime visualization.
DESCRIPTION
"@" sources a PyMOL command script as if all of the commands in the
file were typed into the PyMOL command line.
USAGE
@ <script-file>
PYMOL API
Not directly available. Instead, use cmd.do("@...").
DESCRIPTION
"attach" adds a single atom onto the picked atom.
USAGE
attach name, geometry, valence
PYMOL API
cmd.attach( name, geometry, valence )
NOTES
Immature functionality. See code for details.
DESCRIPTION
"backward" moves the movie back one frame.
USAGE
backward
PYMOL API
cmd.backward()
SEE ALSO
mset, forward, rewind
DESCRIPTION
"bg_color" sets the background color
USAGE
bg_color [color]
PYMOL API
cmd.color(string color="black")
DESCRIPTION
"bond" creates a new bond between two selections, each of
which should contain one atom.
USAGE
bond [atom1,atom2 [,order]]
PYMOL API
cmd.bond(string atom1, string atom2)
NOTES
The atoms must both be within the same object.
The default behavior is to create a bond between the (lb) and (rb)
selections.
SEE ALSO
unbond, fuse, attach, replace, remove_picked
DESCRIPTION
"button" can be used to redefine what the mouse buttons do.
USAGE
button <button>,<modifier>,<action>
PYMOL API
cmd.button( string button, string modifier, string action )
NOTES
button: L, M, R
modifers: None, Shft, Ctrl, CtSh
actions: Rota, Move, MovZ, Clip, RotZ, ClpN, ClpF
lb, mb, rb, +lb, +mb, +rb,
PkAt, PkBd, RotF, TorF, MovF, Orig
Switching from visualization to editing mode will redefine the
buttons, so do not use the built-in switch if you want to preserve
your custom configuration.
DESCRIPTION
"cartoon" changes the default cartoon for a set of atoms.
USAGE
cartoon type, (selection)
type = skip | automatic | loop | rectangle | oval | tube | arrow | dumbbell
PYMOL API
cmd.cartoon(string type, string selection )
EXAMPLES
cartoon rectangle,(chain A)
cartoon skip,(resi 145:156)
NOTES
the "automatic" mode utilizes ribbons according to the
information in the PDB HELIX and SHEET records.
DESCRIPTION
"cd" changes the current working directory.
USAGE
cd <path>
SEE ALSO
pwd, ls, system
DESCRIPTION
"clip" alterss the near and far clipping planes according to
USAGE
clip {near|far|move|slab}, distance
EXAMPLES
clip near, -5 # moves near plane away from you by 5 A
clip far, 10 # moves far plane towards you by 10 A
clip slab, 20 # sets slab thickness to 20 A
clip move, -5 # moves the slab away from you by 5 A
PYMOL API
cmd.clip( string mode, float distance )
SEE ALSO
zoom, reset
DESCRIPTION
"cls" clears the output buffer.
USAGE
cls
DESCRIPTION
"color" changes the color of an object or an atom selection.
USAGE
color color-name
color color-name, object-name
color color-name, (selection)
PYMOL API
cmd.color( string color, string color-name )
EXAMPLES
color yellow, (name C*)
COMMANDS
INPUT/OUTPUT load save delete quit
VIEW turn move clip rock
show hide enable disable
reset refresh rebuild
zoom origin orient
view get_view set_view
MOVIES mplay mstop mset mdo
mpng mmatrix frame
rewind middle ending
forward backward
IMAGING png mpng
RAY TRACING ray
MAPS isomesh isodot
DISPLAY cls viewport splash
SELECTIONS select mask
SETTINGS set button
ATOMS alter alter_state
EDITING create replace remove h_fill remove_picked
edit bond unbond h_add fuse
undo redo protect cycle_valence attach
FITTING fit rms rms_cur pair_fit
intra_fit intra_rms intra_rms_cur
COLORS color set_color
HELP help commands
DISTANCES dist
STEREO stereo
SYMMETRY symexp
SCRIPTS @ run
LANGUAGE alias extend
Try "help <command-name>". Also see the following extra topics:
"movies", "keyboard", "mouse", "selections",
"examples", "launching", "editing", and "api".
DESCRIPTION
"copy" creates a new object that is an identical copy of an
existing object
USAGE
copy target, source
copy target = source # (DEPRECATED)
PYMOL API
cmd.copy(string target,string source)
SEE ALSO
create
DESCRIPTION
"count_atoms" returns a count of atoms in a selection.
USAGE
count (selection)
PYMOL API
cmd.count(string selection)
DESCRIPTION
"count_states" is an API-only function which returns the number of
states in the selection.
PYMOL API
cmd.count_states(string selection="(all)")
SEE ALSO
frame
DESCRIPTION
"create" creates a new molecule object from a selection. It can
also be used to create states in an existing object.
NOTE: this command has not yet been throughly tested.
USAGE
create name, (selection) [,source_state [,target_state ] ]
create name = (selection) [,source_state [,target_state ] ]
# (DEPRECATED)
name = object to create (or modify)
selection = atoms to include in the new object
source_state (default: 0 - copy all states)
target_state (default: 0)
PYMOL API
cmd.create(string name, string selection, int state, int target_state)
NOTES
If the source and target states are zero (default), all states will
be copied. Otherwise, only the indicated states will be copied.
SEE ALSO
load, copy
DESCRIPTION
"cycle_valence" cycles the valence on the currently selected bond.
USAGE
cycle_valence [ h_fill ]
PYMOL API
cmd.cycle_valence(int h_fill)
EXAMPLES
cycle_valence
cycle_valence 0
NOTES
If the h_fill flag is true, hydrogens will be added or removed to
satisfy valence requirements.
This function is usually connected to the DELETE key and "CTRL-W".
SEE ALSO
remove_picked, attach, replace, fuse, h_fill
DESCRIPTION
"delete" removes an object or a selection.
USAGE
delete name
delete all # deletes all objects
name = name of object or selection
PYMOL API
cmd.delete (string name = object-or-selection-name )
SEE ALSO
remove
DESCRIPTION
"deprotect" reveres the effect of the "protect" command.
USAGE
deprotect (selection)
PYMOL API
cmd.deprotect(string selection="(all)")
SEE ALSO
protect, mask, unmask, mouse, editing
DESCRIPTION
"disable" disables display of an object and all currently visible
representations.
USAGE
disable name
disable all
"name" is the name of an object or a named selection
PYMOL API
cmd.disable( string name )
EXAMPLE
disable my_object
SEE ALSO
show, hide, enable
DESCRIPTION
"distance" creates a new distance object between two
selections. It will display all distances within a cutoff.
USAGE
distance
distance (selection1), (selection2)
distance name = (selection1), (selection1) [,cutoff [,mode] ]
name = name of distance object
selection1,selection2 = atom selections
cutoff = maximum distance to display
mode = 0 (default)
PYMOL API
cmd.distance( string name, string selection1, string selection2,
string cutoff, string mode )
returns the average distance between all atoms/frames
NOTES
The distance wizard makes measuring distances easier than using
the "dist" command for real-time operations.
"dist" alone will show distances between selections (lb) and (rb)
created by left and right button atom picks. CTRL-SHIFT/left-click
on the first atom, CTRL-SHIFT/right-click on the second, then run
"dist".
DESCRIPTION
"do" makes it possible for python programs to issue simple PyMOL
commands as if they were entered on the command line.
PYMOL API
cmd.do( commands )
USAGE (PYTHON)
from pymol import cmd
cmd.do("load file.pdb")
DESCRIPTION
"edit" picks an atom or bond for editing.
USAGE
edit (selection) [ ,(selection) ]
PYMOL API
cmd.edit( string selection [ ,string selection ] )
NOTES
If only one selection is provided, an atom is picked.
If two selections are provided, the bond between them
is picked (if one exists).
SEE ALSO
unpick, remove_picked, cycle_valence, torsion
EDITING KEYS
These are defaults, which can be redefined. Note that while
entering text on the command line, some of these control keys take on
text editing functions instead (CTRL - A, E, and K, and DELETE), so
you should clear the command line before trying to edit atoms.
ATOM REPLACEMENT
CTRL-C Replace picked atom with carbon (C)
CTRL-N Replace picked atom with nitrogen (N)
CTRL-O Replace picked atom with oxygen (O)
CTRL-S Replace picked atom with sulpher (S)
CTRL-G Replace picked atom with hydrogen (H)
CTRL-F Replace picked atom with fluorene (F)
CTRL-L Replace picked atom with chlorine (Cl)
CTRL-B Replace picked atom with bromine (Br)
CTRL-I Replace picked atom with iodine (I)
ATOM MODIFICATION
CTRL-J Set charge on picked atom to -1
CTRL-K Set charge on picked atom to +1
CTRL-D Remove atom or bond (DELETE works too).
CTRL-Y Add a hydrogen to the current atom
CTRL-R Adjust hydrogens on atom/bond to match valence.
CTRL-E Inverts the picked stereo center, but you must first
indicate the constant portions with the (lb) and (rb)
selections.
CTRL-T Connect atoms in the (lb) and (rb) selections.
CTRL-W Cycle the bond valence on the picked bond.
UNDO and REDO of conformational changes (not atom changes!)
CTRL-Z undo the previous conformational change.
(you can not currently undo atom modifications).
CTRL-A redo the previous conformational change.
SUMMARY
PyMOL has a rudimentary, but quite functional molecular structure
editing capability. However, you will need to use an external mimizer
to "clean-up" your structures after editing. Furthermore, if you are
going to modify molecules other than proteins, then you will also need
a way of assigning atom types on the fly.
To edit a conformation or structure, you first need to enter editing
mode (see Mouse Menu). Then you can pick an atom (CTRL-Middle click)
or a bond (CTRL-Right click). Next, you can use the other
CTRL-key/click combinations listed on the right hand side of the
screen to adjust the attached fragments. For example, CTRL-left click
will move fragments about the selected torsion.
Editing structures is done through a series of CTRL key actions
applied to the currently selected atom or bonds. See "help edit_keys"
for the exact combinations. To build structures, you usually just
replace hydrogens with methyl groups, etc., and then repeat. They are
no short-cuts currently available for building common groups, but that
is planned for later versions.
NOTE
Only "lines" and "sticks" representations can be picked using the
mouse, however other representations will not interfere with picking
so long as one of these representation is present underneath.
DESCRIPTION
"enable" enable display of an object and all currently visible representations.
USAGE
enable name
enable all
name = object or selection name
PYMOL API
cmd.enable( string object-name )
EXAMPLE
enable my_object
SEE ALSO
show, hide, disable
DESCRIPTION
"ending" goes to the end of the movie.
USAGE
ending
PYMOL API
cmd.ending()
EXAMPLE ATOM SELECTIONS
select bk = ( name ca or name c or name n )
* can be abbreviated as *
sel bk = (n;ca,c,n)
select hev = ( not hydro )
* can be abbreviated as *
sel hev = (!h;)
select site = ( byres ( resi 45:52 expand 5 ))
* can be abbreviated as *
sel site = (b;(i;45:52 x;5))
select combi = ( hev and not site )
* can be abbreviated as *
sel combi = (hevsite)
DESCRIPTION
"extend" is an API-only function which binds a new external
function as a command into the PyMOL scripting language.
PYMOL API
cmd.extend(string name,function function)
PYTHON EXAMPLE
def foo(moo=2): print moo
cmd.extend('foo',foo)
The following would now be valid within PyMOL:
foo
foo 3
foo moo=5
SEE ALSO
alias, api
RAY TRACING OPTIMIZATION
1. Reduce object complexity to a minimum acceptable level.
For example, try lowering:
"cartoon_sampling"
"ribbon_sampling", and
"surface_quality", as appropriate.
2. Increase "hash_max" so as to obtain a voxel dimensions of
0.3-0.6. Proper tuning of "hash_max" can speed up
rendering by a factor of 2-3 for non-trivial scenes.
WARNING: memory usage depends on hash_max^3, so avoid
pushing into virtual memory. Roughly speaking:
hash_max = 80 --> ~9 MB hash + data
hash_max = 160 --> ~72 MB hash + data
hash_max = 240 --> ~243 MB hash + data
Avoid using virtual memory.
3. Recompiling with optimizations on usually gives a 25-33%
performance boost for ray tracing.
DESCRIPTION
"feedback" allows you to control what and how much text is output
from PyMOL.
USAGE
feedback action,module,mask
action is one of ['set','enable','disable']
module is a space-separated list of strings or simply "all"
mask is a space-separated list of strings or simply "everything"
NOTES:
"feedback" alone will print a list of the available choices
PYMOL API
cmd.feedback(string action,string module,string mask)
EXAMPLES
feedback enable, all , debugging
feedback disable, selector, warnings actions
feedback enable, main, blather
DESCRIPTION
"find_pairs" is currently undocumented.
DESCRIPTION
"finish_object" is used in cases where many individual states are
being loaded and it is advantageos to avoid processing them until
all states have been loaded into RAM. This function should always
be called after loading an object with the finish flag set to zero.
PYMOL API
cmd.finish(string name)
"name" should be the name of the object
DESCRIPTION
"fit" superimposes the model in the first selection on to the model
in the second selection. Only matching atoms in both selections
will be used for the fit.
USAGE
fit (selection), (target-selection)
EXAMPLES
fit ( mutant and name ca ), ( wildtype and name ca )
SEE ALSO
rms, rms_cur, intra_fit, intra_rms, intra_rms_cur
DESCRIPTION
"flag" sets the indicated flag for atoms in the selection and
clears the indicated flag for atoms not in the selection. This
is primarily useful for passing selection information into
Chempy models.
USAGE
flag number, selection
flag number = selection # (DEPRECATED)
PYMOL API
cmd.flag( int number, string selection )
EXAMPLES
flag 0, (name ca)
flag 1, (resi 45 x; 6)
DESCRIPTION
"forward" moves the movie one frame forward.
USAGE
forward
PYMOL API
cmd.forward()
SEE ALSO
mset, backward, rewind
DESCRIPTION
"fragment" retrieves a 3D structure from the fragment library, which is currently
pretty meager (just amino acids).
USAGE
fragment name
DESCRIPTION
"frame" sets the viewer to the indicated movie frame.
USAGE
frame frame-number
PYMOL API
cmd.frame( int frame_number )
NOTES
Frame numbers are 1-based
SEE ALSO
count_states
DESCRIPTION
"full_screen" enables or disables PyMOL's full_screen mode. This
is only functions well on PC's.
USAGE
full_screen on
full_screen off
DESCRIPTION
"fuse" joins two objectss into one by forming a bond. A copy of
the object containing the second atom is moved so as to form an
approximately resonable bond with the first, and is then merged
with the first object.
USAGE
fuse (selection1), (selection2)
PYMOL API
cmd.fuse( string selection1="(lb)", string selection2="(lb)" )
NOTES
Each selection must include a single atom in each object.
The atoms can both be hydrogens, in which case they are
eliminated, or they can both be non-hydrogens, in which
case a bond is formed between the two atoms.
SEE ALSO
bond, unbond, attach, replace, fuse, remove_picked
PRE-RELEASE functionality - API will change
DESCRIPTION
"get_extent" returns the minimum and maximum XYZ coordinates of a
selection as an array:
[ [ min-X , min-Y , min-Z ],[ max-X, max-Y , max-Z ]]
PYMOL API
cmd.get_extent(string selection="(all)", state=0 )
DESCRIPTION
"get_frame" returns the current frame index (1-based)
PYMOL API
Frames refers to sequences of images in a movie. Sequential frames
may contain identical molecular states, they may have one-to-one
correspondance to molecular states (default), or they may have an
arbitrary relationship, specific using the "mset" command.
SEE ALSO
get_state
DESCRIPTION
"get_model" returns a Chempy "Indexed" format model from a selection.
PYMOL API
cmd.get_model(string selection [,int state] )
DESCRIPTION
"get_names" returns a list of object and/or selection names.
PYMOL API
cmd.get_names( [string: "objects"|"selections"|"all"] )
NOTES
The default behavior is to return only object names.
SEE ALSO
get_type, count_atoms, count_states
DESCRIPTION
"get_state" returns the current state index (1-based)
PYMOL API
cmd.get_state()
NOTES
States refer to different geometric configurations which an object
can above. By default, states and movie frames have a one-to-one
relationship. States can be visited in an arbitrary order to
create frames. The "mset" command allows you to build a
relationship between states and frames.
SEE ALSO
get_frame
DESCRIPTION
"get_type" returns a string describing the named object or
selection or the string "nonexistent" if the name in unknown.
PYMOL API
cmd.get_type(string object-name)
NOTES
Possible return values are
"object:molecule"
"object:map"
"object:mesh"
"object:distance"
"selection"
SEE ALSO
get_names
DESCRIPTION
"get_view" returns and optionally prints out the current view
information in a format which can be embedded into a command
script and used in subsequent calls to "set_view"
USAGE
get_view
PYMOL API
cmd.get_view(output=1)
API USAGE
cmd.get_view(0) # zero option suppresses output
DESCRIPTION
"h_add" uses a primitive algorithm to add hydrogens
onto a molecule.
USAGE
h_add (selection)
PYMOL API
cmd.h_add( string selection="(all)" )
SEE ALSO
h_fill
DESCRIPTION
"h_fill" removes and replaces hydrogens on the atom
or bond picked for editing.
USAGE
h_fill
PYMOL API
cmd.h_fill()
NOTES
This is useful for fixing hydrogens after changing
bond valences.
SEE ALSO
edit, cycle_valences, h_add
DESCRIPTION
"help" prints out the online help for a given command.
USAGE
help command
DESCRIPTION
"hide" turns of atom and bond representations.
The available representations are:
lines spheres mesh ribbon cartoon
sticks dots surface labels
nonbonded nb_spheres
USAGE
hide reprentation [,object]
hide reprentation [,(selection)]
hide (selection)
PYMOL API
cmd.hide( string representation="", string selection="")
EXAMPLES
hide lines,all
hide ribbon
SEE ALSO
show, enable, disable
DESCRIPTION
"id_atom" returns the original source id of a single atom, or
raises and exception if the atom does not exist or if the selection
corresponds to multiple atoms.
PYMOL API
list = cmd.id_atom(string selection)
DESCRIPTION
"identify" returns a list of atom IDs corresponding to the ID code
of atoms in the selection.
PYMOL API
list = cmd.identify(string selection="(all)")
DESCRIPTION
"index" returns a list of tuples corresponding to the
object name and index of the atoms in the selection.
PYMOL API
list = cmd.index(string selection="(all)")
NOTE
Atom indices are fragile and will change as atoms are added
or deleted. Whenever possible, use integral atom identifiers
instead of indices.
DESCRIPTION
"intra_fit" fits all states of an object to an atom selection
in the specified state. It returns the rms values to python
as an array.
USAGE
intra_fit (selection),state
PYMOL API
cmd.intra_fit( string selection, int state )
EXAMPLES
intra_fit ( name ca )
PYTHON EXAMPLE
from pymol import cmd
rms = cmd.intra_fit("(name ca)",1)
SEE ALSO
fit, rms, rms_cur, intra_rms, intra_rms_cur, pair_fit
DESCRIPTION
"intra_rms" calculates rms fit values for all states of an object
over an atom selection relative to the indicated state.
Coordinates are left unchanged. The rms values are returned
as a python array.
PYMOL API
cmd.intra_rms( string selection, int state)
PYTHON EXAMPLE
from pymol import cmd
rms = cmd.intra_rms("(name ca)",1)
SEE ALSO
fit, rms, rms_cur, intra_fit, intra_rms_cur, pair_fit
DESCRIPTION
"intra_rms_cur" calculates rms values for all states of an object
over an atom selection relative to the indicated state without
performing any fitting. The rms values are returned
as a python array.
PYMOL API
cmd.intra_rms_cur( string selection, int state)
PYTHON EXAMPLE
from pymol import cmd
rms = cmd.intra_rms_cur("(name ca)",1)
SEE ALSO
fit, rms, rms_cur, intra_fit, intra_rms, pair_fit
DESCRIPTION
"invert" inverts the stereo-chemistry of the atom currently picked
for editing (pk1). Two additional atom selections must be provided
in order to indicate which atoms remain stationary during the
inversion process.
USAGE
invert (selection1),(selection2)
PYMOL API
cmd.api( string selection1="(lb)", string selection2="(lb)" )
NOTE
The invert function is usually bound to CTRL-E in editing mode.
The default selections are (lb) and (rb), meaning that you can pick
the atom to invert with CTRL-middle click and then pick the
stationary atoms with CTRL-SHIFT/left-click and CTRL-SHIFT/right-
click, then hit CTRL-E to invert the atom.
DESCRIPTION
"isodot" creates a dot isosurface object from a map object.
USAGE
isodot name = map, level [,(selection) [,buffer [, state ] ] ]
"map" is the name of the map object to use.
"level" is the contour level.
"selection" is an atom selection about which to display the mesh with
an additional "buffer" (if provided).
NOTES
If the dot isosurface object already exists, then the new dots will
be appended onto the object as a new state.
SEE ALSO
load, isomesh
DESCRIPTION
"isomesh" creates a mesh isosurface object from a map object.
USAGE
isomesh name, map, level [,(selection) [,buffer [,state [,carve ]]]]
"name" is the name for the new mesh isosurface object.
"map" is the name of the map object to use for computing the mesh.
"level" is the contour level.
"selection" is an atom selection about which to display the mesh with
an additional "buffer" (if provided).
"state" is the state into which the object should be loaded.
"carve" is a radius about each atom in the selection for which to
include density. If "carve" is not provided, then the whole
brick is displayed.
NOTES
If the mesh object already exists, then the new mesh will be
appended onto the object as a new state (unless you indicate a state).
SEE ALSO
isodot, load
DESCRIPTION
"iterate" iterates over an expression with a separate name space
for each atom. However, unlike the "alter" command, atomic
properties can not be altered. Thus, "iterate" is more efficient
than "alter".
It can be used to perform operations and aggregations using atomic
selections, and store the results in any global object, such as the
predefined "stored" object.
The local namespace for "iterate" contains the following names
name, resn, resi, chain, alt, elem,
q, b, segi, and type (ATOM,HETATM),
partial_charge, formal_charge,
text_type, numeric_type, ID
All strings in the expression must be explicitly quoted. This
operation typically takes a second per thousand atoms.
USAGE
iterate (selection),expression
EXAMPLES
stored.net_charge = 0
iterate (all),stored.net_charge = stored.net_charge + partial_charge
stored.names = []
iterate (all),stored.names.append(name)
SEE ALSO
iterate_state, atler, alter_state
DESCRIPTION
"iterate_state" is to "alter_state" as "iterate" is to "alter"
USAGE
iterate_state state,(selection),expression
EXAMPLES
stored.sum_x = 0.0
iterate 1,(all),stored.sum_x = stored.sum_x + x
SEE ALSO
iterate, alter, alter_state
KEYBOARD COMMANDS and MODIFIERS
ESC Toggle onscreen text.
INSERT Toggle rocking.
LEFT ARROW, RIGHT ARROW Go backward or forward one frame, or when
editing, go forward or back one character.
HOME, END Go to the beginning or end of a movie.
Command Entry Field in the Interal GUI (black window)
TAB Complete commmand or filename (like in tcsh or bash).
CTRL-A Go to the beginning of the line.
CTRL-E Go to the end of the line.
CTRL-K Delete through to the end of the line.
Command Entry Field on the External GUI (gray window).
CTRL-C These operating system-provided cut and paste functions
CTRL-V will only work in the external GUI command line.
EDITING
type "help edit_keys" for keyboard shortcuts used in editing.
DESCRIPTION
"label" labels one or more atoms properties over a selection using
the python evaluator with a separate name space for each atom. The
symbols defined in the name space are:
name, resn, resi, chain, q, b, segi, type (ATOM,HETATM)
formal_charge, partial_charge, numeric_type, text_type
All strings in the expression must be explicitly quoted. This
operation typically takes several seconds per thousand atoms
altered.
To clear labels, simply omit the expression or set it to ''.
USAGE
label (selection),expression
EXAMPLES
label (chain A),chain
label (n;ca),"%s-%s" % (resn,resi)
label (resi 200),"%1.3f" % partial_charge
PyMOL COMMAND LINE OPTIONS
pymol.com [-ciqstwx] <file.xxx> [-p <file.py> ] ...
-c Command line mode, no GUI. For batch opeations.
-i Disable the internal OpenGL GUI (object list, menus, etc.)
-x Disable the external GUI module.
-t Use Tcl/Tk based external GUI module (pmg_tk).
-w Use wxPython based external GUI module (pmg_wx).
-q Quiet launch. Suppress splash screen.
-p Listen for commands on standard input.
-r <file.py>[,global|local|module] Run a python program in on startup.
-l <file.py>[,global|local|module] Spawn a python program in new thread.
-d <string> Run pymol command string upon startup.
<file> can have one of the following extensions, and all
files provided will be loaded or run after PyMOL starts.
.pml PyMOL command script to be run on startup
.py, .pym, .pyc Python program to be run on startup
.pdb Protein Data Bank format file to be loaded on startup
.mmod Macromodel format to be loaded on startup
.mol MDL MOL file to be loaded on startup
.xplor X-PLOR Map file to be loaded on startup
.pkl Pickled ChemPy Model (class "chempy.model.Indexed")
.r3d Raster3D Object
.cc1, .cc2 ChemDraw 3D cartesian coordinate file
DESCRIPTION
"load" reads several file formats. The file extension is used to
determine the format. PDB files must end in ".pdb", MOL files must
end in ".mol", Macromodel files must end in ".mmod", XPLOR
maps must end in ".xplor", CCP4 maps must end in ".ccp4",
Raster3D input (Molscript output) must end in ".r3d".
Pickled ChemPy models with a ".pkl" can also be directly read.
If an object is specified, then the file is load into that object.
Otherwise, an object is created with the same name as the file
prefix.
USAGE
load filename [,object [,state [,format [,finish [,discrete ]]]]]
PYMOL API
cmd.load( filename [,object [,state [,format [,finish [,discrete ]]]]]
NOTES
You can override the file extension by giving a format string:
'pdb' : PDB, 'mmod' : Macromodel, 'xyz' : Tinker, 'cc1' : ChemDraw3D
'mol' : MDL MOL-file, 'sdf' : MDL SD-file
'xplor' : X-PLOR/CNS map, 'ccp4' : CCP4 map,
'callback' : PyMOL Callback object (PyOpenGL)
'cgo' : compressed graphics object (list of floats)
SEE ALSO
save
Temporary routine for GAMESS-UK project.
DESCRIPTION
"load_callback" is used to load a generic Python callback object.
These objects are called every time the screen is updated and can be used
to trigger OpenGL rendering calls (such as with PyOpenGL).
PYMOL API
cmd.load_callback(object,name,state,finish,discrete)
DESCRIPTION
"load_cgo" is used to load a compiled graphics object, which is
actually a list of floating point numbers built using the constants
in the $PYMOL_PATH/modules/pymol/cgo.py file.
PYMOL API
cmd.load_cgo(object,name,state,finish,discrete)
Temporary routine for the Phenix project.
DESCRIPTION
"load_model" reads a ChemPy model into an object
PYMOL API
cmd.load_model(model, object [,state [,finish [,discrete ]]])
DESCRIPTION
"load_object" is a general developer function for loading Python objects
into PyMOL.
PYMOL API
cmd.load_object(type,object,name,state=0,finish=1,discrete=0)
NOTE type is one one of the numberic cmd.loadable types
DESCRIPTION
List contents of the current working directory.
USAGE
ls [pattern]
dir [pattern]
EXAMPLES
ls
ls *.pml
SEE ALSO
cd, pwd, system
DESCRIPTION
"mask" makes it impossible to select the indicated atoms using the
mouse. This is useful when you are working with one molecule in
front of another and wish to avoid accidentally selecting atoms in
the background.
USAGE
mask (selection)
PYMOL API
cmd.mask( string selection="(all)" )
SEE ALSO
unmask, protect, deprotect, mouse
DESCRIPTION
"mclear" clears the movie frame image cache.
USAGE
mclear
PYMOL API
cmd.mclear()
DESCRIPTION
"mdo" sets up a command to be executed upon entry into the
specified frame of the movie. These commands are usually created
by a PyMOL utility program (such as util.mrock). Command can
actually contain several commands separated by semicolons ';'
USAGE
mdo frame : command
PYMOL API
cmd.mdo( int frame, string command )
EXAMPLE
// Creates a single frame movie involving a rotation about X and Y
load test.pdb
mset 1
mdo 1: turn x,5; turn y,5;
mplay
NOTES
The "mset" command must first be used to define the movie before
"mdo" statements will have any effect. Redefinition of the movie
clears any existing mdo statements.
SEE ALSO
mset, mplay, mstop
DESCRIPTION
"mem" Dumps current memory state to standard output. This is a
debugging feature, not an official part of the API.
DESCRIPTION
"meter_reset" resets the frames per secound counter
USAGE
meter_reset
DESCRIPTION
"middle" goes to the middle of the movie.
USAGE
middle
PYMOL API
cmd.middle()
DESCRIPTION
"mmatrix" sets up a matrix to be used for the first frame of the movie.
USAGE
mmatrix {clear|store|recall}
PYMOL API
cmd.mmatrix( string action )
EXAMPLES
mmatrix store
MOUSE CONTROLS
The configuration can be changed using the "Mouse" menu. The
current configuration is described on screen with a small matrix on
the lower right hand corner, using the following abbreviations:
Buttons (Horizontal Axis)
L = left mouse click
M = middle mouse click
R = right mouse click
Modifiers (Veritical axis on the matrix)
None = no keys held down while clicking
Shft = hold SHIFT down while clicking
Ctrl = hold CTRL down while clicking
CtSh = hold both SHIFT and CTRL down while clicking
Visualization Functions
Rota = Rotates camera about X, Y, and Z axes
RotZ = Rotates camera about the Z axis
Move = Translates along the X and Y axes
MovZ = Translates along Z axis
Clip = Y motion moves the near clipping plane while
PkAt = Pick an atom
PkBd = Pick a bond
Orig = Move origin to selected atom
+lb = Add an atom into the (lb) selection
lb = Define the (lb) selection with the indicated atom.
rb = Define the (rb) selection with the indicated atom.
Editing Functions
RotF = Rotate fragment
MovF = Move fragment
TorF = Torsion fragment
DESCRIPTION
"move" translates the world about one of the three primary axes.
USAGE
move axis,angle
EXAMPLES
move x,3
move y,-1
PYMOL API
cmd.move( string axis, float distance )
SEE ALSO
turn
MOVIES
To create a movie, simply load multiple coordinate files
into the same object. This can be accomplish at the command line,
using script files, or by writing PyMOL API-based programs.
The commands:
load frame001.pdb,mov
load frame002.pdb,mov
will create a two frame movie. So will the following program:
from pymol import cmd
for a in ( "frame001.pdb","frame002.pdb" ):
cmd.load(a,"mov")
which can be executed at the command line using the "run" command.
Python built-in glob module can be useful for loading movies.
from pymol import cmd
import glob
for a in ( glob.glob("frame*.pdb") ):
cmd.load(a,"mov")
NOTE
Because PyMOL stores all movie frames in memory, there is a
a practical limit to the number of atoms in all coordinate files.
160 MB free RAM enables 500,000 atoms with line representations.
Complex representations require significantly more memory.
DESCRIPTION
"mplay" starts the movie.
USAGE
mplay
PYMOL API
cmd.mplay()
SEE ALSO
mstop, mset, mdo, mclear, mmatrix
DESCRIPTION
"mpng" writes a series of numbered movie frames to png files with
the specified prefix. If the "ray_trace_frames" variable is
non-zero, these frames will be ray-traced. This operation can take
several hours for a long movie.
Be sure to disable "cache_frames" when issuing this operation on a
long movie (typically >100 frames to avoid running out of memory).
USAGE
mpng prefix
PYMOL API
cmd.mpng( string prefix )
DESCRIPTION
"mset" sets up a relationship between molecular states and movie
frames. This makes it possible to control which states are shown
in which frame.
USAGE
mset specification
PYMOL API
cmd.mset( string specification )
EXAMPLES
mset 1 // simplest case, one state -> one frame
mset 1 x10 // ten frames, all corresponding to state 1
mset 1 x30 1 -15 15 x30 15 -1
// more realistic example:
// the first thirty frames are state 1
// the next 15 frames pass through states 1-15
// the next 30 frames are of state 15
// the next 15 frames iterate back to state 1
SEE ALSO
mdo, mplay, mclear
DESCRIPTION
"mstop" stops the movie.
USAGE
mstop
PYMOL API
cmd.mstop()
SEE ALSO
mplay, mset, mdo, mclear, mmatrix
DESCRIPTION
"orient" aligns the principal components of the atoms in the
selection with the XYZ axes. The function is similar to the
orient command in X-PLOR.
USAGE
orient object-or-selection
orient (selection)
PYMOL API
cmd.orient( string object-or-selection )
SEE ALSO
zoom, origin, reset
DESCRIPTION
"origin" sets the center of rotation about a selection
USAGE
origin object-or-selection
origin (selection)
PYMOL API
cmd.origin( string object-or-selection )
SEE ALSO
zoom, orient, reset
DESCRIPTION
"pair_fit" fits a set of atom pairs between two models. Each atom
in each pair must be specified individually, which can be tedious
to enter manually. Script files are recommended when using this
command.
USAGE
pair_fit (selection), (selection), [ (selection), (selection) [ ...] ]
SEE ALSO
fit, rms, rms_cur, intra_fit, intra_rms, intra_rms_cur
DESCRIPTION
"png" writes a png format image file of the current image to disk.
USAGE
png filename
PYMOL API
cmd.png( string file )
DESCRIPTION
"protect" protects a set of atoms from tranformations performed
using the editing features. This is most useful when you are
modifying an internal portion of a chain or cycle and do not wish
to affect the rest of the molecule.
USAGE
protect (selection)
PYMOL API
cmd.protect(string selection)
SEE ALSO
deprotect, mask, unmask, mouse, editing
DESCRIPTION
"push_undo" stores the currently conformations of objects in the
selection onto their individual kill rings.
USAGE
push_undo (all)
SEE ALSO
undo, redo
DESCRIPTION
Print current working directory.
USAGE
pwd
SEE ALSO
cd, ls, system
DESCRIPTION
"quit" terminates the program.
USAGE
quit
PYMOL API
cmd.quit()
DESCRIPTION
"ray" creates a ray traced image of the current frame. This
can take some time (up to several minutes, depending on image
complexity).
USAGE
ray [width,height]
PYMOL API
cmd.ray(int width,int height)
SEE ALSO
"help faster" for optimization tips
DESCRIPTION
"read_mmodstr" reads a macromodel format structure from a Python
string.
DESCRIPTION
"read_molstr" reads an MDL MOL format file as a string
PYMOL API ONLY
cmd.read_molstr( string molstr, string name, int state=0,
int finish=1, int discrete=1 )
NOTES
"state" is a 1-based state index for the object, or 0 to append.
"finish" is a flag (0 or 1) which can be set to zero to improve
performance when loading large numbers of objects, but you must
call "finish_object" when you are done.
"discrete" is a flag (0 or 1) which tells PyMOL that there will be
no overlapping atoms in the file being loaded. "discrete"
objects save memory but can not be edited.
DESCRIPTION
"read_pdbstr" in an API-only function which reads a pdb file from a
Python string. This feature can be used to load or update
structures into PyMOL without involving any temporary files.
PYMOL API ONLY
cmd.read_pdbstr( string pdb-content, string object name
[ ,int state [ ,int finish [ ,int discrete ] ] ] )
NOTES
"state" is a 1-based state index for the object.
"finish" is a flag (0 or 1) which can be set to zero to improve
performance when loading large numbers of objects, but you must
call "finish_object" when you are done.
"discrete" is a flag (0 or 1) which tells PyMOL that there will be
no overlapping atoms in the PDB files being loaded. "discrete"
objects save memory but can not be edited.
DESCRIPTION
"rebuild" forces PyMOL to recreate all geometric objects in
case any of them have gone out of sync.
USAGE
rebuild
PYMOL API
cmd.rebuild()
SEE ALSO
refresh
DESCRIPTION
"redo" reapplies the conformational change of the object currently
being edited.
USAGE
redo
SEE ALSO
undo, push_undo
DESCRIPTION
"refresh" causes the scene to be refresh as soon as it is safe to
do so.
USAGE
refresh
PYMOL API
cmd.refresh()
SEE ALSO
rebuild
RELEASE NOTES
PyMOL is a free, open, and expandable molecular graphics system
written by a computational scientist to enable molecular modeling from
directly within Python. It will be of most benefit to hybrid
scientist/developers in the fields of structural biology,
computational chemistry, and informatics who seek an open and
unrestricted visualization tool for interfacing with their own
programs. PyMOL will also be of benefit to advanced non-developers
familiar with similar programs such as Midas, O, Grasp, X-PLOR and
CNS.
Due to PyMOL's current "user-unfriendliness", this release is most
appropriate for those who prefer to use text commands and scripts, and
for developers who want to integrate PyMOL's visualization and
molecular editing capabilities with their own work.
PyMOL currently includes a diverse command language, a powerful
application programmers interface (API), and a variety of mouse and
keyboard driven functionality for viewing, animation, rendering, and
molecular editing. A partial manual is now available on the web.
Two external GUI development options are supported for PyMOL:
"Tkinter" and "wxPython". Developers can take their pick. I am
committed to insuring that PyMOL will work with both of them, but it
is unlikely that I will have time to develop a complete external GUI
myself any time soon using either toolkit.
Note that only Tkinter is supported under Windows with the default
PyMOL and Python distributions, so for maximum ease of installation
under Windows, stick with Tkinter (Tcl/Tk). For this reason, the
Tkinter-based GUI is going to be the default GUI for standard PyMOL
despite its drawbacks.
Warren L. DeLano (5/1/2001), warren@delanoscientific.com
DESCRIPTION
"remove" eleminates a selection of atoms from models.
USAGE
remove (selection)
PYMOL API
cmd.remove( string selection )
EXAMPLES
remove ( resi 124 )
SEE ALSO
delete
DESCRIPTION
"remove_picked" removes the atom or bond currently
picked for editing.
USAGE
remove_picked [hydrogens]
PYMOL API
cmd.remove_picked(integer hydrogens=1)
NOTES
This function is usually connected to the
DELETE key and "CTRL-D".
By default, attached hydrogens will also be deleted unless
hydrogen-flag is zero.
SEE ALSO
attach, replace
DESCRIPTION
"rename" creates new atom names which are unique within residues.
USAGE
CURRENT
rename object-name [ ,force ]
force = 0 or 1 (default: 0)
PROPOSED
rename object-or-selection,force
PYMOL API
CURRENT
cmd.rename( string object-name, int force )
PROPOSED
cmd.rename( string object-or-selection, int force )
NOTES
To regerate only some atom names in a molecule, first clear them
with an "alter (sele),name=''" commmand, then use "rename"
SEE ALSO
alter
DESCRIPTION
"replace" replaces the picked atom with a new atom.
USAGE
replace name, geometry, valence
PYMOL API
cmd.replace(string name, int geometry,int valence )
NOTES
Immature functionality. See code for details.
SEE ALSO
remove, attach, fuse, bond, unbond
DESCRIPTION
"reset" restores the rotation matrix to identity, sets the origin
to the center of mass (approx.) and zooms the window and clipping
planes to cover all objects.
USAGE
reset
PYMOL API
cmd.reset ( )
DESCRIPTION
"rewind" goes to the beginning of the movie.
USAGE
rewind
PYMOL API
cmd.rewind()
DESCRIPTION
"rms" computes a RMS fit between two atom selections, but does not
tranform the models after performing the fit.
USAGE
rms (selection), (target-selection)
EXAMPLES
fit ( mutant and name ca ), ( wildtype and name ca )
SEE ALSO
fit, rms_cur, intra_fit, intra_rms, intra_rms_cur, pair_fit
DESCRIPTION
"rms_cur" computes the RMS difference between two atom
selections without performing any fitting.
USAGE
rms_cur (selection), (selection)
SEE ALSO
fit, rms, intra_fit, intra_rms, intra_rms_cur, pair_fit
DESCRIPTION
"rock" toggles Y axis rocking.
USAGE
rock
PYMOL API
cmd.rock()
DESCRIPTION
"run" executes an external Python script in a local name space, the
global namespace, or in its own namespace (as a module).
USAGE
run python-script [, (local | global | module) ]
PYMOL API
Not directly available. Instead, use cmd.do("run ...").
NOTES
The default mode for run is "global".
Due to an idiosyncracy in Pickle, you can not pickle objects
directly created at the main level in a script run as "module",
(because the pickled object becomes dependent on that module).
Workaround: delegate construction to an imported module.
DESCRIPTION
"save" writes selected atoms to a file. The file format is
autodetected if the extesion is ".pdb" or ".pkl"
USAGE
save file [,(selection) [,state [,format]] ]
PYMOL API
cmd.save(file, selection, state, format)
SEE ALSO
load, get_model
DESCRIPTION
"select" creates a named selection from an atom selection.
USAGE
select (selection)
select name, (selection)
select name = (selection) # (DEPRECATED)
PYMOL API
cmd.select(string name, string selection)
EXAMPLES
select near , (ll expand 8)
select near , (ll expand 8)
select bb, (name ca,n,c,o )
NOTES
'help selections' for more information about selections.
DESCRIPTION
Selections are enclosed in parentheses and contain predicates,
logical operations, object names, selection names and nested
parenthesis: ( [... [(...) ... ]] )
name <atom names> n;<atom names>
resn <residue names> r;<residue names>
resi <residue identifiers> i;<residue identifiers>
chain <chain ID> c;<chain identifiers>
segi <segment identifiers> s;<segment identifiers>
elem <element symbol> e;<element symbols>
flag <number> f;<number>
alt <code>
numeric_type <numeric type> nt;<numeric type>
text_type <text type> tt;<text type>
b <operator> <value>
q <operator> <value>
formal_charge <op> <value> fc;<operator> <value>
partial_charge <op> <value> pc;<operator> <value>
id <original-index>
hydrogen h;
all *
visible v;
hetatm
<selection> and <selection> <selection>lt;selection>
<selection> or <selection> <selection>|<selection>
not <selection> !<selection>
byres <selection> br;<selection>
byobj <selection> bo;<selection>
around <distance> a;<distance>
expand <distance> e;<distance>
gap <distance>
in <selection>
like <selection> l;<selection>
DESCRIPTION
"set" changes one of the PyMOL state variables,
USAGE
set name, value [,object-or-selection [,state ]]
set name = value # (DEPRECATED)
WARNING: object and state specific settings are not yet fully
implemented -- look for them in version 0.51.
PYMOL API
cmd.set ( string name, string value,
string selection='', int state=0,
int quiet=0, int updates=1 )
NOTES
The default behavior (with a blank selection) changes the global
settings database. If the selection is 'all', then the settings
database in all individual objects will be changed. Likewise, for
a given object, if state is zero, then the object database will be
modified. Otherwise, the settings database for the indicated state
within the object will be modified.
If a selection is provided, then all objects in the selection will
be affected.
DESCRIPTION
"set_color" defines a new color with color indices (0.0-1.0)
USAGE
set_color name, [ red-float, green-float, blue-float ]
set_color name = [ red-float, green-float, blue-float ]
# (DEPRECATED)
PYMOL API
cmd.set_color( string name, float-list rgb )
EXAMPLES
set_color red = [ 1.0, 0.0, 0.0 ]
DESCRIPTION
"set_key" binds a specific python function to a key press.
PYMOL API
cmd.set_key( string key, function fn, tuple arg=(), dict kw={})
PYTHON EXAMPLE
from pymol import cmd
def color_blue(object):
cmd.color("blue",object)
cmd.set_key( 'F1' , make_it_blue, ( "object1" ) )
cmd.set_key( 'F2' , make_it_blue, ( "object2" ) )
// would turn object1 blue when the F1 key is pressed and
// would turn object2 blue when the F2 key is pressed.
SEE ALSO
button
DESCRIPTION
"set_title" attaches a text string to the state of a particular
object which can be displayed when the state is active. This is
useful for display the energies of a set of conformers.
USAGE
set_title object,state,text
PYMOL API
cmd.set_title(string object,int state,string text)
DESCRIPTION
"set_view" sets viewing information for the current scene,
including the rotation matrix, position, origin of rotation,
clipping planes, and the orthoscopic flag.
USAGE
set_view (...) where ... is 18 floating point numbers
PYMOL API
cmd.set_view(string-or-sequence view)
DESCRIPTION
"show" turns on atom and bond representations.
The available representations are:
lines spheres mesh ribbon cartoon
sticks dots surface labels
nonbonded nb_spheres
USAGE
show
show reprentation [,object]
show reprentation [,(selection)]
show (selection)
PYMOL API
cmd.show( string representation="", string selection="" )
EXAMPLES
show lines,(name ca or name c or name n)
show ribbon
NOTES
"selection" can be an object name
"show" alone will turn on lines for all bonds.
SEE ALSO
hide, enable, disable
DESCRIPTION
"sort" reorders atoms in the structure. It usually only necessary
to run this routine after an "alter" command which has modified the
names of atom properties. Without an argument, sort will resort
all atoms in all objects.
USAGE
sort [object]
PYMOL API
cmd.sort(string object)
SEE ALSO
alter
DESCRIPTION
"spawn" launches a Python script in a new thread which will run
concurrently with the PyMOL interpreter. It can be run in its own
namespace (like a Python module, default), a local name space, or
in the global namespace.
USAGE
run python-script [, (local | global | module )]
PYMOL API
Not directly available. Instead, use cmd.do("spawn ...").
NOTES
The default mode for spawn is "module".
Due to an idiosyncracy in Pickle, you can not pickle objects
directly created at the main level in a script run as "module",
(because the pickled object becomes dependent on that module).
Workaround: delegate construction to an imported module.
The best way to spawn processes at startup is to use the -l option
(see "help launching").
DESCRIPTION
"splash" shows the splash screen information.
USAGE
splash
DESCRIPTION
"stereo" activates or deactives stereo mode. Currently only
high-end stereo graphics are supported on the SGI (stereo in a
window).
USAGE
stereo on
stereo off
PYMOL API
cmd.stereo(string state="on")
DESCRIPTION
"symexp" creates all symmetry related objects for the specified object
that occurs within a cutoff about an atom selection. The new objects
are labeled using the prefix provided along with their crystallographic
symmetry operation and translation.
USAGE
symexp prefix = object, (selection), cutoff
PYMOL API
cmd.symexp( string prefix, string object, string selection, float cutoff)
SEE ALSO
load
DESCRIPTION
"system" executes a command in a subshell under Unix or Windows.
USAGE
system command
PYMOL API
cmd.system(string command)
SEE ALSO
ls, cd, pwd
DESCRIPTION
"torsion" rotates the torsion on the bond currently
picked for editing. The rotated fragment will correspond
to the first atom specified when picking the bond (or the
nearest atom, if picked using the mouse).
USAGE
torsion angle
PYMOL API
cmd.torsion( float angle )
SEE ALSO
edit, unpick, remove_picked, cycle_valence
DESCRIPTION
"turn" rotates the world about one of the three primary axes
USAGE
turn axis, angle
EXAMPLES
turn x,90
turn y,45
PYMOL API
cmd.turn( string axis, float angle )
SEE ALSO
move
DESCRIPTION
"unbond" removes all bonds between two selections.
USAGE
unbond atom1,atom2
PYMOL API
cmd.unbond(selection atom1="(lb)",selection atom2="(rb)")
SEE ALSO
bond, fuse, remove_picked, attach, detach, replace
DESCRIPTION
"undo" restores the previous conformation of the object currently
being edited.
USAGE
undo
SEE ALSO
redo, push_undo
DESCRIPTION
"unmask" reverses the effect of "mask" on the indicated atoms.
PYMOL API
cmd.unmask( string selection="(all)" )
USAGE
unmask (selection)
SEE ALSO
mask, protect, deprotect, mouse
DESCRIPTION
"unpick" deletes the special "pk" atom selections (pk1, pk2, etc.)
used in atom picking and molecular editing.
USAGE
unpick
PYMOL API
cmd.unpick()
SEE ALSO
edit
DESCRIPTION
"update" transfers coordinates from one selection to another.
USAGE
update (target-selection),(source-selection)
EXAMPLES
update target,(variant)
NOTES
Currently, this applies across all pairs of states. Fine
control will be added later.
SEE ALSO
load
DESCRIPTION
"view" makes it possible to save and restore viewpoints on a given
scene within a single session.
USAGE
view key[,action]
view ?
key can be any string
action should be 'store' or 'recall' (default: 'recall')
PYMOL API
cmd.view(string key,string action)
EXAMPLES
view 0,store
view 0
SEE ALSO
get_view
DESCRIPTION
"viewport" changes the size of the viewing port (and thus the size
of all png files subsequently output)
USAGE
viewport width, height
PYMOL API
cmd.viewport(int width, int height)
DESCRIPTION
"wizard" launches on of the built-in wizards. There are special
Python scripts which work with PyMOL in order to obtain direct user
interaction and easily peform complicated tasks.
USAGE
wizard name
PYMOL API
cmd.wizard(string name)
EXAMPLE
wizard distance # launches the distance measurement wizard
DESCRIPTION
"zoom" scales and translates the window and the origin to cover the
atom selection.
USAGE
zoom object-or-selection [,buffer]
zoom (selection) [,buffer]
PYMOL API
cmd.zoom( string object-or-selection [,float buffer] )
SEE ALSO
origin, orient
Contents
Previous
Copyright © 2001 DeLano
Scientific. All rights reserved.
Hosted at:
