PyMOL Wiki - User contributions [en]

Scripting FAQs

2014-01-15T16:42:45Z

Rlc: Fixed error in example for passing command line options to a script.

==Script within a Structure==
Q: Is there a way to embed a script within a PDB structure?

A: Yes, there are two ways
* Use the [[Read_Pdbstr]] command like,
delete all
cmd.read_pdbstr("""HETATM 1985 O00 MOH 132 18.797 6.477 -12.112 0.00 0.00 O\
HETATM 1988 H03 MOH 132 18.437 7.229 -11.665 0.00 0.00 H\
HETATM 1989 C04 MOH 132 17.737 5.662 -12.563 0.00 0.00 C\
HETATM 1990 H05 MOH 132 18.129 4.785 -13.080 0.00 0.00 H\
HETATM 1991 H06 MOH 132 17.096 6.211 -13.253 0.00 0.00 H\
HETATM 1992 H07 MOH 132 17.130 5.322 -11.722 0.00 0.00 H""","mymolecule")
show sticks

Don't forget the backslashes there -- it's one long command.
[http://chips.csb.ki.se/pymol/msg02104.html Example]

* Or, as Warren noted, you can do with with a "p1m" file, which is like a "pml" file, but data can be included as well. Also note that p1m files are intended for web publishing, so embedded Python is disallowed. In p1m files, there is an "embed" command that enables this for PDB, MOL, MOL2, SDF, and XPLOR data. It works like this:
embed tag, format
****REPLACE THIS LINE WITH YOUR DATA FILE****
embed end

load_embedded tag
where tag is some identifier of your choice.

==Scripting and Command Line Options==
PyMol will allow you to use command line options in a script. That means, the following
<source lang="python">
pymol -qrc script.py arg1 arg2
</source>
will work if you add a double-hyphen before the first argument in order
to signal Pymol to stop interpreting arguments:

<source lang="python">
pymol -qrc script.py -- arg1 arg2
</source>

Then your script can get these arguments as follows:

<source lang="python">
from sys import argv
my_argv = argv[1:]
print my_argv[0], my_argv[1]
</source>

[[Category:Scripting]]

Split chains

2013-04-04T13:28:52Z

Rlc: Added fix to check for blank chain ID.

{{Infobox psico
|module = psico.editing
}}

'''split_chains''' is a script that creates for each chain in selection its own object.

== Usage ==

split_chains [ selection [, prefix ]]

== Example ==

<source lang="python">
fetch 2yko 2ykp 2ykq, async=0
split_chains
delete 2yko 2ykp 2ykq
alignto 2yko_A
</source>

== The Script ==

<source lang="python">
from pymol import cmd, CmdException

def split_chains(selection='(all)', prefix=None):
'''
DESCRIPTION

Create a single object for each chain in selection

SEE ALSO

split_states, http://pymolwiki.org/index.php/Split_object
'''
count = 0
models = cmd.get_object_list('(' + selection + ')')
for model in models:
for chain in cmd.get_chains('(%s) and model %s' % (selection, model)):
if chain == '':
chain = "''"
count += 1
if not prefix:
name = '%s_%s' % (model, chain)
else:
name = '%s%04d' % (prefix, count)
cmd.create(name, '(%s) and model %s and chain %s' % (selection, model, chain))
cmd.disable(model)

cmd.extend('split_chains', split_chains)
</source>

== See Also ==

* [[Split_States|split_states]]
* [[split_object]]

[[Category:Script_Library]]

Peptide Sequence

2009-01-21T15:16:56Z

Rlc:

=Building a Peptide Sequence From Hand=
There are more than one method in PyMol for building a peptide sequence from hand. First, you may simply hold down the '''alt''' ('''option''' on Mac) key and type in the one-letter code for the sequence. Secondly, you can write a script like the following
<source lang="python">
for aa in "DCAHWLGELVWCT": cmd._alt(string.lower(aa))
</source>
which will build the amino acid sequence "DCAHWLGELVWCT".

==Other Sources==
Robert Campbell has notified us of [http://pldserver1.biochem.queensu.ca/~rlc/work/pymol his two scripts] to solve the problem. You can apparently specify phi/psi angles, too. Look for '''build_seq.py''' and '''build_seq_phi_psi.py'''.

Also check out [[CreateSecondaryStructure]] , which you can build repeating units of different types of secondary structure (a-helix,b-sheets, loops,etc) (Dan Kulp)

In addition, [[Rotamer Toggle]] can set the sidechains to different rotamers or specific side-chain angle sets. (Dan Kulp)

Color Objects

2008-06-23T20:39:27Z

Rlc: corrected web page reference for RLC's web site

<source lang="python">
#####################################################################
#
# Colour by object
#
#####################################################################

def color_obj(rainbow=0):

"""

AUTHOR

Gareth Stockwell

USAGE

color_obj(rainbow=0)

This function colours each object currently in the PyMOL heirarchy
with a different colour. Colours used are either the 22 named
colours used by PyMOL (in which case the 23rd object, if it exists,
gets the same colour as the first), or are the colours of the rainbow

"""

# Process arguments
rainbow = int(rainbow)

# Get names of all PyMOL objects
obj_list = cmd.get_names('models')

if rainbow:

print "\nColouring objects as rainbow\n"

nobj = len(obj_list)

# Create colours starting at blue(240) to red(0), using intervals
# of 240/(nobj-1)
for j in range(nobj):
hsv = (240-j*240/(nobj-1), 1, 1)
# Convert to RGB
rgb = hsv_to_rgb(hsv)
# Define the new colour
cmd.set_color("col" + str(j), rgb)
print obj_list[j], rgb
# Colour the object
cmd.color("col" + str(j), obj_list[j])

else:

print "\nColouring objects using PyMOL defined colours\n"

# List of available colours
colours = ['red', 'green', 'blue', 'yellow', 'violet', 'cyan', \
'salmon', 'lime', 'pink', 'slate', 'magenta', 'orange', 'marine', \
'olive', 'purple', 'teal', 'forest', 'firebrick', 'chocolate', \
'wheat', 'white', 'grey' ]
ncolours = len(colours)

# Loop over objects
i = 0
for obj in obj_list:
print " ", obj, colours[i]
cmd.color(colours[i], obj)
i = i+1
if(i == ncolours):
i = 0

# HSV to RGB routine taken from Robert L. Campbell's color_b.py script
# See http://pldserver1.biochem.queensu.ca/~rlc/work/pymol/
# Original algorithm from: http://www.cs.rit.edu/~ncs/color/t_convert.html
def hsv_to_rgb(hsv):

h = float(hsv[0])
s = float(hsv[1])
v = float(hsv[2])

if( s == 0 ) :
#achromatic (grey)
r = g = b = v

else:
# sector 0 to 5
h = h/60.
i = int(h)
f = h - i # factorial part of h
#print h,i,f
p = v * ( 1 - s )
q = v * ( 1 - s * f )
t = v * ( 1 - s * ( 1 - f ) )

if i == 0:
(r,g,b) = (v,t,p)
elif i == 1:
(r,g,b) = (q,v,p)
elif i == 2:
(r,g,b) = (p,v,t)
elif i == 3:
(r,g,b) = (p,q,v)
elif i == 4:
(r,g,b) = (t,p,v)
elif i == 5:
(r,g,b) = (v,p,q)
else:
(r,g,b) = (v,v,v)
print "error, i not equal 1-5"

return [r,g,b]

# Add color_obj to the PyMOL command list
cmd.extend("color_obj",color_obj)
</source>

[[Category:Script_Library|Color Objects]]

Color

2008-06-23T20:38:22Z

Rlc: /* Reassigning B-Factors and Coloring */

===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===
<source lang="python">cmd.color( string color, string selection )</source>

==Using RGB for Color==
If you prefer RGB to color any object
<source lang="python">
set_color newcolor, [r,g,b]
color newcolor
</source>
List of [[Color Values]]

==EXAMPLES==
===Color all carbons yellow===
<source lang="python">color yellow, (name C*)</source>

===RGB Example===
<source lang="python">
set_color khaki, [195,176,145]
color khaki
</source>

===Color by Spectrum Example===
Color by spectrum is in the GUI menu but did you realize that the spectrum is not limited to a simple rainbow?
<source lang="python">
spectrum count, x, object_name
</source>
x can can be anyone of the following:
blue_green, green_white_magenta, red_cyan, blue_magenta, green_white_red, red_green, blue_red, green_white_yellow, red_white_blue, blue_white_green, green_yellow, red_white_cyan, blue_white_magenta, green_yellow_red, red_white_green, blue_white_red, magenta_blue, red_white_yellow, blue_white_yellow, magenta_cyan, red_yellow, blue_yellow, magenta_green, red_yellow_green, cbmr, magenta_white_blue, rmbc, cyan_magenta, magenta_white_cyan, yellow_blue, cyan_red, magenta_white_green, yellow_cyan, cyan_white_magenta, magenta_white_yellow, yellow_cyan_white, cyan_white_red, magenta_yellow, yellow_green, cyan_white_yellow, rainbow, yellow_magenta, cyan_yellow, rainbow2, yellow_red, gcbmry, rainbow2_rev, yellow_white_blue, green_blue, rainbow_cycle, yellow_white_green, green_magenta, rainbow_cycle_rev, yellow_white_magenta, green_red, rainbow_rev, yellow_white_red, green_white_blue, red_blue, yrmbcg

===B-Factors===
The command to color a molecule by B-Factors (B Factors) is:
<source lang="python">
cmd.spectrum("b", selection="SEL");
</source>
where '''SEL''' is a valid selection, for example, "protA and n. CA", for protein A's alpha carbons.

You can choose the spectrum you want with the command:
<source lang="python">
cmd.spectrum("b", 'rainbow', selection="SEL");
</source>

where '''rainbow''' is a valid selection from the list:
<pre>
blue_green green_white_magenta red_cyan
blue_magenta green_white_red red_green
blue_red green_white_yellow red_white_blue
blue_white_green green_yellow red_white_cyan
blue_white_magenta green_yellow_red red_white_green
blue_white_red magenta_blue red_white_yellow
blue_white_yellow magenta_cyan red_yellow
blue_yellow magenta_green red_yellow_green
cbmr magenta_white_blue rmbc
cyan_magenta magenta_white_cyan yellow_blue
cyan_red magenta_white_green yellow_cyan
cyan_white_magenta magenta_white_yellow yellow_cyan_white
cyan_white_red magenta_yellow yellow_green
cyan_white_yellow rainbow yellow_magenta
cyan_yellow rainbow2 yellow_red
gcbmry rainbow2_rev yellow_white_blue
green_blue rainbow_cycle yellow_white_green
green_magenta rainbow_cycle_rev yellow_white_magenta
green_red rainbow_rev yellow_white_red
green_white_blue red_blue yrmbcg
</pre>

====Reassigning B-Factors and Coloring====
It is commonplace to replace the B-Factor column of a protein with some other biochemical property at that residue, observed from some calculation or experiment. PyMOL can easily reassign the B-Factors and color them, too. The following example will load a protein, set ALL it's B Factors to "0", read in a list of properties for each alpha carbon in the proteins, assign those new values as the B-Factor values and color by the new values. This example is possible because commands PyMOL does not recognize are passed to the Python interpreter --- a very powerful tool.
<source lang="python">
# load the protein
cmd.load("protA.pdb")

# open the file of new values (just 1 column of numbers, one for each alpha carbon)
inFile = open("newBFactors", 'r')

# create the global, stored array
stored.newB = []

# read the new B factors from file
for line in inFile.readlines(): stored.newB.append( float(line) )

# close the input file
inFile.close()

# clear out the old B Factors
alter protA, b=0.0

# update the B Factors with new properties
alter protA and n. CA, b=stored.newB.pop(0)

# color the protein based on the new B Factors of the alpha carbons
cmd.spectrum("b", "protA and n. CA")
</source>

If you want to save the file with the new B Factor values for each alpha carbon,
<source lang="python">
cmd.save("protA_newBFactors.pdb", "protA")
</source>
or similar is all you need.

A script (data2bfactor.py) that loads data into the B-factor (b) or occupancy (q) columns from an external file can be found in Robert Campbell's PyMOL script repository (http://pldserver1.biochem.queensu.ca/~rlc/work/pymol/)

===== Expanding to Surface =====
If you have run the above code and would like the colors to be shown in the [[Surface]] representation, too, then you need to do the following:
<source lang="python">
# Assumes alpha carbons colored from above.
create ca_obj, your-object-name and name ca
ramp_new ramp_obj, ca_obj, [0, 10], [-1, -1, 0]
set surface_color, ramp_obj, your-object-name
</source>

Thanks to Warren, for this one.

[[Category:Objects_and_Selections]]
[[Category:Commands|color]]

Advanced Coloring

2008-06-23T20:33:47Z

Rlc: modified rlc's web site location and changed some outdated text describing color_b.py

=Coloring Molecules=

==Basic Coloring==
Any molecule in PyMOL can be assigned a color using the small rightmost buttons in the object list (in the upper right part of the main GUI window. The [[Color]] command will do the same.

PyMOL has a predefined set of colors that can be edited in the ''Settings->Colors'' menu.
Alternatively, you can use the [[Set_Color]] command.

==Coloring secondary structures==
To assign helices, sheets and loops individual colors, do:
<source lang="python">
color red, ss h
color yellow, ss s
color green, ss l+''
</source>

When the colour bleeds from the ends of helices and sheets into loops, do:
<source lang="python">
set cartoon_discrete_colors, 1
</source>
Or activate ''Cartoon -> Discrete Colors'' in the GUI menu.

==Coloring by atom type==
The util.cba* ("Color By Atom") commands color atoms according to type: oxygen in red, nitrogen in blue, hydrogen in white. Carbon will get a different colors, depending on the command: cbag (gray), cbac (cyan), cbas (salmon), cbap (purple), cbak (pink), cbaw (white), cbab (slate).
For instance:
<source lang="python">
util.cbay three
</source>
will color the object ''three'' by atom type, with the carbon atoms in yellow.

==CMYK-safe Colors==
There are two distinct color spaces on computers: RGB (red-green-blue), which is for screens, and CMYK (cyan-magenta-yellow-black), which is for printing.
Some RGB triplets do have equivalents in CMYK space. As a result, a figure that looks great on a screen can come out with unpredictable colors when printed.

Most applications do a good job with RGB-to-CMYK conversions for photos, but do not do such a good job with graphics that use pure primary colors. For example, reds are generally OK, but pure blues and greens do not translate very well.

Here are some RGB values that are within the CMYK gamut (i.e. are "CMYK-safe"):
<source lang="python">
#optimized rgb values for cmyk output:
set_color dblue= [0.05 , 0.19 , 0.57]
set_color blue= [0.02 , 0.50 , 0.72]
set_color mblue= [0.5 , 0.7 , 0.9 ]
set_color lblue= [0.86 , 1.00 , 1.00]

set_color green= [0.00 , 0.53 , 0.22]
set_color lgreen=[0.50 , 0.78 , 0.50]
set_color yellow=[0.95 , 0.78 , 0.00]
set_color orange=[1.00 , 0.40 , 0.0 ]

# these are trivial
set_color red= [1.00 , 0.00 , 0.00]
set_color mred= [1.00 , 0.40 , 0.40]
set_color lred= [1.00 , 0.80 , 0.80]
set_color vlred= [1.00 , 0.90 , 0.90]
set_color white= [1.00 , 1.00 , 1.00]
set_color vlgray=[0.95 , 0.95 , 0.95]
set_color lgray= [0.90 , 0.90 , 0.90]
set_color gray= [0.70 , 0.70 , 0.70]
set_color dgray= [0.50 , 0.50 , 0.50]
set_color vdgray=[0.30 , 0.30 , 0.30]
set_color black= [0.00 , 0.00 , 0.00]
##
</source>

Note that there are default atom colors such as "carbon", "nitrogen", "oxygen", "hydrogen", "sulfur", etc. which should also be redefined:
<source lang="python">
set_color carbon= [0.00 , 0.53 , 0.22]
etc.
</source>

==Coloring with 'chainbows' from a script==
The chainbow function can be invoked by:
<source lang="python">
util.chainbow("object-name")
</source>

==Assign color by B-factor==
Robert Campbell has a color_b.py python script on his PyMOL web page that you can use.
it has a number of options including the selection, minimum and maximum values to consider and several types of colouring schemes (a selection of gradients plus the ability to set the saturation and brightness levels) and two types of binning of the colours (equal number of atoms in each colour or equal spacing of colours along the B-factor range).

See http://pldserver1.biochem.queensu.ca/~rlc/work/pymol to download.

====PyMol B-factor Coloring====
This concept is also discussed in [[Color#Color_by_Spectrum_Example|Coloring by BFactors and Spectrum]] and has a '''great list of the colors in the spectrum'''.
This just shows a quick standard PyMol way to color your protein by b-factor. It also sets the range of color for coloring:
spectrum b, minimum=20, maximum=50

Or to color on a per-object basis:
load myprotein.pdb
spectrum b, selection=myprotein, minimum=20, maximum=50

= See Also =
[[Color]], [[Color#Color_by_Spectrum_Example|Coloring with Spectrum]]

==Creating a Color bar==
To show a vertical/horizontal color bar indiacting the b-factor variation, use the script pseudobar.pml on the structure pseudobar.pdb, or do the following:
# Create a pdb-file which contains CA positions only, whereas the numbers correspond to your wanted increments of colors. Be sure that CA's are separated by a contant value, say 5 Angstroem.
# Load this new pseudobar-pdb file into PyMOL, make bonds between increment 1 and increment 2 [increment 2 and increment 3 and so on...], define/assign a smooth color for each increment (copy colors definition from automatically created colors made by b-factor script) and show the b-factor bar as lines (or sticks).

==Coloring insides and outsides of helices differently==
The inside of helices can be adressed with:
<source lang="python">
set cartoon_highlight_color, red
</source>

==Coloring all objects differently==
Is there a simple way to colour each object currently loaded, with a different colour?
There is a script color_obj.py that does the job.
The script is also available at
http://www.ebi.ac.uk/~gareth/misc

USAGE

color_obj(rainbow=0)

This function colours each object currently in the PyMOL heirarchy
with a different colour. Colours used are either the 22 named
colours used by PyMOL (in which case the 23rd object, if it exists,
gets the same colour as the first), or are the colours of the rainbow

==List the color of atoms==
To retrieve the color for all residues in a selection, you can iterate over it from the PyMOL command line
<source lang="python">
iterate all, print color
</source>
In Python, it looks like this:
<source lang="python">
import pymol
pymol.color_list = []
cmd.iterate('all', 'pymol.color_list.append(color)')
print pymol.color_list
</source>

[[Category:Publication_Quality|Advanced Coloring]]
[[Category:Coloring|Advanced Coloring]]